text
stringlengths 7
3.69M
|
|---|
import React from 'react';
import { Redirect } from 'react-router-dom';
import PostApi from "../../services/PostApi";
import PostCardList from './PostCardList';
import { Layout, Pagination } from 'antd';
import PopitHeader from "../PopitHeader";
import PopitFooter from "../PopitFooter";
import '../popit.css';
const { Content } = Layout;
const MAX_NUM_POSTS = 10;
export default class RecentPostsPageDesktop extends React.Component {
constructor(props) {
super(props);
let posts;
let totalRecords = 0;
if (process.env.BROWSER) {
if (window.__INITIAL_DATA__) {
posts = window.__INITIAL_DATA__.data.posts;
totalRecords = window.__INITIAL_DATA__.data.total;
}
delete window.__INITIAL_DATA__;
} else {
posts = this.props.staticContext.data.posts;
totalRecords = this.props.staticContext.data.total;
}
this.state = {
posts: posts,
totalRecords: totalRecords,
loading: posts ? false : true,
errorMessage: "",
};
this.page = parseInt(this.props.pageParam, 10);
this.getRecentPosts = this.getRecentPosts.bind(this);
this.getNextPage = this.getNextPage.bind(this);
}
componentDidMount () {
if (!this.state.posts) {
this.getRecentPosts(this.page);
}
}
getNextPage(page) {
document.location.href = '/page/' + page;
}
getRecentPosts(page) {
PostApi.getRecentPosts(page, MAX_NUM_POSTS, true)
.then(json => {
if (json.success !== true) {
this.setState({
loading: false,
errorMessage: json.message,
posts: [],
totalRecords: 0,
});
return;
}
this.setState({
loading: false,
posts: json.data.posts,
totalRecords: json.data.total,
});
})
.catch(error => {
alert("Error:" + error);
});
};
render() {
const { loading, posts, errorMessage, totalRecords } = this.state;
if (loading === true) {
return (<div style={{textAlign: 'center', marginTop: 20}}>Loading...</div>)
}
return (
<Layout className="layout" hasSider={false} style={{background: '#ffffff'}}>
<PopitHeader />
<Content style={{padding: '20px 10px', maxWidth: 1360, margin: '74px auto auto auto'}}>
<div style={{width: 900, maxWidth: 900, margin: 'auto', textAlign: 'left'}}>
<h1>전체글</h1>
{ (errorMessage) ? (<div style={{fontWeight: 'bold', fontSize: 16}}>Error: {errorMessage}</div>) : null }
<PostCardList posts={posts}
showAuthor={true}/>
<Pagination current={this.page} total={totalRecords} onChange={this.getNextPage}/>
</div>
</Content>
<PopitFooter/>
</Layout>
)
}
}
|
import { expect } from 'chai';
import { REHYDRATE } from 'redux-persist';
import agents from './agents';
import * as actionTypes from '../constants/actionTypes';
import * as statusTypes from '../constants/status';
import { TestProcessBuilder, TestAgentBuilder } from '../test/builders/api';
describe('agents reducer', () => {
it('returns previous state for unknown action', () => {
const initialState = { random: 'junk' };
const newState = agents(initialState, { type: 'UNKNOWN_ACTION' });
expect(newState).to.deep.equal(initialState);
});
it('loads new agent and keeps previously loaded agents', () => {
const initialState = {
agent1: {
status: statusTypes.LOADED,
url: 'http://localhost:3000',
processes: {}
}
};
const loadAgentAction = {
type: actionTypes.AGENT_INFO_REQUEST,
name: 'agent2',
url: 'http://localhost:3001'
};
const newState = agents(initialState, loadAgentAction);
expect(newState.agent1).to.deep.equal(initialState.agent1);
expect(newState.agent2.status).to.equal(statusTypes.LOADING);
expect(newState.agent2.url).to.equal('http://localhost:3001');
expect(newState.agent2.processes).to.deep.equal({});
});
it('updates state when fetching agent failed', () => {
const initialState = {
agent1: { status: statusTypes.LOADING, url: 'http://localhost:3000' }
};
const agentFailureAction = {
type: actionTypes.AGENT_INFO_FAILURE,
name: 'agent1',
error: 'invalid url'
};
const failedState = agents(initialState, agentFailureAction);
expect(failedState.agent1.status).to.equal(statusTypes.FAILED);
expect(failedState.agent1.error).to.equal('invalid url');
expect(failedState.agent1.url).to.equal('http://localhost:3000');
});
it('handles agents without processes', () => {
const testAgent = new TestAgentBuilder().build();
const agentSuccessAction = {
type: actionTypes.AGENT_INFO_SUCCESS,
name: 'agent1',
agent: testAgent
};
const loadedState = agents({}, agentSuccessAction);
expect(loadedState.agent1.status).to.equal(statusTypes.LOADED);
expect(Object.keys(loadedState.agent1.processes).length).to.equal(0);
});
it('updates state with processes details on success', () => {
const initialState = {
agent1: { status: statusTypes.LOADING, url: 'http://localhost:3000' }
};
const testProcess = new TestProcessBuilder('simpleprocess').build();
const testAgent = new TestAgentBuilder().withProcess(testProcess).build();
const agentSuccessAction = {
type: actionTypes.AGENT_INFO_SUCCESS,
name: 'agent1',
agent: testAgent
};
const loadedState = agents(initialState, agentSuccessAction);
expect(loadedState.agent1.status).to.equal(statusTypes.LOADED);
expect(loadedState.agent1.url).to.equal('http://localhost:3000');
const process = loadedState.agent1.processes.simpleprocess;
expect(process.name).to.equal('simpleprocess');
});
it('updates state with process actions on success', () => {
const testProcess = new TestProcessBuilder('withActions')
.withAction('init', ['title'])
.build();
const testAgent = new TestAgentBuilder().withProcess(testProcess).build();
const agentSuccessAction = {
type: actionTypes.AGENT_INFO_SUCCESS,
name: 'local',
agent: testAgent
};
const loadedState = agents({}, agentSuccessAction);
const process = loadedState.local.processes.withActions;
expect(Object.keys(process.actions).length).to.equal(1);
const action = process.actions.init;
expect(action.args.length).to.equal(1);
expect(action.args[0]).to.equal('title');
});
it('updates state with process store on success', () => {
const testProcess = new TestProcessBuilder('withStore')
.withStoreAdapter('dummyStore', 'v1', 'c1', 'desc')
.build();
const testAgent = new TestAgentBuilder().withProcess(testProcess).build();
const agentSuccessAction = {
type: actionTypes.AGENT_INFO_SUCCESS,
name: 'local',
agent: testAgent
};
const loadedState = agents({}, agentSuccessAction);
const process = loadedState.local.processes.withStore;
expect(process.store).to.deep.equal({
name: 'dummyStore',
version: 'v1',
commit: 'c1',
description: 'desc'
});
});
it('updates state with process fossilizers on success', () => {
const testProcess = new TestProcessBuilder('withFossilizers')
.withFossilizer('f1', 'v1', 'c1', 'd1', 'b1')
.withFossilizer('f2', 'v2', 'c2', 'd2', 'b2')
.build();
const testAgent = new TestAgentBuilder().withProcess(testProcess).build();
const agentSuccessAction = {
type: actionTypes.AGENT_INFO_SUCCESS,
name: 'local',
agent: testAgent
};
const loadedState = agents({}, agentSuccessAction);
const process = loadedState.local.processes.withFossilizers;
expect(process.fossilizers).to.have.length(2);
expect(process.fossilizers[0]).to.deep.equal({
name: 'f1',
version: 'v1',
commit: 'c1',
description: 'd1',
blockchain: 'b1'
});
expect(process.fossilizers[1]).to.deep.equal({
name: 'f2',
version: 'v2',
commit: 'c2',
description: 'd2',
blockchain: 'b2'
});
});
it('removes the agent from state on delete action', () => {
const state = {
foo: {},
bar: {}
};
const newState = agents(state, {
type: actionTypes.AGENT_INFO_DELETE,
name: 'foo'
});
expect(newState).to.deep.equal({ bar: {} });
});
it('do nothing if name to delete does not exist', () => {
const state = {
foo: {},
bar: {}
};
const newState = agents(state, {
type: actionTypes.AGENT_INFO_DELETE,
name: 'foobar'
});
expect(newState).to.deep.equal({ foo: {}, bar: {} });
});
it('handles REHYDRATE with empty payload', () => {
const state = {
foo: {},
bar: {}
};
const newState = agents(state, {
type: REHYDRATE,
payload: undefined
});
expect(newState).to.deep.equal(state);
});
it('change status to STALE on REHYDRATE', () => {
const state = {
foo: {
status: 'foo',
url: 'foo/url',
dummy: true
},
bar: {
status: 'bar',
url: 'bar/url',
nothing: false
}
};
const newState = agents(state, {
type: REHYDRATE,
payload: { agents: state }
});
expect(newState).to.deep.equal({
foo: {
status: statusTypes.STALE,
url: 'foo/url'
},
bar: {
status: statusTypes.STALE,
url: 'bar/url'
}
});
});
});
|
import Permissions from 'react-native-permissions'
import LocationHelper from './location';
export default class PermissionsHandler {
static permissionTypes = Object.freeze ({
"LOCATION" : "location",
"CAMERA" : "camera",
"MICROPHONE" : "microphone",
"PHOTO" : "photo",
"CONTACTS" : "contacts",
"EVENT" : "event",
"BLUETOOTH" : "bluetooth",
"REMINDER" : "reminder",
"PUSH_NOTIFICATION" : "notification",
"BACKGROUND_REFRESH" : "backgroundRefresh",
"SPEECH_REGONITION" : "speechRecognition",
"MEDIA_LIBRARY" : "mediaLibrary",
"MOTION" : "motion",
"STORAGE" : "storage",
"PHONE_CALL" : "callPhone",
"READ_SMS" : "readSms",
"RECEIVE_SMS" : "receiveSms"
})
static permissionStates = Object.freeze ({
"AUTHORIZED" : "authorized",
"DENIED" : "denied",
"RESTRICTED" : "restricted",
"UNDETERMINED" : "'undetermined'"
})
static errorMessages = Object.freeze ({
"LOCATION_DENIED" : 'You cannot access the entire features of the app without location' ,
'NOTIFICATION_DENIED' : 'You cannot help anybody that well without notifications :('
})
static iosFlags = Object.freeze ({
"LOCATION" : {
type: 'always'
},
"CAMERA" : {},
"MICROPHONE" : {},
"PHOTO" : {},
"CONTACTS" : {},
"EVENT" : {},
"BLUETOOTH" : {},
"REMINDER" : {},
"PUSH_NOTIFICATION" : {
type: ['alert', 'badge']
},
"BACKGROUND_REFRESH" : {},
"SPEECH_REGONITION" : {},
"MEDIA_LIBRARY" : {},
"MOTION" : {},
"STORAGE" : {},
"PHONE_CALL" : {},
"READ_SMS" : {},
"RECEIVE_SMS" : {}
})
static genericCheckPermission (permission, type, successCallback, failureCallback) {
Permissions.check (permission, type).then ( response => {
if (response !== PermissionsHandler.permissionStates.AUTHORIZED)
failureCallback ()
else
successCallback ()
})
}
static genericRequestPermission (permission, type, successCallback, failureCallback) {
console.log ('permission', permission);
Permissions.request (permission, { type: 'always' }).then ( response => {
if (response !== PermissionsHandler.permissionStates.AUTHORIZED)
failureCallback ()
else
successCallback ()
}).catch (error => {
console.warn ('error : ', error);
})
}
static async requestLocationPermission (successCallback, failureCallback) {
console.log ("*requesting location*")
PermissionsHandler.genericRequestPermission (PermissionsHandler.permissionTypes.LOCATION, PermissionsHandler.iosFlags.LOCATION, () => {
LocationHelper.locationEnabled = true;
successCallback ();
}, () => {
console.log ("SET TO FALSE");
LocationHelper.locationEnabled = false;
failureCallback (PermissionsHandler.errorMessages.LOCATION_DENIED)
});
}
// REMOVE CODE FROM PUSHNOTIFICATIONS FILE AND ADD TO HERE
static requestPushNotificationPermission (successCallback, failureCallback) {
PermissionsHandler.genericRequestPermission (PermissionsHandler.permissionTypes.PUSH_NOTIFICATION, PermissionsHandler.iosFlags.PUSH_NOTIFICATION, () => {
successCallback ();
}, () => {
failureCallback (PermissionsHandler.errorMessages.NOTIFICATIONS_DENIED)
});
}
}
|
function Transaction(balance = new Balance(), dataValidation = new DataValidation()) {
this.transactions = [];
this.balance = balance;
this.dataValidation = dataValidation;
}
Transaction.prototype.withdraw = function (date, value) {
this.dataValidation.validate(date, value);
const returnedBalance = this.balance.calculate(this.transactions, {
date,
debit: value,
credit: 0,
balance: 0,
});
this.transactions.push(returnedBalance);
return this.transactions.slice(-1)[0];
};
Transaction.prototype.deposit = function (date, value) {
this.dataValidation.validate(date, value);
const returnedBalance = this.balance.calculate(this.transactions, {
date,
debit: 0,
credit: value,
balance: 0,
});
this.transactions.push(returnedBalance);
return this.transactions.slice(-1)[0];
};
|
import { formatSalary, isAValidNumber, transformDate, isMonthValid, isDayValid } from '..';
describe('#formatSalary', () => {
it('returns formatted string with valid inputs', () => {
expect(formatSalary(60000)).toEqual('60,000 USD per year');
expect(formatSalary(600)).toEqual('600 USD per year');
});
});
describe('#isAValidNumber', () => {
it('returns valid output', () => {
expect(isAValidNumber('=')).toEqual(false);
expect(isAValidNumber('23')).toEqual(true);
expect(isAValidNumber('23/')).toEqual(false);
});
})
describe('#transformDate', () => {
it('returns current date if date string is invalid', () => {
const mockDate = new Date(1466424490000);
const spy = jest
.spyOn(global, 'Date')
.mockImplementation(() => mockDate);
expect(transformDate('', '20/02/').getTime()).toEqual(mockDate.getTime());
spy.mockRestore();
})
it('returns the actual date if date string is valid', () => {
const inputTime = new Date(1992, 10, 11);
expect(transformDate('', '11/11/1992').getTime()).toEqual(inputTime.getTime());
})
})
describe('#isMonthValid', () => {
it('returns true if it is a valid month', () => {
expect(isMonthValid(12)).toEqual(true)
})
it('returns true if it is an invalid month', () => {
expect(isMonthValid(13)).toEqual(false)
})
})
describe('#isDayValid', () => {
it('returns true if it is a valid date', () => {
expect(isDayValid(12, 12, 2020)).toEqual(true)
expect(isDayValid(29, 2, 2020)).toEqual(true)
})
it('returns true if it is an invalid date', () => {
expect(isDayValid(32)).toEqual(false)
expect(isDayValid(30, 2, 2020)).toEqual(false)
expect(isDayValid(29, 2, 2019)).toEqual(false)
})
})
|
//---------path模块-----
//1.路径的解析
var path=require('path');
var myPath=path.normalize(__dirname+'/input.txt'); //normalize()方法解析路径返回完整路径，__dirname是代变量
// console.log(myPath);
//2.路径的结合，合并，路径最后不会带目录分隔符
var myPath=path.join('path1', '/path2/aa', 'baz/asdf');
// console.log(myPath); // path1/path2/aa/baz/asdf
//3.在当前路径下生成绝对路径，只在当前运行目录下找。要求参数是字符串，可为多个参数
var myPath=path.resolve('app/test/haha','../input.txt');
// console.log(myPath); // /opt/zhoulin/node/app/test/input.txt
//4.获取相对路径 path.relative(form,to) 返回基于from指定到to的相对路径
var form='/zhoulin/Document/circle/node/input.txt'; //form与to是绝对路径
var to='/zhoulin/Document/circle/node/myapp/bin/www';
var _path=path.relative(form,to);
// console.log(_path); // ../../ebook
//5.获取路径中目录名(到目录文件之前的绝对目录)
var myPath=path.dirname(__dirname+'/input.txt');
// console.log(myPath); // /opt/zhoulin/node
//6.获取路径中目标文件名，后缀可选，不需要话第二个参数以'.ext'方式传入
var myPath=path.basename(__dirname+'/input.txt','.txt');
// console.log(myPath); // input
//7.获取路径中目标文件的扩展名，没有.返回空
var myPath=path.extname('/input.txt');
// console.log(myPath); // .txt
//8.sep属性，返回操作系统文件分隔符，window返回'\\', unix是'/'
var myPath=path.sep;
// console.log(myPath); // /
//9.delimiter属性，返回操作系统目录分隔符，window是 ';' unix是 ':'
var myPath=path.delimiter;
// console.log(myPath); // :
//10.parse()返回文件的详细路径信息对象
var pathJson=path.parse('/zhoulin/Document/circle/node/input.txt');
// console.log(pathJson)
// {
// root:'/',
// dir:'/zhoulin/Document/circle/node',
// base:'input.txt',
// ext:'txt',
// name:'input'
// }
//11.format()通过json组合成路径，与parse()相反
var myPath=path.format({
root:'/',
dir:'/zhouzhou/node',
base:'input.html'
});
//12.isAbsolute()判断是否为绝对路径，返回true/false
var isabsolut=path.isAbsolute('/root/circle/input.txt');
// console.log(isabsolut);
//------------------------fs文件系统模块------
var fs=require('fs');
//1.readFile(filename,[options],callback)读取文件内容
/**
* filename, 必选参数，文件名
* [options],可选参数，可指定flag（文件操作选项，如r+ 读写；w+ 读写，文件不存在则创建）及encoding属性
* callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
*/
// fs.readFile(__dirname+'/input.txt',{flag:'r+',encoding:'utf8'},function(err,data){
// if(err){
// console.error(err);
// return ;
// }
// console.log(data); // 测试数据
// });
//2.writeFile(filename,data,[options],callback)写入内容到文件
/**
* filename, 必选参数，文件名
* data, 写入的数据，可以字符或一个Buffer对象
* [options],flag,mode(权限),encoding
* callback 读取文件后的回调函数，参数默认第一个err,第二个data 数据
*/
// var w_data='这是一段通过fs.writeFile函数写入的内容；\r\n';
// fs.writeFile(__dirname+'/input.txt',w_data,{flag:'a'},function(err,data){
// if(err){
// console.error(err);
// return ;
// }else{
// console.log('写入成功！');
// }
// });
//3.appendFile(filename,data,[options],callback)以追加的方式写入文件
// fs.appendFile(__dirname+'/input.txt','这里是追加写入的内容',function(){
// console.log('追加写入完成！');
// });
//4.open(filename,flags,[mode],callback)
/**
* flags, 操作标识，如"r",读方式打开
* [mode],权限，如777，表示任何用户读写可执行
* callback 打开文件后回调函数，参数默认第一个err,第二个fd为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄
*/
// fs.open(__dirname+'/input.txt','r','0666',function(err,fd){
// console.log(fd);
// })
//5.read()读文件，读取打开的文件内容到缓冲区中
//fs.read(fd, buffer, offset, length, position, callback);
/**
* fd, 使用fs.open打开成功后返回的文件描述符
* buffer, 一个Buffer对象，v8引擎分配的一段内存
* offset, 整数，向缓存区中写入时的初始位置，以字节为单位
* length, 整数，读取文件的长度
* position, 整数，读取文件初始位置；文件大小以字节为单位
* callback(err, bytesRead, buffer), 读取执行完成后回调函数，bytesRead实际读取字节数，被读取的缓存区对象
*/
// fs.open(__dirname+'/input.txt','r',function(err,fd){
// if(err){
// console.error(err);
// return;
// }else{
// var buffer=new Buffer(255);
// console.log(buffer.length); //缓存空间长度255
// ////每一个汉字utf8编码是3个字节，英文是1个字节，这里是从第二个节开始读取
// fs.read(fd,buffer,0,9,3,function(err,bytesRead,buffer){
// if(err){
// throw err;
// }else{
// console.log(bytesRead); //9
// console.log(buffer.slice(0,bytesRead).toString()); //试数据
// //读取完后，再使用fd读取时，基点是基于上次读取位置计算；
// fs.read(fd,buffer,0,9,null,function(err,bytesRead,buffer){
// console.log(bytesRead); //9
// console.log(buffer.slice(0,bytesRead).toString()); //测试数
// });
// }
// });
// }
// })
//6.写文件，将缓冲区内数据写入使用fs.open打开的文件
// fs.write(fd,buffer,offset,length,position,callback);
//callback参数：err错误，written实际写入字节数，buffer被读取的缓存区对象
// fs.open(__dirname+'/input.txt','a',function(err,fd){
// if(err){
// console.error(err);
// return ;
// }else{
// var buffer=new Buffer('写入文件数据内容');
// //写入‘入文件’三个字
// fs.write(fd,buffer,3,9,12,function(err,written,buffer){
// if(err){
// console.log('写入失败');
// console.error(err);
// return ;
// }else{
// console.log('写入成功');
// }
// })
// }
// })
//7.刷新缓存区 fs.fsync(fd,callback)
// 使用fs.write写入文件时，操作系统是将数据读到内存，再把数据写入到文件中，当数据读完时并不代表数据已经写完，因为有一部分还可能在内在缓冲区内。
// 因此可以使用fs.fsync方法将内存中数据写入文件；--刷新内存缓冲区；
// fs.open(__dirname+'/input.txt','a',function(err,fd){
// if(err){
// console.error(err);
// }else{
// var buffer=new Buffer('我爱nodejs编程');
// fs.write(fd,buffer,0,9,0,function(err,written,buffer){
// console.log(written.toString());
// fs.write(fd,buffer,9,buffer.length-9,null,function(err,written){
// console.log(written.toString());
// fs.fsync(fd);
// fs.close(fd);
// })
// })
// }
// })
//8.创建目录 fs.mkdir(path,[mode],callback);
//mode表示权限
// fs.mkdir(__dirname+'/fsDir',function(err){
// if(err){
// console.error(err);
// }else{
// console.log('创建目录成功！')
// }
// })
//9.读取目录，列出目录下的子文件名
//fs.readdir(path,callback);
//callback(err,files) ,files是数组，读取到目录下的文件
// fs.readdir(__dirname+'/test',function(err,files){
// if(err){
// console.error(err);
// return ;
// }else{
// files.forEach(function(file,index){
// console.log(index+'---',file)
// })
// }
// })
//10查看文件与目录的信息
//fs.stat(path,callback);或fs.lstat(path,callback); //查看符号链接文件
// fs.lstat(__dirname+'/input.txt',function(err,res){
// console.log(res) //返回一个对象，包含文件相关信息
// })
//11.查看文件与目录是否存在 fs.exists(path,[callback(exists)]) //exists为true是存在
// fs.exists(__dirname+'/input.txt',function(exists){
// var retTxt=(exists ? '存在': '不存在')
// console.log(retTxt);
// })
//12.修改文件访问时间与修改时间 fs.utimes(path,atime,mtime,callback);
//atime:新的访问时间 ctime新的修改时间
// fs.stat(__dirname+'/input.txt',function(err,stat){
// console.log('访问时间：'+stat.atime+'\n修改时间：'+stat.mtime); //修改之前最近的一次时间
// console.log(stat.mode);
// })
// fs.utimes(__dirname+'/input.txt',new Date(),new Date(),function(err){
// if(err){
// console.error(err);
// return ;
// }
// fs.stat(__dirname+'/input.txt',function(err,stat){
// console.log('访问时间：'+stat.atime+'\n修改时间：'+stat.mtime); //修改之后的时间
// console.log(stat.mode);
// })
// })
//13.修改文件的访问权限 fs.chmod(path,mode,callback)
//mode表示权限，0666是所有用户可读可写
// fs.chmod(__dirname+'/input.txt','0666',function(err){
// if(err){
// console.error(err);
// return ;
// }
// console.log('修改权限成功')
// })
//14.移动/重命名文件或目录 fs.rename(oldPath,newPath,callback);
// fs.rename(__dirname+'/input.txt',__dirname+'/input1.txt',function(err){
// if(err){
// console.error(err);
// return ;
// }else{
// console.log('移动/重命名文件成功！');
// }
// })
//15.删除空目录(无子文件)
// fs.rmdir(__dirname+'/test',function(err){
// if(err){
// console.log('删除空目录失败，可能原因：1、目录不存在，2、目录不为空');
// console.error(err);
// return ;
// }else{
// console.log('删除目录成功')
// }
// })
//16.监视文件，被修改时进行处理 fs.watchFile(filename,[options],listener);
//[options], persistent true表示持续监视，不退出程序；interval 单位毫秒，表示每隔多少毫秒监视一次文件
//listener ,文件发生变化时回调，有两个参数：curr为被修改后文件一个fs.Stat对象，prev为被修改前文件一个fs.Stat对象
// fs.watchFile(__dirname+'/input.txt',{interval:1000},function(curr,prev){
// if(Date.parse(prev.ctime)==0){
// console.log('文件被创建！');
// }else if(Date.parse(curr.ctime)==0){
// console.log('文件被删除！');
// }else if(Date.parse(curr.mtime)!=Date.parse(prev.mtime)){
// console.log('文件被修改！');
// }
// })
//17.取消监听文件 fs.unwatchFile(filename,[listener]); //listener如果不指定监听器事件，则取消所有监听处理事件
// var listener=function(curr,prev){
// console.log('我是监视函数')
// }
// fs.unwatchFile(__dirname+'/input.txt',listener);
//18.监视文件或目录 fs.watch(filename,[options],[listener])
// fs.watch返回一个fs.FSWatcher对象，拥有一个close方法，用于停止watch操作；
// 当fs.watch有文件变化时，会触发fs.FSWatcher对象的change(err, filename)事件，err错误对象，filename发生变化的文件名
// fs.watch(filename, [options], [listener]);
// var fsWatcher=fs.watch(__dirname+'/input.txt',function(event,filename){
// // console.log(event);
// });
// fsWatcher.on('change',function(event,filename){
// console.log(filename+' 发生变化')
// });
// setTimeout(function(){
// console.log('关闭watch')
// fsWatcher.close(function(err){
// if(err){
// console.log(err)
// }
// });
// },30000)
//19.文件可读流fs.createReadStream(path[,options])
//20.暂停pause()会使 flowing 模式的流停止触发 'data' 事件
//21.恢复resume()会重新触发 'data' 事件, 将暂停模式切换到流动模式
// var rs=fs.createReadStream('out.txt',{
// flags:'r',
// encoding:'utf8',
// autoClose:true,
// highWaterMark:3, //每次读取3位
// start:0, //默认从0开始
// end:3 //读到下标到3的字符结束，0-3共4位
// });
// rs.on('data',function(data){
// console.log(data);
// rs.pause(); //暂停'data'触发
// });
// setTimeout(function(){
// rs.resume(); //恢复'data'触发
// },5000)
// rs.on('end',function(){
// console.log('over!');
// });
// rs.on('open',function(){
// console.log('open!');
// })
// rs.on('close',function(){
// console.log('close!')
// })
//22.文件写入流fs.createWriteStream(path[,options]);
var ws=fs.createWriteStream('out.txt',{
flags:'w', //如果不想覆盖式写入，则为 ‘r+’
encoding:'utf8',
autoClose:true,
highWaterMark:6,
mode:0o666, //权限
});
var flag1=ws.write('hello','utf8',function(){ //返回flag1的值为true/false，代表是否还可以继续写入
console.log('写完！')
});
console.log(flag1); //注：为false时，数据不会丢失，也会被写入
|
import React, {Component} from 'react';
import BackgroundImage from './BackgroundImage.js';
import LeftArrow from './LeftArrow.js';
import RightArrow from './RightArrow.js';
import CircleButtons from './CircleButtons.js';
class BackgroundContainer extends Component {
constructor(props) {
super(props);
// Max number is 5
this.state = {
previousSlideNumber: 0,
slideNumber : 0,
}
}
// Delegate function for next image
nextImage = () => {
if (this.state.slideNumber + 1 > 5) {
this.setState({
slideNumber: 0,
});
} else {
this.setState({
slideNumber: this.state.slideNumber + 1,
});
}
}
// Delegate function for previous image
previousImage = () => {
if (this.state.slideNumber - 1 < 0){
this.setState({
slideNumber: 5,
});
} else {
this.setState({
slideNumber: this.state.slideNumber - 1,
});
}
}
// Delegate Function for circle buttons
setCircleImage = (circleNumber) => {
this.setState({
slideNumber : circleNumber,
});
}
render () {
return (
<div className="slider">
{/* Slides */}
<BackgroundImage slideNumber={this.state.slideNumber} previousSlideNumber={this.state.previousSlideNumber} />
{/*Arrows and Dots */}
<RightArrow nextImage={this.nextImage} />
<LeftArrow previousImage={this.previousImage} />
<CircleButtons setCircleImage={this.setCircleImage} />
</div>
);
}
}
export default BackgroundContainer;
|
define(function(require, exports, module){
var G=require('../../c/js/globale');
require('../../c/js/registerHelper');
require('../../c/js/zepto.lazyload');
var Tpage=require('./page.handlebars');
var main = {
init:function(){
var self=main;
self.from=$('#J-from').val();
//如果图片加载慢ios需要js滚动方式
G._scroll();
/*获取登录信息*//*购物车数量*/
G._getCartCount();
self.pageId=G._getUrlParam('pageId');
self._getData();
},
_getData:function(){
var self=this;
var url=self.from=='fsl' ? '/fsl/channel/listImg.json' : '/channel/listImg.json';
$.ajax({
type:'get',
cach:false,
url:url,
data:{
pageId:self.pageId
},
success:function(res){
if(res=='noLogin'){
location.href='/login.do?target='+location.href;
return;
};
if(res.info.ok==true){
$('#page').html(Tpage(res.data.map.result));
/*图片延迟加载*/
$(".content img.lazy").lazyload({
event:"sporty",
threshold : 10
});
var timeout = setTimeout(function() {
$("img.lazy").trigger("sporty")
}, 200);
$.refreshScroller();
setTimeout(function(){
$.refreshScroller();
$.init();
},600);
setInterval(function(){
$.refreshScroller();
},600);
};
},
beforeSend:function(){
// $.showIndicator();
},
complete:function(){
// $.hideIndicator();
},
error:function(){
// alert('error');
}
});
}
};
G._getLoginUser(main.init);
});
|
'use strict';
const inspiration = require('./TheMindOfAGustin');
/**
* https://api.slack.com/docs/message-formatting
* @param predicate
* @param message
* @returns {number}
*/
function formatSlackMessage(message) {
return {
response_type: 'in_channel',
text: message,
attachments: [],
};
}
function verifyWebhook(body) {
if (! body || body.token !== process.env.SLACK_TOKEN) {
const error = new Error('Invalid credentials');
error.code = 401;
throw error;
}
}
function justInspire(predicate = "") {
return new Promise((resolve, reject) => {
resolve(formatSlackMessage(inspiration.say(predicate.trim())));
});
}
exports.justInspire = (req, res) => {
return Promise.resolve().then(() => {
if (req.method !== 'POST') {
const error = new Error('Only POST requests are accepted');
error.code = 405;
throw error;
}
verifyWebhook(req.body);
return justInspire(req.body.text);
}).then(response => {
res.json(response);
}).catch(err => {
console.error(err);
res.status(err.code || 500).send(err);
return Promise.reject(err);
});
};
|
const projectInitialState = {
m_no: '',
m_introduce: '',
m_school: '',
m_degree: '',
m_major: '',
m_inyear: '',
m_outyear: '',
m_skill: '',
experience: [],
};
export default function (state = projectInitialState, action) {
switch (action.type) {
case 'CREATE_RESUME_REQUEST': {
return { ...state, isLoading: true, errorMsg: null };
}
case 'CREATE_RESUME_SUCCESS': {
const {
data: { data, token }, status,
} = action.res;
return status === 200
? {
...state,
token,
...data,
isLoading: false,
errorMsg: null,
}
: state;
}
case 'CREATE_RESUME_FAILED':
return { ...state, errorMsg: 'Create Resume Failed', isLoading: false };
case 'UPDATE_RESUME_REQUEST': {
return { ...state, isLoading: true, errorMsg: null };
}
case 'UPDATE_RESUME_SUCCESS': {
const { data: { data, token }, status } = action.res;
return status === 200
? {
...state,
...data,
token,
isLoading: false,
errorMsg: null,
}
: state;
}
case 'UPDATE_RESUME_FAILED':
return { ...state, errorMsg: 'Create Resume Failed', isLoading: false };
default:
return state;
}
}
|
var nextPhraseGenerator = (function () {
var slangPhrases = [
", yeah!",
", this is crazy, I tell ya.",
", can U believe this?",
", eh?",
", aw yea.",
", yo.",
"? No way!",
". Awesome!"
],
current = 0;
return {
next: function () {
if (current > slangPhrases.length - 1)
current = 0;
return slangPhrases[current++];
}
}
})();
var isEven = true;
var fs = require("fs");
fs.readFileSync("input.txt").toString().split("\n").forEach(function (line) {
if (line !== "") {
slangFlavor(line);
}
});
function slangFlavor(line) {
var temp = line.trim(),
result = [],
sentenceStart = 0,
sentence;
for (var i = 0, count = temp.length; i < count; i++) {
if (".!?".indexOf(temp[i]) !== -1) {
sentence = temp.substr(sentenceStart, i - sentenceStart).trim();
result.push(processSentence(sentence, temp[i]));
sentenceStart = i + 1;
}
}
console.log(result.join(" "));
}
function processSentence(sentence, endPunctMark) {
if ((isEven = !isEven) === true) {
return sentence + nextPhraseGenerator.next();
} else {
return sentence + endPunctMark;
}
}
|
function getCopyRight(){
today = new Date();
myDate = today.getFullYear();
copy = "© Copyright 200x -" + myDate + " hogehoge All rights reserved.";
return copy;
}
|
import * as assert from 'assert'
import * as _ from 'lodash'
// Actions
const PATHWAY_LOADING_SUCCESS = 'pathways/pathway/PATHWAY_LOADING_SUCCESS'
const PATHWAY_ADD_NODE = 'pathways/pathway/PATHWAY_ADD_NODE'
const PATHWAY_DELETE_NODE = 'pathways/pathway/PATHWAY_DELETE_NODE'
const SIDEBAR_CREATE = 'pathways/pathway/SIDEBAR_CREATE'
const SIDEBAR_VIEW_NODE = 'pathways/pathway/SIDEBAR_VIEW_NODE'
const SIDEBAR_VIEW_NONE = 'pathways/pathway/SIDEBAR_VIEW_NONE'
const ERROR = 'pathways/pathway/ERROR'
const CHANGE_LOAD_STATE = 'pathways/pathway/CHANGE_LOAD_STATE'
// Action creators
export function changeLoadState (state) {
assert(state in loadingStateEnum, 'State not in enum')
return {
type: CHANGE_LOAD_STATE,
state
}
}
export function loadUserPathway () {
return async (dispatch, getState) => {
dispatch(changeLoadState(loadingStateEnum.DURING_LOAD))
const fetchResult = await fetch('/api/v1/user/pathway')
if (!fetchResult.ok) {
return dispatch({ type: ERROR, message: await fetchResult.text() })
}
const data = await fetchResult.json()
dispatch({ type: PATHWAY_LOADING_SUCCESS, pathway: data.pathway })
}
}
export function sidebarSwitchToCreate () {
return { type: SIDEBAR_CREATE }
}
export function sidebarSwitchToViewNode (nodeId) {
return { type: SIDEBAR_VIEW_NODE, nodeId }
}
export function sidebarSwitchToDefault () {
return { type: SIDEBAR_VIEW_NONE }
}
export function uploadPathToServer () {
return async (dispatch, getState) => {
const state = getState()
dispatch(changeLoadState(loadingStateEnum.DURING_RELOAD))
const options = {
method: 'POST',
headers: { 'Content-type': 'application/json' },
body: JSON.stringify({ pathway: state.pathway.pathway })
}
const fetchResult = await fetch('/api/v1/user/pathway', options)
if (!fetchResult.ok) {
dispatch({ type: ERROR, message: await fetchResult.text() })
}
dispatch(changeLoadState(loadingStateEnum.AFTER_RELOAD))
}
}
export function saveNodeToPathway (grade, courses) {
return async (dispatch) => {
const event = {
type: PATHWAY_ADD_NODE,
grade,
courses
}
dispatch(event)
try {
await dispatch(uploadPathToServer())
} catch (e) {
return dispatch({ type: ERROR, message: e.message })
}
dispatch(sidebarSwitchToViewNode(grade))
}
}
export function deleteNodeFromPathway (grade) {
return async (dispatch) => {
dispatch(sidebarSwitchToDefault())
const event = {
type: PATHWAY_DELETE_NODE,
grade
}
dispatch(event)
try {
await dispatch(uploadPathToServer())
} catch (e) {
return dispatch({ type: ERROR, message: e.message })
}
}
}
// Enums
export const loadingStateEnum = Object.freeze({
BEFORE_LOAD: 'BEFORE_LOAD',
DURING_LOAD: 'DURING_LOAD',
AFTER_LOAD: 'AFTER_LOAD',
FAILED_LOAD: 'FAILED_LOAD',
DURING_RELOAD: 'DURING_RELOAD',
AFTER_RELOAD: 'AFTER_RELOAD',
FAILED_RELOAD: 'FAILED_RELOAD'
})
export const sidebarModeEnum = Object.freeze({
CREATE: 'create',
VIEW: 'view',
NONE: 'none'
})
// Default state
const defaultState = {
pathway: {
9: [],
10: []
},
loading: loadingStateEnum.BEFORE_LOAD,
sidebar: {
type: sidebarModeEnum.NONE
},
error: null
}
export default (state = defaultState, action) => {
switch (action.type) {
case PATHWAY_LOADING_SUCCESS:
return { ...state, pathway: action.pathway, loading: loadingStateEnum.AFTER_LOAD }
case SIDEBAR_CREATE:
return { ...state, sidebar: { type: sidebarModeEnum.CREATE } }
case SIDEBAR_VIEW_NODE:
return { ...state, sidebar: { type: sidebarModeEnum.VIEW, nodeId: action.nodeId } }
case SIDEBAR_VIEW_NONE:
return { ...state, sidebar: { type: sidebarModeEnum.NONE } }
case PATHWAY_ADD_NODE:
return { ...state, pathway: { ...state.pathway, [action.grade]: action.courses } }
case PATHWAY_DELETE_NODE:
return { ...state, pathway: _.omit(state.pathway, action.grade) }
case CHANGE_LOAD_STATE:
return { ...state, loading: action.state }
case ERROR:
return { ...state, error: action.message }
default: return state
}
}
|
import React, { Fragment, useContext, useEffect } from 'react';
import { Button, Select, Form, Input } from 'antd';
import './style.css';
import { multiStepContext } from '../StepContext';
import DataRestaurants from '../data/dishes.json';
const { Option } = Select
const validateMessages = {
required: 'Value is not null',
types: {
'date': 'Value is not validate date!',
'number': 'Value is not a validate number!',
},
number: {
'range': 'Value must be between 0 and 10',
},
};
function Step2() {
const { setCurrent, data, setData } = useContext(multiStepContext);
console.log(data);
const [form] = Form.useForm();
let DataRestaurant = DataRestaurants.dishes;
let newDataRestaurant = [];
let dataNew = [];
newDataRestaurant = DataRestaurant.map((item) => item.restaurant);
newDataRestaurant = newDataRestaurant.filter((item,index) =>{
return newDataRestaurant.indexOf(item) === index;
});
console.log(newDataRestaurant);
const onFinishs = () => {
setCurrent(2)
}
useEffect(() => {
form.setFieldsValue({ user: data })
}, [data, form])
const handleChangeRestaurant = (e) => {
setData({ ...data, restaurant: e })
}
return (
<div className='body'>
<div>
<Form form={form} name="nest-messages" onFinish={onFinishs} validateMessages={validateMessages}>
<Form.Item name={['user', 'restaurant']} label="Name" rules={[{ required: true }]}>
<Select
labelInValue='meal'
placeholder='Select a meal'
style={{ width: 400 }}
onChange={handleChangeRestaurant}
value={data.Restaurant}
>
{newDataRestaurant ? newDataRestaurant.map((item, index) => (
<Fragment key={index}>
{newDataRestaurant.includes(data.meal.value)===true?<Option key={index} value={item}>{item}</Option>:''}
</Fragment>
)) : ''}
</Select>
</Form.Item>
<Form.Item className="mt-3 " wrapperCol={{ span: 5, offset: 4 }}>
<Button type="primary" htmlType="submit">
Next
</Button>
<Button onClick={() => setCurrent(0)}>Previous</Button>
</Form.Item>
</Form>
</div>
</div>
)
}
export default Step2
|
/*color Palette:
dark blue: 85, 91, 110
blue: 137, 176, 174
light blue: 190, 227, 219
white: 250, 249, 249
pink: 255, 214, 186 */
//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
import Display from "./display.js";
//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
const X = 0;
const Y = 0;
let screenState = 0;
let display = new Display(X, Y, screenState);
//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
function reset() {
display.screenState = 0;
display.tutorialScreen = 1;
display.money = 100;
display.care.money = display.money;
display.animal.state = 1;
display.happyBar.currentValue = 61;
display.levelBar.currentValue = 0;
}
function mouseClicked() {
if (display.screenState === 0) {
if (
display.tutorial.hitTestNext() &&
(display.tutorialScreen === 1 || display.tutorialScreen === 2)
) {
display.tutorialScreen += 1;
}
if (
display.tutorial.hitTestBack() &&
(display.tutorialScreen === 2 || display.tutorialScreen === 3)
) {
display.tutorialScreen -= 1;
}
if (display.startButton.hitTest()) {
display.screenState = 1;
}
} else if (display.screenState === 1) {
display.systemClicked();
} else if (display.screenState === 2 || display.screenState === 3) {
if (display.replayButton.hitTest()) {
reset();
}
}
}
function keyTyped() {
display.systemTyped();
}
//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
display.animateTamagotchi();
function draw() {
background(255);
if (display.screenState === 0) {
display.startScreen();
} else if (display.screenState === 1) {
display.mainScreen();
} else if (display.screenState === 2) {
display.endScreen();
} else if (display.screenState === 3) {
display.deathScreen();
}
}
//–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
window.keyTyped = keyTyped;
window.draw = draw;
window.mouseClicked = mouseClicked;
|
import { storage } from '@xmini/x-mini/lib/index';
import api from '../../api/index';
// import { sa } from '../../utils/shence.js';
// console.warn('=======store user.js api', api)
let userInfo = storage.get('userInfo') || {};
console.log(userInfo);
function isLogin(data = {}) {
return !!(data.token && data.user_id);
}
// wx.getSetting({
// success(res) {
// console.warn(res.authSetting)
// }
// })
export default {
state: {
userInfo: userInfo,
logged: isLogin(userInfo),
isRefuseUserAuth: false, // 用户是否拒绝用户信息授权了
isRefusePhoneAuth: false, // 用户是否拒绝手机号授权了
// loginStatus: {
// status: 0, // 0未登录，1登录中...，2登录成功!，3登录失败!
// statusText: '未登录', // 未登录，登录中...，登录成功!，登录失败1
// }
},
mutations: {
['SET_USER_INFO'](state, userData){
console.log('::::::::::::::::::更新用户信息', userData);
state.userInfo = userData
state.logged = isLogin(userData);
console.log(state.logged)
api.setCommonParams({
token: (userData && userData.token) || '',
uid: (userData && userData.user_id) || '',
uuid: (userData && userData.user_id) || '',
})
storage.set('userInfo', userData)
// sa.login(userData.user_id);
},
['SET_IS_USER_AUTH_STATUS'](state, flag){
state.isRefuseUserAuth = flag;
},
['SET_IS_PHONE_AUTH_STATUS'](state, flag) {
state.isRefusePhoneAuth = flag;
},
},
actions: {
// 修改用户信息
setUserInfo({ commit, state }, userData) {
console.log('::::::::::::::::::修改用户信息', userData);
commit('SET_USER_INFO', userData)
},
setIsRefuseUserAuth({ commit, state }, flag) {
commit('SET_IS_USER_AUTH_STATUS', flag)
},
setIsRefusePhoneAuth({ commit, state }, flag) {
commit('SET_IS_PHONE_AUTH_STATUS', flag)
},
},
};
|
const initState = {
activeTab: "dashboard",
};
const sideNavReducer = (state = initState, action) => {
switch (action.type) {
case "CHANGE":
return {
activeTab: action.data,
};
default:
return state;
}
};
export default sideNavReducer;
|
var number = new Buffer('123456789');
console.log(number.toString());
var slice = number.slice(3,6);
console.log(slice.toString());
slice[0] = '#'.charCodeAt(0);
console.log(slice.toString());
slice[slice.length - 1] = '#'.charCodeAt(0);
console.log(slice.toString());
console.log(number.toString());
|
module.exports = {
port: process.env.PORT || 5000,
DB: {
uri: 'mongodb://localhost:27017/cookbook-test2',
options: { useNewUrlParser: true, useUnifiedTopology: true },
},
};
|
function happy() {
if(document.getElementById('exampleInputName2').value<=0){
sweetAlert("输入错误", "请输入>=0的数据","error");
return false;
}
else if(document.getElementById('exampleInputName2').value>99){
sweetAlert("输入错误", "请输入<100的数据","error");
return false;
}
else{
$('tr').remove();
var n = parseInt(document.getElementById('exampleInputName2').value);
var Move;
var N;
var posOne = 0;
var posZero;
var posMax;
var a = new Array();
if (n % 2 == 0) {
N = n;
for (var x = 0; x < N; x++) {
a[x] = x + 1;
}
Move = (n - 4) / 2;
posMax = N - 1;
for (var i = 0; i < n - 1; i++) {
//$('.head').append('<td>第'+(i+1)+'轮</td>');
$('.table').append('<tr class=\''+(i+1)+'\'><td>第'+(i+1)+'轮</td></tr>');
for (var j = 0; j < N / 2; j++)
$('.'+(i+1)).append("<td>" + a[j] + "-" + a[N - 1 - j] + "</td>");
if (posMax == N - 1) {
posOne += (Move + 1);
if (posOne > N - 2)
posOne -= (N - 1);
a[posOne] = 1;
posMax = 0;
for (var I = posOne + 1; I < N; I++)
a[I] = a[I - 1] + 1;
if (posOne > 1)
a[posOne - 1] = N - 1;
for (var J = posOne - 2; J > 0; J--)
a[J] = a[J + 1] - 1;
a[posMax] = n;
} else {
posOne += (Move + 1);
if (posOne > N - 1)
posOne -= (N - 1);
a[posOne] = 1;
posMax = N - 1;
for (var I = posOne + 1; I < N; I++)
a[I] = a[I - 1] + 1;
if (posOne > 1)
a[posOne - 1] = N - 1;
for (var J = posOne - 2; J >= 0; J--)
a[J] = a[J + 1] - 1;
a[posMax] = n;
}
}
} else {
N = n + 1;
Move = (N - 4) / 2;
for (var x = 0; x < N; x++)
a[x] = x + 1;
a[N - 1] = 0;
posZero = N - 1;
for (var i = 0; i < n; i++) {
$('.table').append('<tr class=\''+(i+1)+'\'><td>第'+(i+1)+'轮</td></tr>');
for (var j = 0; j < N / 2; j++)
$('.'+(i+1)).append("<td>" + a[j] + "-" + a[N - 1 - j] + "</td>");
if (posZero == N - 1) {
posOne += (Move + 1);
if (posOne > N - 2)
posOne -= (N - 1);
a[posOne] = 1;
posZero = 0;
for (var I = posOne + 1; I < N; I++)
a[I] = a[I - 1] + 1;
if (posOne > 1)
a[posOne - 1] = N - 1;
for (var J = posOne - 2; J > 0; J--)
a[J] = a[J + 1] - 1;
a[posZero] = 0;
} else {
posOne += (Move + 1);
if (posOne > N - 1)
posOne -= (N - 1);
a[posOne] = 1;
posZero = N - 1;
for (var I = posOne + 1; I < N; I++)
a[I] = a[I - 1] + 1;
if (posOne > 1)
a[posOne - 1] = N - 1;
for (var J = posOne - 2; J >= 0; J--)
a[J] = a[J + 1] - 1;
a[posZero] = 0;
}
}
}
swal("干得漂亮！", "成功输出列表！","success")
}
}
|
import React, { Component } from 'react';
import Item from './item';
import './style.scss';
export default class Form extends Component {
static isObj(obj) {
return obj && typeof(obj) === 'object';
}
constructor(props) {
super(props);
}
shouldComponentUpdate(nextProps) {
return nextProps.value !== this.props.value;
}
handleChange = (k, v) => {
const { value } = this.props;
value.$update({
$merge: {
[k]: v
}
});
};
render() {
const { name, value } = this.props;
return (
<div className="form-group">
<label className="form-group-title">{name}</label>
<ul className="form-group-list">
{Object.entries(value).filter(([k]) => {
return (
k.indexOf('@') === -1 &&
(!value[`@${k}`] || value[`@${k}`].type !== 'hidden')
);
}).map(([k, v]) => (
<li key={k}>
{Form.isObj(v) && !value[`@${k}`] ? (
<Form value={v} name={k} />
): (
<Item
name={k}
value={v}
describe={value[`@${k}`]}
onChange={(v) => this.handleChange(k, v)}
/>
)}
</li>
))}
</ul>
</div>
)
}
}
|
import { useEffect, useState } from "react"
import banner from "../banner.jpg"
import { Link } from "react-router-dom";
const Banner = () => {
const [search, setSearch] = useState();
const [find, setFind] = useState([]);
const [word, setWord] = useState("");
useEffect(() => {
setSearch(["a","b","test", "mb"])
}, [])
const findSearch = (e) => {
setWord(e.target.value)
const filteredCountries = search.filter(item => item.indexOf(e.target.value) > -1 ? item : null);
e.target.value.length === 0 ? setFind([]) : setFind(filteredCountries);
}
const findResult = () => {
if (find.length === 0 && word.length > 0) {
return <div className="find-search">Not Found</div>
}
if (find.length > 0) {
return <div className="find-search">
{
find.map(item => {
return <Link key={item} to="#">{item}</Link>
})
}
</div>
}
}
return (
<div className="banner d-flex align-items-center" style={{ backgroundImage: `url(${banner})` }}>
<div className="bg-custom">
<div className="container">
<div className="row">
<div className="col-lg-6 mx-auto">
<div className="banner-area text-center pt-4 pb-4">
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit</p>
<h2 className="mt-2 mb-4 banner-title"><strong> Lorem Ipsum Dolor</strong> </h2>
<div className="search-area">
<input value={word} onChange={(e) => findSearch(e)} type="text" className="inp-search" placeholder="Search" />
<button className="btn-search m-2">Search All</button>
</div>
{findResult()}
</div>
</div>
</div>
</div>
</div>
</div>
)
}
export default Banner;
|
import React from 'react';
import {
Silence,
Affirmations,
Visualization,
Exercise,
Reading,
Scribing,
Chinese,
} from './Savers';
function isSunday() {
return (new Date()).getDay() === 0;
}
function Sunday() {
return (
<React.Fragment>
<Chinese text="I complete a lesson in Duolingo." />
<Exercise />
</React.Fragment>
);
}
function Everyday() {
return (
<React.Fragment>
<Silence />
<Affirmations />
<Visualization />
<Scribing />
<Chinese text="I complete a quest in Duolingo." />
<Reading />
<Exercise />
</React.Fragment>
);
}
function Morning() {
return isSunday() ? <Sunday /> : <Everyday />;
}
export default Morning;
|
const httprequest = new XMLHttpRequest();
httprequest.open("GET", "http://localhost:2000/getSupermarkets");
httprequest.send();
httprequest.onreadystatechange = function () {
if (httprequest.status === 200 && httprequest.readyState === 4) {
document.getElementById("container").appendChild(createTable(JSON.parse(httprequest.responseText)));
}
if (httprequest.status === 404 && httprequest.readyState === 4) {
document.getElementById("p").innerHTML = JSON.parse(httprequest.responseText).error;
}
};
function createTable(jsonObj) {
let i;
const col = ["Name", "Logo"];
const table = document.createElement("table");
let tr = table.insertRow(-1);
for (i = 0; i < col.length; i++) {
const th = document.createElement("th");
th.innerHTML = col[i];
tr.appendChild(th);
}
for (i = 0; i < jsonObj.length; i++) {
tr = table.insertRow(-1);
for (let j = 0; j < col.length; j++) {
const tabCell = tr.insertCell(-1);
if (col[j] === "Logo") {
if (jsonObj[i].logo === "null") {
tabCell.innerHTML = "No logo yet";
} else {
tabCell.innerHTML = "<img style='height:30px;' src='data:image/png;base64," + jsonObj[i].logo + "'>";
}
}
else {
const x = document.createElement("a");
x.href = "supermarket.html?id=" + jsonObj[i].id;
x.setAttribute("class", "nav-link");
x.innerHTML = jsonObj[i].name.split("+").join(" ");
tabCell.appendChild(x);
}
}
}
table.setAttribute("class", "table");
return table;
}
|
import React, { Component } from "react";
class CountUp extends Component {
state = {
diffStr: ""
};
componentDidMount() {
setInterval(() => {
let diffstring =
(new Date().getTime() - this.props.start.getTime()) / 1000;
diffstring = diffstring.toFixed(0);
this.setState({ diffStr: diffstring + " seconds live" });
});
}
render() {
return <span>{this.state.diffStr}</span>;
}
}
export default CountUp;
|
var firebase = require('firebase');
// connect to Firebase
// Initialize Cloud Firestore through Firebase
var config = {
apiKey: "AIzaSyAUv8Qv0jrVbJYX5iDr-WE-n4MPGJfM5ms",
authDomain: "bioandes-2019.firebaseapp.com",
databaseURL: "https://bioandes-2019.firebaseio.com",
projectId: "bioandes-2019"
};
firebase.initializeApp(config);
module.exports = firebase.firestore();
|
const express = require('express');
var path = require('path');
const app = express();
var bodyParser = require('body-parser');
const session = require('express-session');
const passport = require('passport');
const flash = require('connect-flash');
const jwt = require('jsonwebtoken');
const {check,validationResult} = require('express-validator');
var sid = null;
var student = null;
var academic = null;
var father = null;
var mother = null;
var address = null;
//------------ Passport Configuration ------------//
require('./config/passport')(passport);
// creating connection to database
const db =require('./database/connect.js');
//------------ EJS Configuration ------------//
//app.use(expressLayouts);
app.set('views',path.join(__dirname,'static'));
app.set('view engine', 'ejs');
app.use(express.static('static'));
//------------ Bodyparser Configuration ------------//
app.use(express.urlencoded({ extended: false }))
//------------ Express session Configuration ------------//
app.use(session({
secret: 'secret',
cookie :{maxAge : 3000},
resave : true,
saveUninitialized : true
}));
//------------ Passport Middlewares ------------//
app.use(passport.initialize());
app.use(passport.session());
//------------ Connecting flash ------------//
app.use(flash());
//------------ Global variables ------------//
app.use(function(req, res, next) {
res.locals.success_msg = req.flash('success_msg');
res.locals.error_msg = req.flash('error_msg');
res.locals.error = req.flash('error');
next();
});
//------------ Routes ------------//
app.use('/', require('./routes/index'));
app.use('/', require('./routes/page2'));
app.use('/', require('./routes/page3'));
app.use('/', require('./routes/success'));
app.use('/auth', require('./routes/auth'));
//---------------initialing server----------//
const PORT = process.env.PORT || 5000;
app.listen(PORT, console.log(`Server running on PORT ${PORT}`));
|
var createError = require('http-errors'); // errors 모듈
var express = require('express'); // expresss 모듈
var path = require('path'); // path 모듈
var cookieParser = require('cookie-parser'); // 쿠키 모듈
var expressSession = require('express-session'); // 세션 모듈
var FileStore = require('session-file-store')(expressSession);
var http = require("http");
var app = express();
//세션 환경 세팅
app.use(expressSession({
secret: 'secretKey',
resave: false,
saveUninitialized: true, // 세션이 저장되기 전에 uninitialized 상태로 미리 만들어서 저장.
store: new FileStore()
})
);
// req.session이 undefined 되는 문제 해결
// app.use(expressSession) 구문을 라우터보다 먼저 사용
// req.session.save 함수를 명시적으로 사용하여 안전하게 session에 값이 저장된 후 redirect를 한다.
// res.redirect를 바로 하면 node.js는 비동기적으로 처리하기 때문에 session에 값이 저장되기 전에 redirect 될 수 있다.
var bodyParser = require('body-parser'); // body-parser 모듈 로드
var logger = require('morgan'); // 로거 모듈
var server = http.Server(app);
var io = require('socket.io')(server);
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(logger('dev')); // logger 모듈 사용
app.use(express.json()); // json 모듈 사용
app.use(express.urlencoded({ extended: false })); // express-parser 사용
app.use(bodyParser.urlencoded({ extended: false })); // body-parser 사용
app.use(cookieParser()); // cookieParser 모듈 사용
app.use(express.static(path.join(__dirname, 'public'))); // 정적 파일 로드 사용
var indexRouter = require('./routes/index'); // index 라우터
var usersRouter = require('./routes/users'); // users 라우터
var chatRouter = require('./routes/openchat'); // chat 라우터
var directRouter = require('./routes/direct'); // direct 라우터
// use bootstrap
app.use('/js', express.static(__dirname + '/node_modules/bootstrap/dist/js')); // redirect bootstrap JS
app.use('/css', express.static(__dirname + '/node_modules/bootstrap/dist/css')); // redirect CSS bootstrap
// set Rounter
app.use('/', indexRouter);
app.use('/users', usersRouter);
app.use('/openchat', chatRouter);
app.use('/direct', directRouter);
// catch 404 and forward to error handler
app.use(function (req, res, next) {
next(createError(404));
});
// error handler
app.use(function (err, req, res, next) {
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// render the error page
res.status(err.status || 500);
res.render('error');
});
module.exports = app;
|
import React, {Component} from "react";
import ReactDOM from "react-dom";
class Counter extends Component{
state={
value:this.props.cont.value,
tags:["tag1","tag2"]
};
/* constructor(){
super()
// console.log("constructor",this);
this.handleIncrement=this.handleIncrement.bind(this);
} */
a=5;
styles={
fontSize:"10px",
fontWeight:"bold"
}
handleIncrement=()=>{
this.setState({value:this.state.value+1})
}
formatCount(){
const {value}=this.props.cont;
return value===0? "zero": value;
}
onDelete=()=>{
this.props.delete()
console.log(this.props.cont.id)
}
render(){
const inner="miichael;"
const a=false;
return (
<React.Fragment >
<span style={this.styles} className="badge badge-primary m-2"> {this.formatCount()} </span>
<button className="btn btn-secondary btn-sm" onClick={()=>this.props.onIncrement(this.props.cont)}> Increment</button>
<button className="btn btn-danger btn-sm" onClick={()=>this.props.delete(this.props.cont.id)}> Delete</button>
<ul>
{this.state.tags.map(tg=><li key={tg}>{tg}</li>)}
</ul>
<h6>{this.state.tags.length===0 && "please create a new tag!"}</h6>
</React.Fragment>
);
}
}
export default Counter;
|
'use strict';
module.exports = (sequelize, DataTypes) => {
var isDescendentOf_cache={};
var isAncestorOf_cache={};
var Organization = sequelize.define('Organization', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
},
parentId: {
type: DataTypes.INTEGER,
hierarchy: true
},
name:{type: DataTypes.STRING,allowNull: false},
caption:{type:DataTypes.STRING,allowNull: true},
description: DataTypes.TEXT,
extra: DataTypes.TEXT
}, {
indexes: [
{
unique: true,
fields: ['name']
}
]
});
Organization.associate = function(models) {
// associations can be defined here
Organization.hasMany(models.User, { foreignKey: 'organizationId', sourceKey: 'id', as: 'HasUsers', onDelete: 'CASCADE' });
Organization.hasMany(models.Group, { foreignKey: 'organizationId', sourceKey: 'id', as: 'HasGroups', onDelete: 'CASCADE' });
Organization.hasMany(models.Project, { foreignKey: 'organizationId', sourceKey: 'id', as: 'HasProjects', onDelete: 'CASCADE' });
Organization.belongsTo(models.Map, { as:'DefaultMap',constraints: false , foreignKey: 'defaultMap', targetKey: 'id', as: 'DefaultMap'});
};
Organization.prototype._isDescendentOf = async function (organization) {
if(!organization){
return false;
}
var cacheKey=this.id+'_'+organization.id;
if(typeof isDescendentOf_cache[cacheKey] !=='undefined'){
return isDescendentOf_cache[cacheKey];
}
var result=false;
if(this.parentId==organization.id){
result=true;
}else if( this.parentId== organization.parentId){
result=false;
}else{
result= await this.hasAncestor(organization.id);
}
isDescendentOf_cache[cacheKey]=result;
return result;
};
Organization.prototype._isAncestorOf = async function (organization) {
if(!organization){
return false;
}
var cacheKey=this.id+'_'+organization.id;
if(typeof isAncestorOf_cache[cacheKey] !=='undefined'){
return isAncestorOf_cache[cacheKey];
}
var result=false;
if(this.id==organization.parentId){
result=true;
}else if( this.parentId== organization.parentId){
result=false;
}else{
result= await this.hasDescendent(organization.id);
}
isAncestorOf_cache[cacheKey]=result;
return result;
};
Organization.prototype._isAncestorOfId = async function (organization_Id) {
if(!organization_Id){
return false;
}
var cacheKey=this.id+'_'+organization_Id;
if(typeof isAncestorOf_cache[cacheKey] !=='undefined'){
return isAncestorOf_cache[cacheKey];
}
var result=false;
// if(this.id==organization.parentId){
// result=true;
// }else if( this.parentId== organization.parentId){
// result=false;
// }else{
result= await this.hasDescendent(organization_Id);
//}
isAncestorOf_cache[cacheKey]=result;
return result;
};
return Organization;
};
|
/**
* class to store all blocks and their possible offsets
*
* @author MrXeth
*/
export default class Tetrominos
{
//#region all blocks
static none = {
color: 0x0
}
static ghost = {
color: 0x808B96
}
static i = {
color: 0x85C1E9,
coords: 0x7042
}
static j = {
color: 0x0016FC,
coords: 0x7E41
}
static l = {
color: 0xBA4A00,
coords: 0x7049
}
static o = {
color: 0xF1C40F,
coords: 0x3F1F8
}
static s = {
color: 0x00FC25 ,
coords: 0x8E41
}
static t = {
color: 0x6C3483,
coords: 0x7E08
}
static z = {
color: 0xFC0000,
coords: 0x38049
}
//#endregion
//#region get method
/**
*
* returns the specific block to an id
*
* @param {number} id id of the block
*
* @returns {*} the block
*/
static block(id)
{
switch (id)
{
case 0: return this.none;
case 1: return this.ghost;
case 2: return this.i;
case 3: return this.j;
case 4: return this.l;
case 5: return this.o;
case 6: return this.s;
case 7: return this.t;
case 8: return this.z;
}
}
//#endregion
}
|
'use strict';
angular.module('nameInput', []);
|
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const User = require('../models/user.js');
const usersController = {};
usersController.create = (req, res) => {
const salt = bcrypt.genSaltSync();
const hash = bcrypt.hashSync(req.body.password_digest, salt);
User.findByUserName(req.body.username).then(username => {
if (!username) {
User.findByEmail(req.body.email).then(email => {
if (!email) {
User.createUser({
username: req.body.username,
email: req.body.email,
password_digest: hash
}).then(user => {
res.send(user);
}).catch(error => {
res.status(500).send(error);
});
} else {
res.status(409).send('This email is already registered.');
}
});
} else {
res.status(409).send('This username has already been taken. Please choose another.')
}
});
}
usersController.login = (req, res) => {
User.findByUserName(req.body.username).then(user => {
if (!user) {
res.send('please enter valid username');
} else {
bcrypt.compare(req.body.password, user.password_digest, (err, response) => {
if(response) {
const token = jwt.sign({ id: user.id, username: user.username }, process.env.SESSION_KEY, {
expiresIn: 604800 // 1 WEEK
});
res.send({ token, user });
} else {
res.send('Incorrect username/password combination');
}
});
}
});
}
module.exports = usersController;
|
// Select Elements
// ===============
const wordEl = document.getElementById("word");
const wrongLettersEl = document.getElementById("wrong-letters");
const playAgainBtn = document.getElementById("play-button");
const popup = document.getElementById("popup-container");
const notification = document.getElementById("notification-container");
const finalMessage = document.getElementById("final-message");
const figureParts = document.querySelectorAll(".figure-part");
// Global Variables
// ================
const words = ["application", "programming", "interface", "wizard"];
let selectedWord = words[Math.floor(Math.random() * words.length)];
const correctLetters = []; // start game with empty arrays
const wrongLetters = [];
// EventListeners
// ===============
// Keyboard Input EventListener
// ---------------------------
// 1. check if key input is a letter
// 2. if letter is in word
// a. Check if already tried
// b. Add to Correct Letters Array
// c. Display Letter
// 3. if letter is NOT in word
// a. Add to Wrong Letters Array
// b. update number of Wrong Letters and increase Hangman
window.addEventListener("keydown", (e) => {
console.log(e.key);
if (e.key >= "a" && e.key <= "z") {
const letter = e.key;
if (selectedWord.includes(letter)) {
if (!correctLetters.includes(letter)) {
correctLetters.push(letter);
displayWord();
} else {
showWarningNotification();
}
} else {
if (!wrongLetters.includes(letter)) {
wrongLetters.push(letter);
updateWrongLettersEl();
} else {
showWarningNotification();
}
}
}
});
// Restart Play Button EventListner
// --------------------------------
playAgainBtn.addEventListener("click", () => {
// Empty Arrays
correctLetters.splice(0);
wrongLetters.splice(0);
// Select New RandomWord
selectedWord = words[Math.floor(Math.random() * words.length)];
displayWord(); // Display guess word on Screen
updateWrongLettersEl();
popup.style.display = "none"; // Remove popup with restart button
});
displayWord();
// Functions
// =========
// DisplayWord()
// ------------
// 1. Take Guess word and split into letters
// 2. For each letter in guess word compare with letters in correctLetter Array
// 3. If letter is in, display HTML
// 4. Concaternate all display HTML elements with join()
// Concaternate array elements into a string
// 5. Remove the new lines from the concat string
// 6. Check if all the letters have been guessed -> display msg
function displayWord() {
wordEl.innerHTML = `
${selectedWord
.split("")
.map(
(letter) => `
<span class="letter">
${correctLetters.includes(letter) ? letter : ""}
</span>
`
)
.join("")}`;
const innerWord = wordEl.innerText.replace(/\n/g, "");
console.log(innerWord);
if (innerWord === selectedWord) {
finalMessage.innerText = "Congratulations, Right Answer";
popup.style.display = "flex";
}
}
// updateWrongLettersEl()
// ----------------------
// 1. Display incorrect letter
// 2. Add Parts to Hangman
// 3. Check if run out of guesses
function updateWrongLettersEl() {
// if there are incorrect letters, add Wrong title to innerHTML, and for each letter add to list.
wrongLettersEl.innerHTML = `
${wrongLetters.length > 0 ? "<p>Wrong</p>" : ""}
${wrongLetters.map((letter) => `<span>${letter}</span>`)}
`;
// for each wrong letter, add a part to the hangman
figureParts.forEach((part, index) => {
const errors = wrongLetters.length; // calc the number of incorrect letters
if (index < errors) {
part.style.display = "block"; // display part
} else {
part.style.display = "none"; // do not display part
}
});
// Check if the number of wrong letters = total parts on hangman
if (wrongLetters.length === figureParts.length) {
finalMessage.innerText = "You Lost!";
popup.style.display = "flex";
}
}
// showWarningNotification()
// -------------------------
// Show a warning msg if repeat same letter
function showWarningNotification() {
notification.classList.add("show"); // add show class to Notification element
setTimeout(() => {
notification.classList.remove("show"); // remove msg after 2sec
}, 2000);
}
|
const Messenger = require('../composers/messenger');
const PlayerController = require('../../database/controllers/player.js');
function initializeMessengerEvent(message, client) {
client.sendPacket(new Messenger.InitializeMessengerComposer());
PlayerController.getFriends(client.player.id).then((friends) => {
client.sendPacket(new Messenger.PlayerFriendsComposer(friends));
}).catch((err) => {
console.error(err);
});
}
function requestFriendRequestEvent(message, client) {
client.sendPacket(new Messenger.PlayerFriendRequestsComposer());
}
module.exports.InitializeMessengerEvent = initializeMessengerEvent;
module.exports.RequestFriendRequestEvent = requestFriendRequestEvent;
|
/*
================================
Coder: Emily Yu
Date: 02/11/2019 - 02/23/2019
Main Related Files: textAdventureGame.html, textGameStyle.css
Description:
Text adventure game where player types in instructions to forward the story.
Feature within This Javascript File:
User interface related events are located in this file.
Event listeners include clicking a button or entering an input or closing a modal.
The page is displayed using the render function.
====================================
*/
//"use strict";
function checkBackpack(){
if(backpack == "undefined" || backpack.length === 0){
outputItem.innerHTML = "";
}else{
outputItem.innerHTML = "You find " + backpack.join(", ") + " in your backpack.";
}
}
function saveGame(){
let saveLocation = mapLocation;
let saveItems = JSON.stringify(itemsToTake);
let saveBackpack = JSON.stringify(backpack);
let saveMagic = JSON.stringify(magic);
let saveGameWorldItems = JSON.stringify(items);
let saveGameItemsLocation = JSON.stringify(itemsLocation);
localStorage.setItem("location", saveLocation);
localStorage.setItem("item", saveItems);
localStorage.setItem("backpack", saveBackpack);
localStorage.setItem("magic", saveMagic);//in case the player saves the progress at the end of game
localStorage.setItem("inWorldItems", saveGameWorldItems);//to track items that have already materialized in game but are not initialized in game
localStorage.setItem("inWorldItemsLocation", saveGameItemsLocation);//to track items that have already materialized in game but are not initialized in game
//since localStorage is not empty, enable the restore button
restoreButton.disabled = false;
}
function disableRestore(){
restoreButton.disabled = true;
//if localStorage is not empty, enable the restore button
if(localStorage.length !== 0){
restoreButton.disabled = false;
}
}
function restoreGame(){
//even if mapLocation has not gone through JSON.stringify, need to remember to parse the value, or else the script will treat it as a string and this will cause an error
mapLocation = JSON.parse(localStorage.getItem("location"));
itemsToTake = JSON.parse(localStorage.getItem("inWorldItem"));
backpack = JSON.parse(localStorage.getItem("backpack"));
magic = JSON.parse(localStorage.getItem("magic"));//in case the player saves the progress at the end of game
items = JSON.parse(localStorage.getItem("inWorldItems"));
itemsLocation = JSON.parse(localStorage.getItem("inWorldItemsLocation"));
//console.log(itemsToTake);
checkBackpack();
//I don't use the render() here to prevent from showing the wrong game messages and I don't want to adjust the render() since the messages are taken care of by other methods
mapImage.src = "../img/" + images[mapLocation];
outputMap.innerHTML = "You are currently at: " + map[mapLocation];
outputGame.innerHTML = game[mapLocation];
}
function endGame(){
outputItem.innerHTML = "You wind the clock using the key to match the time on the watch and ....<br><br><br>Masters of Magic!!! You've been teleported to a secret room!!!";
magic = true;
mapLocation = 3;
enterButton.removeEventListener("click", gameAction, false);//prevent the player from entering input again
window.removeEventListener("keydown", keydownHandler, false);//prevent the player from entering input again
}
function restartGame(){
localStorage.clear();
//even though the storage is cleared, things are not set to their initialized state so here's a repeat of the items which might be written as a object/function in a future version
backpack = [];
magic = false;
items = ["glass", "mirror", "book", "spectacles", "mat", "chair", "clock", "stool", "movie"];
itemsLocation = [0, 1, 4, 4, 5, 6, 7, 8, 10]
itemsToTake = ["glass", "mirror", "book", "spectacles"];
//restart game with mapLocation at 5
mapLocation = 5;
outputGame.innerHTML = game[5];
outputItem.innerHTML = "";
//disable the restore button
disableRestore();
render();
}
function render(){
//an attempt to access the secret room forces the player to start journey at mapLocation[5] again
if(mapLocation == 3 && magic == false){
mapLocation = 5;
mapImage.src = "../img/" + images[mapLocation];
outputMap.innerHTML = "You are currently at: " + map[mapLocation];
outputGame.innerHTML = "I'm sorry. You breached into something that is forbidden. You're not <em>there<em> yet.";
}else{
mapImage.src = "../img/" + images[mapLocation];
outputMap.innerHTML = "You are currently at: " + map[mapLocation];
}
happen.value = "";//reset input value to blank and allow player to conveniently type stuff in again
}
function keydownHandler(e){
//press enter to start game
if(e.keyCode === 13){
gameAction();
}
}
let mapLocation = 5;
outputGame.innerHTML = game[5];
//wait till the window loads to render the game
window.addEventListener("load", render, false);
let enterButton = document.getElementById("enter");
enterButton.addEventListener("click", gameAction, false);
window.addEventListener("keydown", keydownHandler, false);
//toggle cheat sheet to display
let displayCS = document.getElementById("cheatSheet");
let cheatContent = document.getElementById("cheatContent");
displayCS.addEventListener("click", () => {if(cheatContent.style.display === "block"){cheatContent.style.display = "none"}else{cheatContent.style.display = "block"};}, false)
//check backpack
let checkBP = document.getElementById("backpackCheck");
checkBP.addEventListener("click", checkBackpack, false);
let saveButton = document.getElementById("save");
let restoreButton = document.getElementById("restore");
let restartButton = document.getElementById("restart");
//to prevent the player from clicking on the restore button with no saved game, check for whether to disable the button once the page is loaded
window.addEventListener("load", disableRestore, false);
//check if browser supports local storage
if(typeof(Storage) !== "undefined"){
saveButton.addEventListener("click", saveGame, false);
restoreButton.addEventListener("click", restoreGame, false);//since button is disabled, I'll add the event listener here instead of adding it when the button is enabled
restartButton.addEventListener("click", restartGame, false);
}else{
//do nothing
}
let gameplayButton = document.getElementById("gameplay");//target gameplay walkthrough button
let modalIntro = document.getElementById("modalIntro");
let closeModal = document.getElementById("close");
let modalGamePlay = document.getElementById("modalGamePlay");
let closeModalTwo = document.getElementById("closeTwo");
closeModal.addEventListener("click", () => {modalIntro.style.display = "none";}, false);
window.addEventListener("click", () => {if(event.target == modalIntro){modalIntro.style.display = "none";}}, false);//closes the modal by clicking anywhere on the page (which is within the area of the modal)
gameplayButton.addEventListener("click", () => {modalGamePlay.style.display = "block";}, false);
closeModalTwo.addEventListener("click", () => {modalGamePlay.style.display = "none";}, false);
window.addEventListener("click", () => {if(event.target == modalGamePlay){modalGamePlay.style.display = "none";}}, false);//closes the modal by clicking anywhere on the page (which is within the area of the modal)
|
require('colors/safe')
|
/**
* Created by woody on 2015/11/10.
*/
angular.module('myapp').factory('JumpUtil', ['$rootScope','$state','$ionicViewSwitcher',function($rootScope,$state,$ionicViewSwitcher){
var alertRes = {
addBackInfo : function(data){
$rootScope.barkInfoArray[$rootScope.barkInfoArray.length]=data;
},
goBackFun : function(){
$ionicViewSwitcher.nextDirection('back');
//$ionicViewSwitcher.nextTransition('ios');//造成卡顿所以注销掉
var index=$rootScope.barkInfoArray.length-1;
var path=$rootScope.barkInfoArray[index].data.backUrl;
var param=$rootScope.barkInfoArray[index]
$rootScope.barkInfoArray.pop();
if(param.data.level == 1)
{
$state.go(path);
}
else
{
$state.go(path,param);
}
},
goFun : function(data){
//console.log("result="+JSON.stringify(data));
$ionicViewSwitcher.nextDirection('forward');
//$ionicViewSwitcher.nextTransition('ios');
alertRes.addBackInfo(data.backData);
if(data.gotoData.param == undefined)
{
$state.go(data.gotoData.url);
}
else
{
$state.go(data.gotoData.url,data.gotoData.param);
}
}
};
return alertRes;
}]);
//修改编码
|
$(document).ready(function () {
$('.elemento').resizable();
});
|
/*
Requires manual maintanance
Groups different Agent status Reasons, used to sort agent statuses & give a color (components/AgentSection/)
*/
const free = ['Login', 'Sisäänkirjaus']
const call = ['JÄLKIKIRJAUS', 'PUHELU (Sisään)', 'PUHELU (Ulos)', 'SÄHKÖPOSTI (Sisään)', 'SÄHKÖPOSTI (Ulos)', 'WRAPUP TIME', 'CALL (In)', 'CALL (Out)']
export default {call, free}
|
var marker1, marker2, marker3, marker4;
var poly, geodesicPoly;
function initMap() {
var map = new google.maps.Map(document.getElementById('map'), {
zoom: 12
, center: {
lat: 9.9656553
, lng: -84.1201701
}
});
map.controls[google.maps.ControlPosition.TOP_CENTER].push(
document.getElementById('info'));
}
|
import {createContainer} from '../addEditPageContainer';
import showDialog from '../../../../standard-business/showDialog';
import helper,{fetchJson} from '../../../../common/common';
const URL_ADD_CONFIG = '/api/basic/defaultOutput/reciversConfig';
// 为EditDialog组件构建状态
const buildEditDialogState = (config,tableItems =[],index,type) => {
return {
title: "设置接受信息",
...config,
tableCols:config[type],
tableItems: tableItems,
index
};
};
const addDriver = async (tableItems,index,type) => {
try {
tableItems = tableItems ? JSON.parse(tableItems) : [];
const config = await fetchJson(URL_ADD_CONFIG);
const payload = buildEditDialogState(config.result, tableItems,index,type);
showDialog(createContainer, payload);
} catch(e) {
helper.showError(e.message);
}
};
export default addDriver;
|
/* 🤖 this file was generated by svg-to-ts*/
export const EOSIconsLocalBar = {
name: 'local_bar',
data: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M21 5V3H3v2l8 9v5H6v2h12v-2h-5v-5l8-9zM7.43 7L5.66 5h12.69l-1.78 2H7.43z"/></svg>`
};
|
var args = process.argv;
console.log(args[2]);
|
const studants = [
{ name: 'Anna', grade:6 },
{ name: 'John', grade:4 },
{ name: 'Maria', grade:9 }
]
const isApproved = student => student.grade >= 9
const approvedStudents = students.filter(isApproved)
|
const {mysql} = require('../qcloud');
module.exports = async ctx => {
const {id} = ctx.request.query;
ctx.state.data = await mysql('books').select().where('id', id).first();
await mysql('books').where('id', id).increment('count', 1);
};
|
import React from 'react';
const ResumeLink = React.forwardRef((props, ref) => (
<a href="../pdf/files/ResumeMWills.pdf"></a>
))
export default ResumeLink;
|
import React from 'react';
import './App.css';
import axios from 'axios';
import { useEffect } from 'react';
import { useState } from 'react';
import {BrowserRouter as Router, Route, Switch} from 'react-router-dom';
import SharedQuote from './SharedQuote';
import ShareButton from './ShareButton'
export default function App() {
const [advice, setAdvice] = useState([])
const fetchAdvice = () => {
axios.get('https://api.adviceslip.com/advice')
.then( (res) => {
const {advice} = res.data.slip;
setAdvice(advice) //set the state of app component to fetched value
})
.catch( (error) => {
console.log(error);
})
};
useEffect(() => {
fetchAdvice();
}, []);
return (
<Router>
<Switch>
<Route exact path="/">
<div className="app">
<div className="card">
<h2 className="heading">{advice}</h2>
<button onClick={fetchAdvice} className="button">
<span className="span">Another one</span>
</button>
<ShareButton advice={advice} /> {/* Should set a link and display it on click either with a modal or simply below*/}
</div>
</div>
</Route>
<Route path="/shared/:id">
<SharedQuote />
</Route>
</Switch>
</Router>
)
}
|
"use strict";
var request = require('request');
var assert = require('assert');
var fs = require('fs');
var common = require('../../common');
var csMock = require('../mock/customerSuccess');
var customerMock = require('../mock/customerSession');
var baseUrl = common.baseUrl;
var localUrl = common.localUrl;
describe('middleware', function () {
var cid, csid, mid;
before(function (done) {
csMock.create(function (res) {
var data = JSON.parse(res.body);
csid = data.msg.csid;
done();
});
});
before(function (done) {
customerMock.create(function (res) {
var customer = JSON.parse(res.body);
cid = customer.msg.cid;
done();
});
});
after(function (done) {
csMock.delete(csid, done);
});
after(function (done) {
customerMock.delete(cid, done);
});
describe('#cros', function () {
describe('##POST /messages/customer/:cid/cs/:csid/image', function () {
describe(baseUrl, function () {
it('should response with success', function (done) {
var formData = {
// Pass data via Streams
image: fs.createReadStream(__dirname + '/../../../client/static/images/contact.png')
};
request.post({
url: baseUrl + '/messages/customer/' + cid + '/cs/' + csid + '/image',
headers:{
referer: baseUrl
},
formData: formData
}, function (err, res) {
assert.ifError(err);
var message = JSON.parse(res.body);
assert.equal(message.code, 2001);
done();
});
});
});
describe(localUrl, function () {
it('should response with success', function (done) {
var formData = {
// Pass data via Streams
image: fs.createReadStream(__dirname + '/../../../client/static/images/contact.png')
};
request.post({
url: localUrl + '/messages/customer/' + cid + '/cs/' + csid + '/image',
headers:{
referer: localUrl
},
formData: formData
}, function (err, res) {
assert.ifError(err);
var message = JSON.parse(res.body);
assert.equal(message.code, 200);
done();
});
});
});
});
});
});
|
module.exports = {
singlePortrait: require('./single-portrait')
}
|
/* See license.txt for terms of usage */
/*global define:1*/
define([
"firebug/firebug",
"firebug/lib/trace",
"firebug/lib/array",
"firebug/lib/css",
"firebug/lib/dom",
"firebug/lib/domplate",
"firebug/lib/events",
"firebug/lib/locale",
"firebug/lib/object",
"firebug/lib/persist",
"firebug/lib/xpath",
"firebug/chrome/module",
"firebug/chrome/rep",
"firebug/debugger/breakpoints/breakpointGroup",
"firebug/html/htmlReps",
],
function(Firebug, FBTrace, Arr, Css, Dom, Domplate, Events, Locale, Obj, Persist, Xpath,
Module, Rep, BreakpointGroup, HTMLReps) {
"use strict";
// ********************************************************************************************* //
// Constants
var {domplate, TAG, DIV, SPAN, INPUT} = Domplate;
var BP_BREAKONATTRCHANGE = 1;
var BP_BREAKONCHILDCHANGE = 2;
var BP_BREAKONREMOVE = 3;
var BP_BREAKONTEXT = 4;
var TraceError = FBTrace.toError();
var Trace = FBTrace.to("DBG_HTMLMODULE");
// ********************************************************************************************* //
// HTMLModule
/**
* @module
*/
var HTMLModule = Obj.extend(Module,
/** @lends HTMLModule */
{
dispatchName: "htmlModule",
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Initialization
initialize: function(prefDomain, prefNames)
{
Module.initialize.apply(this, arguments);
Firebug.connection.addListener(this.DebuggerListener);
},
shutdown: function()
{
Module.shutdown.apply(this, arguments);
Firebug.connection.removeListener(this.DebuggerListener);
},
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
initContext: function(context, persistedState)
{
Module.initContext.apply(this, arguments);
context.mutationBreakpoints = new MutationBreakpointGroup(context);
},
loadedContext: function(context, persistedState)
{
context.mutationBreakpoints.load(context);
},
destroyContext: function(context, persistedState)
{
Module.destroyContext.apply(this, arguments);
context.mutationBreakpoints.store(context);
},
deleteNode: function(node, context)
{
Events.dispatch(this.fbListeners, "onBeginFirebugChange", [node, context]);
node.parentNode.removeChild(node);
Events.dispatch(this.fbListeners, "onEndFirebugChange", [node, context]);
},
deleteAttribute: function(node, attr, context)
{
Events.dispatch(this.fbListeners, "onBeginFirebugChange", [node, context]);
node.removeAttribute(attr);
Events.dispatch(this.fbListeners, "onEndFirebugChange", [node, context]);
}
});
// ********************************************************************************************* //
// Mutation Breakpoints
/**
* @class Represents {@link Firebug.Debugger} listener. This listener is reponsible for
* providing a list of mutation-breakpoints into the Breakpoints side-panel.
*/
HTMLModule.DebuggerListener =
{
getBreakpoints: function(context, groups)
{
if (!context.mutationBreakpoints.isEmpty())
groups.push(context.mutationBreakpoints);
}
};
HTMLModule.MutationBreakpoints =
{
breakOnNext: function(context, breaking)
{
context.breakOnNextMutate = breaking;
},
breakOnNextMutate: function(event, context, type)
{
if (!context.breakOnNextMutate)
return false;
// Ignore changes in ignored branches
if (isAncestorIgnored(event.target))
return false;
context.breakOnNextMutate = false;
this.breakWithCause(event, context, type);
},
breakWithCause: function(event, context, type)
{
var changeLabel = HTMLModule.BreakpointRep.getChangeLabel({type: type});
context.breakingCause = {
title: Locale.$STR("html.Break On Mutate"),
message: changeLabel,
type: event.type,
target: event.target,
relatedNode: event.relatedNode, // http://www.w3.org/TR/DOM-Level-2-Events/events.html
prevValue: event.prevValue,
newValue: event.newValue,
attrName: event.attrName,
attrChange: event.attrChange,
};
Trace.sysout("htmlModule.breakWithCause;", context.breakingCause);
Firebug.Breakpoint.breakNow(context.getPanel("html", true));
return true;
},
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Mutation event handlers.
onMutateAttr: function(event, context)
{
if (this.breakOnNextMutate(event, context, BP_BREAKONATTRCHANGE))
return;
var breakpoints = context.mutationBreakpoints;
var self = this;
breakpoints.enumerateBreakpoints(function(bp)
{
if (bp.checked && bp.node == event.target && bp.type == BP_BREAKONATTRCHANGE)
{
self.breakWithCause(event, context, BP_BREAKONATTRCHANGE);
return true;
}
});
},
onMutateText: function(event, context)
{
if (this.breakOnNextMutate(event, context, BP_BREAKONTEXT))
return;
},
onMutateNode: function(event, context)
{
var node = event.target;
var removal = event.type == "DOMNodeRemoved";
if (this.breakOnNextMutate(event, context, removal ?
BP_BREAKONREMOVE : BP_BREAKONCHILDCHANGE))
{
return;
}
var breakpoints = context.mutationBreakpoints;
var breaked = false;
var self = this;
if (removal)
{
breaked = breakpoints.enumerateBreakpoints(function(bp)
{
if (bp.checked && bp.node == node && bp.type == BP_BREAKONREMOVE)
{
self.breakWithCause(event, context, BP_BREAKONREMOVE);
return true;
}
});
}
if (!breaked)
{
// Collect all parents of the mutated node.
var parents = [];
for (var parent = node.parentNode; parent; parent = parent.parentNode)
parents.push(parent);
// Iterate over all parents and see if some of them has a breakpoint.
breakpoints.enumerateBreakpoints(function(bp)
{
for (var i=0; i<parents.length; i++)
{
if (bp.checked && bp.node == parents[i] && bp.type == BP_BREAKONCHILDCHANGE)
{
self.breakWithCause(event, context, BP_BREAKONCHILDCHANGE);
return true;
}
}
});
}
if (removal)
{
// Remove all breakpoints associated with removed node.
var invalidate = false;
breakpoints.enumerateBreakpoints(function(bp)
{
if (bp.node == node)
{
breakpoints.removeBreakpoint(bp);
invalidate = true;
}
});
if (invalidate)
context.invalidatePanels("breakpoints");
}
},
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Context menu items
getContextMenuItems: function(context, node, target, items)
{
if (!(node && node.nodeType == Node.ELEMENT_NODE))
return;
var breakpoints = context.mutationBreakpoints;
var attrBox = Dom.getAncestorByClass(target, "nodeAttr");
if (Dom.getAncestorByClass(target, "nodeAttr"))
{
}
if (!(Css.nonEditableTags.hasOwnProperty(node.localName)))
{
items.push(
"-",
{
label: "html.label.Break_On_Attribute_Change",
tooltiptext: "html.tip.Break_On_Attribute_Change",
type: "checkbox",
checked: breakpoints.findBreakpoint(node, BP_BREAKONATTRCHANGE),
command: Obj.bindFixed(this.onModifyBreakpoint, this, context, node,
BP_BREAKONATTRCHANGE)
},
{
label: "html.label.Break_On_Child_Addition_or_Removal",
tooltiptext: "html.tip.Break_On_Child_Addition_or_Removal",
type: "checkbox",
checked: breakpoints.findBreakpoint(node, BP_BREAKONCHILDCHANGE),
command: Obj.bindFixed(this.onModifyBreakpoint, this, context, node,
BP_BREAKONCHILDCHANGE)
},
{
label: "html.label.Break_On_Element_Removal",
tooltiptext: "html.tip.Break_On_Element_Removal",
type: "checkbox",
checked: breakpoints.findBreakpoint(node, BP_BREAKONREMOVE),
command: Obj.bindFixed(this.onModifyBreakpoint, this, context, node,
BP_BREAKONREMOVE)
}
);
}
},
onModifyBreakpoint: function(context, node, type)
{
var xpath = Xpath.getElementXPath(node);
Trace.sysout("html.onModifyBreakpoint " + xpath);
var breakpoints = context.mutationBreakpoints;
var bp = breakpoints.findBreakpoint(node, type);
// Remove an existing or create new breakpoint.
if (bp)
breakpoints.removeBreakpoint(bp);
else
breakpoints.addBreakpoint(node, type);
Events.dispatch(HTMLModule.fbListeners, "onModifyBreakpoint",
[context, xpath, type]);
}
};
HTMLModule.Breakpoint = function(node, type)
{
this.node = node;
this.xpath = Xpath.getElementXPath(node);
this.checked = true;
this.type = type;
};
HTMLModule.BreakpointRep = domplate(Rep,
{
inspectable: false,
tag:
DIV({"class": "breakpointRow focusRow", $disabled: "$bp|isDisabled", _repObject: "$bp",
role: "option", "aria-checked": "$bp.checked"},
DIV({"class": "breakpointBlockHead"},
INPUT({"class": "breakpointCheckbox", type: "checkbox",
_checked: "$bp.checked", tabindex: "-1", onclick: "$onEnable"}),
TAG("$bp.node|getNodeTag", {object: "$bp.node"}),
DIV({"class": "breakpointMutationType"}, "$bp|getChangeLabel"),
SPAN({"class": "closeButton", onclick: "$onRemove"})
),
DIV({"class": "breakpointCode"},
TAG("$bp.node|getSourceLine", {object: "$bp.node"})
)
),
getNodeTag: function(node)
{
var rep = Firebug.getRep(node, Firebug.currentContext);
return rep.shortTag ? rep.shortTag : rep.tag;
},
getSourceLine: function(node)
{
return HTMLReps.getNodeTag(node, false);
},
getChangeLabel: function(bp)
{
switch (bp.type)
{
case BP_BREAKONATTRCHANGE:
return Locale.$STR("html.label.Break On Attribute Change");
case BP_BREAKONCHILDCHANGE:
return Locale.$STR("html.label.Break On Child Addition or Removal");
case BP_BREAKONREMOVE:
return Locale.$STR("html.label.Break On Element Removal");
case BP_BREAKONTEXT:
return Locale.$STR("html.label.Break On Text Change");
}
return "";
},
isDisabled: function(bp)
{
return !bp.checked;
},
onRemove: function(event)
{
Events.cancelEvent(event);
var bpPanel = Firebug.getElementPanel(event.target);
var context = bpPanel.context;
if (Css.hasClass(event.target, "closeButton"))
{
// Remove from list of breakpoints.
var row = Dom.getAncestorByClass(event.target, "breakpointRow");
context.mutationBreakpoints.removeBreakpoint(row.repObject);
bpPanel.refresh();
}
},
onEnable: function(event)
{
var checkBox = event.target;
var bpRow = Dom.getAncestorByClass(checkBox, "breakpointRow");
if (checkBox.checked)
{
Css.removeClass(bpRow, "disabled");
bpRow.setAttribute("aria-checked", "true");
}
else
{
Css.setClass(bpRow, "disabled");
bpRow.setAttribute("aria-checked", "false");
}
var bp = bpRow.repObject;
bp.checked = checkBox.checked;
var bpPanel = Firebug.getElementPanel(event.target);
var context = bpPanel.context;
context.mutationBreakpoints.updateListeners();
},
supportsObject: function(object, type)
{
return object instanceof HTMLModule.Breakpoint;
}
});
// ********************************************************************************************* //
function MutationBreakpointGroup(context)
{
this.breakpoints = [];
this.context = context;
}
MutationBreakpointGroup.prototype = Obj.extend(new BreakpointGroup(),
{
name: "mutationBreakpoints",
title: Locale.$STR("html.label.HTML Breakpoints"),
addBreakpoint: function(node, type)
{
this.breakpoints.push(new HTMLModule.Breakpoint(node, type));
this.updateListeners();
},
matchBreakpoint: function(bp, args)
{
var node = args[0];
var type = args[1];
return (bp.node == node) && (!bp.type || bp.type == type);
},
removeBreakpoint: function(bp)
{
Arr.remove(this.breakpoints, bp);
this.updateListeners();
},
hasEnabledBreakpoints: function()
{
return this.breakpoints.some(function(bp)
{
return bp.checked;
});
},
updateListeners: function()
{
var htmlPanel = this.context.getPanel("html");
htmlPanel.updateMutationBreakpointListeners();
},
// Persistence
load: function(context)
{
var panelState = Persist.getPersistedState(context, "html");
if (panelState.breakpoints)
this.breakpoints = panelState.breakpoints;
this.enumerateBreakpoints(function(bp)
{
var elts = Xpath.getElementsByXPath(context.window.document, bp.xpath);
bp.node = elts && elts.length ? elts[0] : null;
});
this.updateListeners();
},
store: function(context)
{
this.enumerateBreakpoints(function(bp)
{
bp.node = null;
});
var panelState = Persist.getPersistedState(context, "html");
panelState.breakpoints = this.breakpoints;
},
});
function isAncestorIgnored(node)
{
for (var parent = node; parent; parent = parent.parentNode)
{
if (Firebug.shouldIgnore(parent))
return true;
}
return false;
}
// ********************************************************************************************* //
// Registration
// Backwards compatibility
HTMLModule.SourceText = HTMLReps.SourceText;
Firebug.HTMLModule = HTMLModule;
Firebug.registerModule(HTMLModule);
Firebug.registerRep(HTMLModule.BreakpointRep);
return HTMLModule;
// ********************************************************************************************* //
});
|
import React from "react";
import { storiesOf } from "@storybook/react";
import { withKnobs } from "@storybook/addon-knobs";
import { getStoryName } from "storybook/storyTree";
import A11yStory from "./examples/test/A11y";
import ScreenerStory from "./examples/test/Screener";
import ShowcaseStory from "./examples/Showcase";
import * as Select from "./examples/Basic";
const storyName = getStoryName("Select");
storiesOf(storyName, module)
.addDecorator(withKnobs)
.add("Showcase", ShowcaseStory);
storiesOf(`${storyName}/Examples`, module)
.add("With Selected Option", () => <Select.WithSelectedOption />)
.add("With isDisabled", () => <Select.DisableSelect />)
.add("With isReadOnly", () => <Select.ReadOnlySelect />)
.add("With hasError", () => <Select.HasErrorSelect />);
storiesOf(`${storyName}/Backyard/Tests`, module)
.add("Screener", () => <ScreenerStory />)
.add("Accessibility", () => <A11yStory />);
|
function validate(field, regex) {
if (regex.test(field.value)) {
field.className = 'form-control valid';
} else {
field.className = 'form-control invalid';
}
}
function validateInputs(inputs, patterns) {
let valid = true;
inputs.forEach((input) => {
let regex = patterns[input.attributes.id.value];
if (regex.test(input.value) == false) {
input.className = 'form-control invalid';
if (valid == true) {
document.getElementById(input.attributes.id.value).focus();
}
valid = false;
}
});
return valid;
}
|
const Report = require('../models').Report;
const create = async function (req, res) {
const body = req.body;
try {
if(!body){
return ReS(res, 'Bad request', 400);
}else {
let objReport = await Report.findOne({idReporter:body.idReporter, idPersonBeingReported: body.idPersonBeingReported});
if(objReport){
objReport.set(body);
let isSuccess = await objReport.save();
if(isSuccess){
return ReS(res, {message: 'Gửi báo cáo thành công',isSuccess:true }, 200);
}
else {
return ReS(res, {message: 'Gửi báo cáo không thành công',isSuccess:false }, 200);
}
}
else {
let objReport = new Report({
idReporter: body.idReporter,
idPersonBeingReported: body.idPersonBeingReported,
reason: body.reason
});
let isSuccess = await objReport.save();
if(isSuccess){
return ReS(res, {message: 'Gửi báo cáo thành công',isSuccess:true }, 200);
}
else {
return ReS(res, {message: 'Gửi báo cáo không thành công',isSuccess:false }, 200);
}
}
}
}
catch (e) {
}
};
module.exports.create = create;
const get = async function (req, res) {
try {
Report.find({
status: false
}, function (err, listReport) {
if(err){
return ReS(res, {message:'Not found report'}, 404);
}
return ReS(res, {message: 'Tải danh sách báo cáo thành công',listReport:listReport }, 200);
});
}
catch (e) {
return ReS(res, {message:'Tải danh sách báo cáo không thành công'}, 503);
}
};
module.exports.get = get;
const updateReportDoctorProcessing = async function (req, res) {
try {
if(req.params.id){
let objReport = await Report.findById({_id:req.params.id});
if(objReport){
objReport.set({status:true});
let objReportReturn = await objReport.save();
if(objReportReturn){
return ReS(res, {message: 'Xử lý báo cáo thành công',objReportReturn:objReportReturn }, 200);
}
else {
return ReS(res, {message: 'Xử lý báo cáo không thành công'}, 503);
}
}
else {
return ReS(res, {message: 'Xử lý báo cáo không thành công'}, 503);
}
}
else {
return ReS(res, {message: 'BAD REQUEST'}, 503);
}
}
catch (e) {
return ReS(res, {message: 'Xử lý báo cáo không thành công'}, 503);
}
};
module.exports.updateReportDoctorProcessing = updateReportDoctorProcessing;
|
'use strict';
var Ticks = function(newWorld) {
var mudSecLen = newWorld.config.mudMinute;
var previousTick = Date.now()
var ticks = this;
var gameLoop = function() {
var now = Date.now();
if (previousTick + mudSecLen <= now) {
previousTick = now
ticks.gameTime(newWorld);
}
if (Date.now() - previousTick < mudSecLen - 16) {
setTimeout(gameLoop)
} else {
setImmediate(gameLoop)
}
}
gameLoop();
}
Ticks.prototype.gameTime = function(World, runCombatLoop) {
var timeMsgs = [{
/*
{
msg: '',
area: '' (falsey is all areas),
awake: true (must be awake),
outdoor: false (must be outdoors)
filter: (entity) -> return true
}
*/
}];
var areaMsg;
World.time.minute += 1;
if (World.time.minute === 60) {
World.time.minute = 1;
World.time.hour += 1;
}
if (World.time.hour === World.time.month.hoursInDay) {
World.time.hour = 1;
World.time.day += 1;
World.time.month.day += 1;
}
if (World.time.hour === World.time.month.hourOfLight && World.time.minute === 1) {
World.time.isDay = true;
areaMsg = 'The sun appears over the horizon.';
} else if (World.time.hour === World.time.month.hourOfNight && World.time.minute === 1) {
World.time.isDay = false;
areaMsg = 'The sun fades fully from view as night falls.';
}
if (World.time.month.day > World.time.month.days) {
World.time.month = World.time.months[0];
}
if (World.cmds.length) {
this.cmdLoop(World);
}
// combat loop and wait reduction
if (World.battleLock === 0) {
var i = 0;
var battles = [...World.battles];
var canRunExisting = (World.time.minute % 9) === 0;
World.battleLock = battles.length;
for (i; i < battles.length; i += 1) {
if (World.combat.getNumberOfOpenBattlePositions(battles[i]) > 0) {
// any battleObj on its initial round is ran immediately
if (canRunExisting || battles[i].round === 0 || runCombatLoop) {
World.combat.round(battles[i]);
}
// TODO: round callback for immediate cleanup?
} else {
World.combat.removeBattle(battles[i]);
}
if (World.battleLock > 0) {
World.battleLock -= 1;
}
}
// TODO: extend wait state reduction to all game entites
if (canRunExisting) {
i = 0;
for (i; i < World.players.length; i += 1) {
var player = World.players[i];
if (!player.fighting && (player.position === 'sleeping' ||
player.position === 'resting' || player.position === 'standing')) {
World.character.changeWait(player, -1);
}
}
}
}
// ai loop
if ((World.time.minute % 4) === 0) {
var i = 0;
var j = 0;
var k = 0;
var area;
var players;
var roomObj;
if (!World.aiLock) {
World.aiLock = true;
for (i; i < World.areas.length; i += 1) {
area = World.areas[i];
players = World.getAllPlayersFromArea(area);
if (players.length || area.runOnAliveWhenEmpty) {
j = 0;
for (j; j < area.rooms.length; j += 1) {
roomObj = area.rooms[j];
k = 0;
for (k; k < roomObj.monsters.length; k += 1) {
if ((area.runOnAliveWhenEmpty || players.length)
|| (roomObj.monsters[k].originatingArea !== area.id)) {
if (roomObj.monsters[k].chp >= 1 && (roomObj.monsters[k].runOnAliveWhenEmpty || roomObj.playersInRoom.length)) {
World.processEvents('onAlive', roomObj.monsters[k], roomObj);
}
}
}
}
j = 0;
for (j; j < players.length; j += 1) {
roomObj = World.getRoomObject(World.areas[i], players[j].roomid);
if (players[j].chp >= 1) {
World.processEvents('onAlive', players[j], roomObj);
}
// Chance of trigger character save
if (players[j].position === 'standing' && !players[j].fighting && World.dice.roll(1, 100) >= 99) {
World.character.save(players[j]);
}
}
}
}
World.aiLock = false;
}
}
// hunger, thirst
if ((World.time.hour % 8) === 0 && World.time.minute === 30) {
this.hungerThirstLoop(World);
}
if (areaMsg) {
var i = 0;
for (i; i < World.areas.length; i += 1) {
roomCnt = World.areas[i].rooms.length;
if (roomCnt) {
j = 0;
for (j; j < roomCnt; j += 1) {
World.msgRoom(World.areas[i].rooms[j], {
msg: areaMsg,
styleClass: 'warning'
});
}
}
}
}
// general game alerts
var alerts = [
'Use HELP COMMANDS to see a list of the most common commands.',
'Use the SCAN command to get a quick look at the rooms adjacent to you.',
'If you need to make some money try selling some furs and venison from the elks north of camp. You will need to learn how to SKIN animals first.',
'Save your character with the <strong>save</strong> command.',
'The <strong>say</strong> command is used when you want to send a message to everyone in your current room.',
'You can see an items required level before picking it up!',
'Use the QUEST command to see your current quests.',
'RockMUD skills are dynamic. You can obtain and use skills beyond those of your core class.'
];
if (World.players.length && ((World.time.hour % 15) === 0) && World.time.minute === 1) {
if (World.dice.roll(1, 2) === 1) {
World.msgWorld({
msg: '<span><label class="red">Tip</label>: <span class="alertmsg"> '
+ alerts[World.dice.roll(1, alerts.length) - 1] + '</span></span>'
});
}
}
// decay
if ((World.time.hour % 10) === 0 && World.time.minute === 1) {
var i = 0;
var j;
var mobs;
var rooms;
var roomCnt;
var processItemDecay = function(obj) {
var j = 0,
decayMsg,
lightFlickerMsg,
lightDecayMsg,
item;
for (j; j < obj.items.length; j += 1) {
item = obj.items[j];
// Roll a dice to slow down decay for items found in player inventories
if (item.decay >= 0 && World.dice.roll(1, 20) > 15) {
if (item.decay && item.decay >= 1) {
item.decay -= 1;
// Level reduction for rotting corpses
if (obj.itemType === 'corpse' && obj.level >= 2) {
obj.level -= 1;
}
} else if (item.decay === 0) {
obj.items.splice(j, 1);
if (!item.decayMsg) {
decayMsg = item.short + ' rots into nothing.';
} else {
decayMsg = item.short + ' ' + item.decayMsg;
}
if (obj.playersInRoom) {
World.msgRoom(obj, {
msg: decayMsg,
styleClass: 'blue'
});
} else if (obj.isPlayer) {
World.msgPlayer(obj, {
msg: decayMsg,
styleClass: 'blue'
});
}
}
}
// light decay
if (item.equipped && item.light && item.decayLight !== -1) {
if (item.lightDecay >= 1) {
item.lightDecay -= 1;
if (World.dice.roll(1, 4) >= 2 && item.lightDecay !== 1) {
if (!item.lightFlickerMsg) {
lightFlickerMsg = 'The light from ' + item.short +' flickers.';
} else {
lightFlickerMsg = item.displayName + ' ' + item.lightFlickerMsg;
}
World.msgPlayer(obj, {
msg: lightFlickerMsg,
styleClass: 'yellow'
});
}
} else if (item.lightDecay === 0) {
if (!item.lightDecayMsg) {
lightDecayMsg = 'The light from ' + item.short +' goes out!';
} else {
lightDecayMsg = item.displayName + ' ' + item.lightDecayMsg;
}
World.msgPlayer(obj, {
msg: lightDecayMsg,
className: 'yellow'
});
}
}
}
};
// decay player items
if (World.dice.roll(1, 20) < 15) {
if (World.players.length > 0) {
for (i; i < World.players.length; i += 1) {
if (World.players[i].items.length) {
processItemDecay(World.players[i]);
}
}
}
}
// decay room items
if (World.dice.roll(1, 20) < 18) {
i = 0;
for (i; i < World.areas.length; i += 1) {
roomCnt = World.areas[i].rooms.length;
if (roomCnt) {
j = 0;
for (j; j < roomCnt; j += 1) {
if (!World.areas[i].rooms[j].preventDecay && World.areas[i].rooms[j].items.length) {
processItemDecay(World.areas[i].rooms[j]);
}
}
}
}
}
// decay mob items
if (World.dice.roll(1, 20) < 10) {
if (World.players.length > 0) {
i = 0;
for (i; i < World.areas.length; i += 1) {
mobs = World.getAllMonstersFromArea(World.areas[i]);
if (mobs) {
j = 0;
for (j; j < mobs.length; j += 1) {
if (!mobs[j].preventItemDecay && mobs[j].items) {
processItemDecay(mobs[j]);
}
}
}
}
}
}
// affect decay
if (World.players.length > 0) {
i = 0;
for (i; i < World.players.length; i += 1) {
if (World.players[i].affects.length) {
j = 0;
for (j; j < World.players[i].affects.length; j += 1) {
var affect = World.players[i].affects[j];
if (affect.decay !== -1) {
if (affect.decay > 0) {
affect.decay -= 1;
} else {
if (affect.decayMsg) {
World.msgPlayer(World.players[i], {msg: affect.decayMsg});
}
World.removeAffect(World.players[i], affect.id);
}
}
}
}
}
i = 0;
for (i; i < World.areas.length; i += 1) {
mobs = World.getAllMonstersFromArea(World.areas[i]);
if (mobs) {
j = 0;
for (j; j < mobs.length; j += 1) {
if (mobs[j].affects.length) {
var affect;
var k = 0;
for (k; k < mobs[i].affects.length; k += 1) {
affect = mobs[k].affects[i];
if (affect.decay !== -1) {
if (affect.decay > 0) {
affect.decay -= 1;
} else {
World.removeAffect(mobs[i], affect.id);
}
}
}
}
}
}
}
}
}
// time message
if (areaMsg) {
var i = 0;
for (i; i < World.areas.length; i += 1) {
World.msgArea(World.areas[i].name, {
msg: areaMsg
});
}
}
// respawn
if ((World.time.day % 2) === 0 && (World.time.hour % 12) === 0 && World.time.minute === 1) {
var playersInArea;
var area;
var i = 0;
var refresh = true;
for (i; i < World.areas.length; i += 1) {
area = World.areas[i];
playersInArea = World.getPlayersByArea(area.id);
if (!playersInArea.length && !area.preventRespawn) {
if (area.respawnOn > area.respawnTick) {
area.respawnTick += 1;
}
if (area.respawnTick >= area.respawnOn) {
area.respawnTick = 0;
if (refresh) {
if (!area.persistence) {
World.reloadArea(area);
} else if (World.dataDriver && World.dataDriver.saveArea) {
World.dataDriver.saveArea(area);
}
}
}
}
}
}
// area messages
if ((World.time.hour % 3) === 0 && World.time.minute === 1) {
var i = 0;
var msgObj;
for (i; i < World.areas.length; i += 1) {
if (typeof World.areas[i].message === 'function') {
World.areas[i].messages = World.areas[i].messages(World.areas[i]);
}
if (World.areas[i].messages.length && World.dice.roll(1, 3) == 1) {
msgObj = World.areas[i].messages[World.dice.roll(1, World.areas[i].messages.length) - 1];
if (!msgObj.hour) { // check to see if this message can only be sent at a specific game hour
World.msgArea(World.areas[i].name, {
msg: msgObj.msg,
randomPlayer: msgObj.random // this option randomizes who hears the message
});
} else if (msgObj.hour === World.time.hour) {
World.msgArea(World.areas[i].name, {
msg: msgObj.msg,
randomPlayer: msg.random // this option randomizes who hears the message
});
}
}
}
}
// broken connections
if ((World.time.hour % 4) === 0 && World.time.minute === 30) {
var i = 0;
var player;
for (i; i < World.players.length; i += 1) {
player = World.players[i];
if (!player.connected) {
return player.socket.terminate();
}
player.connected = false;
player.socket.ping();
}
}
}
Ticks.prototype.cmdLoop = function(World) {
var cmdArr = World.cmds.slice();
var cmdObj;
var cmdEntity;
World.cmds = [];
try {
while (cmdArr.length) {
cmdObj = cmdArr[0];
cmdEntity = cmdObj.entity;
cmdObj.entity = null;
if (cmdEntity.isPlayer && !cmdEntity.connected) {
cmdEntity.connected = true;
}
if (!cmdObj.skill) {
World.commands[cmdObj.cmd](cmdEntity, cmdObj, World);
} else {
// todo: run a check for skill improvement
World.skills[cmdObj.cmd](
cmdObj.skill,
cmdEntity,
cmdObj.roomObj,
cmdObj,
World
);
}
cmdArr.splice(0, 1);
}
} catch (e) {
console.error('COMMAND LOOP ERROR:', e);
}
}
Ticks.prototype.hungerThirstLoop = function(World) {
var i = 0;
var player;
for (i; i < World.players.length; i += 1) {
player = World.players[i];
World.character.hunger(player);
World.character.thirst(player);
if (player.cmv > 0 && player.hunger < 8 && player.thirst < 8 && !player.fighting) {
World.character.hpRegen(World.players[i]);
World.character.manaRegen(World.players[i]);
World.character.mvRegen(World.players[i]);
}
}
}
module.exports = Ticks;
|
(global.webpackJsonp = global.webpackJsonp || []).push([ [ "pages/house_circles/_event_item" ], {
"3f8e": function(e, n, t) {
t.d(n, "b", function() {
return o;
}), t.d(n, "c", function() {
return c;
}), t.d(n, "a", function() {});
var o = function() {
var e = this;
e.$createElement;
e._self._c;
}, c = [];
},
"412c": function(e, n, t) {
var o = t("4148");
t.n(o).a;
},
4148: function(e, n, t) {},
"5d3c": function(e, n, t) {
n.a = function(e) {
e.options.wxsCallMethods || (e.options.wxsCallMethods = []);
};
},
d0e56: function(e, n, t) {
t.r(n);
var o = t("f8fe"), c = t.n(o);
for (var i in o) [ "default" ].indexOf(i) < 0 && function(e) {
t.d(n, e, function() {
return o[e];
});
}(i);
n.default = c.a;
},
f3ce: function(e, n, t) {
t.r(n);
var o = t("3f8e"), c = t("d0e56");
for (var i in c) [ "default" ].indexOf(i) < 0 && function(e) {
t.d(n, e, function() {
return c[e];
});
}(i);
t("412c");
var a = t("f0c5"), u = t("5d3c"), f = Object(a.a)(c.default, o.b, o.c, !1, null, "a1fccd46", null, !1, o.a, void 0);
"function" == typeof u.a && Object(u.a)(f), n.default = f.exports;
},
f8fe: function(e, n, t) {
Object.defineProperty(n, "__esModule", {
value: !0
}), n.default = void 0;
var o = {
components: {
SingleImg: function() {
t.e("components/views/event_single_img").then(function() {
return resolve(t("0975"));
}.bind(null, t)).catch(t.oe);
}
},
mixins: [ function(e) {
return e && e.__esModule ? e : {
default: e
};
}(t("0b91")).default ],
created: function() {
this.max_length = 110;
},
methods: {
goDetail: function() {
wx.navigateTo({
url: "/pages/building/main?building_id=".concat(this.item.building_id)
});
},
tapVideo: function() {}
},
props: {
item: {
type: Object
}
}
};
n.default = o;
}
} ]), (global.webpackJsonp = global.webpackJsonp || []).push([ "pages/house_circles/_event_item-create-component", {
"pages/house_circles/_event_item-create-component": function(e, n, t) {
t("543d").createComponent(t("f3ce"));
}
}, [ [ "pages/house_circles/_event_item-create-component" ] ] ]);
|
var d3 = require('d3');
var crossfilter = require('crossfilter');
module.exports = function(data) {
var self = this;
self.dateFormat = d3.time.format('%B %d %Y');
self.data = data;
self.ndx = null;
self.transform = function() {
self.data.forEach(function(d) {
d.dd = self.dateFormat.parse(d.DATE);
d.week = d3.time.monday(d.dd);
d.holds = +d.NUMBER_OF_HOLDS;
d.title = d["TITLE"].toUpperCase();
})
};
self.getNdx = function() {
if (self.ndx == null) {
self.ndx = crossfilter(data);
}
return self.ndx;
};
self.init = function() {
self.transform();
self.ndx = crossfilter(data);
};
return {
init: self.init,
getNdx: self.getNdx,
dateFormat: self.dateFormat
};
};
|
if (window === top) {
window.addEventListener('keyup', function (e) {
if (e.ctrlKey && e.keyCode === 68) {
var description = window.getSelection().toString(),
url = "http://pinboard.in/add?jump=close&url="
+ encodeURIComponent(window.location) + "&title="
+ encodeURIComponent(document.title);
if (description.length > 0) {
url += "&description=" + encodeURIComponent(description.substr(0, 256));
}
window.open(url, 'pinboard.in', "location=no,links=no,scrollbars=no,toolbar=no,width=700,height=300");
}
}, false);
}
|
import { Sprite, window, Res } from 'alpha'
// 加载背景图片
export default class Bg extends Sprite {
constructor(props) {
super({
name: 'wecome背景',
width: window.innerWidth,
height: window.innerHeight
})
this.init()
}
init() {
const that = this
Res.loadImage({
url: '/image/wecome/bg.png',
success: function (img) {
that.setDrawObject(img)
}
})
}
}
|
import { makeStyles } from '@material-ui/core/styles';
import { createMuiTheme } from "@material-ui/core/styles";
export const useStyles = makeStyles({
root: {
width: "100%",
overflowX: "auto",
},
menuItemDefault: {
color: "#a1bbd6"
},
menuItemActive: {
color: "#0090E6 !important",
fontWeight: "bold"
},
});
export const theme = createMuiTheme({
overrides: {
MuiBottomNavigation: {
root: {
height: 75
},
},
MuiBottomNavigationAction: {
root: {
padding: "6px 0px 8px",
outline: "none !important",
flex: 1,
maxWidth: "unset"
}
}
}
});
|
/**
* 所有群列表
*/
Ext.define('eapp.view.duocaijiayuan.GroupListAll',
{
extend: 'Ext.dataview.List',
xtype:'grouplistallview',
config:
{
title:'群列表',
iconCls: 'info',
cls:'textcolor7',
store:null,
itemTpl:
[
'<div style="width: 98%">',
' <div class="left">',
' <div><span>{groupName}</span></div>',
//' <div><span>{materialPublicDate}</span></div>',
' </div>',
' <div class="clear"></div>',
'</div>',
],
},
init:function(jsonData)
{
var me = this;
var store = Ext.create('eapp.store.Group', {data: jsonData.result});
me.setStore(store);
}
});
|
const Discord = require("discord.js")
const client = new Discord.Client()
const config = require("./config.json")
const db = require("quick.db")
const fs = require("fs");
client.on("ready", () => {
console.log(`Logged in discord Bot name:${client.user.username}`)
})
const prefix = config.prefix
client.commands = new Discord.Collection(undefined,undefined);
client.aliases = new Discord.Collection(undefined,undefined);
fs.readdir("./cmds/", async (err, files) => {
if(err) console.log(err)
if(!files) return console.log("Unable to find commands.")
let jsfile = files.filter(f => f.split(".").pop() == "js")
if (jsfile <= 0){
console.log("Unable to find commands.")
return;
}
for (const f of jsfile){
let props = require(`./cmds/${f}`)
console.log(`${f} loaded.`)
client.commands.set(props.help.name,props)
for (const aliase of props.conf.aliase){
client.aliases.set(aliase,props)
}
};
console.log("All Commands have been loaded successfully.")
})
client.on("message" , msg => {
if(msg.content == "Dream Code"){
return msg.reply("Dream Code <3")
}
if(msg.content == prefix + "botinfo"){
let botinfo = new Discord.MessageEmbed()
.setColor("RANDOM")
.setThumbnail(client.user.avatarURL())
.setDescription(`Username:${client.user.username} \n ID:${client.user.id} \n Developer:${client.users.cache.find(user => user.id == config.owner).tag}(<@${config.owner}>) \n Discord.js Version:${Discord.version} \n Quick.db Version:${db.version}`)
msg.channel.send(botinfo)
}
})
client.on("message", async message => {
if(message.author.bot) return;
let prefix;
if(!message.guild) prefix = db.fetch(`prefix.${message.guild.id}`) || config.prefix
if(message.guild) prefix = db.fetch(`prefix.${message.guild.id}`) || config.prefix
if(!message.content.startsWith(prefix)) return;
if(!message.guild) return message.channel.send("You can't use commands via DMs in this bot. You can only use guild").catch(e => client.channels.cache.get("724983000286101636").send(e))
let messageArray = message.content.split(' ').join(' ').split(" ");
let cmd = messageArray[0]
let args = messageArray.slice(1);
let commandfile = client.commands.get(cmd.slice(prefix.length));
if(!commandfile) commandfile = client.aliases.get(cmd.slice(prefix.length))
if(commandfile) commandfile.run(client,message,args);
})
client.snipe = new Map()
client.on("messageDelete", async(message,channel) => {
if(message.author.bot) return;
if(!message.guild) return;
client.snipe.set(message.channel.id, {
msg:message.content,
user:message.author.tag,
profilephoto:message.author.displayAvatarURL(),
image:message.attachments.first() ? message.attachments.first().proxyURL : null,
date:message.createdTimestamp
})
})
client.on("message", async message => {
if(message.author.bot) return;
if(!message.guild) return;
let xpReward;
if(client.user.id === "721417495797301370") xpReward = Math.floor(Math.random() * 6) + 7
if(xpReward == 0) xpReward = 10
let xp = db.fetch(`xp.${message.author.id}`)
let level = db.fetch(`level.${message.author.id}`) || "0" //I Change xp reward because I record video :D
let level2 = level + 1
let levels = level2 * 1000 // level * 1000 = 5 * 1000 = 5000 xp
if(!xp){
db.add(`xp.${message.author.id}`,xpReward)
}else if(xp){
db.add(`xp.${message.author.id}`,xpReward)
}
// I reset levels .
if(xp > levels){
db.add(`level.${message.author.id}`,1)
// message.reply(`**Congratulations You Level Up On Our Server.** \n **New Level:${level2}**`)
// if you want channel send
client.channels.cache.get("724999684887806063").send(`<@${message.author.id}>, **Congratulations You Level Up On Our Server.** \n **New Level:${level2}**`)
}
})
client.on("message", async message => {
if(message.content.startsWith(prefix + "afk")) return;
if(!db.fetch(`afk.${message.author.id}.${message.guild.id}`)) return;
let username = message.member.nickname ? message.member.nickname : message.author.username;
if(username !== message.author.username && username.startsWith("[AFK]")){
message.member.setNickname(db.fetch(`afk.${message.author.id}.${message.guild.id}.name`))
}
db.delete(`afk.${message.author.id}.${message.guild.id}`)
return message.channel.send(`you are not afk`)
})
client.on("message",async message => {
let coin = db.fetch(`coin.${message.author.id}`)
//xD smart system
db.add(`coin.${message.author.id}`,1)
}
)
client.on("messageDelete", async message => {
if(!message.guild) return;
if(message.author.bot) return;
let number = db.fetch(`snipe.${message.guild.id}`)
let new_number = Number(number+1)
if(number >= 3) {
let snipe_Data = db.fetch(`msnipe.${message.guild.id}`)
snipe_Data.sort((a,b) => a.date > b.date)
snipe_Data.splice(snipe_Data[2],1)
db.set(`msnipe.${message.guild.id}`,snipe_Data)
db.push(`msnipe.${message.guild.id}`,{author:message.author.id,content:message.content,id:new_number,date:Date.now(),channel:message.channel.id})
}else {
db.push(`msnipe.${message.guild.id}`,{author:message.author.id,content:message.content,id:new_number,date:Date.now(),channel:message.channel.id})
db.add(`snipe.${message.guild.id}`,1)
}
})
// let test it
client.login(config.token)
/*
{
"owner":"Your ID",
"prefix":"Your Prefix",
"token":"Your Bot Token"
}
*/
|
const MacrosService = {
macrosSoFar(meals, usrMacros) {
let protein = 0;
let carbs = 0;
let fats = 0;
meals.forEach(meal => {
protein += parseInt(meal.protein);
carbs += parseInt(meal.carbs);
fats += parseInt(meal.fats);
});
const macros = { protein, carbs, fats };
const proteinPercent = Math.round((protein / usrMacros.protein) * 100);
const carbsPercent = Math.round((carbs / usrMacros.carbs) * 100);
const fatsPercent = Math.round((fats / usrMacros.fats) * 100);
const macrosPercent = { proteinPercent, carbsPercent, fatsPercent };
if (macrosPercent.proteinPercent > 100) {
macrosPercent.proteinPercent = 100;
}
if (macrosPercent.carbsPercent > 100) {
macrosPercent.carbsPercent = 100;
}
if (macrosPercent.fatsPercent > 100) {
macrosPercent.fatsPercent = 100;
}
return { macrosPercent, macros };
},
totalMealMacros(foods) {
let protein = 0;
let carbs = 0;
let fats = 0;
foods.forEach(food => {
protein += parseInt(food.protein);
carbs += parseInt(food.carbs);
fats += parseInt(food.fats);
});
const macros = { protein, carbs, fats };
return macros;
},
totalFoodMacros(food) {
Object.keys(food).map(key => {
if (key === 'protein' || key === 'carbs' || key === 'fats') {
food[key] = parseInt(food.servings) * parseInt(food[key]);
}
return key;
});
},
calculateUserMacros(user) {
const { gender, goals, height, age, activity_lvl } = user;
const weight = parseFloat(user.weight);
const usrHeight = parseFloat(height);
let pCoef = 1;
let fCoef = 0.4;
let tdee;
if (gender === 'male') {
tdee = 10 * weight + 6.25 * usrHeight - 5 * parseInt(age) + 5;
}
if (gender === 'female') {
fCoef = 0.3;
tdee = 10 * weight + 6.25 * usrHeight - 5 * parseInt(age) - 161;
}
tdee *= parseFloat(activity_lvl);
if (goals === 'gain') {
tdee += 500;
} else if (goals === 'lose') {
tdee -= 500;
}
const protein = Math.round(weight * 2.2 * pCoef);
tdee -= protein * 4;
const fats = Math.round(weight * 2.2 * fCoef);
tdee -= fats * 9;
const carbs = Math.round(tdee / 4);
const userMacros = { protein, carbs, fats };
return userMacros;
}
};
module.exports = MacrosService;
|
import React from 'react'
import CustomIcon from '../CustomIcon'
const CaretRight = (props) => (
<CustomIcon {...props}>
<path d="M7.09524 22L17 12L7.09524 2" stroke="currentColor" strokeWidth="3" strokeLinecap="round" strokeLinejoin="round"/>
</CustomIcon>
)
export default CaretRight
|
import { allHeads } from "./HeadsDataProvider.js"
import { HeadComponent } from "./HeadsHTMLConverter.js"
const entryLog = document.querySelector(".content--right")
export const headList= () => {
const heads = allHeads()
console.log(heads)
let HeadHTMLRepresentations = ""
for (const head of heads) {
HeadHTMLRepresentations += HeadComponent(head)
}
entryLog.innerHTML += `
<article class= "heads">
<h2 class="articleHeader"> Heads of State </h2>
${HeadHTMLRepresentations}
</article> ` }
|
'use strict';
const scriptInfo = {
name: 'Channel Token',
desc: 'Give a IRC user a unique token that identifies them to a channel',
createdBy: 'IronY'
};
const moment = require('moment');
const Models = require('bookshelf-model-loader');
const logger = require('../../lib/logger');
const randToken = require('rand-token');
const scheduler = require('../../lib/scheduler');
module.exports = app => {
// Log nick changes in the alias table
if (!app.Database && !Models.Token) return;
// Hold the token model
const tokenModel = Models.Token;
// Go through the users tokens and remove them if they are over a week old
const cleanTokens = scheduler.schedule('cleanTokens', {
hour: 0,
minute: 0
}, () => {
let now = moment();
tokenModel
.fetchAll()
.then(results =>
results.forEach(result => {
// This is not a very old record, move on
if (now.diff(moment(result.attributes.timestamp), 'weeks') < 1) return;
return result
.destroy()
.then(deleted => logger.info(`User Token for ${result.attributes.user} on ${result.attributes.channel} has been removed`))
.catch(err => logger.error('Error In removing a user token', {
err
}));
}))
.then(() => logger.info('Finished clearing User Token'))
.catch(err => logger.error('Error removing User tokens', {
err
}));
});
// API End point, get a nick verified by channel token
const getNickByTokenApi = (req, res) => {
let error = {
status: 'error',
result: null
};
let token = req.body.token;
// No token available
if (!token) return res.json(error);
tokenModel.query(qb =>
qb
.where('token', token)
.select(['user', 'channel', 'timestamp'])
)
.fetch()
.then(result => {
if (!result) return res.json(error);
res.json({
status: 'success',
result: result
});
});
};
// Register upload Handler
app.WebRoutes.set('getNickByToken', {
handler: getNickByTokenApi,
desc: 'Handle File Upload',
path: '/api/getNickByToken',
name: 'getNickByToken',
verb: 'post'
});
// Register a user to a token
const registerToken = (to, from, text, message) => {
// Only accept messages from channel
if (to === from) {
app.say(to, 'You must be in a channel to request a token');
return;
}
let token = randToken.generate(8);
tokenModel
.query(qb =>
qb
.where('user', from)
.where('channel', to)
)
.fetch()
.then(result => {
// If no previous tokens exist
if (!result) {
tokenModel.create({
user: from,
channel: to,
token: token
})
.then(() => {
app.say(to, `Your token has been safely private messaged to you ${from}`);
app.say(from, `Your new token for ${to} is ${token}, it will expire in 7 days`);
});
}
// If previous token exists
else {
tokenModel
.where({
user: from,
channel: to,
})
.save({
token: token,
timestamp: Models.Bookshelf.knex.fn.now(),
}, {
patch: true
})
.then(() => app.say(from, `Your new token for ${to} is ${token}`));
}
});
};
// Register token
app.Commands.set('token', {
desc: 'Get a unique token for uploading images to file',
access: app.Config.accessLevels.identified,
call: registerToken
});
return scriptInfo;
};
|
const replaceRefs = (obj, searchStr, replaceStr) => {
if (!obj) {
return;
}
if (typeof obj === 'string') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map(k => replaceRefs(k, searchStr, replaceStr));
} else if (typeof obj === 'object') {
return Object.assign(
{},
...Object.keys(obj).map(k => {
if (typeof obj[k] === 'object') {
if (k === searchStr) {
return {[replaceStr]: replaceRefs(obj[k], searchStr, replaceStr)};
}
return {[k]: replaceRefs(obj[k], searchStr, replaceStr)};
}
if (k === searchStr) {
return {[replaceStr]: obj[k]};
}
return {[k]: obj[k]};
})
);
}
};
exports.replaceRefsJSON = obj => replaceRefs(obj, '$ref', '_ref');
exports.replaceRefsMongo = obj => replaceRefs(obj, '_ref', '$ref');
|
import path from 'path';
import getConfigKey from './getConfigKey';
const getFilePath = (location, fileName) => {
const address = getConfigKey("address");
const currentDir = location.pathname;
const url = address + path.join(currentDir, fileName);
return url;
};
export default getFilePath;
|
/*
Author: Marco Santomo
Updated: June 2016
*/
$(function() {
$('#alertMe').click(function(e) {
e.preventDefault();
$('#successAlert').slideDown();
});
$('a.pop').click(function(e) {
e.preventDefault();
});
$('a.pop').popover();
$('[rel="tooltip"]').tooltip();
});
function sendMail() {
var yourMessage = document.getElementById("inputMessage").value
var subject = document.getElementById("inputObject").value
var mail="mailto:indirizzodellatim@timhypermedia2016.it?subject="+subject+"&body="+yourMessage;
window.location.href = mail;
}
$(document).bind("mobileinit", function () {
$.support.cors = true;
$.mobile.allowCrossDomainPages = true; });
|
// 환경 변수에 따라 설정 달리함
if (process.env.NODE_ENV === 'production') {
// 환경변수 production 일 때 ./prod를 요청
module.exports = require('./prod');
} else {
// 환경변수 development 일 때 ./dev 요청
module.exports = require('./dev');
}
|
({
/**
* Do Init
*
* @param {Component}
* component
* @param {Event}
* event
* @param {Helper}
* helper
* @return {}
*/
doInit : function(component, event, helper) {
var parentGroupId = component.get("v.parentGroupId");
if (!$A.util.isEmpty(parentGroupId)) {
helper.showSpinner(component);
// Apex Controller Action
var action = component.get("c.getGroupCompetitors");
action.setParams({
"parentGroupId" : parentGroupId
});
// Set Callback behavior when response is recieved from Apex
// Controller
action.setCallback(this, function(response) {
var state = response.getState();
if (component.isValid() && state === "SUCCESS") {
component.set("v.competitors", response.getReturnValue());
helper.hideSpinner(component);
} else {
console.log("Failed with state: " + state);
}
});
// Send action off to be executed
$A.enqueueAction(action);
} else {
console.log("parentGroupId Is Null");
}
},
/**
* Fires Events For Edit & Delete Menu Actions
*
* @param {Component}
* component
* @param {Event}
* event
* @param {Helper}
* helper
* @return {}
*/
competitorMenuSelect : function(component, event, helper) {
var selectedMenuAction = event.getParam("value").split("_");
var action = selectedMenuAction[0];
var rowIdx = selectedMenuAction[1];
var competitors = component.get("v.competitors");
var competitor = competitors[rowIdx];
component.set("v.activeRow", rowIdx);
if (action == "EditCompetitor") {
var editCompetitor = component.getEvent("editCompetitor");
editCompetitor.setParams({
"competitor" : competitor,
"competitoridx": rowIdx
});
editCompetitor.fire();
} else if (action == "DeleteCompetitor") {
competitors.splice(rowIdx, 1);
component.set("v.competitors", competitors);
} else {
// Do Nothing
}
},
/**
* Handles Selection of List Item Row
*
* @param {Component}
* component
* @param {Event}
* event
* @param {Helper}
* helper
* @return {}
*/
handleRowSelect : function(component, event, helper) {
var selectedRowSection = helper.findSelectedRow(component, event);
if (selectedRowSection == undefined) {
// Do Nothing
} else {
var table = selectedRowSection.parentNode;
helper.unselectAllRows(component, table);
helper.selectRow(component, selectedRowSection);
}
},
})
|
// @flow
import React from "react";
import { useState, useEffect } from "react";
import moment from "moment";
import { OPERATION_LIST_ENTITIES } from "lk/operations.js";
import { getLKQuery } from "../../redux/actions.js";
function loadLog( importId, setIsLogLoading, setIsLogLoadingError, setLog )
{
let dataWithOperation =
{
operation: OPERATION_LIST_ENTITIES,
entity: "OffersImportLog",
data:
{
id: importId
}
};
const setLogLoadingSuccess = ( json ) =>
{
// Нам может вернуться правильный ответ с ошибкой
if( json.hasOwnProperty( "error" ) && json.error )
{
setLogLoadingError( json.errorMessage );
return;
}
setIsLogLoading( false );
setIsLogLoadingError( null );
setLog( json.items );
};
const setLogLoadingError = ( errorMessage ) =>
{
setIsLogLoading( false );
setIsLogLoadingError( errorMessage );
setLog( [] );
};
getLKQuery(
dataWithOperation,
( json ) => setLogLoadingSuccess( json ),
( error ) => setLogLoadingError( error )
);
// Sets the loading state
setIsLogLoading( true );
setIsLogLoadingError( false );
setLog( [] );
}
type LogStringType =
{
id: string,
import_id: number,
timestamp: string,
line_num: number,
message: string
};
function LogString( props: LogStringType )
{
const { id, import_id, timestamp, line_num, message } = props;
const formattedDate = moment( timestamp ).format( "DD.MM.YYYY" );
return (
<tr>
<td></td>
<td>{ formattedDate }</td>
<td>{ line_num }</td>
<td colspan="4">{ message }</td>
</tr>
);
}
export function ImportLog( props )
{
const [ isLogLoading, setIsLogLoading ] = useState( false );
const [ isLogLoadingError, setIsLogLoadingError ] = useState( null );
const [ log, setLog ] = useState( [] );
// At first we trying to load log
useEffect( () => loadLog( props.importId, setIsLogLoading, setIsLogLoadingError, setLog ), [] );
if( isLogLoading || isLogLoadingError || log === undefined || log.length === 0 )
return null;
return (
<React.Fragment>
{
log.map( ( element ) => <LogString key={ element.id } { ...element } />)
}
</React.Fragment>
);
}
|
import React from "react";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import {
faUser,
faEnvelopeOpen,
faCalendarTimes,
faMap,
faPhone,
faLock,
faGreaterThan,
} from "@fortawesome/free-solid-svg-icons";
function UserData({ isLoading, showUserData, title, subTitle, newRandomUser }) {
return (
<div className="main">
<h3>My {subTitle} is</h3>
<h1>{title}</h1>
<div className="buttons-container">
<FontAwesomeIcon
icon={faUser}
className="icon"
onMouseEnter={() => showUserData("name")}
/>
<FontAwesomeIcon
icon={faEnvelopeOpen}
className="icon"
onMouseEnter={() => showUserData("email")}
/>
<FontAwesomeIcon
icon={faCalendarTimes}
className="icon"
onMouseEnter={() => showUserData("age")}
/>
<FontAwesomeIcon
icon={faMap}
className="icon"
onMouseEnter={() => showUserData("country")}
/>
<FontAwesomeIcon
icon={faPhone}
className="icon"
onMouseEnter={() => showUserData("phone")}
/>
<FontAwesomeIcon
icon={faLock}
className="icon"
onMouseEnter={() => showUserData("password")}
/>
</div>
<button className="random-user-btn" onClick={newRandomUser}>
{isLoading ? "Loading..." : "Random User"}
</button>
</div>
);
}
export default UserData;
|
const express = require("express");
var router = express.Router();
const mongoose = require("mongoose");
const Student = mongoose.model("Student");
router.get("/", (req, res) => {
res.render("studentFilter/addOrEdit", {
viewTitle: "SEARCH STUDENT BY"
});
});
router.post("/", (req, res) => {
// console.log(req.body);
Student.find({ studentCurrentSemester: req.body.sem }, (err, docs) => {
if (!err) {
res.render("student/list", {
list: docs
});
} else {
console.log("Error in retriving Supervisior Detail :" + err);
}
});
});
module.exports = router;
|
(function () {
'use strict';
/**
* @ngdoc service
* @name marketing.factory:Marketing
*
* @description
*
*/
angular
.module('marketing')
.factory('Marketing', Marketing);
function Marketing($http,consts) {
var MarketingBase = {};
MarketingBase.sendMessageToClients = function(emailAddress,message,subject) {
return $http({
method: "GET",
url: consts.serverUrl + "Marketing/SendMessageToClients",
params: {
emailAddress:emailAddress,
message:message,
subject:subject
}
});
};
return MarketingBase;
}
}());
|
#!/usr/bin/env node
var minimist = require("minimist"),
args;
args = minimist(process.argv.slice(2), {
alias: {
d: "domain",
h: "help",
p: "project",
t: "token",
u: "user",
v: "version"
}
});
function format(data) {
return data.reduce(function (accumulator, item) {
return accumulator.concat(`- ${item.Id}\n`);
}, "");
}
function log([users, projects, assignments, result]) {
if (result.Deleted && result.Deleted.Items && result.Deleted.Items.length > 0) {
console.log(`Unassigned items:\n${format(result.Deleted.Items)}`);
}
if (result.NotDeleted && result.NotDeleted.Items && result.NotDeleted.Items.length > 0) {
console.log(`Items that were not unassigned:\n${format(result.NotDeleted.Items)}`);
}
}
if (args.version) {
console.log("v" + require("../package.json").version);
} else if (args.help || process.argv.length < 5 || !args.domain || !args.token || (!args.user && !args.project)) {
require("../lib/command/usage")(process.argv[1]).then(console.error);
} else {
require("../lib/adapter/authorize-unassign")(args).then(log, console.error);
}
|
/*Problem 3. Underage people
Write a function that prints all underaged persons of an array of person
Use Array#filter and Array#forEach
Use only array methods and no regular
loops (for, while)*/
var arr = [ { names: 'ivan', age: 115, gender: true },
{ names: 'petur', age: 12, gender: false },
{ names: 'george', age: 11, gender: false },
{ names: 'george', age: 115, gender: false }];
function printUnderaged(arr, func) {
console.log(arr.filter(func));
}
function is18(age, index) {
var num = arr[index].age;
console.log(num);
console.log(index);
if( num < 18){
return age;
}
}
printUnderaged(arr, is18);
|
#!/usr/bin/env node
import * as fs from 'fs'
import { renderFile } from './render/typescript'
import { readDirectory } from './parse/read'
import { parseModule } from './parse/parse'
async function main() {
const inDir = process.argv[2]
const outFile = process.argv[3]
const rootDirectory = await readDirectory(inDir)
const root = parseModule(rootDirectory)
try {
await fs.promises.writeFile(outFile, renderFile(root))
} catch (e) {
console.error("Failed to build schema: check the debug.json AST for debugging")
throw e
}
}
if (require.main === module) {
main().catch(console.error)
}
|
function submitCustomerForm(event) {
let customerDetails = customerInformations("customer_form");
addCustomerRow(customerDetails, "customers_list");
// Those 2 lines must been commented for Gatling test
// cleanForm("customer_form");
// event.preventDefault();
}
function addCustomerRow(customerDetails, tableName) {
const customerTable = document.getElementById(tableName);
const workingTBody = customerTable.getElementsByTagName("tbody")[0];
const nextId = workingTBody.getElementsByTagName("tr").length + 1;
customerDetails["id"] = nextId;
// const customerRow = document.createElement("tr");
const customerRow = workingTBody.insertRow();
const dataOrdered = ["id", "knickname", "firstname", "lastname", "birthdate", "credits", "email", "select"];
for (let i = 0; i < 8; i++) {
//const cell = document.createElement("td");
const cell = customerRow.insertCell(i);
if (dataOrdered[i] === "select") {
// Specific case to add checkbox
cell.setAttribute("class", "td_checkbox");
const checkbox = document.createElement("input");
checkbox.type = "checkbox";
cell.appendChild(checkbox);
} else {
//cell.appendChild(document.createTextNode(customerDetails[dataOrdered[i]]));
cell.textContent = customerDetails[dataOrdered[i]];
}
//customerRow.appendChild(cell); // Unnecessary when using insertCell
}
//workingTBody.appendChild(customerRow); // Not necessary when using insertRow
}
/*
Get all input field from given form and put them in object through its attributes.
*/
function customerInformations(formName) {
const workingForm = document.getElementById(formName);
const inputs = workingForm.getElementsByTagName("input");
let result = {};
for (let i of inputs) {
result[i.name] = i.value;
}
return result;
}
/*
Clean all input field from given form.
WARNING : This function must not be called before a "real" submit !
*/
function cleanForm(formName){
const workingForm = document.getElementById(formName);
const inputs = workingForm.getElementsByTagName("input");
let result = {};
for (let i of inputs) {
i.value = "";
}
}
function init() {
'use strict';
document.getElementById("customer_form").addEventListener("submit", submitCustomerForm, false);
}
document.addEventListener("DOMContentLoaded", init, false);
|
//Define your S3 site buckets and regions, as well as site-specific datatypes
var SITES = [
{
name: 'Site Number One',
markdown_bucket: 'site-one-markdown',
assets_bucket: 'site-one-assets',
site_bucket: 'site-one-site',
aws_region: 'us-east-1',
datatypes: [],
templates: [],
menu_template: null
}
];
//Global data types
var DEFAULT_DATATYPES = [
{id: 'html', name: 'HTML'},
{id: 'markdown', name: 'Markdown'},
{id: 'multiples', name: 'Multiples'}
];
var DATATYPES = DEFAULT_DATATYPES;
//Global templates
var DEFAULT_TEMPLATES = [ {id: 'templates/entry.html', name: 'Generic Page'} ];
var TEMPLATES = DEFAULT_TEMPLATES;
var PARTIALS_PATH = 'public/js/data-types/partials/';
var DATA_KEY = '.dodgercms/data.json'; //contains folder structure reference
var MENU_TEMPLATE = 'templates/menu.html'; //the menu template
var DATA_BUCKET;
var ASSETS_BUCKET;
var SITE_BUCKET;
var AWS_REGION = 'us-east-1';
//if only one site defined, set the globals automatically
if (SITES.length === 1) {
DATA_BUCKET = SITES[0].markdown_bucket;
ASSETS_BUCKET = SITES[0].assets_bucket;
SITE_BUCKET = SITES[0].site_bucket;
AWS_REGION = SITES[0].aws_region;
if (SITES[0].datatypes) {
_.each(SITES[0].datatypes, function(dt){
DATATYPES.push(dt);
});
}
}
var SITE_ENDPOINT = 'http://' + SITE_BUCKET + '.s3-website-' + AWS_REGION + '.amazonaws.com/';
var CONTENT_TYPE = 'text/plain; charset=UTF-8';
var S3_ENDPOINT = 's3.amazonaws.com';
//Cognito
var POOL_ID = '';
var CLIENT_ID = '';
var ID_POOL_ID = '';
|
const assert = require('assert');
const Human = require('../src/Human.js');
const Computer = require('../src/Computer.js');
const Tictactoe = require('../src/Tictactoe.js');
describe("Tic Tac Toe App Test", function() {
let testBoard, grid;
let playerOne = new Human('Player1', 'x');
let playerTwo = new Human('Player2', 'o');
let computer = new Computer('Computer', 'o');
before(function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
});
describe("Starting a game", function() {
it("should have total moves of 9", function() {
let len = grid.length
assert.deepEqual(len, 9);
});
it("should contain array with integers 0-8", function() {
assert.deepEqual(grid, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
});
it("should have first move by Player 1", function() {
assert.deepEqual(testBoard.isPlayerOneTurn(), true);
});
});
describe("Player1's first move",function() {
it("should have a cell fill by Player1's move", function() {
playerOne.setSquare(grid, 2);
assert.deepEqual(grid[2],playerOne.marker);
});
it("should be a data type string by Player1's move", function() {
assert.deepEqual(typeof grid[0],'number');
assert.deepEqual(typeof grid[1],'number');
assert.deepEqual(typeof grid[2],'string');
});
it("should not end the game", function() {
assert.deepEqual(testBoard.isGameOver(playerOne.isWinner(grid)), false);
});
it("should switch player move", function() {
testBoard.nextPlayerTurn();
assert.deepEqual(testBoard.isPlayerOneTurn(), false);
});
});
describe("Player2's move",function() {
it("should have a cell fill by Player2's move", function() {
playerTwo.setSquare(grid, 4);
assert.deepEqual(grid[4],playerTwo.marker);
});
it("should be a data type string by Player2's move", function() {
assert.deepEqual(typeof grid[0],'number');
assert.deepEqual(typeof grid[1],'number');
assert.deepEqual(typeof grid[4],'string');
});
it("should not end the game", function() {
assert.deepEqual(testBoard.isGameOver(playerTwo.isWinner(grid)), false);
});
it("should switch player move", function() {
testBoard.nextPlayerTurn();
assert.deepEqual(testBoard.isPlayerOneTurn(), true);
});
});
describe("Reset the game",function() {
it("should have total moves of 9", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
let len =grid.length
assert.deepEqual(len, 9);
});
it("should contain array with integers 0-8", function() {
assert.deepEqual(grid, [0,1,2,3,4,5,6,7,8]);
});
it("should have first move by Player 1", function() {
assert.deepEqual(testBoard.isPlayerOneTurn(), true);
});
});
describe("Winning row indicator",function() {
it("should have a win in Row 1", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 0);
playerOne.setSquare(grid, 1);
playerOne.setSquare(grid, 2);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [0,1,2]);
});
it("should have a win in Row 2", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 3);
playerOne.setSquare(grid, 4);
playerOne.setSquare(grid, 5);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [3,4,5]);
});
it("should have a win in Row 3", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 6);
playerOne.setSquare(grid, 7);
playerOne.setSquare(grid, 8);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [6,7,8]);
});
});
describe("Winning horizontal indicator",function() {
it("should have a win in Horizontal 1", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 0);
playerOne.setSquare(grid, 3);
playerOne.setSquare(grid, 6);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [0,3,6]);
});
it("should have a win in Horizontal 2", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 1);
playerOne.setSquare(grid, 4);
playerOne.setSquare(grid, 7);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [1,4,7]);
});
it("should have a win in Horizontal 3", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 2);
playerOne.setSquare(grid, 5);
playerOne.setSquare(grid, 8);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [2,5,8]);
});
});
describe("Winning diagonal indicator",function() {
it("should have a win in Diagonal 1", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 0);
playerOne.setSquare(grid, 4);
playerOne.setSquare(grid, 8);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [0,4,8]);
});
it("should have a win in Diagonal 2", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 2);
playerOne.setSquare(grid, 4);
playerOne.setSquare(grid, 6);
let player = playerOne.isWinner(grid);
assert.deepEqual(player.marker, playerOne.marker);
assert.deepEqual(player.index, [2,4,6]);
});
});
describe("Draw indicator",function() {
before(function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 1);
playerTwo.setSquare(grid, 3);
playerOne.setSquare(grid, 4);
playerTwo.setSquare(grid, 7);
playerOne.setSquare(grid, 6);
playerTwo.setSquare(grid, 2);
playerOne.setSquare(grid, 0);
playerTwo.setSquare(grid, 8);
playerOne.setSquare(grid, 5);
});
it("should have no empty cells", function(){
assert.deepEqual(testBoard.hasTie(), true);
});
it("should not have player 1 win", function() {
let playerI = playerOne.isWinner(testBoard.getBoard());
assert.deepEqual(playerI, false);
let resultI = testBoard.isGameOver(playerI);
assert.deepEqual(resultI, true);
});
it("should not have player 2 win", function() {
let playerII = playerTwo.isWinner(testBoard.getBoard());
assert.deepEqual(playerII, false);
let resultII = testBoard.isGameOver(playerII);
assert.deepEqual(resultII, true);
});
});
describe("Playing against a Computer",function() {
it("should have Player 1 move first", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
assert.deepEqual(testBoard.isPlayerOneTurn(), true);
});
it("should get computer's move to be a number", function() {
playerOne.setSquare(testBoard.getBoard(), 1);
computer.setSquare(testBoard.getBoard());
assert.deepEqual(typeof computer.getMove(), 'number');
});
it("should find a possible AI win", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 1);
computer.setSquare(grid);
playerOne.setSquare(grid, 2);
computer.setSquare(grid);
playerOne.setSquare(grid, 5);
computer.setSquare(grid);
assert.deepEqual(playerOne.isWinner(grid), false);
assert.deepEqual(typeof computer.isWinner(grid), 'object');
});
it("should not allow a Human to win, Human Lose", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 3);
computer.setSquare(grid);
playerOne.setSquare(grid, 5);
computer.setSquare(grid);
playerOne.setSquare(grid, 8);
computer.setSquare(grid);
playerOne.setSquare(grid, 1);
computer.setSquare(grid);
assert.deepEqual(playerOne.isWinner(grid), false);
assert.deepEqual(typeof computer.isWinner(grid), 'object');
});
it("should not allow a Human to win, Draw", function() {
testBoard = new Tictactoe();
grid = testBoard.getBoard();
playerOne.setSquare(grid, 3);
computer.setSquare(grid);
playerOne.setSquare(grid, 4);
computer.setSquare(grid);
playerOne.setSquare(grid, 2);
computer.setSquare(grid);
playerOne.setSquare(grid, 7);
computer.setSquare(grid);
playerOne.setSquare(grid, 8);
let human = playerOne.isWinner(grid);
assert.deepEqual(human, false);
let result = testBoard.isGameOver(human);
assert.deepEqual(result, true);
let Ai = computer.isWinner(grid);
assert.deepEqual(Ai, false);
let resultAi = testBoard.isGameOver(Ai);
assert.deepEqual(resultAi, true);
});
});
});
|
import React, { Component } from 'react';
import { Field, reduxForm } from 'redux-form';
import { Link } from 'react-router';
import { renderField, renderFieldFocus } from '../helpers/render_field';
class ChangePasswordForm extends Component {
render() {
const { handleSubmit } = this.props;
return(
<form onSubmit={handleSubmit}>
<Field name="currentPassword" component={renderFieldFocus} type="password" placeholder="Current Password" />
<Field name="newPassword" component={renderField} type="password" placeholder="New Password" />
<Field name="passwordConfirm" component={renderField} type="password" placeholder="Confirm New Password" />
<hr />
<button type="submit" className="btn btn-primary">Change Password</button>
</form>
);
}
}
ChangePasswordForm = reduxForm({
form: 'change_password'
})(ChangePasswordForm);
export default ChangePasswordForm;
|
require('should');
const _ = require('lodash');
const DiscountedCashFlow = require('../src/DiscountedCashFlow');
describe('DiscountedCashFlow', async () => {
describe('getGrowthRateForYear', () => {
it('should get 0.1 for all years', () => {
const growthRates = [0.1];
for (
let yearIndex = 0;
yearIndex < DiscountedCashFlow.MAX_YEARS;
yearIndex++
) {
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
yearIndex
);
selectedGrowthRate.should.equal(growthRates[0]);
}
});
it('should get 0.4 for year 6, index 5', () => {
const growthRates = [0.5, 0.4];
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
5
);
selectedGrowthRate.should.equal(growthRates[1]);
});
it('should get 0.5 for year 5, index 4', () => {
const growthRates = [0.5, 0.4];
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
4
);
selectedGrowthRate.should.equal(growthRates[0]);
});
it('should get 0.2 for year 10, index 9', () => {
const growthRates = [0.5, 0.4, 0.2];
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
9
);
selectedGrowthRate.should.equal(growthRates[2]);
});
it('should get 0.1 for year 1, index 0', () => {
const growthRates = [0.1, 0.4, 0.2];
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
0
);
selectedGrowthRate.should.equal(growthRates[0]);
});
it('should retrieve same rate for every 2 years', () => {
const growthRates = [0.4, 0.1, 0.7, 0.8, 0.2];
DiscountedCashFlow.getGrowthRateForYear(growthRates, 0).should.equal(
growthRates[0]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 1).should.equal(
growthRates[0]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 2).should.equal(
growthRates[1]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 3).should.equal(
growthRates[1]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 4).should.equal(
growthRates[2]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 5).should.equal(
growthRates[2]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 6).should.equal(
growthRates[3]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 7).should.equal(
growthRates[3]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 8).should.equal(
growthRates[4]
);
DiscountedCashFlow.getGrowthRateForYear(growthRates, 9).should.equal(
growthRates[4]
);
});
it('should retrieve last rate if it goes over maximum number of years', () => {
const growthRates = [0.4, 0.1, 0.7, 0.8, 0.2];
DiscountedCashFlow.getGrowthRateForYear(growthRates, 11).should.equal(
growthRates[4]
);
});
it('should get different rate for every year', () => {
const growthRates = Array.from(Array(10).keys());
growthRates.map((growthRate, index) => {
const selectedGrowthRate = DiscountedCashFlow.getGrowthRateForYear(
growthRates,
index
);
selectedGrowthRate.should.be.eql(growthRates[growthRate]);
});
});
});
describe('getGrowthOfValue', () => {
it('calculate the growth of apple free cash flow over the years, 12% in first 5, 7% onwards', () => {
const firstValue = 58.896;
const growthRates = [0.12, 0.07];
const decimals = 2;
const freeCashFlows = DiscountedCashFlow.getGrowthOfValue(
firstValue,
growthRates
);
let roundedFreeCashFlows = freeCashFlows.map((e) => _.round(e, decimals));
roundedFreeCashFlows.should.be.eql([
58.9,
65.96,
73.88,
82.74,
92.67,
99.16,
106.1,
113.53,
121.48,
129.98
]);
});
it('should calculate growth with a rate of 0', () => {
const firstValue = 10;
const growthRates = [0];
const freeCashFlows = DiscountedCashFlow.getGrowthOfValue(
firstValue,
growthRates
);
freeCashFlows.every((e) => e.should.be.eql(firstValue));
});
it('should calculate growth with rate -3% in first 5 years and -1% onwards', () => {
const firstValue = 58.896;
const growthRates = [-0.03, -0.01];
const decimals = 1;
const freeCashFlows = DiscountedCashFlow.getGrowthOfValue(
firstValue,
growthRates
);
let roundedFreeCashFlows = freeCashFlows.map((e) => _.round(e, decimals));
roundedFreeCashFlows.should.be.eql([
58.9,
57.1,
55.4,
53.8,
52.1,
51.6,
51.1,
50.6,
50.1,
49.6
]);
});
});
describe('getDiscountedValueByYear', () => {
it('get discounted value on year 7 with discount rate of 0.1', () => {
const value = 106.1;
const discountRate = 0.1;
const year = 7;
const discountedValue = DiscountedCashFlow.getDiscountedValueByYear(
value,
discountRate,
year
);
discountedValue.should.be.eql(54.44607634427795);
});
});
describe('getTotalPresentValue', () => {
it('calculate total present value: future cash flows plus sale value, both discounted to present value', () => {
const presentValueFutureCashFlows = [
53.54,
54.52,
55.51,
56.52,
57.54,
55.97,
54.45,
52.96,
51.52,
50.11
];
const presentValueFutureSale = 751.69;
const result = DiscountedCashFlow.getTotalPresentValue(
presentValueFutureCashFlows,
presentValueFutureSale
);
result.should.be.eql(1294.33);
});
});
describe('getPresentValueFutureFlows', () => {
it('calculate present value of apple future cash flows', () => {
const appleFreeCashFlow = [
58.9,
65.96,
73.88,
82.74,
92.67,
99.16,
106.1,
113.53,
121.48,
129.98
];
const discountRate = 0.1;
const decimals = 2;
const rawPresentValues = DiscountedCashFlow.getPresentValueFutureFlows(
appleFreeCashFlow,
discountRate
);
let roundedPresentValues = rawPresentValues.map((e) =>
_.round(e, decimals)
);
roundedPresentValues.should.be.eql([
53.55,
54.51,
55.51,
56.51,
57.54,
55.97,
54.45,
52.96,
51.52,
50.11
]);
});
});
describe('calculate', () => {
it('should calculate discounted cash flow', () => {
let growthRateUntilFive = 0.12;
let growthRateUntilTen = 0.07;
let freeCashFlow = 58.896;
let terminalPE = 15;
let discountRate = 0.1;
let result = DiscountedCashFlow.calculate(
freeCashFlow,
[growthRateUntilFive, growthRateUntilTen],
terminalPE,
discountRate
);
result.should.be.eql({
futureCashFlows: [
58.9,
65.96,
73.88,
82.74,
92.67,
99.16,
106.1,
113.53,
121.48,
129.98
],
presentValueFutureCashFlows: [
53.54,
54.52,
55.51,
56.52,
57.54,
55.97,
54.45,
52.96,
51.52,
50.11
],
valueFutureSale: 1949.7,
presentValueFutureSale: 751.69,
totalPresentValue: 1294.33
});
});
});
});
|
import { createStore } from "vuex";
import {shipments} from "./shipments";
export default createStore({
state: {
// just a fake login for fun
userName: "",
},
getters: {
getUserName(state){
return state.userName
}
},
mutations: {
setUserName(state, payload) {
state.userName = payload;
},
},
actions: {
logUser({ commit }, userName) {
commit("setUserName", userName);
},
},
modules: {
shipments,
},
});
|
import { createSlice } from '@reduxjs/toolkit';
import {
postPhoto,
postPostcard,
} from '../services/api';
import {
setResponseError,
// changeInputFieldValue,
} from './commonSlice';
const initialState = {
writePageIndex: 0,
inputFields: {
isPrivate: true,
secretMessage: {
value: '',
error: false,
},
sender: {
value: '',
error: false,
},
receiver: {
value: '',
error: false,
},
contents: {
value: '',
error: '',
},
photo: {
value: '',
error: false,
},
photoMessage: {
value: '',
error: false,
},
preview: {
isFrontPage: true,
},
complete: {
key: '',
secretMessage: '',
},
},
};
const { actions, reducer } = createSlice({
name: 'write',
initialState,
reducers: {
changeInputFieldValue(state, { payload: { type, value } }) {
return {
...state,
inputFields: {
...state.inputFields,
[type]: {
...state.inputFields[type],
value,
},
},
};
},
setInputFieldsError(state, { payload: { type, error } }) {
return {
...state,
inputFields: {
...state.inputFields,
[type]: {
...state.inputFields[type],
error,
},
},
};
},
increaseWritePageIndex(state) {
return {
...state,
writePageIndex: (+state.writePageIndex) + 1,
};
},
decreaseWritePageIndex(state) {
return {
...state,
writePageIndex: (+state.writePageIndex) - 1,
};
},
flipPreviewPostcard(state) {
// state는 이곳의 slice에서 init한 상태만 가져온다. 그렇기 때문에 밑의 inputFields는 다 common에만 이씅ㅁ.
return {
...state,
inputFields: {
...state.inputFields,
preview: {
...state.inputFields.preview,
isFrontPage: !state.inputFields.preview.isFrontPage,
},
},
};
},
setWriteCompleteValues(state, { payload: { url, secretMessage } }) {
return {
...state,
inputFields: {
...state.inputFields,
complete: {
url,
secretMessage,
},
},
};
},
changeRadioChecked(state, { payload: value }) {
return {
...state,
inputFields: {
...state.inputFields,
isPrivate: value,
},
};
},
resetPostcardInputFields(state) {
return {
...state,
inputFields: {
isPrivate: true,
secretMessage: {
value: '',
error: false,
},
sender: {
value: '',
error: false,
},
receiver: {
value: '',
error: false,
},
contents: {
value: '',
error: '',
},
photo: {
value: '',
error: false,
},
photoMessage: {
value: '',
error: false,
},
preview: {
isFrontPage: true,
},
complete: {
key: '',
secretMessage: '',
},
},
};
},
},
});
export const {
increaseWritePageIndex,
decreaseWritePageIndex,
flipPreviewPostcard,
setWriteCompleteValues,
changeRadioChecked,
resetPostcardInputFields,
changeInputFieldValue,
setInputFieldsError,
} = actions;
export function sendPhoto({ file }) {
return async (dispatch) => {
const photo = await postPhoto({ file });
dispatch(changeInputFieldValue({
type: 'photo',
value: photo,
}));
};
}
export function sendPostcard({ postcardValues, onClickNext }) {
return async (dispatch) => {
const response = await postPostcard(postcardValues);
if (response.error) {
dispatch(setResponseError(response.error));
return;
}
const { url, secretMessage } = response.data;
dispatch(setWriteCompleteValues({
url,
secretMessage,
}));
onClickNext();
};
}
export default reducer;
|
'use strict';
var catalogo = require('../models/catalogue');
var jose = require('node-jose');
const mongoose = require('mongoose');
var jwt = require('jsonwebtoken');
/**
@description Retorna el catálogo completo de la aplicación
**/
module.exports.catalogueGET = function catalogueGET(req, res, next) {
catalogo.find({}, (err, catalogue) => {
res.status(200).send({
message: "ok",
product: jwt.sign(JSON.stringify(catalogue), 'test')
});
})
}
/**
* @author Raphael Martinez
* @description Lista catálogo de la aplicación según el respectivo filtro
**/
module.exports.getCatalogueByFilter = function getCatalogueByFilter(req, res, next) {
let valueFilter = req.swagger.params['filter'].value;
catalogo.find({$or:[{nombre:{$regex:valueFilter,$options: 'i'}},
{presentacion:{$regex:valueFilter,$options: 'i'}},
{categoria:{$regex:valueFilter,$options: 'i'}}]}, (err,catalogue) =>{
if (catalogue.length !== 0 ){
res.status(200).send({
message:"ok",
product:jwt.sign(JSON.stringify(catalogue), 'test')
});
}
else {
res.status(201).send({
message:"No se encuentra parametros para este filtro",
product:jwt.sign(JSON.stringify(catalogue), 'test')
});
}
})
};
/**
@description Lista catálogo de la aplicación según el respectivo filtro
**/
module.exports.postChange = function postChange(req, res, next) {
let catalogue = req.swagger.params['productos'].value
catalogue.map(value => {
value.cantidad = value.cantidad - value.cantidadVendido
delete value.cantidadVendido
let id = mongoose.Types.ObjectId(value._id)
catalogo.findOneAndUpdate({ _id: id }, value, (err, res) => {
})
})
res.status(200).send({
message: "No se encuentra parametros para este filtro",
});
}
|
//todo --> Variables
const boton = document.getElementById('boton');
const insertar = document.getElementById('insertar');
const insertarDos = document.getElementById('insertarDos');
const alerta = document.getElementById('alerta');
const amiga = document.getElementById('amiga');
//todo --> EventListeners
eventListeners();
function eventListeners() {
const pagina = document.addEventListener('DOMContentLoaded', paginaPrincipal)
// boton.addEventListener('click', amigas )
}
// boton.addEventListener('click', imprimir);
//todo --> Functions
function paginaPrincipal(e) {
e.preventDefault();
// crear objeto
const xhr = new XMLHttpRequest();
// CREAR LA CONEXION
xhr.open('GET', 'https://deperu.com/api/rest/cotizaciondolar.json', true)
//todo --> carga y lee datos
xhr.onload = function () {
if (this.status === 200) {
// console.log(JSON.parse(this.responseText));
const respuesta = JSON.parse(this.responseText);
// console.log(respuesta.cotizacion[0].Compra);
insertar.innerHTML = `
<div class="text-center card card-image cartilla "
>
<!-- Content -->
<div class="text-white rgba-black-strong py-5 px-4">
<div>
<h3 class="card-title pt-2 pb-3"><strong> Precio de Compra </strong></h3>
<img src="fotos/dolar.jpg" class="img-fluid rounded-circle tmnoficial mb-2" alt="">
<h2 class="text-info"> <strong><br> S/. ${respuesta.cotizacion[0].Compra} soles. </strong> </h2>
<a href="${respuesta.enlace} " class="">Página de guía</a>
</div>
</div>
</div>
`
// background: url('fotos/dolar.jpg');
// <ul>
// <h2>Precio de Compra: <br> S/. ${respuesta.cotizacion[0].Compra} soles.</h2>
// </ul>
}
if (this.status === 200) {
// console.log(JSON.parse(this.responseText));
const respuesta = JSON.parse(this.responseText);
// console.log(respuesta.cotizacion[0].Compra);
insertarDos.innerHTML = `
<div class="text-center card card-image cartilla "
>
<!-- Content -->
<div class="text-white rgba-black-strong py-5 px-4">
<div>
<h3 class="card-title pt-2 pb-3"><strong> Precio de Venta </strong></h3>
<img src="fotos/dolar.jpg" class="img-fluid rounded-circle tmnoficial mb-2" alt="">
<h2 class="text-success"> <strong><br> S/. ${respuesta.cotizacion[0].Venta} soles. </strong> </h2>
<a href="${respuesta.enlace} " class="">Página de guía</a>
</div>
</div>
</div>
`
}
setTimeout(function(){
alerta.innerHTML = `<div class="container alert alert-success text-center alert-dismissible fade show" role="alert">
<strong>Hola, el valor de la moneda esta actualizado, así que puedes confiar al 100% en esta página. <br> Gracias!! <br> <hr>
<small class="text-secondary" > <strong> creado por Key Dave </strong></small>
</strong>
<button type="button" class="close" data-dismiss="alert" aria-label="Close">
<span aria-hidden="true">×</span>
</button>
</div>`
setTimeout(function(){
alerta.remove()
},8000)
},3000)
}
//todo --> enviar la CONEXION
xhr.send();
}
// function amigas(e) {
// e.preventDefault();
// amiga.innerText = 'Hola Johaira!!'
// }
|
import React from "react";
import Progress from "./Progress";
export default {
title: "form/Progress Bar",
component: Progress,
};
export const ProgressBar = () => <Progress />;
|
const express = require('express')
const {urlPageScraper, repoUrls, endingUrl} = require('./url_scraper')
const server = require('./backend/server')
const readline = require('readline')
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
// you need to manually iterate this url (the number by the first p={num}) by 3 after every pass.
// so starting url "https://github.com/search?p=1&q=stars%3Aetc..." becomes "https://github.com/search?p=4&q=stars%3Aetc..."
let startingUrl = "https://github.com/search?p=1&q=stars%3A%3E100&s=stars&type=Repositories"
let logo = `
███████╗███████╗██████╗ ██╗ █████╗ ██╗
██╔════╝██╔════╝██╔══██╗██║██╔══██╗██║
███████╗█████╗ ██████╔╝██║███████║██║
╚════██║██╔══╝ ██╔══██╗██║██╔══██║██║
███████║███████╗██║ ██║██║██║ ██║███████╗
╚══════╝╚══════╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝╚══════╝
██████╗ ██████╗ ███╗ ██╗████████╗██████╗ ██╗██████╗ ██╗ ██╗████████╗ ██████╗ ██████╗
██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██║██╔══██╗██║ ██║╚══██╔══╝██╔═══██╗██╔══██╗
██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝██║██████╔╝██║ ██║ ██║ ██║ ██║██████╔╝
██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██║██╔══██╗██║ ██║ ██║ ██║ ██║██╔══██╗
╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║██║██████╔╝╚██████╔╝ ██║ ╚██████╔╝██║ ██║
╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝╚═╝╚═════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ `
console.log(logo)
console.log('©️2020 By: Yosef Herskovitz')
rl.question('Press any button to continue', () => {
urlPageScraper(startingUrl)
server()})
|
var expect = require('chai').expect;
describe('DependencyValidator', function() {
it('exists', function() {
var DependencyValidator = require('./dependency_validator.js');
expect(DependencyValidator).to.not.be.undefined;
});
});
describe('DependencyValidator', function() {
it('takes input', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate('some input string');
expect(result).to.not.be.undefined;
});
});
describe('DependencyValidator', function() {
it('validates its an array of strings', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate('some input string');
expect(result).to.equal('INVALID - NOT AN ARRAY');
result = DependencyValidator.validate(58934);
expect(result).to.equal('INVALID - NOT AN ARRAY');
result = DependencyValidator.validate({'some': 'object'});
expect(result).to.equal('INVALID - NOT AN ARRAY');
result = DependencyValidator.validate();
expect(result).to.equal('INVALID - NOT AN ARRAY');
result = DependencyValidator.validate(["Leetmeme: "]);
expect(result).to.not.equal('INVALID - NOT AN ARRAY');
});
});
describe('DependencyValidator', function() {
it('returns a strings list', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["Leetmeme: Ice", "Ice: "]);
expect(result).to.be.a('string');
});
});
describe('DependencyValidator', function() {
it('correctly returns lists with no dependencies', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["KittenService: ", "CamelCaser: "]);
expect(result).to.be.oneOf(['KittenService, CamelCaser', 'CamelCaser, KittenService']);//either should be valid without any dependencies and no instructions requiring alphabetical sorting
});
});
describe('DependencyValidator', function() {
it('correctly returns simple dependencies', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["KittenService: CamelCaser", "CamelCaser: "]);
expect(result).to.equal('CamelCaser, KittenService');
});
});
describe('DependencyValidator', function() {
it('correctly returns more nested dependencies', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["KittenService: CamelCaser", "CamelCaser: Ice", "Leetmeme: ", "Ice: Leetmeme"]);
expect(result).to.equal('Leetmeme, Ice, CamelCaser, KittenService');
});
});
describe('DependencyValidator', function() {
it('correctly returns the explicitly defined valid input example 2 milestone', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["KittenService: ", "Leetmeme: Cyberportal", "Cyberportal: Ice", "CamelCaser: KittenService", "Fraudstream: Leetmeme", "Ice: "]);
expect(result).to.be.oneOf(['KittenService, Ice, Cyberportal, Leetmeme, CamelCaser, Fraudstream',
'Ice, KittenService, Cyberportal, Leetmeme, CamelCaser, Fraudstream',
'KittenService, Ice, Cyberportal, CamelCaser, Leetmeme, Fraudstream',
'Ice, KittenService, Cyberportal, CamelCaser, Leetmeme, Fraudstream',
'KittenService, Ice, CamelCaser, Cyberportal, Leetmeme, Fraudstream',
'Ice, KittenService, CamelCaser, Cyberportal, Leetmeme, Fraudstream',]);
});//there are actually many valid configurations for this test.
//I left it liket his with Ice and KittenService up front since they both have no dependencies,
//but technically as long as the only constraint is to have the order such that a package's dependency precedes the package,
//even something like "Ice, Cyberportal, Leetmeme, Fraudstream, KittenService, CamelCaser" would be technically valid.
//tricky... to get a full test suite you would either need a lot of permutations or replicating some of the logic in the test suite.
});
describe('DependencyValidator', function() {
it('rejects circular references', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["Leetmeme: Ice", "Ice: Leetmeme"]);
expect(result).to.equal('INVALID - CIRCULAR REFERENCE');
});
});
describe('DependencyValidator', function() {
it('correctly rejects the explicitly defined invalid input example', function() {
var DependencyValidator = require('./dependency_validator.js');
var result = DependencyValidator.validate(["KittenService: ", "Leetmeme: Cyberportal", "Cyberportal: Ice", "CamelCaser: KittenService", "Fraudstream: Leetmeme", "Ice: Leetmeme"]);
expect(result).to.equal('INVALID - CIRCULAR REFERENCE');
});
});
|
import React from 'react'
import TestMenu from '../components/TestMenu'
const TestLayout = (props) => {
return (
<React.Fragment>
<TestMenu/>
{props.children}
</React.Fragment>
)
}
export default TestLayout
|
import React, { useEffect, useContext } from 'react';
import { Link } from 'react-router-dom';
import RecipeContext from '../hooks/RecipeContext';
import recipeRequest from '../services/recipeRequest';
import { Header, Footer } from '.';
import '../Style/mainScreen.css';
function ExploreFoodIngredients() {
const {
foodIngredientsCategory,
setFoodIngredientsCategory,
setFoodRecipes,
} = useContext(RecipeContext);
const getAPI = async () => {
const ZERO = 0;
const TWELVE = 12;
const response = await fetch('https://www.themealdb.com/api/json/v1/1/list.php?i=list');
const json = await response.json();
const results = await json.meals;
await setFoodIngredientsCategory(results.slice(ZERO, TWELVE));
};
const getFilterFood = async (url) => {
const newState = await recipeRequest(url);
console.log(newState);
await setFoodRecipes(newState.meals);
};
useEffect(() => {
getAPI();
}, []);
const EIGHTY = 80;
const px = 'px';
const renderCards = () => (
<div className="recipes-container" style={ { marginTop: EIGHTY + px } }>
{foodIngredientsCategory.map((ingredient, index) => (
<div
data-testid={ `${index}-ingredient-card` }
key={ index }
className="card-container"
>
<Link
onClick={ () => getFilterFood(`https://www.themealdb.com/api/json/v1/1/filter.php?i=${ingredient.strIngredient}`) }
to="/comidas"
key={ index }
className="details-link"
>
<p data-testid={ `${index}-card-name` }>
{ ingredient.strIngredient}
</p>
<img
src={ `https://www.themealdb.com/images/ingredients/${ingredient.strIngredient}-Small.png` }
data-testid={ `${index}-card-img` }
alt={ ingredient.strIngredient }
/>
</Link>
</div>
))}
</div>
);
return (
<div>
<Header pageName="Explore Ingredients" />
{!foodIngredientsCategory ? 'Loading' : renderCards()}
<Footer />
</div>
);
}
export default ExploreFoodIngredients;
|
'use strict';
var emitter = require('./emitter');
var mongoose = require('mongoose');
var Board = mongoose.model('board', require('../config/schemas/board'));
var Event = mongoose.model('event', require('../config/schemas/event'));
module.exports = function(req) {
var boardQuery = Board.find({'members.isActive': true}).populate('members.user');
boardQuery.exec(function(err, boards) {
if (!err) {
boards.map(function(board) {
var didChange = false;
board.members.map(function(member) {
if(Date.now() - member.lastSeen > 20000) {
member.isActive = false;
didChange = true;
}
})
if(didChange) {
board.save(function (err, savedboard) {
new Event({
'type': 'BOARD_EDIT',
'board': savedboard.id,
'data': {
'newAttributes': {
'name': savedboard.name,
'description': savedboard.description,
'background': savedboard.background,
'customBackground': savedboard.customBackground,
'size': {
'width': savedboard.size.width,
'height': savedboard.size.height,
},
'members': savedboard.members
}
}
}).save(function(err, ev) {
if(err) {
return console.error(err);
}
emitter.to(savedboard.id).emit('board:event', ev.toObject());
});
})
}
})
}
})
}
|
//@ts-check
import * as React from "react";
const { PureComponent } = React;
import { expect } from "chai";
import { render, act } from "reshow-unit";
import sinon from "sinon";
import { createReducer } from "reshow-flux-base";
import useConnect from "../useConnect";
describe("useConnect Unmount Test", () => {
const sandbox = sinon.createSandbox();
let reducer;
beforeEach(() => {
reducer = createReducer((_state, action) => action, {});
});
afterEach(() => {
sandbox.restore();
});
it("basic test", async () => {
const [store, dispatch] = reducer;
const Foo = (/**@type any*/ props) => {
const state = useConnect({
storeLocator: () => store,
calculateState: () => {
return store.getState();
},
})(props);
return <div className={state.foo} />;
};
const oFake = {};
class FakeComponent extends PureComponent {
state = { show: true };
constructor(/**@type any*/ props) {
super(props);
oFake.set = (/**@type any*/ k, /**@type any*/ v) => {
this.setState({ [k]: v });
};
}
render() {
if (this.state.show) {
return <Foo />;
} else {
return null;
}
}
}
render(<FakeComponent />);
sandbox.spy(store, "removeListener");
console.log("before unmount", store.removeListener.callCount);
expect(store.removeListener.callCount).to.equal(0);
await act(() => oFake.set("show", false));
expect(store.removeListener.callCount).to.equal(1);
console.log("after unmount", store.removeListener.callCount);
dispatch({});
});
});
|
import React from 'react';
import {connect} from "react-redux";
import {bindActionCreators} from 'redux';
import increase from "../../actions/increase";
import decrease from "../../actions/decrease";
import setStep from "../../actions/setStep";
const Controls = ({setStep, increase, decrease, currentValue, step}) => {
return (
<div className="controls">
<button onClick={() => increase(currentValue, step)}>+</button>
<button onClick={() => decrease(currentValue, step)}>-</button>
<input
type="number"
onChange={(e) => setStep(e.target.value)}
placeholder="Enter number"
/>
</div>
)
};
const mapStateToProps = (state) => {
let {currentValue, step} = state.counter;
return {currentValue, step}
};
const mapDispatchToProps = (dispatch) => {
return bindActionCreators({
increase,
decrease,
setStep
}, dispatch);
};
export default connect(mapStateToProps, mapDispatchToProps)(Controls);
|
const express = require("express");
const Stripe = require("stripe");
const cors = require("cors");
// const captureWebsite = require("capture-website");
const nodemailer = require("nodemailer");
const sharp = require("sharp");
const path = require('path');
//stripe
const app = express();
const stripe = new Stripe(
"sk_test_51IRxezLeEfBz7v63tNaTPPWBdlMaVCVHxVDsqQ5Z4BzVxIf5fgxI4fTkznzt1S8ZRNnyc146VPqA29I4lmsNl1C600nnih2m6x"
);
var bodyParser = require("body-parser");
app.use(function (req, res, next){
if (req.headers['x-forwarded-proto'] === 'https') {
res.redirect('http://' + req.hostname + req.url);
} else {
next();
}
});
app.use(bodyParser({ limit: "4MB" }));
app.use(bodyParser.urlencoded({ limit: "5mb", extended: true }));
app.use(cors({origin: true}));
app.use(express.json());
app.post('/checkout', async (req, res) => {
const { id, amount, description } = req.body;
const payment = await stripe.paymentIntents.create({
amount,
currency: "EUR",
description,
payment_method: id,
confirm: true,
});
res.send({ message: "Sucess payment" });
});
const { ImgurClient } = require("imgur");
let client;
client = new ImgurClient({
accessToken: "951002f7bcce68011275532e7e0ce8745417f07b",
});
//download image
const https = require("https");
const fs = require("fs");
//app.use("/", express.static(__dirname + "/../src/img/bodygraphs"));
// app.use('/img/bodygraphs', express.static(__dirname + '/img/bodygraphs'));
// app.use(express.static(__dirname + '/public'));
app.post("/downloadimg", (req, res) => {
const path = __dirname + '/' + req.body.params.filename;
console.log(req.body)
https.get(req.body.params.url, function (res) {
const fileStream = fs.createWriteStream(
path
);
res.pipe(fileStream);
fileStream.on("finish", function () {
fileStream.close();
console.log("done");
});
});
res.send("downloaded", `dirname ${__dirname}`);
// async function imgur() {
// const response = await client.upload(path);
// console.log(response.link);
// }
// imgur();
});
//uploading image to imgur
//downloading pdf
const Anvil = require("@anvilco/anvil");
const pdfTemplateID = "fukMYxVuzF2BoUtXLNk6";
const apiKey = "YpL1QrATKdEETO3iWHsj0dtHPLr62tuN";
app.post("/uploadimage", (req, res) => {
async () => {
const response = await client.upload(req.body.img);
return response.data.link;
};
});
app.post("/downloadpdf", async (req, res) => {
let p = req.body.params;
let loc = (
__dirname + `/../src/img/bodygraphs/pngs/${p.name}.png`
).toString();
// try {
// await captureWebsite.file(p.bodygraph, loc, {
// height: 350,
// width: 332,
// });
// } catch (err) {
// console.log(err);
// }
let cropped = (
__dirname + `/../src/img/bodygraphs/pngs/${p.name}CROPPED.png`
).toString();
try {
if (!fs.existsSync(cropped)) {
await sharp(loc)
.extract({ width: 663, height: 620, left: 0, top: 70 })
.toFile(cropped)
.then(function (new_file_info) {
console.log("Image cropped and saved");
})
.catch(function (err) {
console.log(err);
});
}
} catch (err) {
console.error(err);
}
const response = await client.upload(cropped);
let puno = p.puertasUno[0];
let pdos = p.puertasUno[1];
let ptres = p.puertasDos[0];
let pcuatro = p.puertasDos[1];
let estrategia = p.estrategia;
let estrategiaCap =
estrategia.charAt(0).toUpperCase() + estrategia.slice(1).toLowerCase();
let autoridad = p.autoridad;
let autoridadCap =
autoridad.charAt(0).toUpperCase() + autoridad.slice(1).toLowerCase();
let Resumen = p.Resumen;
const payload = {
title: "My PDF Title",
fontSize: 10,
data: {
Nombre: p.name,
Fecha: p.fecha,
Hora: p.hora,
Lugar: p.lugar,
Tipo: p.tipo,
TipoDescripcion: p.tipodesc,
Corr1: p.corr1.toUpperCase(),
Incorr1: p.incorr1.toUpperCase(),
Corr2: p.corr2,
Incorr2: p.incorr2,
Estrategia: estrategiaCap,
Autoridad: autoridadCap,
PerfilUno: p.perfilUno,
PerfilDos: p.perfilDos,
PerfilDescripcion: p.perfilDescripcion,
Definicion: p.definicion,
Bodygraph: response.data.link,
Cabeza:
p.cabeza == "opened"
? "https://i.imgur.com/BdU4va9.jpg"
: "https://i.imgur.com/TPLIbop.jpg",
Ajna:
p.ajna == "opened"
? "https://i.imgur.com/Ib8EyKZ.jpg"
: "https://i.imgur.com/pjicwet.jpg",
Garganta:
p.garganta == "opened"
? "https://i.imgur.com/vWA2Hhs.jpg"
: "https://i.imgur.com/nuGnPzR.jpg",
GI:
p.gi == "opened"
? "https://i.imgur.com/mrBgCDI.jpg"
: "https://i.imgur.com/VJ6yuTV.jpg",
Corazon:
p.corazon == "opened"
? "https://i.imgur.com/Esl4tuy.jpg"
: "https://i.imgur.com/qJ4hXEM.jpg",
PlexoSolar:
p.plexosolar == "opened"
? "https://i.imgur.com/WySdnAP.jpg"
: "https://i.imgur.com/B0C0XsT.jpg",
Sacral:
p.sacral == "opened"
? "https://i.imgur.com/4GZbKZZ.jpg"
: "https://i.imgur.com/q5J0vYu.jpg",
Bazo:
p.bazo == "opened"
? "https://i.imgur.com/vPDlxKk.jpg"
: "https://i.imgur.com/Mzmwe2o.jpg",
Raiz:
p.raiz == "opened"
? "https://i.imgur.com/mooSy9b.jpg"
: "https://i.imgur.com/7xVrCXi.jpg",
PuertasUnoUno: puno,
PuertasUnoDos: pdos,
PuertasDosUno: ptres,
PuertasDosDos: pcuatro,
CruzNombre: p.cruzNombre,
FechaDiseno: p.currdate,
Logo: p.logo,
CanalUno: p.CanalUno,
CanalDos: p.CanalDos,
CanalTres: p.CanalTres,
CanalCuatro: p.CanalCuatro,
CanalCinco: p.CanalCinco,
CanalSeis: p.CanalSeis,
CanalSiete: p.CanalSiete,
CanalOcho: p.CanalOcho,
Cuantas: p.cuantas,
UserImage: p.UserImage,
Resumen: Resumen,
},
};
const options = {
dataType: "buffer",
};
const anvilClient = await new Anvil({ apiKey });
const { statusCode, data } = await anvilClient.fillPDF(
pdfTemplateID,
payload,
options
);
try {
fs.writeFile(`${p.name.split(" ").join("")}.pdf`, data, (err) => {
if (err) throw err;
console.log('The file has been saved!');
});
res.send(`${p.name.split(" ").join("")}.pdf`);
} catch (err) {
console.log(err);
}
});
app.get("/downloadpdftodisk", async (req, res) => {
const loc = __dirname + '/../' + req.query.filename;
var filestream = fs.createReadStream(loc);
filestream.pipe(res);
})
app.post("/downloadpdfcompleto", async(req, res) => {
let p = req.body.params;
let loc = (
__dirname + `/../src/img/bodygraphs/pngs/${p.name}.png`
).toString();
await captureWebsite.file(p.bodygraph, loc, {
height: 350,
width: 332,
});
const response = await client.upload(loc);
let puno = p.puertasUno[0];
let pdos = p.puertasUno[1];
let ptres = p.puertasDos[0];
let pcuatro = p.puertasDos[1];
let estrategia = p.estrategia;
let estrategiaCap =
estrategia.charAt(0).toUpperCase() + estrategia.slice(1).toLowerCase();
let autoridad = p.autoridad;
let autoridadCap =
autoridad.charAt(0).toUpperCase() + autoridad.slice(1).toLowerCase();
const payload = {
title: "My PDF Title",
fontSize: 10,
data: {
Nombre: p.name,
Fecha: p.fecha,
Hora: p.hora,
Lugar: p.lugar,
Tipo: p.tipo,
TipoDescripcion: p.tipodesc,
Corr1: p.corr.toUpperCase(),
Incorr1: p.incorr.toUpperCase(),
Estrategia: estrategiaCap,
Autoridad: autoridadCap,
PerfilUno: p.perfilUno,
PerfilDos: p.perfilDos,
PerfilDescripcion: p.perfilDescripcion,
Definicion: p.definicion,
Bodygraph: response.data.link,
Cabeza:
p.cabeza == "opened"
? "https://i.imgur.com/BdU4va9.jpg"
: "https://i.imgur.com/TPLIbop.jpg",
Ajna:
p.ajna == "opened"
? "https://i.imgur.com/Ib8EyKZ.jpg"
: "https://i.imgur.com/pjicwet.jpg",
Garganta:
p.garganta == "opened"
? "https://i.imgur.com/vWA2Hhs.jpg"
: "https://i.imgur.com/nuGnPzR.jpg",
GI:
p.gi == "opened"
? "https://i.imgur.com/mrBgCDI.jpg"
: "https://i.imgur.com/VJ6yuTV.jpg",
Corazon:
p.corazon == "opened"
? "https://i.imgur.com/Esl4tuy.jpg"
: "https://i.imgur.com/qJ4hXEM.jpg",
PlexoSolar:
p.plexosolar == "opened"
? "https://i.imgur.com/WySdnAP.jpg"
: "https://i.imgur.com/B0C0XsT.jpg",
Sacral:
p.sacral == "opened"
? "https://i.imgur.com/4GZbKZZ.jpg"
: "https://i.imgur.com/q5J0vYu.jpg",
Bazo:
p.bazo == "opened"
? "https://i.imgur.com/vPDlxKk.jpg"
: "https://i.imgur.com/Mzmwe2o.jpg",
Raiz:
p.raiz == "opened"
? "https://i.imgur.com/mooSy9b.jpg"
: "https://i.imgur.com/7xVrCXi.jpg",
PuertasUnoUno: puno,
PuertasUnoDos: pdos,
PuertasDosUno: ptres,
PuertasDosDos: pcuatro,
CruzNombre: p.cruzNombre,
FechaDiseno: p.currdate,
Logo: "https://i.imgur.com/o7LC7ua.jpg",
CanalUno: p.CanalUno,
CanalDos: p.CanalDos,
CanalTres: p.CanalTres,
CanalCuatro: p.CanalCuatro,
CanalCinco: p.CanalCinco,
CanalSeis: p.CanalSeis,
CanalSiete: p.CanalSiete,
CanalOcho: p.CanalOcho,
Cuantas: p.cuantas,
TipoUpperCase: "TipoUpperCase",
TipoPorcentaje: p.TipoPorcentaje,
DefinidoUno: p.DefinidoUno,
DefinidoUnoImg: p.DefinidoUnoImg,
DefinidoDos: p.DefinidoDos,
DefinidoDosImg: p.DefinidoDosImg,
Conectado: p.Conectado,
Aura: p.Aura,
TipoImg: p.TipoImg,
Modo: p.Modo,
EstrategiaCompleto: p.EstrategiaCompleto,
Rol: p.Rol,
Tema: p.Tema,
Busqueda: p.Busqueda,
Dilema: p.Dilema,
Psicologia: p.Psicologia,
Pregunta: p.Pregunta,
NoSer: p.NoSer,
TipoLineaUno: p.TipoLineaUno,
TipoLineaDos: p.TipoLineaDos,
TipoLineaTres: p.TipoLineaTres,
TipoLineaCuatro: p.TipoLineaCuatro,
TipoLineaCinco: p.TipoLineaCinco,
TipoLineaSeis: p.TipoLineaSeis,
TipoLineaSeite: p.TipoLineaSeite,
TipoLineaOcho: p.TipoLineaOcho,
TipoLineaNueve: p.TipoLineaNueve,
TipoLineaDiez: p.TipoLineaDiez,
TipoLineaOnce: p.TipoLineaOnce,
TipoUpperCaseDos: p.TipoUpperCaseDos,
TipoImgDos: p.TipoImgDos,
Estrategia1num: p.Estrategia1num,
Estrategia1: p.Estrategia1,
Estrategia2num: p.Estrategia2num,
Estrategia2: p.Estrategia2,
Estrategia3num: p.Estrategia3num,
Estrategia3: p.Estrategia3,
Estrategia4num: p.Estrategia4num,
Estrategia4: p.Estrategia4,
Estrategia5num: p.Estrategia5num,
Estrategia5: p.Estrategia5,
Estrategia6num: p.Estrategia6num,
Estrategia6: p.Estrategia6,
Estrategia7num: p.Estrategia7num,
Estrategia7: p.Estrategia7,
Estrategia8num: p.Estrategia8num,
Estrategia8: p.Estrategia8,
Estrategia9num: p.Estrategia9num,
Estrategia9: p.Estrategia9,
Estrategia10num: p.Estrategia10num,
Estrategia10: p.Estrategia10,
Estrategia11num: p.Estrategia11num,
Estrategia11: p.Estrategia11,
Estrategia12num: p.Estrategia12num,
Estrategia12: p.Estrategia12,
Estrategia13: p.Estrategia13,
Estrategia14: p.Estrategia14,
Estrategia15: p.Estrategia15,
Estrategia16: p.Estrategia16,
Estrategia17: p.Estrategia17,
Estrategia18: p.Estrategia18,
Estrategia19: p.Estrategia19,
Estrategia20: p.Estrategia20,
Estrategia21: p.Estrategia21,
Estrategia22: p.Estrategia22,
Estrategia23: p.Estrategia23,
Estrategia24: p.Estrategia24,
Estrategia25: p.Estrategia25,
Estrategia26: p.Estrategia26,
Estrategia27: p.Estrategia27,
Estrategia28: p.Estrategia28,
Estrategia29: p.Estrategia29,
Estrategia30: p.Estrategia30,
Estrategia31: p.Estrategia31,
Estrategia32: p.Estrategia32,
Estrategia33: p.Estrategia33,
Estrategia34: p.Estrategia34,
Estrategia35: p.Estrategia35,
Estrategia36: p.Estrategia36,
Estrategia37: p.Estrategia37,
Estrategia38: p.Estrategia38,
Estrategia39: p.Estrategia39,
Estrategia40: p.Estrategia40,
Estrategia41: p.Estrategia41,
Estrategia42: p.Estrategia42,
Estrategia44: p.Estrategia44,
Estrategia45: p.Estrategia45,
Estrategia46: p.Estrategia46,
Estrategia47: p.Estrategia47,
Estrategia48: p.Estrategia48,
Estrategia49: p.Estrategia49,
Estrategia50: p.Estrategia50,
Estrategia51: p.Estrategia51,
Estrategia13num: p.Estrategia13num,
Estrategia14num: p.Estrategia14num,
Estrategia15num: p.Estrategia15num,
Estrategia16num: p.Estrategia16num,
Estrategia17num: p.Estrategia17num,
Estrategia18num: p.Estrategia18num,
Estrategia19num: p.Estrategia19num,
Estrategia20num: p.Estrategia20num,
Estrategia21num: p.Estrategia21num,
Estrategia22num: p.Estrategia22num,
Estrategia23num: p.Estrategia23num,
Estrategia24num: p.Estrategia24num,
Estrategia25num: p.Estrategia25num,
Estrategia26num: p.Estrategia26num,
Estrategia27num: p.Estrategia27num,
Estrategia28num: p.Estrategia28num,
Estrategia29num: p.Estrategia29num,
Estrategia30num: p.Estrategia30num,
Estrategia31num: p.Estrategia31num,
Estrategia32num: p.Estrategia32num,
Estrategia33num: p.Estrategia33num,
Estrategia34num: p.Estrategia34num,
Estrategia35num: p.Estrategia35num,
Estrategia36num: p.Estrategia36num,
Estrategia37num: p.Estrategia37num,
Estrategia38num: p.Estrategia38num,
Estrategia39num: p.Estrategia39num,
Estrategia40num: p.Estrategia40num,
Estrategia41num: p.Estrategia41num,
Estrategia42num: p.Estrategia42num,
Estrategia44num: p.Estrategia44num,
Estrategia45num: p.Estrategia45num,
Estrategia46num: p.Estrategia46num,
Estrategia47num: p.Estrategia47num,
Estrategia48num: p.Estrategia48num,
Estrategia49num: p.Estrategia49num,
Estrategia50num: p.Estrategia50num,
Estrategia51num: p.Estrategia51num,
AutoridadImg: p.AutoridadImg,
AutoridadUpperCase: p.AutoridadUpperCase,
AutoridadTexto: p.AutoridadTexto,
Autoridad1: p.Autoridad1,
Autoridad1num: p.Autoridad1num,
Autoridad2: p.Autoridad2,
Autoridad3: p.Autoridad3,
Autoridad4: p.Autoridad4,
Autoridad5: p.Autoridad5,
Autoridad6: p.Autoridad6,
Autoridad7: p.Autoridad7,
Autoridad8: p.Autoridad8,
Autoridad9: p.Autoridad9,
Autoridad10: p.Autoridad10,
Autoridad11: p.Autoridad11,
Autoridad12: p.Autoridad12,
Autoridad13: p.Autoridad13,
Autoridad14: p.Autoridad14,
Autoridad15: p.Autoridad15,
Autoridad16: p.Autoridad16,
Autoridad17: p.Autoridad17,
Autoridad18: p.Autoridad18,
Autoridad19: p.Autoridad19,
Autoridad20: p.Autoridad20,
Autoridad21: p.Autoridad21,
Autoridad22: p.Autoridad22,
Autoridad24: p.Autoridad24,
Autoridad25: p.Autoridad25,
Autoridad2num: p.Autoridad2num,
Autoridad3num: p.Autoridad3num,
Autoridad4num: p.Autoridad4num,
Autoridad5num: p.Autoridad5num,
Autoridad6num: p.Autoridad6num,
Autoridad7num: p.Autoridad7num,
Autoridad8num: p.Autoridad8num,
Autoridad9num: p.Autoridad9num,
Autoridad10num: p.Autoridad10num,
Autoridad11num: p.Autoridad11num,
Autoridad12num: p.Autoridad12num,
Autoridad13num: p.Autoridad13num,
Autoridad14num: p.Autoridad14num,
Autoridad15num: p.Autoridad15num,
Autoridad16num: p.Autoridad16num,
Autoridad17num: p.Autoridad17num,
Autoridad18num: p.Autoridad18num,
Autoridad19num: p.Autoridad19num,
Autoridad20num: p.Autoridad20num,
Autoridad21num: p.Autoridad21num,
Autoridad22num: p.Autoridad22num,
Autoridad24num: p.Autoridad24num,
Autoridad25num: p.Autoridad25num,
DefinicionUpperCase: p.DefinicionUpperCase,
ModoDefinicion: p.ModoDefinicion,
Porcentaje: p.Porcentaje,
Areas: p.Areas,
ElementosPrincipal: p.ElementosPrincipal,
ElementosSecundario: p.ElementosSecundario,
Tiempo: p.Tiempo,
Influencia: p.Influencia,
Grafico: p.Grafico,
Perfil11num: p.Perfil11num,
Perfil10num: p.Perfil10num,
Perfil9num: p.Perfil9num,
Perfil8num: p.Perfil8num,
Perfil7num: p.Perfil7num,
Perfil6num: p.Perfil6num,
Perfil5num: p.Perfil5num,
Perfil4num: p.Perfil4num,
Perfil3num: p.Perfil3num,
Perfil2num: p.Perfil2num,
Perfil1num: p.Perfil1num,
Estrategia43: p.Estrategia43,
Estrategia43num: p.Estrategia43num,
Autoridad23: p.Autoridad23,
Autoridad23num: p.Autoridad23num,
PuertaImg1: p.PuertaImg1,
PuertaImg2: p.PuertaImg2,
PuertaImg3: p.PuertaImg3,
PuertaImg4: p.PuertaImg4,
CanalImg1: p.CanalImg1,
CanalImg2: p.CanalImg2,
CanalImg3: p.CanalImg3,
CanalImg4: p.CanalImg4,
CanalImg5: p.CanalImg5,
CanalImg6: p.CanalImg6,
CanalImg7: p.CanalImg7,
CanalImg8: p.CanalImg8,
CanalImg9: p.CanalImg9,
CanalImg10: p.CanalImg10,
CruzNombreUpperCase: p.CruzNombreUpperCase,
CruzImg: p.CruzImg,
Cruz1: p.Cruz1,
Cruz2: p.Cruz2,
Cruz3: p.Cruz3,
Cruz4: p.Cruz4,
Cruz5: p.Cruz5,
Cruz6: p.Cruz6,
Cruz7: p.Cruz7,
Cruz8: p.Cruz8,
Cruz9: p.Cruz9,
PerfilUpperCase: p.PerfilUpperCase,
PerfilImg: p.PerfilImg,
Perfil1: p.Perfil1,
Perfil2: p.Perfil2,
Perfil3: p.Perfil3,
Perfil4: p.Perfil4,
Perfil5: p.Perfil5,
Perfil6: p.Perfil6,
Perfil7: p.Perfil7,
Perfil8: p.Perfil8,
Perfil9: p.Perfil9,
Perfil10: p.Perfil10,
Perfil11: p.Perfil11,
Perfil12: p.Perfil12,
Perfil13: p.Perfil13,
Perfil14: p.Perfil14,
Perfil15: p.Perfil15,
Perfil16: p.Perfil16,
Perfil17: p.Perfil17,
Perfil18: p.Perfil18,
Perfil19: p.Perfil19,
Perfil20: p.Perfil20,
Perfil21: p.Perfil21,
Perfil22: p.Perfil22,
Perfil23: p.Perfil23,
Perfil24: p.Perfil24,
Perfil25: p.Perfil25,
Perfil12num: p.Perfil12num,
Perfil13num: p.Perfil13num,
Perfil14num: p.Perfil14num,
Perfil15num: p.Perfil15num,
Perfil16num: p.Perfil16num,
Perfil17num: p.Perfil17num,
Perfil18num: p.Perfil18num,
Perfil19num: p.Perfil19num,
Perfil20num: p.Perfil20num,
Perfil21num: p.Perfil21num,
Perfil22num: p.Perfil22num,
Perfil23num: p.Perfil23num,
Perfil24num: p.Perfil24num,
Perfil25num: p.Perfil25num,
},
};
const options = {
dataType: "buffer",
};
const anvilClient = await new Anvil({ apiKey });
const { statusCode, data } = await anvilClient.fillPDF(
"NXSN2jsh0YtxA7cDkjsY",
payload,
options
);
fs.writeFileSync(`${p.name.split(" ").join("")}.pdf`, data, {
encoding: null,
});
});
//sending email
app.post("/sendmail", async(req, res) => {
let p = req.body.params;
let transporter = nodemailer.createTransport({
host: "smtp.gmail.com",
port: 465,
secure: true,
auth: {
user: "radioheadboy0@gmail.com",
pass: "brbaricvegcwyarf",
},
});
let info = await transporter.sendMail({
attachments: [
{
filename: "TuAnalisis.pdf",
path: `./${p.name}.pdf`,
},
],
from: '"QND" <foo@example.com>',
to: p.mail,
subject: "✔ Tu analisis basico esta completo",
html: `Hola, ${p.name} <br /> Te envio tu analisis del Diseno Humano. <br /> Cualquiera consulta a tu disposicion, <br /> equipo QND `, // html body
});
res.send("sent email");
});
app.use(express.static(path.join(__dirname, '../build')));
app.listen(process.env.PORT || 3001, () => {
console.log("server listened", 3001);
});
|
import React from "react"
export default () => {
return <div>Comment box</div>
}
|
import http from 'k6/http';
const url = 'https://httpbin.test.k6.io/patch';
export default function () {
const headers = { 'Content-Type': 'application/json' };
const data = { name: 'Bert' };
const res = http.patch(url, JSON.stringify(data), { headers: headers });
console.log(JSON.parse(res.body).json.name);
}
|
import {SERVICE_URLS} from '../constants/serviceUrl';
import * as types from '../constants/actiontypes';
import axios from 'axios';
import toastr from 'toastr';
/*get equipment category*/
let getEquipmentCategory=(token)=>{
const url=SERVICE_URLS.GET_EQUIPMENT_LIST;
var config = {
headers: {'Authorization':'Token '+token}
};
const apicategoryListRequest=axios.get(url,config);
return(dispatch)=>{
return apicategoryListRequest.then(({data})=>{
dispatch({type:types.GET_EQUIPMENT_CATEGORY,apiResult:data});
}).catch((error)=>{
if(error != "Error: Request failed with status code 401"){
toastr.error(error);
}
throw(error);
});
}
};
let getEquipmentCategoryObject = (categoryId, token) =>{
const url = SERVICE_URLS.EQUIPMENT_CATEGORY_OBJECT + categoryId + '/?format=json';
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCourseRequest = axios.get(url, config);
return(dispatch) => {
return apiCourseRequest.then(({data})=>{
dispatch({type:types.GET_EQUIPMENT_CATEGORY_OBJECT,apiResult:data});
return data;
}).catch((error)=>{
toastr.error(error);
throw(error);
});
}
}
let getEquipmentCategoryDetails = (categoryId, token) =>{
const url = SERVICE_URLS.EQUIPMENT_DETAILS + categoryId + '/details/?format=json';
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCourseRequest = axios.get(url, config);
return(dispatch) => {
return apiCourseRequest.then(({data})=>{
dispatch({type:types.GET_EQUIPMENT_CATEGORY_DETAIL,apiResult:data});
return data;
}).catch((error)=>{
toastr.error(error);
throw(error);
});
}
}
let addNewEquipmentCategory=( token, name)=>{
const url=SERVICE_URLS.EQUIPMENT_ADD_CATEGORY;
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCategoryRequest=axios.post(url, {name:name}, config);
return(dispatch)=>{
return apiCategoryRequest.then(({data})=>{
}).catch((error)=>{
throw(error);
});
}
};
let addNewEquipmentCategoryPost=(id, token, subject_line)=>{
const url=SERVICE_URLS.EQUIPMENT_ADD_POST +id+'/?format=json';
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCategoryRequest=axios.post(url, {subject_line:subject_line}, config);
return(dispatch)=>{
return apiCategoryRequest.then(({data})=>{
// dispatch({type:types.GET_FORUM_COURSES,apiResult:data});
}).catch((error)=>{
throw(error);
});
}
};
let addEquipmentCategoryComment=(categoryId, id,token,body)=>{
const url=SERVICE_URLS.EQUIPMENT_CATEGORY_COMMENT + categoryId +'/'+ id + '/comments/';
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCommentRequest = axios.post(url, { body: body}, config);
return(dispatch)=>{
return apiCommentRequest.then(({data})=>{
toastr.success("Comment Added Successfully");
}).catch((error)=>{
toastr.error(error);
throw(error);
});
}
}
let searchEquipmentCategoryPosts = (token, cid, keyword) =>{
const url = SERVICE_URLS.EQUIPMENT_CATEGORY_POST_SEARCH + cid+ '/search' + '/?format=json' + '&kw=' + keyword ;
var config = {
headers: {'Authorization':'Token '+token}
};
const apiPostRequest = axios.get(url, config);
return(dispatch) => {
return apiPostRequest.then(({data})=>{
dispatch({type:types.GET_EQUIPMENT_CATEGORYLIST,apiResult:data});
}).catch((error)=>{
throw(error);
});
}
}
let searchCategory = (token, keyword) =>{
const url = SERVICE_URLS.SEARCH_EQUIPMENT_CATEGORY + '?format=json&kw='+keyword ;
var config = {
headers: {'Authorization':'Token '+token}
};
const apiCourseRequest = axios.get(url, config);
return(dispatch) => {
return apiCourseRequest.then(({data})=>{
dispatch({type:types.GET_EQUIPMENT_SEARCH_CATEGORYLIST,apiResult:data});
}).catch((error)=>{
throw(error);
});
}
}
export {getEquipmentCategory, getEquipmentCategoryObject, getEquipmentCategoryDetails, addNewEquipmentCategory, addNewEquipmentCategoryPost,
addEquipmentCategoryComment, searchEquipmentCategoryPosts, searchCategory};
|
var express = require('express');
var exec = require('node-exec-promise').exec;
var router = express.Router();
var fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
require('dotenv').config();
let id = process.env.API_KEY;
let updateFreq = process.env.UPDATE_FREQUENCY;
let url = 'https://oslobysykkel.no/api/v1';
async function getAvail() {
return await readFile('jsonfiles/avail_bergen.json', 'utf8');
}
async function getStations() {
return await readFile('jsonfiles/stations_bergen.json', 'utf8');
}
router.get('/api/v1/bergen/updatefiles', function(req, res) {
fs.stat('jsonfiles/avail_bergen.json', function(err, stats) {
let seconds = (new Date().getTime() - stats.mtime) / 1000;
if (seconds > updateFreq) {
exec('curl -H http://gbfs.urbansharing.com/bergenbysykkel.no/station_status.json').then(
function(out) {
fs.writeFile('jsonfiles/avail_bergen.json', out.stdout, 'utf8', function readFileCallback(err) {});
},
function(err) {
console.error(err);
}
);
}
});
fs.stat('jsonfiles/stations_bergen.json', function(err, stats) {
let seconds = (new Date().getTime() - stats.mtime) / 1000;
if (seconds > (updateFreq * 280)) {
exec('curl -H http://gbfs.urbansharing.com/bergenbysykkel.no/station_information.json').then(
function(out) {
fs.writeFile('jsonfiles/stations_bergen.json', out.stdout, 'utf8', function readFileCallback(err) {});
},
function(err) {
console.error(err);
}
);
}
});
function feedback(){
res.json({ success: true });
}
setTimeout(feedback, 2500);
});
router.get('/api/v1/bergen/stasjoner/:stasjoner', function(req, res) {
var avail, stations;
getAvail().then(availdata => {
getStations()
.then(stationsdata => {
avail = JSON.parse(availdata);
stations = JSON.parse(stationsdata);
})
.then(printJson => {
var stasjonsId = req.params.stasjoner.split('-');
if(stasjonsId[0] == '302'){
stasjonsId = [];
stasjonsId[0] = stations.data.stations[0].station_id;
stasjonsId[1] = stations.data.stations[1].station_id;
stasjonsId[2] = stations.data.stations[2].station_id;
}
var station = [];
for (var i = 0, len = stasjonsId.length; i < len; i++) {
if (i < 6) {
station[i] = stations.data.stations.find(item => item.station_id === stasjonsId[i]);
}
}
for (var i = 0, len = stasjonsId.length; i < len; i++) {
if (i < 6) {
station[i].status = avail.data.stations.find(item => item.station_id === stasjonsId[i]);
}
}
res.json({ station });
});
});
});
router.get('/api/v1/bergen/allestasjoner', function(req, res) {
getStations()
.then(stationsdata => {
stations = JSON.parse(stationsdata);
})
.then(printJson => {
res.json({ stations });
});
});
module.exports = router;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.