text
stringlengths 7
3.69M
|
|---|
import * as errorTypes from "../ActionTypes/errorTypes";
export const errorReducer = (state={msg: ""}, action) => {
switch (action.type) {
case errorTypes.SET_ERROR:
break;
case errorTypes.RESET_ERROR:
return {msg: ""}
default:
return state;
}
};
|
/**
* Created by Lenovo on 2017/6/21.
* 文件仅用于站点信息配置，不做其他特殊处理。
* 文件应在其他js代码执行之前进行加载。
*/
require(['../scripts/lib/zepto.js'], function () {
window.htconfig = __config = {
host: "http://139.129.205.178:8088/tuj/"
}
window.GetQueryStr = function (name) {
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
var r = window.location.search.substr(1).match(reg);
return r != null ? decodeURIComponent(r[2]) : null;
}
$.ajax = function (base) {
return function (opt) {
if (opt && opt.success) {
opt.url = opt.islocal == true ? opt.url : __config.host + opt.url;
opt.success = function (successfn) {
return function (res) {
console.log("Success=====>>is act!");
successfn.call(null, res);
}
}(opt.success);
}
base.call(null, opt);
}
}($.ajax);
})
|
export default {
props:{
subject:{
type:Object,
default(){
return {
stem:null,
branch:null,
type:null,
answer:null,
mode:null,
}
}
}
},
data(){
return {
subAnswer:null
}
},
methods:{
validateAnswer(answer){
if(this.subject.validateAnswer){
return this.subject.validateAnswer(answer)
}
return false
},
}
}
|
var wordOrder = function(phrase) {
var phraseArray = phrase.split(" ");
debugger;
var finalArray = [];
var counter = 1;
var word = phraseArray[0]
for (word = 0; word < phraseArray.length; word += 1) {
wordToCompare = PhraseArray.shift();
for (var wordPosition = 0; wordPosition < phraseArray.length; wordPosition += 1) {
if wordToCompare === phraseArray[wordPosition] {
counter+=1;
wordToRemove
}
var word = phraseArray[wordPosition2];
if (word === phraseArray[wordPosition]) {
counter+= 1;
}
var wordArray = [word, counter];
}
phraseArray.shift();
finalArray.push(wordArray);
}
return finalArray;
}
for (var wordPosition2 = 0; wordPosition2 < phraseArray.length; wordPosition2 += 1) {
|
const { spawn } = require('child_process');
function run(command, emit) {
let response = ''
return new Promise((resolve, reject) => {
const cmdArr = command.split(/[ ]/g)
console.log('command', cmdArr)
const bat = spawn('powershell.exe', cmdArr);
bat.stdout.on('data', (data) => {
response += data.toString()
// console.log('data.toString()');
console.log(data.toString());
});
bat.stderr.on('data', (data) => {
console.error(data.toString());
});
bat.on('exit', (code) => {
resolve(response)
});
})
}
function start(initialCommand) {
let response = ''
const cmdArr = initialCommand.split(/[ ]/g)
console.log('command', cmdArr)
const bat = spawn('powershell.exe', cmdArr);
const handlers = []
function emit(event) {
handlers.forEach(handler => handler(event))
}
/**
* * register a callback
* * @param {Function} handler
* */
function on(handler) {
handlers.push(handler)
}
bat.stdout.on('data', (data) => {
response += data.toString()
emit(response)
});
// bat.stdin
bat.stderr.on('data', (data) => {
console.error(data.toString());
});
bat.on('exit', (code) => {
console.log('exiting')
// resolve(response)
return
});
return { on }
}
module.exports = {
run,
start
}
|
import React from 'react';
import PropTypes from 'prop-types';
import PaginateOffset from './paginate-offset';
import PaginateSize from './paginate-size';
import PageConstants from '../../constants/pageConstants';
/**
* Hosts both pagination components (display size and page number)
*/
class PaginateContainer extends React.Component {
constructor(props) {
super(props);
this.state = {
offset: '1',
size: '25',
};
this.handlePageSize = ::this.handlePageSize;
this.handlePageOffset = ::this.handlePageOffset;
}
handlePageSize(e) {
this.setState({ size: e.target.value });
// always reset page number to avoid overshooting and mis-rendering
this.props.setPaginations(PageConstants.defaultPage, e.target.value);
}
handlePageOffset(e) {
this.setState({ offset: e.target.value });
this.props.setPaginations(e.target.value, this.state.size);
}
render() {
return (
<div id="paginate">
<PaginateOffset handlePageOffset={this.handlePageOffset} pageRange={this.props.pageRange} />
<PaginateSize text="Products Per Page" handlePageSize={this.handlePageSize} value={this.state.size} />
</div>
);
}
}
PaginateContainer.propTypes = {
setPaginations: PropTypes.func.isRequired,
pageRange: PropTypes.objectOf(PropTypes.string).isRequired,
};
export default PaginateContainer;
|
const express = require('express')
const cookieSession = require('cookie-session')
const passport = require('passport')
const bodyParser = require('body-parser')
const app = express()
const authKeys = require('./authKeys') // * Keep it below the 'dotenv'
require('../../models/User')
require('./passport')
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: false }))
// ? Using cookie based sessions and defining max Age of a cookie + cookie secret (key)
app.use(
cookieSession({
maxAge: 2592000000, // * 30 days
keys: [authKeys.cookieKey]
})
)
app.use(passport.initialize())
app.use(passport.session())
|
let fs = require('fs');
(() => {
fs.open(process.argv[2], "r", (err, fd) => {
if(err) {
throw err;
}
fs.readFile(fd, 'utf8', (err, data) => {
if(err) {
throw err;
}
let lines = data.split('\n');
let vectorData = {
v: [],
vt: [],
vn: [],
};
let outputData = {
vertices: [],
vertexTextureCoordinates: [],
vertexNormals: []
}
lines.forEach((line, index, array) => {
let lineContent = line.split(" ");
switch(lineContent[0]) {
case "v": {
let floatArray = ParseFloatArray([lineContent[1], lineContent[2], lineContent[3]], false);
vectorData.v.push(floatArray);
}
break;
case "vt": {
let floatArray = ParseFloatArray([lineContent[1], lineContent[2]], false);
vectorData.vt.push(floatArray);
}
break;
case "vn": {
let floatArray = ParseFloatArray([lineContent[1], lineContent[2], lineContent[3]], false);
vectorData.vn.push(floatArray);
}
break;
// faces are guranteed to come after we've parsed all of the vector data so these operations are safe.
case "f": {
let face = [];
face.push(ParseFloatArray(lineContent[1].split("/"), true));
face.push(ParseFloatArray(lineContent[2].split("/"), true));
face.push(ParseFloatArray(lineContent[3].split("/"), true));
face.forEach((vertexPropertyIndex, index, array) => {
let vertexTextureCoordinate = [];
if(vertexPropertyIndex[1] !== -1) {
vertexTextureCoordinate = vectorData.vt[vertexPropertyIndex[1]];
}
outputData.vertices.push(vectorData.v[vertexPropertyIndex[0]]);
if(vertexTextureCoordinate.length !== 0) {
outputData.vertexTextureCoordinates.push(vertexTextureCoordinate);
}
outputData.vertexNormals.push(vectorData.vn[vertexPropertyIndex[2]]);
});
}
break;
}
});
//generate the json as a javascript variable
let objectAsJSONString = JSON.stringify(outputData, null, 4);
let arrayRegex = /(\[)\n\s*([+-]?[0-9]*[.]?[0-9]+[\,]?)\n\s*([+-]?[0-9]*[.]?[0-9]+[\,]?)\n\s*([+-]?[0-9]*[.]?[0-9]+[\,]?)\n\s*(\])([\,]?)/g;
let pathWithoutExtension = process.argv[2].split(".")[1];
let prettyJson = "let " + pathWithoutExtension.split("/")[pathWithoutExtension.split("/").length - 1] + "ObjectAttributes = \n" + objectAsJSONString.replace(arrayRegex, '$2 $3 $4$6');
let textureCoordRegex = /(\[)\n\s*([+-]?[0-9]*[.]?[0-9]+[\,]?)\n\s*([+-]?[0-9]*[.]?[0-9]+[\,]?)\n\s*(\])([\,]?)/g;
prettyJson = prettyJson.replace(textureCoordRegex, "$2 $3$5");
if(!fs.existsSync("." + (pathWithoutExtension.split("/").slice(0, pathWithoutExtension.split("/").length - 1).join("/")))) {
fs.mkdirSync("." + (pathWithoutExtension.split("/").slice(0, pathWithoutExtension.split("/").length - 1).join("/")));
}
// write variable to javascript file
fs.open("." + pathWithoutExtension + "Model.js", "w", (err, fd) => {
if(err) {
throw err;
}
fs.write(fd, prettyJson, "utf8", (err) => {
if(err) {
throw err;
}
});
});
});
});
})();
function ParseFloatArray(array, isIndex) {
let floatArr = [];
array.forEach((value, index, arr) => {
if(value === "") {
value = '0.0';
}
value = parseFloat(value);
if(isIndex) {
value--;
}
floatArr.push(value);
});
return floatArr;
}
|
// only use service worker if Chrome or Firefox -- Safari is problematic
if (navigator.userAgent.search("Chrome") >= 0 || navigator.userAgent.search("Firefox") >= 0) {
// register a service worker
if (navigator.serviceWorker) {
navigator.serviceWorker.register('/sw.js')
.then(function(reg) {
console.log("service worker registered!");
}).catch(function(error) {
console.log("service worker NOT registered!");
});
}
}
|
export let getSpreadseetId = (state) => {
return state.spreadsheetPage.spreadseetId;
}
|
import React from 'react'
import {connect} from 'react-redux'
import {compose, withHandlers, onlyUpdateForKeys, withPropsOnChange} from 'recompose'
// local libs
import {
getRouterContext,
plainProvedGet as g,
immutableProvedGet as ig,
PropTypes,
ImmutablePropTypes,
setPropTypes,
breakpoints,
imagesRandomWidth,
} from 'src/App/helpers'
import {routerContextModel} from 'src/App/models'
import {immutableVideoItemModel} from 'src/generic/VideoItem/models'
import routerGetters from 'src/App/routerGetters'
import VideoItem from 'src/generic/VideoItem'
import {List} from 'src/generic/VideoList/assets'
import nicheActions from 'src/App/Niche/actions'
import pornstarActions from 'src/App/Pornstar/actions'
import findVideosActions from 'src/App/FindVideos/actions'
import favoriteActions from 'src/App/Favorite/actions'
import appActions from 'src/App/actions'
import {NICHE, PORNSTAR, FIND_VIDEOS, FAVORITE} from 'src/App/constants'
const
VideoList = props => <List>
{ ! g(props, 'styledBounds') ? null : g(props, 'videoList').map((x, idx) => <VideoItem
style={ig(props.styledBounds, `${idx}`)}
key={ig(x, 'id')}
x={x}
cb={g(props, 'cb')}
isSSR={g(props, 'isSSR')}
favoriteVideoList={g(props, 'favoriteVideoList')}
addVideoToFavoriteHandler={g(props, 'addVideoToFavoriteHandler')}
removeVideoFromFavoriteHandler={g(props, 'removeVideoFromFavoriteHandler')}
getVideoLink={g(props, 'getVideoLink')}
getSearchLink={g(props, 'getSearchLink')}
/>)}
</List>
export default compose(
connect(
(state, props) => ({
cb: state.getIn(['app', 'ui', 'currentBreakpoint']),
isSSR: ig(state, 'app', 'ssr', 'isSSR'),
routerContext: getRouterContext(state),
favoriteVideoList: ig(state, 'app', 'ui', 'favoriteVideoList'),
randomWidthList:
ig(state, 'app', g(props, 'videoListRandomWidthForPage'), 'randomWidthList'),
}),
{
addVideoToFavorite: g(appActions, 'addVideoToFavorite'),
removeVideoFromFavorite: g(appActions, 'removeVideoFromFavorite'),
setRandomWidthListForNiche: g(nicheActions, 'setRandomWidthList'),
setRandomWidthListForPornstar: g(pornstarActions, 'setRandomWidthList'),
setRandomWidthListForFindVideos: g(findVideosActions, 'setRandomWidthList'),
setRandomWidthListForFavorite: g(favoriteActions, 'setRandomWidthList'),
}
),
onlyUpdateForKeys(['cb', 'favoriteVideoList', 'videoList']),
withHandlers({
setRandomWidthList: props => x => {
switch (g(props, 'videoListRandomWidthForPage')) {
case NICHE:
props.setRandomWidthListForNiche(x)
break
case PORNSTAR:
props.setRandomWidthListForPornstar(x)
break
case FIND_VIDEOS:
props.setRandomWidthListForFindVideos(x)
break
case FAVORITE:
props.setRandomWidthListForFavorite(x)
break
default:
break
}
},
addVideoToFavoriteHandler: props => event => {
event.preventDefault()
const
id = Number(g(event.currentTarget.getAttribute('data-favorite-video-id'), [])),
x = props.videoList.find(x => ig(x, 'id') === id)
props.addVideoToFavorite(x)
},
removeVideoFromFavoriteHandler: props => event => {
event.preventDefault()
const
id = Number(g(event.currentTarget.getAttribute('data-favorite-video-id'), [])),
x = props.videoList.find(x => ig(x, 'id') === id)
props.removeVideoFromFavorite(ig(x, 'id'))
},
getVideoLink: props => x => routerGetters.video.link(
g(props, 'routerContext'),
ig(x, 'videoPageRef'),
ig(x, 'title')
),
getSearchLink: props => x => routerGetters.findVideos.link(
g(props, 'routerContext'),
{searchQuery: x},
['searchQuery'],
),
}),
withPropsOnChange(['data'], props => ({
randomWidthListSize: g(props, 'videoList', 'size'),
})),
imagesRandomWidth,
setPropTypes(process.env.NODE_ENV === 'production' ? null : {
cb: PropTypes.oneOf(breakpoints),
isSSR: PropTypes.bool,
routerContext: routerContextModel,
videoList: ImmutablePropTypes.listOf(immutableVideoItemModel),
favoriteVideoList: ImmutablePropTypes.listOf(PropTypes.number),
videoListRandomWidthForPage: PropTypes.string,
addVideoToFavorite: PropTypes.func,
addVideoToFavoriteHandler: PropTypes.func,
removeVideoFromFavorite: PropTypes.func,
removeVideoFromFavoriteHandler: PropTypes.func,
getVideoLink: PropTypes.func,
getSearchLink: PropTypes.func,
setRandomWidthList: PropTypes.func,
setRandomWidthListForNiche: PropTypes.func,
setRandomWidthListForPornstar: PropTypes.func,
setRandomWidthListForFindVideos: PropTypes.func,
setRandomWidthListForFavorite: PropTypes.func,
})
)(VideoList)
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = insertTable;
var _prosemirrorModel = require('prosemirror-model');
var _prosemirrorState = require('prosemirror-state');
var _prosemirrorTransform = require('prosemirror-transform');
var _NodeNames = require('./NodeNames');
var ZERO_WIDTH_SPACE_CHAR = '\u200B';
function insertTable(tr, schema, rows, cols) {
if (!tr.selection || !tr.doc) {
return tr;
}
var _tr$selection = tr.selection,
from = _tr$selection.from,
to = _tr$selection.to;
if (from !== to) {
return tr;
}
var nodes = schema.nodes;
var cell = nodes[_NodeNames.TABLE_CELL];
var paragraph = nodes[_NodeNames.PARAGRAPH];
var row = nodes[_NodeNames.TABLE_ROW];
var table = nodes[_NodeNames.TABLE];
if (!(cell && paragraph && row && table)) {
return tr;
}
var rowNodes = [];
for (var rr = 0; rr < rows; rr++) {
var cellNodes = [];
for (var cc = 0; cc < cols; cc++) {
var textNode = schema.text(ZERO_WIDTH_SPACE_CHAR);
var paragraphNode = paragraph.create({}, _prosemirrorModel.Fragment.from(textNode));
var cellNode = cell.create({}, _prosemirrorModel.Fragment.from(paragraphNode));
cellNodes.push(cellNode);
}
var rowNode = row.create({}, _prosemirrorModel.Fragment.from(cellNodes));
rowNodes.push(rowNode);
}
var tableNode = table.create({}, _prosemirrorModel.Fragment.from(rowNodes));
tr = tr.insert(from, _prosemirrorModel.Fragment.from(tableNode));
var selection = _prosemirrorState.TextSelection.create(tr.doc, from + 5, from + 5);
tr = tr.setSelection(selection);
return tr;
}
|
'use strict';
// Load modules
const Chalk = require('chalk');
// Declare internals
const internals = {
TIMEOUT: 30 * 1000
};
exports.plugin = {
name: 'gracefully',
register: async function (server, options) {
// Handle Break
process.on('SIGINT', async function () {
try {
await server.stop({
timeout: internals.TIMEOUT
});
console.log(Chalk.green('Server stopped'));
process.exit(0);
}
catch (e) {
console.error(Chalk.red('Server failed to shut down gracefully'), e);
process.exit(1);
}
});
}
};
|
// initialization
var dateOfBirth = document.querySelector("#date-of-birth");
var luckyNumber = document.querySelector("#lucky-number");
var checkNumber = document.querySelector("#check-number");
var outputBox = document.querySelector("#output-box");
checkNumber.addEventListener("click", checkBirthdayIsLucky);
function checkBirthdayIsLucky() {
console.log(dateOfBirth.value, luckyNumber.value);
var birthDate = dateOfBirth.value;
var addSum = calculateSum(birthDate);
var luckyNumberValue = luckyNumber.value;
if(addSum && birthDate) {
if(addSum % luckyNumberValue === 0) {
outputBox.innerHTML = "Your Birthday is lucky!🎉🎊";
} else {
outputBox.innerHTML ="Your Birthday is NOT lucky, so sad! 😑";
}
} else {
outputBox.innerHTML = "Enter both the fields! 👏";
}
}
function calculateSum(birthDate) {
var addNum = 0;
for(var i=0;i<birthDate.length;i++) {
if(birthDate[i] == "-") {
continue;
} else {
addNum = addNum + Number(birthDate[i]);
}
}
return addNum;
}
|
import React from 'react'
import Lottie from "react-lottie"
import Typography from '@material-ui/core/Typography'
import Grid from '@material-ui/core/Grid'
import {useTheme, makeStyles} from '@material-ui/core/styles'
import useMediaQuery from '@material-ui/core/useMediaQuery'
const useStyles = makeStyles(theme=>({
textContainer:{
width:'25rem',
textAlign:'right',
[theme.breakpoints.down(1530)]:{
marginLeft:'4rem',
},
[theme.breakpoints.down('sm')]:{
width:'100%',
textAlign:'center',
marginLeft:0
}
}
}))
const AnimationTextBlock = ({ header, body, animation, animationStyles }) => {
const theme=useTheme()
const matchSM= useMediaQuery(theme.breakpoints.down('sm'))
const classes=useStyles()
const defaultOptions = {
loop: true,
autoplay: true,
animationData: animation,
rendererSettings: {
preserveAspectRatio: 'xMidYMid slice'
}
}
return (
<Grid container justify={ matchSM?'center':'flex-end'} >
<Grid item style={{marginTop:matchSM? 0 :'2rem'}}>
<Lottie options={defaultOptions} style={animationStyles}
/>
</Grid>
<Grid item >
<Grid container direction='column' className={classes.textContainer} >
<Grid item>
<Typography variant='h4'>{header}</Typography>
</Grid>
<Grid item>
<Typography variant='body1' >{body}</Typography>
</Grid>
</Grid>
</Grid>
</Grid>
)
}
export default AnimationTextBlock
|
{
const playGame = function (playerInput){
clearMessages();
const getMoveName = function (argMoveId){
if(argMoveId == 1){
return 'kamień';
}
else if(argMoveId == 2) {
return 'papier';
}
else if(argMoveId == 3) {
return 'nożyce';
}
}
const displayResult = function (argComputerMove, argPlayerMove) {
console.log(argComputerMove);
if( argComputerMove == 'kamień' && argPlayerMove == 'papier'){
printMessage('Ty wygrywasz!');
}
else if (argComputerMove == 'papier' && argPlayerMove == 'nożyce') {
printMessage('Ty wygrywasz!');
}
else if (argComputerMove == 'nożyce' && argPlayerMove == 'kamień') {
printMessage('Ty wygrywasz!');
}
else if (argComputerMove == 'nożyce' && argPlayerMove == 'papier') {
printMessage('Niestety przegrywasz!');
}
else if (argComputerMove == 'papier' && argPlayerMove == 'kamień') {
printMessage('Niestety przegrywasz!');
}
else if (argComputerMove == 'kamień' && argPlayerMove == 'nożyce') {
printMessage('Niestety przegrywasz!');
}
else if (argComputerMove == 'papier' && argPlayerMove == 'papier') {
printMessage('Remis!');
}
else if (argComputerMove == 'kamień' && argPlayerMove == 'kamień') {
printMessage('Remis!');
}
else if (argComputerMove == 'nożyce' && argPlayerMove == 'nożyce') {
printMessage('Remis!');
}
else {
printMessage('nieznany ruch!')
}
}
// computer turn
const randomNumber = Math.floor(Math.random() * 3 + 1);
console.log('Wylosowana liczba to: ' + randomNumber);
const computerMove = getMoveName(randomNumber);
printMessage('Mój ruch to: ' + computerMove);
//player turn
console.log('Gracz wpisał: ' + playerInput);
const playerMove = getMoveName(playerInput);
printMessage('Twój ruch to: ' + playerMove);
// display result
displayResult(computerMove, playerMove);
}
const buttonFirst = document.getElementById('play-rock');
buttonFirst.addEventListener('click' , function() {
playGame('1');
});
const buttonPaper = document.getElementById('play-paper');
buttonPaper.addEventListener('click', function() {
playGame('2');
});
const buttonScissors = document.getElementById('play-scissors');
buttonScissors.addEventListener('click', function() {
playGame('3');
});
}
|
const { validationResult } = require("express-validator");
const models = require('../models');
const { returnUserByToken } = require("../middleware");
const get = async (req,res) => {
try {
const user = await returnUserByToken(req);
if(req.query.id){
const carrier = await models.Carrier.findOne({
where:{ user_id : user.id, id},
include: ["carrier_addresses"]
});
return res.status(200).send(carrier);
}
const carriers = await models.Carrier.findAll({
where:{ user_id : user.id },
include: ["carrier_addresses"]
});
return res.status(200).send(carriers);
} catch (error) {
return res.status(500).send(error);
}
}
const create = async (req,res) => {
try {
const errors = validationResult(req);
const user = await returnUserByToken(req);
if(!errors.isEmpty()){
return res.status(422).send({ errors: errors.array()})
}
const carrier = await models.Carrier.create({
...req.body,
base_price: Math.round(req.body.base_price),
extra_price: Math.round(req.body.extra_price),
user_id:user.id
});
return res.status(200).send(carrier);
} catch (error) {
return res.status(500).send(error);
}
}
const update = async (req,res) => {
try {
const { id } = req.params;
const carrier = await models.Carrier.findOne({where:{ id }});
if(!carrier) return res.status(404).send({ message:"bad id" });
carrier.update({
...req.body
})
carrier.save()
return res.status(200).send(carrier);
} catch (error) {
return res.status(500).send(error);
}
}
async function destroy(req,res){
try {
const { id } = req.params;
await models.Carrier.destroy({where:{ id }});
return res.status(200).send({ message:"success" });
} catch (error) {
return res.status(500).send(error);
}
}
module.exports = {
get,
create,
update,
destroy,
}
|
import React, {Component} from 'react';
import {BrowserRouter, Route} from "react-router-dom";
import MuiThemeProvider from "@material-ui/core/styles/MuiThemeProvider";
import './App.css';
import {Switch} from "react-router";
import ButtonAppBar from "./mainComponents/headerbar";
import SignIn from "./auth/login";
import theme from "./theme";
class App extends Component {
render() {
return (
<BrowserRouter>
<MuiThemeProvider theme={theme}>
<div>
<Switch>
<Route path="/" component={ButtonAppBar}/>
<Route path="/login" component={SignIn}/>
</Switch>
</div>
</MuiThemeProvider>
</BrowserRouter>
);
}
}
export default App;
|
/**
* Created by eriy on 27.02.15.
*/
var TABLES = require( '../constants/tables' );
module.exports = function ( PostGre, ParentCollection ) {
var Collection = ParentCollection.extend({
model: PostGre.Models[TABLES.KIT_ORDERS]
});
return Collection;
};
|
module.exports = {
docs: [
{
type: 'category',
label: 'Guides',
collapsed: false,
items: ['concept', 'getting-started', 'breakpoints', 'margin-padding', 'styling', 'intersection-observer', 'typescript', 'control', 'nextjs', 'migrate'],
},
{
type: 'category',
label: 'API',
collapsed: false,
items: ['box', 'use-raster'],
},
{
type: 'category',
label: 'Examples',
collapsed: false,
items: ['example-basic', 'modify-box', 'intersection-fade', 'intersection-fade-scrollbound', 'box-motion', 'motion-link'],
},
],
};
|
import React from "react";
import { useState } from "react";
import { useDispatch, useSelector } from "react-redux";
import ModalEditTask from "../components/Modals/ModalEditTask";
import { actionModalHide } from "../store/modals";
import { actionEditTodo } from "../store/todos";
import { getTodo } from "../store/todos/selectors/index";
export default function ModelEditTaskContainer({id}) {
const { point } = useSelector((state) => getTodo(state));
const findTask = point.find((item) => item.idTask === id);
const dispatch = useDispatch();
const [update, updateValue] = useState({
title: findTask.title,
task: findTask.task,
});
console.log(update)
const handlerChangeInputTitle = (event) => {
return updateValue({
...update,
title: event.target.value,
});
};
const handlerChangeInputTask = (event) => {
return updateValue({
...update,
task: event.target.value,
});
};
const hideModal = () => {
dispatch(actionModalHide());
};
const handlerEditTodo = () => {
const data = {
title: update.title,
task: update.task,
id
}
dispatch(actionEditTodo(data));
hideModal();
}
return (
<ModalEditTask
update={update}
findTask={findTask}
hideModal={hideModal}
handlerChangeInputTitle={handlerChangeInputTitle}
handlerChangeInputTask={handlerChangeInputTask}
handlerEditTodo={handlerEditTodo}
/>
);
}
|
import {observable, computed, autorun, decorate, when} from 'mobx';
import Position from './Position'
const COLORS = ['#FF2600', '#FF9300', '#FEFB00', '#8DF900', '#0096FF', '#9437FF', '#FF40FF', '#FF2F92'];
export class Brick extends Position {
@observable color;
constructor(x, y, color){
super(x, y);
this.color = color;
}
set position(pos){
this.x = pos.x;
this.y = pos.y;
}
@computed get position(){
return this;
}
}
export function createBlackBrick(position){
return new Brick(position.x, position.y, '#000000');
}
export function createRandomColorBrick(position){
const i = Math.floor(Math.random() * COLORS.length);
return new Brick(position.x, position.y, COLORS[i]);
}
|
import React from 'react'
import { storiesOf } from '@storybook/react'
import Button from '../Button'
import ButtonGroup from './index'
storiesOf('core|Form Controls/Button Group', module)
.add(
'with defaults',
() => (
<ButtonGroup>
<Button>Button 1</Button>
<Button>Button 2</Button>
<Button>Button 3</Button>
</ButtonGroup>
),
{
info: `Demonstrates default rendering of ButtonGroup component`,
}
)
.add(
'center aligned',
() => (
<ButtonGroup align="center">
<Button>Button 1</Button>
<Button>Button 2</Button>
<Button>Button 3</Button>
</ButtonGroup>
),
{
info: `Demonstrates center aligned ButtonGroup`,
}
)
.add(
'right aligned',
() => (
<ButtonGroup align="right">
<Button>Button 1</Button>
<Button>Button 2</Button>
<Button>Button 3</Button>
</ButtonGroup>
),
{
info: `Demonstrates right aligned ButtonGroup`,
}
)
|
//fluid main
// For web API
var express = require('express');
var serverAppAPI = express();
var http = require('http').Server(serverAppAPI);
var io = require('socket.io')(http);
// For socket based communication
var net = require('net');
var osc = require('node-osc'); //include node-osc library https://github.com/TheAlphaNerd/node-osc
var fs = require('fs'); // For loading all files into the global namespace - hacky but works..
// Plugins
global._ = require('./scripts/plugins/underscore.js');
globalNetStateJson = undefined; // we always run the net logic on the server
isNode = true;
var basePath = "./scripts/graph/";
var jsFiles = ['configuration.js', 'Util.js', 'NeuralNetLayer.js', 'SignalLayer.js', 'RandomLayer.js',
'OrgasmLayer.js',
'Layers.js', 'Vertice.js', 'Edge.js', 'Net.js', 'netGen.js', 'fluideSelfNetwork.js',
'stateTranslator.js'
];
var networkDef = require(basePath + 'networkDef.js');
for (var i=0; i<jsFiles.length; i++) {
var location = "./" + basePath + jsFiles[i];
eval(fs.readFileSync(location)+'');
}
var clientAPI = createClient('127.0.0.1', 6699, 'fluidServerModule', function(data) {
console.log("DATA from : 'fluidServerModule'" + data);
});
var modulesArr = [
require(basePath + 'sensorAdapterModule.js').sensorAdapterModule(),
require(basePath + 'fluidServerModule.js').fluidServerModule(clientAPI)
];
createWebServerAPI();
runFluid(networkDef.networkDef, modulesArr);
function runFluid(networkDefinition, modules){
// var modulesArr = [fluidServerModule(clientAPI)];
var netToRun = buildFLuideSelfNetwork(networkDefinition, modules);
// console.log('e: ' + netToRun.allEdges.length + ', v:' + netToRun.allVertices.length)
gloablRunningNetObj = netToRun; // Hacky !!!
var mainTicker = function() {
netToRun.checkAndSetParams(conf);
// netToRun.checkAndSetParams('verticeProbability');
netToRun.prepareExternalDataForNextCycle();
netToRun.updateRoots();
netToRun.determineCurrentState();
netToRun.determineNetworkEffect();
// Paint edges of the signaling vertices
netToRun.relayNetStateToExternalConsumer();
netToRun.tick(); // Render the net
netToRun.causeNetworkEffect();
netToRun.prepareForNextState();
setTimeout(mainTicker, conf.cycleTime);
};
setTimeout(mainTicker, conf.cycleTime);
}
function createClient(host, port, name, dataFunction) {
var client = new osc.Client(host, port);
return client;
}
// https://github.com/rauchg/chat-example
function createWebServerAPI() {
var serverAPI_PORT = '3333';
serverAppAPI.get('/', function(req, res){
var path = __dirname + '/index.html';
console.log('loading: ' + path);
res.sendFile(path);
});
serverAppAPI.use('/scripts', express.static(__dirname + '/scripts'));
io.on('connection', function(socket){
socket.on('chat message', function(msg){
io.emit('chat message', msg);
console.log('Browser said: ' + msg);
});
socket.on('change_conf', function(msg){
conf = JSON.parse(msg);
globalNetObject.checkAndSetParams(conf);
console.log('New Configuration: ' + JSON.stringify(conf));
});
socket.on('touch_edge', function(msg){
var id = JSON.parse(msg);
console.log('Vertice ' + id + ' touched by browser');
var v = _.findWhere(gloablRunningNetObj.netVertices, {id: id});
v.triggerSignal();
});
socket.on('update_webgl_view', function(msg){
io.emit('update_webgl_view', (stateTranslator.translate(gloablRunningNetObj)));
});
});
http.listen(serverAPI_PORT, function(){
console.log('listening on localhost:' + serverAPI_PORT);
});
}
|
import { useState, useEffect } from "react";
import getCharactersMatrix from "./getCharactersMatrix";
import useCharacterColumns from "../configuration/useCharacterColumns.hook";
import useMoveCursorSound from "../configuration/useMoveCursorSound.hook";
export default function useCharacterIndex(characters, input, initialIndex = 0) {
const moveCursorSound = useMoveCursorSound();
const columnCount = useCharacterColumns();
const [selectedIndex, selectIndex] = useState(initialIndex);
useEffect(() => {
const newSelectedIndex = initialIndex < characters.length ? initialIndex : 0;
selectIndex(newSelectedIndex);
const matrix = getCharactersMatrix(characters, columnCount);
let selectedRowIndex = 0;
let selectedColumnIndex = 0;
let index = 0;
for (let rowIndex = 0; rowIndex < matrix.length; rowIndex++) {
const row = matrix[rowIndex];
for (let columnIndex = 0; columnIndex < row.length; columnIndex++) {
if (index === newSelectedIndex) {
selectedRowIndex = rowIndex;
selectedColumnIndex = columnIndex;
}
index++;
}
}
const getSelectedIndexFromMatrix = () => {
let selectedIndexFromMatrix = 0;
for (let rowIndex = 0; rowIndex < matrix.length; rowIndex++) {
const row = matrix[rowIndex];
for (let columnIndex = 0; columnIndex < row.length; columnIndex++) {
if (rowIndex === selectedRowIndex && columnIndex === selectedColumnIndex) {
return selectedIndexFromMatrix;
}
selectedIndexFromMatrix++;
}
}
return selectedIndexFromMatrix;
};
const decreaseColumnIndex = () => {
if (selectedColumnIndex > 0) {
selectedColumnIndex -= 1;
} else {
selectedColumnIndex = matrix[selectedRowIndex].length - 1;
}
selectIndex(getSelectedIndexFromMatrix());
moveCursorSound.play();
};
const increaseColumnIndex = () => {
selectedColumnIndex = (selectedColumnIndex + 1) % matrix[selectedRowIndex].length;
selectIndex(getSelectedIndexFromMatrix());
moveCursorSound.play();
};
const decreaseRowIndex = () => {
if (selectedRowIndex > 0) {
selectedRowIndex -= 1;
} else {
for (let rowIndex = matrix.length - 1; rowIndex >= 0; rowIndex--) {
if (selectedColumnIndex < matrix[rowIndex].length) {
selectedRowIndex = rowIndex;
break;
}
}
}
selectIndex(getSelectedIndexFromMatrix());
moveCursorSound.play();
};
const increaseRowIndex = () => {
selectedRowIndex = (selectedRowIndex + 1) % matrix.length;
if (selectedColumnIndex >= matrix[selectedRowIndex].length) {
selectedRowIndex = 0;
}
selectIndex(getSelectedIndexFromMatrix());
moveCursorSound.play();
};
input.addEventListener("left", decreaseColumnIndex);
input.addEventListener("right", increaseColumnIndex);
input.addEventListener("up", decreaseRowIndex);
input.addEventListener("down", increaseRowIndex);
return () => {
input.removeEventListener("left", decreaseColumnIndex);
input.removeEventListener("right", increaseColumnIndex);
input.removeEventListener("up", decreaseRowIndex);
input.removeEventListener("down", increaseRowIndex);
};
}, [input, characters, columnCount, initialIndex, moveCursorSound]);
return selectedIndex;
}
|
/*!
* SAP UI development toolkit for HTML5 (SAPUI5)
*
* (c) Copyright 2009-2014 SAP SE. All rights reserved
*/
jQuery.sap.declare("sap.m.VBoxRenderer");jQuery.sap.require("sap.m.FlexBoxRenderer");sap.m.VBoxRenderer={};
sap.m.VBoxRenderer.render=function(r,c){sap.m.FlexBoxRenderer.render.apply(this,[r,c])};
|
/* Create a new list item when clicking on the "Add" button */
/* Function for primary tag in advanced search: when click in Add button */
function newElement1() {
var li = document.createElement("li");
var inputValue = document.getElementById("primarytag").options[document.getElementById("primarytag").selectedIndex].text;
var t = document.createTextNode(inputValue);
li.appendChild(t);
var containerPrimaryTag = document.getElementById("myUL1")
var size1 = containerPrimaryTag.getElementsByTagName("li").length;
if (inputValue === 'Select primarytag:') {
$.growl.error({ message: "You must select something."});
}
else if (size1 < 1) {
containerPrimaryTag.appendChild(li);
}
else {
$.growl.error({ message: "You can't add more than one primary tag." });
}
document.getElementById("primarytag").options[document.getElementById("primarytag").selectedIndex].text;
var spanPrimaryTag = document.createElement("SPAN");
var txt = document.createTextNode("\u00D7");
spanPrimaryTag.className = "close";
spanPrimaryTag.appendChild(txt);
li.appendChild(spanPrimaryTag);
spanPrimaryTag.onclick = function() {
containerPrimaryTag.removeChild(li);
}
}
/* Function for secondary tag in advanced search: when click in Add button */
function newElement2() {
var li = document.createElement("li");
var inputValue = document.getElementById("secondarytag").options[document.getElementById("secondarytag").selectedIndex].text;
var t = document.createTextNode(inputValue);
li.appendChild(t);
var containerSecondaryTag = document.getElementById("myUL2")
var size2 = containerSecondaryTag.getElementsByTagName("li").length;
if (inputValue === 'Select secondarytag:') {
$.growl.error({ message: "You must select something." });
}
else if (size2 < 3) {
containerSecondaryTag.appendChild(li);
}
else {
$.growl.error({ message: "You can't add more than three secondary tags." });
}
document.getElementById("secondarytag").options[document.getElementById("secondarytag").selectedIndex].text;
var spanSecondaryTag = document.createElement("SPAN");
var txt = document.createTextNode("\u00D7");
spanSecondaryTag.className = "close";
spanSecondaryTag.appendChild(txt);
li.appendChild(spanSecondaryTag);
spanSecondaryTag.onclick = function() {
containerSecondaryTag.removeChild(li);
}
}
/* function that shows or hide the advanced research element */
function showAdvancedSearch() {
// selecting the right component
var researchBar = document.getElementById("advancedResearchContent");
// if not displayed, display it
if(researchBar.style.display == "none") {
researchBar.style.display = "block";
} else {
// if displayed, remove it
researchBar.style.display = "none";
}
}
function getIDsPrimaryTag() {
var elements = document.getElementById("myUL1").getElementsByTagName("li");
//for (i = 0; i < elements.length; i++) {
var elem = elements[0];
var id1 = elem.innerText;
id1 = id1.split(" ");
//alert(id1[0]);
//}
return id1[0];
}
|
(function() {
'use strict';
angular
.module('app')
.config(config);
config.injector = ['$stateProvider', '$urlRouterProvider'];
function config($stateProvider, $urlRouterProvider) {
$urlRouterProvider.otherwise('/');
$stateProvider
.state('games', {
url: '/games',
templateUrl: 'templates/games/index.html',
controller: 'GamesController as games'
});
}
})();
|
var EventSocket = require('/event-socket/event-socket'),
WebSocketServer = require('ws').Server,
port = process.env.PORT || 8080
;
var wss = new WebSocketServer({ port: port });
wss.on('connection', function(socket) {
console.log("CONNECTION");
var es = new EventSocket(socket);
es.send("welcome", "You are now connected.");
es.on('ping', function(data) {
es.send('pong', data);
});
es.on('stream', function(data) {
console.log('STREAM DATA: ', data);
});
});
|
import {resolve} from 'path';
export default {
routes: [
{
path: '/',
component: '../layouts/index',
routes: [
{path: '/', redirect: '/index'},
{path: '/index', component: './find/components/'},
{path: '/home', component: './home/components/'},
{path: '/404', component: './404'},
{path: '/403', component: './403'},
{path: '/500', component: './500'},
]
}
],
plugins: [
['umi-plugin-react', {
default: 'zh-CN',
antd: true,
dva: {
immer: true,
},
dynamicImport: false,
title: '区块链文档预览',
dll: false,
// routes: {
// exclude: [],
// },
hardSource: false,
}],
],
alias: {
components: resolve(__dirname, 'src/components/'),
node_modules: resolve(__dirname, 'src/node_modules/'),
utils: resolve(__dirname, 'src/utils'),
assets: resolve(__dirname, 'src/assets'),
},
proxy: {
'/api': {
target: 'http://127.0.0.1:8080',
changeOrigin: true,
},
},
};
|
var feeds = require('../services/feeds');
var matches = require('../services/matches');
var sf = require('simpleflow');
exports['clear data'] = function (test) {
test.async();
matches.useMemory();
matches.clear(function (err, data) {
test.ok(!err);
test.done();
});
};
exports['load new tipgin live score'] = function (test) {
test.async();
feeds.read('http://www.tipgin.net/datav2/accounts/btafel/soccer/livescore/livescore.xml', function (err, data) {
test.ok(!err);
test.ok(data);
test.equal(typeof data, 'object');
test.done();
});
};
|
/**
* @param {string} s
* @return {string}
*/
const makeStringValid = (s) => {
let chars = s.split('');
let openStack = [];
let deleteIndexes = [];
for (let i = 0; i < chars.length; i++) {
let char = chars[i];
if (char === ')') {
if (openStack.length === 0) {
deleteIndexes.push(i);
} else {
openStack.pop();
}
} else if (char === '(') {
openStack.push(i);
}
}
while (openStack.length > 0) {
deleteIndexes.push(openStack.pop());
}
while (deleteIndexes.length > 0) {
let deleteIndex = deleteIndexes.pop();
delete chars[deleteIndex];
}
return chars.join('');
};
console.log(makeStringValid('((()'));
console.log(
makeStringValid(
'(abcd(ad(adfdf(d)fd)fdfdf)f)g)gg)g)tg)tg)g)g(tgs(ty)t(ty)t(y)ty(tyt)))((bgghgf))gfgf)fgfgg'
)
);
console.log(makeStringValid('a)b(c)d'));
|
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const UserProfileSchema = new Schema({
name: { type: String, required: true, unique: true },
ownTenant: { type: Schema.Types.ObjectId, required: true },
ownProjects: { type: [{ id: Schema.Types.ObjectId }], required: true },
}, {
timestamps: true,
});
module.exports = mongoose.model('userprofile', UserProfileSchema);
|
function setActiveTab(evt)
{
var i, tablinks;
tablinks = document.getElementsByClassName("tablinks");
for(i = 0; i < tablinks.length; i++)
{
tablinks[i].className = tablinks[i].className.replace(" active", "");
}
evt.currentTarget.className += " active";
}
function changeContent(name)
{
if(name === "reg")
{
var removeContent = document.getElementById('sign');
removeContent.style.display = 'none';
var addContent = document.getElementById(name);
addContent.style.display = 'flex';
}
else if(name === "sign")
{
var removeContent = document.getElementById('reg');
removeContent.style.display = 'none';
var addContent = document.getElementById(name);
addContent.style.display = 'flex';
}
}
|
import { SAVE_AGILE, UPDATE_AGILE, DELETE_AGILE } from '../constants/types'
const agileDefaultState = {
month: "",
year: "",
iteration: undefined,
cognizantTeamSize: undefined,
telstraTeamSize: undefined,
numberOfHolidays: undefined,
numberOfLeavesInPersonDays: undefined,
iterationNumber: undefined,
velocity: undefined,
plannedVelocity: undefined,
rejectionRate: undefined,
averageCycle: undefined,
velocityRate: undefined,
commitmentReliability: undefined,
velocityPerWeek: undefined,
comments: "",
messageFromServer: ""
}
const initialState = {
item: {}
}
export default (state = initialState, action) => {
switch (action.type) {
case SAVE_AGILE:
return {
...state,
item: action.updates
}
case UPDATE_AGILE:
return {
...state,
item: action.payload
}
case DELETE_AGILE:
return {
...state,
item: action.payload
}
default:
return state;
}
}
|
import React from 'react';
import { Link } from 'react-router-dom';
class Greetings extends React.Component {
constructor(props) {
super(props);
}
render() {
return (
<div className="jumbotron">
<h1>Hi</h1>
<Link to="/new-event">New Event</Link>
</div>
);
}
}
export default Greetings;
|
const { Event } = require("../db/models");
const { Op } = require("sequelize");
exports.eventList = async (req, res, next) => {
try {
if (Object.keys(req.body).length !== 0) {
const foundEvent = await Event.findAll({ where: { name: req.body } });
foundEvent
? res.json(foundEvent)
: next({
status: 404,
message: "No such event found with name provided!",
});
} else {
const events = await Event.findAll({
attributes: ["id", "name", "image"],
order: [
["startDate", "ASC"],
["name", "ASC"],
],
});
res.status(200).json(events);
}
} catch (error) {
next(error);
}
};
exports.eventDetail = async (req, res, next) => {
const { eventId } = req.params;
const ev = parseInt(eventId);
try {
const foundEvent = await Event.findByPk(ev, {
attributes: ["id", "name", "image"],
});
if (foundEvent) res.json(foundEvent);
else next({ status: 404, message: "No such event found!" });
} catch (error) {
next(error);
}
};
exports.eventCreate = async (req, res, next) => {
try {
if (Array.isArray(req.body)) {
const newEvent = await Event.bulkCreate(req.body, { validate: true });
res.status(201).json(newEvent);
} else {
const newEvent = await Event.create(req.body);
res.status(201).json(newEvent);
}
} catch (error) {
if (error.message === "")
next({ status: 500, message: "Please make sure your input is valid" });
else next({ status: 500, message: error.message });
}
};
exports.eventUpdate = async (req, res, next) => {
const { eventId } = req.params;
try {
const foundEvent = await Event.findByPk(eventId);
foundEvent
? (await foundEvent.update(req.body), res.status(204).end())
: next({ status: 404, message: "No such event found to be updated!" });
} catch (error) {
next(error);
}
};
exports.eventDelete = async (req, res, next) => {
try {
const foundEvent = await Event.findAll({ where: { id: req.body } });
foundEvent.length > 0
? (await Event.destroy({ where: { id: req.body } }),
res.status(204).end())
: next({ status: 404, message: "No such event found to be deleted!" });
} catch (error) {
next(error);
}
};
exports.eventName = async (req, res, next) => {
const { eventName } = req.params;
if (eventName === "full") {
try {
const events = await Event.findAll({
where: {
numOfSeats: {
[Op.col]: "Event.bookedSeats",
},
},
});
events
? res.json(events)
: next({ status: 404, message: "No such event found!" });
} catch (error) {
res.status(500).json({ message: error.message });
}
}
try {
const foundEvent = await Event.findAll({ where: { name: eventName } });
foundEvent
? res.json(foundEvent)
: next({
status: 404,
message: "No such event found with name provided!",
});
} catch (error) {
next(error);
}
};
|
(function () {
"use strict";
function sayhellow(name){
return "Hello " + name;
}
var hellomessage = sayhellow("Emmanuel")
console.log(hellomessage)
var myname = sayhellow("Emmanuel")
function sayhellow(name) {
return "Hello " + name;
}
//Don't modify the following line, it generates a random number between 1 and 3
// and stores it in a variable named random
var random = Math.floor((Math.random() * 3) + 1);
function isTwo(num){
if (num == 2 ){
return true;
} else {
return false;
}
}
console.log(isTwo(random))
function calculateTip(tip, total){
return total * tip
}
function displaytipammount(tip, total) {
total = prompt("bill total")
tip = prompt("input total tip in decimal number")
alert("your tip amount is" + calculateTip(tip, total ))
}
//displaytipammount();
function applyDiscount( price, percentage) {
let discontedPrice = price * percentage;
return price - discontedPrice;
}
console.log(applyDiscount(45.99 , .12));
})();
|
"use strict";
const editProfile = {
template: `
<form ng-submit="$ctrl.addInfo()">
<p>Use the form below to update your profile.</p>
<label for="">Name</label>
<input type="text" class="function" ng-model="$ctrl.user.name" placeholder="Name">
<label for="">Contact</label>
<input type="text" class="function" ng-model="$ctrl.user.contact" placeholder="Email Address">
<label for="">Bio</label>
<textarea class="function" id="bio" ng-model="$ctrl.user.bio" placeholder="Tell us a bit about yourself!"></textarea>
<button class="function">Update</button>
</form>
`,
controller: ["ProfileService", function(ProfileService){
const vm = this;
angular.copy
vm.user = angular.copy(ProfileService.getUserProfile());
vm.addInfo = () => {
ProfileService.setUserProfile(vm.user);
location.hash = "#!/userProfile"
}
vm.getInfo = () => {
ProfileService.setUserProfile();
}
}]
// controller: function() {
// // controller: ["ProfileService" , function(ProfileService) {
// const vm = this;
// vm.user = {};
// vm.addInfo = () => {
// console.log("testing");
// // ProfileService.setUserProfile(user);
// }
// }
}
angular
.module("App")
.component("editProfile", editProfile)
|
<div className="App-header" style={{backgroundColor: 'skyblue'}} >
<img src={unclogo} style={{width: 170, height: 100}} />
</div>
<hr/>
<ul className="header">
<button class="btn btn-default btn-lg btn-block"><Link to="/" style={{ textDecoration: 'none' }}>Home</Link></button>
<button class="btn btn-default btn-lg btn-block"><Link to="/Square4" style={{ textDecoration: 'none' }}>4-Square</Link></button>
<button class="btn btn-default btn-lg btn-block"><Link to="/Square9" style={{ textDecoration: 'none' }}>9-Square</Link></button>
<button class="btn btn-default btn-lg btn-block"><Link to="/Square36" style={{ textDecoration: 'none' }}>36-Square</Link></button>
</ul>
----------------------------------
<div class="btn-group btn-group-justified">
<button class="btn btn-default btn-lg btn-block"><Link to="/Square4" style={{ textDecoration: 'none' }}>4-Square</Link></button>
<button class="btn btn-default btn-lg btn-block"><Link to="/Square9" style={{ textDecoration: 'none' }}>9-Square</Link></button>
<button class="btn btn-default btn-lg btn-block"><Link to="/Square36" style={{ textDecoration: 'none' }}>36-Square</Link></button>
</div>
const Topic = ({ match }) => (
<div>
<h3>{match.params.topicId}</h3>
</div>
)
<Route path={`${match.url}/:topicId`} component={Topic}/>
<Route exact path={match.url} render={() => (
<h3>Please select a topic.</h3>
)}/>
</div>
<img src={unclogo} className="App-logo" alt="logo" />
|
/* eslint-disable import/no-extraneous-dependencies */
import React, { useContext } from 'react';
import { useHistory } from 'react-router';
import styled from 'styled-components';
import TeamContext from '../context/TeamContext';
import ListComponent from './ListComponent';
import ListHeader from './ListHeader';
export default function TeamList() {
const { team, setTeam } = useContext(TeamContext);
const { teams } = team;
const history = useHistory();
function remove(id) {
const newTeam = teams.filter((squad) => squad.id !== id);
setTeam({
...team,
teams: newTeam,
});
}
function edit(id) {
history.push(`/team/${id}`);
}
function share() {
alert('Go tell your frieds');
}
return (
<ListContainer>
<ListHeader />
<ul>
{teams.map((squad) => (
<ListComponent
name={squad.name}
description={squad.description}
key={squad.id}
id={squad.id}
remove={remove}
edit={edit}
share={share}
/>
))}
</ul>
</ListContainer>
);
}
const ListContainer = styled.div`
width:100%;
font-size: 0.7rem;
font-weight: bold;
color: #303030e6;
padding: 18px 6px 0px;
li {
padding: 0px 10px;
border-radius: 6px;
padding: 15px 10px;
display: flex;
justify-content: space-between;
}
li:hover {
background-color: #f7eef6;
color: #873b65;
}
`;
|
/**
* 左侧菜单划出脚本
* @author: terry <jfengsky@gmail.com>
* @date: 2013-10-21 10:47
*/
define(function(require, exports, module) {
var $ = require('jquery'),
move = require('../move');
// require('mods/leftside/leftclick');
function LeftSide(){
this.init = function(){
var haShow;
if( parseInt($('#J_cnt').css('margin-left')) === 0){
haShow = false
} else {
haShow = true
};
var element = document.getElementById('J_leftMenu');
Hammer(element).on('tap', function(){
if(haShow) {
move('#J_cnt',{
'margin-left': 0
});
haShow = false;
} else {
move('#J_cnt',{
'margin-left': -130
});
haShow = true;
}
});
};
}
new LeftSide().init();
});
|
// Cookies
function getCookie(cname)
{
var name = cname + "=";
var ca = document.cookie.split(';');
for(var i=0; i<ca.length; i++)
{
var c = ca[i].trim();
if (c.indexOf(name)==0) return c.substring(name.length,c.length);
}
return "";
}
////
var last_state=new Array();
var last_state_count=0;
function openBox(outerid,innerid,url,qs)
{
//window.open(url+'?'+qs,'', 'height=400,width=600')
$("#"+outerid).css("visibility","visible");
$.post(url,qs,
function(data,status)
{
$("#"+innerid).html(data);
}
);
return false;
}
function closeBox(outerid,innerid)
{
last_state_count=0;
$("#"+outerid).css("visibility","hidden");
$("#"+innerid).html("<center><br><br><img src=\"images/loading.gif\"><br><br><h3>Loading...</h3></center>");
}
function loadBox(url,qs)
{
last_state.push($("#extra_inner_box").html());
last_state_count++;
$("#extra_box_back_button").css("visibility","visible");
$("#extra_inner_box").html("<center><br><br><img src=\"images/loading.gif\"><br><br><h3>Loading...</h3></center>");
$("#extra_inner_box").load(url,qs);
return false;
}
$(document).ready(function(){
$("#extra_box_back_button").click(function(){
last_state_count--;
if(last_state_count==0)
{
$("#extra_box_back_button").css("visibility","hidden");
}
$("#extra_inner_box").html(last_state.pop());
});
});
function loadSearchBox(url,qs)
{
last_state.push($("#search_inner_box").html());
last_state_count++;
$("#search_box_back_button").css("visibility","visible");
$("#search_inner_box").html("<center><br><br><img src=\"images/loading.gif\"><br><br><h3>Loading...</h3></center>");
$("#search_inner_box").load(url,qs);
return false;
}
$(document).ready(function(){
$("#search_box_back_button").click(function(){
last_state_count--;
if(last_state_count==0)
{
$("#search_box_back_button").css("visibility","hidden");
}
$("#search_inner_box").html(last_state.pop());
});
});
|
'use strict'
const path = require('path')
function resolve (dir) {
return path.join(__dirname, '..', dir)
}
module.exports = {
context: path.resolve(__dirname, '../'),
entry: {
app: './src/main.js'
},
output: {
path: path.resolve(__dirname, '../dist'),
filename: 'game.js'
},
resolve: {
extensions: ['.js', '.json'],
alias: {
'@': resolve('src'),
'alpha': resolve('src/alpha'),
'api': resolve('src/api'),
'base': resolve('src/base'),
'common': resolve('src/common'),
'components': resolve('src/components')
}
},
module: {
rules: [
{
test: /\.js$/,
loader: 'babel-loader',
include: [
resolve('src')
]
},
{
test: /\.(png|jpg)$/,
loader: 'url-loader?limit=8192&name=images/[hash:8].[name].[ext]'
}
]
}
}
|
const chai = require('chai');
const expect = chai.expect;
const chaiAsPromised = require('chai-as-promised');
const sinon = require('sinon');
const sinonChai = require('sinon-chai');
chai.use(chaiAsPromised);
chai.use(sinonChai);
const rewire = require('rewire');
let demo = rewire('./app');
describe('app', () => {
context('add', () => {
it('should add two numbers', () => {
expect(demo.add(1, 2)).to.be.equal(3);
});
});
context('addCallback', () => {
it('should add two numbers without throwing an error', (done) => {
demo.addCallback(1, 2, (err, result) => {
expect(err).to.not.exist;
expect(result).to.be.equal(3);
done();
});
});
});
context('addPromise', () => {
it('should add two numbers without throwing an error', (done) => {
demo.addPromise(1, 2).then((result) => {
expect(result).to.be.equal(3);
done();
}).catch(err => {
done(err);
});
});
it('should add two numbers using async/await', async() => {
let result = await demo.addPromise(1, 2);
expect(result).to.be.equal(3);
});
it('should add two numbers using chai-as-promised', async() => {
await expect(demo.addPromise(1, 2)).to.eventually.equal(3);
});
});
context('foo', () => {
it('spy on log', () => {
let spy = sinon.spy(console, 'log');
demo.foo();
//expect(spy.calledOnce).to.be.true;
expect(spy).to.have.been.calledOnce;
spy.restore();
});
it('should stub console.warn', () => {
let stub = sinon.stub(console, 'warn').callsFake(() => { console.log('Message from Stub')});
demo.foo();
expect(stub).to.have.been.calledOnce;
expect(stub).to.have.been.calledWith('console.warn was called');
stub.restore();
});
});
context('bar', () => {
it('should stub private function', async () => {
let createStub = sinon.stub(demo , 'createFile').resolves('create_stub');
let callStub = sinon.stub().resolves('calldb_stub');
demo.__set__('callDB', callStub);
let result = await demo.bar('test.txt');
expect(result).to.equal('calldb_stub');
expect(callStub).to.have.been.calledOnce;
expect(createStub).to.have.been.calledOnce;
expect(createStub).to.have.been.calledWith('test.txt');
});
});
});
|
import React from 'react'
import Touch from './Touch'
import _ from 'lodash'
function noop() {}
class TabContent extends React.PureComponent {
constructor(props) {
super(props);
}
render() {
const {
activeIndex = 1,
onSelect = noop,
children,
width,
isCirculate,
getRef = noop,
handleChildren = noop,
touchStart = noop,
touchMove = noop,
touchEnd = noop
} = this.props
const length = children.length || 0
const wrappedWidth = isCirculate ? `${width * (length + 2)}px` : `${width * length}px`
return (
<div
style={{
width: wrappedWidth
}}
className="tab-content"
ref={r => {
getRef(r)
}}
onTouchStart={touchStart}
onTouchMove={event => _.throttle(touchMove, 50)(event)}
onTouchEnd={touchEnd}
>
{handleChildren()}
</div>
)
}
}
export default Touch(TabContent)
|
var conditionPanel;
var contentPanel
var spec1Rows = 1;
var spec2Rows = 1;
var spec1Store;
var spec2Store;
var spec1Grid;
var spec2Grid;
var specnamePanel = null;
var gridPanel = null;
var isBlur = false;
var typeVal = null;
var conditionViewport;
var isLoad = false;
var isModify = false;
var isChange = false;
var spec_title_1 = '';
var spec_title_2 = '';
var myMask = null;
var spec1Init = '';
var spec2Init = '';
var spectypeStore;
var detail_product_id;
var specPanel;
spectypeStore = Ext.create('Ext.data.Store', {
fields: ['parameterCode', 'parameterName'],
proxy: {
type: 'ajax',
url: '/ProductVendorList/getCateType',
actionMethods: 'post',
reader: {
type: 'json',
root: 'items'
}
}
});
/************** 規格 Model Store **************/
Ext.define('GIGADE.SPEC', {
extend: 'Ext.data.Model',
fields: [
{ name: 'spec_id', type: 'int' },
{ name: 'product_id', type: 'int' },
{ name: 'spec_type', type: 'int' },
{ name: 'spec_name', type: 'string' },
{ name: 'spec_sort', type: 'int' },
{ name: 'spec_status', type: 'int' }
]
});
spec1Store = Ext.create('Ext.data.Store', {
model: 'GIGADE.SPEC',
proxy: {
type: 'ajax',
url: '/ProductVendorList/spec1TempQuery',
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
/******************** Spec2 ***********************/
spec2Store = Ext.create('Ext.data.Store', {
model: 'GIGADE.SPEC',
proxy: {
type: 'ajax',
url: '/ProductVendorList/spec2TempQuery',
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
function initSpecPanel(product_id) {
detail_product_id = product_id;
specPanel = Ext.create('Ext.panel.Panel', {
border: false
});
Ext.Ajax.request({
url: '/ProductVendorList/QueryProduct',
async: false,
method: 'post',
params: {
ProductId: product_id
},
success: function (response, opts) {
var resText = eval("(" + response.responseText + ")");
if (resText != null && resText.data != null) {
typeVal = resText.data.Product_Spec;
if (typeVal == 1) {
typeVal = 1;
spec_title_1 = resText.data.Spec_Title_1;
createContentPanel(1);
specPanel.add(specnamePanel);
specPanel.add(gridPanel);
}
else if (typeVal == 2) {
isLoad = true;
isChange = true;
typeVal = 2;
spec_title_1 = resText.data.Spec_Title_1;
spec_title_2 = resText.data.Spec_Title_2;
createContentPanel(2);
specPanel.add(specnamePanel);
specPanel.add(gridPanel);
}
else {
specnamePanel = Ext.create('Ext.panel.Panel', {
padding: '20 0 0 20',
border: false,
items: [{
xtype: 'displayfield',
labelWidth: 65,
fieldLabel: SPEC_TYPE,
value: SPEC_NULL
}]
});
specPanel.add(specnamePanel);
}
}
else {
specnamePanel = Ext.create('Ext.panel.Panel', {
padding: '20 0 0 20',
border: false,
items: [{
xtype: 'displayfield',
labelWidth: 65,
fieldLabel: SPEC_TYPE,
value: SPEC_NULL
}]
});
specPanel.add(specnamePanel);
}
},
failure: function (response, opts) {
alert("failure");
Ext.create('Ext.panel.Panel', {
padding: '20 0 0 20',
border: false,
renderTo: Ext.getBody(),
items: [{
xtype: 'displayfield',
labelWidth: 65,
fieldLabel: SPEC_TYPE,
value: SPEC_NULL
}]
});
return false;
}
});
}
function destroyPanel() {
if (specnamePanel != null) {
specnamePanel.destroy();
specnamePanel = null;
}
if (gridPanel != null) {
gridPanel.destroy();
gridPanel = null;
}
if (spec1Grid != null) {
spec1Grid.destroy();
spec1Grid = null;
}
if (spec2Grid != null) {
spec2Grid.destroy();
spec2Grid = null;
}
spec1Store.removeAll();
spec2Store.removeAll();
}
function createContentPanel(typeVal) {
destroyPanel();
/**************** 規格名稱 Panel ****************/
specnamePanel = Ext.create('Ext.form.Panel', {
id: 'specnamePanel',
title: '',
fieldDefaults: {
msgTarget: 'side'
},
border: false,
items: [{
xtype: 'displayfield',
id: 'txtSpec1Name',
colName: 'txtSpec1Name',
hidden: false,
allowBlank: false,
submitValue: false,
fieldLabel: SPEC_1_NAME,
labelWidth: 100,
margin: '0 0 10 0'
}],
listeners: {
afterrender: function (panel) {
// window.parent.updateAuth(panel, 'colName');
}
}
});
if (typeVal == 2) {
specnamePanel.add({
xtype: 'displayfield',
id: 'txtSpec2Name',
colName: 'txtSpec2Name',
hidden: false,
allowBlank: false,
submitValue: false,
fieldLabel: SPEC_2_NAME,
labelWidth: 100
});
}
/**************** 規格內容 Grid ****************/
gridPanel = Ext.create('Ext.panel.Panel', {
id: 'gridPanel',
title: '',
padding: '10 0 0 0',
border: false,
layout: 'hbox',
items: []
});
/**************** 規格一 Grid ****************/
var statusStore1 = Ext.create('Ext.data.Store', {
id: 'statusStore1',
autoDestroy: true,
fields: ['parameterCode', 'parameterName'],
autoLoad: false,
data: [
{ parameterCode: '1', parameterName: SPEC_SHOW },
{ parameterCode: '0', parameterName: SPEC_HIDE }
]
})
function statusRenderer1(value, m, r, row, column) {
var index = statusStore1.find("parameterCode", value);
var recode = statusStore1.getAt(index);
if (recode) {
return recode.get("parameterName");
} else {
return value;
}
}
var statusStore2 = Ext.create('Ext.data.Store', {
id: 'statusStore2',
autoDestroy: true,
fields: ['parameterCode', 'parameterName'],
autoLoad: false,
data: [
{ parameterCode: '1', parameterName: SPEC_SHOW },
{ parameterCode: '0', parameterName: SPEC_HIDE }
]
})
function statusRenderer2(value, m, r, row, column) {
var index = statusStore2.find("parameterCode", value);
var recode = statusStore2.getAt(index);
if (recode) {
return recode.get("parameterName");
} else {
return value;
}
}
spec1Grid = Ext.create('Ext.grid.Panel', {
id: 'spec1Grid',
title: SPEC_1,
store: spec1Store,
margin: '0 20 0 0',
width: 355,
height: 300,
columns: [
{ id: 'spec1_name', colName: 'spec_name', hidden: false, menuDisabled: true, width: 150, header: SPEC_CONTENT, dataIndex: 'spec_name' },
{ id: 'spec1_sort', colName: 'spec_sort', hidden: false, menuDisabled: true, width: 100, header: SPEC_SORT, dataIndex: 'spec_sort' },
{ id: 'spec1_status', colName: 'spec_status', hidden: false, menuDisabled: true, width: 100, header: SPEC_SHOW, dataIndex: 'spec_status', renderer: statusRenderer1 },
{ id: 'spec1_id', hidden: true, dataIndex: 'spec_id' }
]
});
/**************** 規格二 Grid ****************/
spec2Grid = Ext.create('Ext.grid.Panel', {
id: 'spec2Grid',
title: SPEC_2,
store: spec2Store,
width: 355,
height: 300,
columns: [
{ id: 'spec2_name', colName: 'spec_name', hidden: false, menuDisabled: true, width: 150, header: SPEC_CONTENT, dataIndex: 'spec_name' },
{ id: 'spec2_sort', colName: 'spec_sort', hidden: false, menuDisabled: true, width: 100, header: SPEC_SORT, dataIndex: 'spec_sort' },
{ id: 'spec2_status', colName: 'spec_status', hidden: false, menuDisabled: true, width: 100, header: SPEC_SHOW, dataIndex: 'spec_status', renderer: statusRenderer2 },
{ id: 'spec2_id', hidden: true, dataIndex: 'spec_id'}]
});
/*********** 添加規格Grid至規格Panel ***********/
gridPanel.add(spec1Grid);
Ext.getCmp('txtSpec1Name').setValue(spec_title_1);
spec1Store.load({ params: { 'ProductId': detail_product_id} });
if (typeVal == 2) {
gridPanel.add(spec2Grid);
Ext.getCmp('txtSpec2Name').setValue(spec_title_2);
spec2Store.load({ params: { 'ProductId': detail_product_id} });
}
}
|
import mongoose from "../config/dbConfig";
import { Schema } from "mongoose";
const studentSchema = new Schema({
stuId: Number,
name: String,
college: String,
location: String,
});
const student = mongoose.model('student', studentSchema);
export default student;
|
/**
* Hermes PhoneGap build service
*/
// nodejs version checking is done in parent process ide.js
var fs = require("fs"),
path = require("path"),
express = require("express"),
util = require("util"),
querystring = require("querystring"),
temp = require("temp"),
zipstream = require('zipstream'),
async = require("async"),
mkdirp = require("mkdirp"),
rimraf = require("rimraf"),
http = require("http"),
child_process = require("child_process"),
api = require("phonegapbuildapi");
var basename = path.basename(__filename);
function BdPhoneGap(config, next) {
function HttpError(msg, statusCode) {
Error.captureStackTrace(this, this);
this.statusCode = statusCode || 500; // Internal-Server-Error
this.message = msg || 'Error';
}
util.inherits(HttpError, Error);
HttpError.prototype.name = "HTTP Error";
// (simple) parameters checking
config.pathname = config.pathname || '/phonegap';
var deployScript = path.join(config.enyoDir, 'tools', 'deploy.js');
try {
var stat = fs.statSync(deployScript);
if (!stat.isFile()) throw "Not a file";
} catch(e) {
// Build a more usable exception
next(new Error("Not a suitable Enyo: it does not contain a usable 'tools/deploy.js'"));
}
console.log("config=", util.inspect(config));
// express 3.x: app is not a server
var app, server;
app = express();
server = http.createServer(app);
/*
* Middleware -- applied to every verbs
*/
app.use(express.logger('dev'));
/**
* Make sane Express matching paths
* @private
*/
function makeExpressRoute(path) {
return (config.pathname + path)
.replace(/\/+/g, "/") // compact "//" into "/"
.replace(/(\.\.)+/g, ""); // remove ".."
}
// CORS -- Cross-Origin Resources Sharing
app.use(function(req, res, next) {
res.header('Access-Control-Allow-Origin', "*"); // XXX be safer than '*'
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Cache-Control');
if ('OPTIONS' == req.method) {
res.status(200).end();
}
else {
next();
}
});
// Authentication
app.use(express.cookieParser());
app.use(function(req, res, next) {
if (req.connection.remoteAddress !== "127.0.0.1") {
next(new Error("Access denied from IP address "+req.connection.remoteAddress));
} else {
next();
}
});
function authorize(req, res, next) {
console.log("bdPhoneGap.authorize(): req.url:", req.url);
console.log("bdPhoneGap.authorize(): req.query:", req.query);
console.log("bdPhoneGap.authorize(): req.cookies:", req.cookies);
var token = req.cookies.token || req.param('token');
if (token) {
req.token = token;
next();
} else {
next (new HttpError('Missing authentication token', 401));
}
}
app.use(makeExpressRoute('/op'), authorize.bind(this));
app.use(makeExpressRoute('/api'), authorize.bind(this));
// Built-in express form parser: handles:
// - 'application/json' => req.body
// - 'application/x-www-form-urlencoded' => req.body
// - 'multipart/form-data' => req.body.<field>[], req.body.file[]
var uploadDir = temp.path({prefix: 'com.palm.ares.hermes.bdPhoneGap'}) + '.d';
fs.mkdirSync(uploadDir);
app.use(express.bodyParser({keepExtensions: true, uploadDir: uploadDir}));
// Global error handler
function errorHandler(err, req, res, next){
console.error("errorHandler(): ", err.stack);
res.status(err.statusCode || 500);
res.contentType('txt'); // direct usage of 'text/plain' does not work
res.send(err.toString());
}
// express-3.x: middleware with arity === 4 is detected as the error handler
app.use(errorHandler);
/*
* Verbs
*/
// '/token' & '/api' -- Wrapped public Phonegap API
app.post(makeExpressRoute('/token'), getToken);
app.get(makeExpressRoute('/api/v1/me'), getUserData);
// '/op' -- localy-implemented operations
// Return the ZIP-ed deployed Enyo application
app.post(makeExpressRoute('/op/deploy'), function(req, res, next) {
async.series([
prepare.bind(this, req, res),
store.bind(this, req, res),
deploy.bind(this, req, res),
zip.bind(this, req, res),
returnZip.bind(this, req, res),
cleanup.bind(this, req, res)
], function (err, results) {
if (err) {
// cleanup & run express's next() : the errorHandler
cleanup.bind(this)(req, res, function() {
next(err);
});
}
// we do not invoke error-less next() here
// because that would try to return 200 with
// an empty body, while we have already sent
});
});
// Upload ZIP-ed deployed Enyo application to the
// https://build.phonegap.com online service and return the
// JSON-encoded response of the service.
app.post(makeExpressRoute('/op/build'), function(req, res, next) {
async.series([
prepare.bind(this, req, res),
store.bind(this, req, res),
deploy.bind(this, req, res),
zip.bind(this, req, res),
upload.bind(this, req, res),
returnBody.bind(this, req, res),
cleanup.bind(this, req, res)
], function (err, results) {
if (err) {
// cleanup & run express's next() : the errorHandler
cleanup.bind(this)(req, res, function() {
next(err);
});
}
// we do not invoke error-less next() here
// because that would try to return 200 with
// an empty body, while we have already sent
// back the response.
});
});
// Send back the service location information (origin,
// protocol, host, port, pathname) to the creator, when port
// is bound
server.listen(config.port, "127.0.0.1", null /*backlog*/, function() {
var tcpAddr = server.address();
return next(null, {
protocol: 'http',
host: tcpAddr.address,
port: tcpAddr.port,
origin: "http://" + tcpAddr.address + ":"+ tcpAddr.port,
pathname: config.pathname
});
});
/**
* Terminates express server & clean-up the plate
*/
this.quit = function(cb) {
app.close();
rimraf(uploadDir, cb);
console.log(basename, " exiting");
};
function prepare(req, res, next) {
var appTempDir = temp.path({prefix: 'com.palm.ares.hermes.bdPhoneGap.'}) + '.d';
req.appDir = {
root: appTempDir,
source: path.join(appTempDir, 'source'),
build: path.join(appTempDir, 'build'),
deploy: path.join(appTempDir, 'deploy')
};
console.log("prepare(): setting-up " + req.appDir.root);
async.series([
function(done) { mkdirp(req.appDir.root, done); },
function(done) { fs.mkdir(req.appDir.source, done); },
function(done) { fs.mkdir(req.appDir.build, done); },
function(done) { fs.mkdir(req.appDir.deploy, done); }
], next);
}
function store(req, res, next) {
if (!req.is('multipart/form-data')) {
next(new HttpError("Not a multipart request", 415 /*Unsupported Media Type*/));
return;
}
if (!req.files.file) {
next(new HttpError("No file found in the multipart request", 400 /*Bad Request*/));
return;
}
async.forEachSeries(req.files.file, function(file, cb) {
var dir = path.join(req.appDir.source, path.dirname(file.name));
//console.log("store(): mkdir -p ", dir);
mkdirp(dir, function(err) {
//console.log("store(): mv ", file.path, " ", file.name);
if (err) {
cb(err);
} else {
fs.rename(file.path, path.join(req.appDir.source, file.name), function(err) {
console.log("store(): Stored: ", file.name);
cb(err);
});
}
});
}, next);
}
function deploy(req, res, next) {
console.log("deploy(): started");
var appManifest = path.join(req.appDir.source, 'package.js');
fs.stat(appManifest, function(err) {
if (err) {
// No top-level package.js: this is
// not a Bootplate-based Enyo
// application & we have no clue on
// wether it is even an Enyo
// application, so we cannot `deploy`
// it easily.
console.log("no '" + appManifest + "': not an Enyo Bootplate-based application");
req.appDir.zipRoot = req.appDir.source;
next();
} else {
req.appDir.zipRoot = req.appDir.deploy;
// Execute the deploy.js script that comes with Enyo.
//
// TODO: scalable processing is better acheived using
// VM <http://nodejs.org/api/vm.html> rather than
// child-processes
// <http://nodejs.org/api/child_process.html>.
var params = [ '--verbose',
'--packagejs', path.join(req.appDir.source, 'package.js'),
'--source', req.appDir.source,
'--enyo', config.enyoDir,
'--build', req.appDir.build,
'--out', req.appDir.deploy,
'--less'];
console.log("deploy(): Running: '", deployScript, params.join(' '), "'");
var child = child_process.fork(deployScript, params, {
silent: false
});
child.on('message', function(msg) {
console.log("deploy():", msg);
if (msg.error) {
console.error("child-process error: ", util.inspect(msg.error));
child.errMsg = msg.error;
} else {
console.error("unexpected child-process message msg=", util.inspect(msg));
}
});
child.on('exit', function(code, signal) {
if (code !== 0) {
next(new HttpError(child.errMsg || ("child-process failed: '"+ child.toString() + "'")));
} else {
console.log("deploy(): completed");
next();
}
});
}
});
}
function zip(req, res, next) {
console.log("zip(): Zipping '" + req.appDir.zipRoot + "'");
//console.log("zip(): ");
req.zip = {};
req.zip.path = path.join(req.appDir.root, "app.zip");
req.zip.stream = zipstream.createZip({level: 1});
req.zip.stream.pipe(fs.createWriteStream(req.zip.path));
_walk.bind(this)(req.appDir.zipRoot, "" /*prefix*/, function() {
try {
req.zip.stream.finalize(function(written){
console.log("finished ", req.zip.path);
next();
});
} catch(e) {
next(e);
}
});
function _walk(absParent, relParent, cb) {
// TODO that _thing_ probably needs a bit of
// refactoring by someone that feels easy with
// node-async _arcanes_.
//console.log("zip._walk(): Parsing: ", relParent);
async.waterfall([
function(cb2) {
//console.log("zip._walk(): readdir: ", absParent);
fs.readdir(absParent, cb2);
},
function(nodes, cb2) {
//console.log("zip._walk(): nodes.forEach");
async.forEachSeries(nodes, function(name, cb3) {
var absPath = path.join(absParent, name),
relPath = path.join(relParent, name);
//console.log("zip._walk(): stat: ", absPath);
fs.stat(absPath, function(err, stat) {
if (err) {
cb3(err);
return;
}
if (stat.isDirectory()) {
_walk(absPath, relPath, cb3);
} else {
console.log("zip._walk(): Adding: ", relPath);
try {
req.zip.stream.addFile(fs.createReadStream(absPath), { name: relPath }, function(err) {
console.log("zip._walk(): Added: ", relPath, "(err=", err, ")");
cb3(err);
});
} catch(e) {
cb3(e);
}
}
});
}, cb2);
}
], cb);
}
}
function getToken(req, res, next) {
// XXX !!! leave this log commented-out to not log password !!!
//console.log("getToken(): req.body = ", util.inspect(req.body));
api.createAuthToken(req.body.username + ':' +req.body.password, {
success: function(token) {
var exdate=new Date();
exdate.setDate(exdate.getDate() + 10 /*days*/);
var cookieOptions = {
domain: '127.0.0.1:' + config.port,
path: config.pathname,
httpOnly: true,
expires: exdate
//maxAge: 1000*3600 // 1 hour
};
res.cookie('token', token, cookieOptions);
console.log("Bdphonegap.getToken(): Set-Cookie: token:", token);
res.status(200).send({token: token}).end();
},
error: function(errStr, statusCode) {
next(new HttpError(errStr, statusCode));
}
});
}
function getUserData(req, res, next) {
api.getUserData(req.token, {
success: function(inValue) {
console.log("typeof inValue:", typeof inValue, ", inValue:", inValue);
res.status(200).send({user: inValue}).end();
},
error: function(errStr, statusCode) {
next(new HttpError(errStr, statusCode));
}
});
}
function upload(req, res, next) {
console.log("upload(): fields req.body = ", util.inspect(req.body));
var reqData = {};
var errs = [];
var mandatory = ['token', 'title'];
mandatory.forEach(function(field) {
if (!req.body[field]) {
errs.push("missing form field: '" + field + "'");
}
});
if (errs.length > 0) {
_fail(errs.toString());
return;
}
// Pick signing keys, if provided
try {
reqData.keys = JSON.parse(req.body.keys);
} catch(e) {
console.log("upload(): no valid signing keys");
}
// When the specific field 'testResponse'
// (JSON-encoded) is present, the build request is not
// presented to the outside build.phonegap.com
// service. This avoids eating build token in a
// frequent test scenario. The Hermes PhoneGap server
// rather returns testResponse.
if (req.body.testJsonResponse) {
try {
res.body = JSON.parse(req.body.testJsonResponse);
next();
} catch(err) {
next(err);
}
} else if (req.body.appId) {
console.log("upload(): updating appId="+ req.body.appId + " (title='" + req.body.title + "')");
api.updateFileBasedApp(req.body.token, req.zip.path, req.body.appId, reqData, {
success: next,
error: _fail
});
} else {
console.log("upload(): creating new appId for title=" + req.body.title + "");
reqData.create_method = 'file';
for (var p in req.body) {
if (!reqData[p] && (typeof p === 'string')) {
reqData[p] = req.body[p];
}
}
console.log("upload(): reqData=", reqData);
api.createFileBasedApp(req.body.token, req.zip.path, reqData, {
success: _success,
error: _fail
});
}
function _success(data) {
try {
console.log("upload(): ", util.inspect(data));
if (typeof data === 'string') {
data = JSON.parse(data);
}
if (typeof data.error === 'string') {
_fail(data.error);
return;
}
res.body = data;
next();
} catch(e) {
_fail(e.toString());
}
}
function _fail(err) {
if (err instanceof Error) {
console.error(err.stack);
} else {
console.error("upload(): error ", err);
}
next(new HttpError("PhoneGap build error: " + err.toString(), 400 /*Bad Request*/));
}
}
function returnZip(req, res, next) {
console.log("returnZip(): ", res.body);
res.status(200).sendfile(req.zip.path);
delete req.zip;
next();
}
function returnBody(req, res, next) {
console.log("returnBody(): ", res.body);
res.status(200).send(res.body);
delete res.body;
delete req.zip;
next();
}
function cleanup(req, res, next) {
console.log("cleanup(): rm -rf " + req.appDir.root);
rimraf(req.appDir.root, function(err) {
console.log("cleanup(): removed " + req.appDir.root);
next(err);
});
}
}
if (path.basename(process.argv[1]) === basename) {
// We are main.js: create & run the object...
var knownOpts = {
"port": Number,
"pathname": String,
"level": ['silly', 'verbose', 'info', 'http', 'warn', 'error'],
"help": Boolean
};
var shortHands = {
"p": "--port",
"P": "--pathname",
"l": "--level",
"v": "--level verbose",
"h": "--help"
};
var argv = require('nopt')(knownOpts, shortHands, process.argv, 2 /*drop 'node' & basename*/);
argv.pathname = argv.pathname || "/phonegap";
argv.port = argv.port || 0;
argv.level = argv.level || "http";
if (argv.help) {
console.log("Usage: node " + basename + "\n" +
" -p, --port port (o) local IP port of the express server (0: dynamic) [default: '0']\n" +
" -P, --pathname URL pathname prefix (before /deploy and /build [default: '/phonegap']\n" +
" -l, --level debug level ('silly', 'verbose', 'info', 'http', 'warn', 'error') [default: 'http']\n" +
" -h, --help This message\n");
process.exit(0);
}
new BdPhoneGap({
pathname: argv.pathname,
port: argv.port,
enyoDir: path.resolve(__dirname, '..', 'enyo')
}, function(err, service){
if(err) process.exit(err);
// process.send() is only available if the
// parent-process is also node
if (process.send) process.send(service);
});
} else {
// ... otherwise hook into commonJS module systems
module.exports = BdPhoneGap;
}
|
import { db } from "../lib/firebase-prod"
export function sendPost(message,setMessage) {
function uuidv4() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
}
if (message.length > 3) {
db.collection("content").add({
type: "post",
content: message,
time: new Date().toISOString().replace('-', '/').split('T')[0].replace('-', '/'),
fullDate: new Date(),
uui: uuidv4()
})
}
setMessage("")
}
|
/**
* [arrFac deliver data about arrondissements]
* @param {[function]} $http [allow ajax call]
* @param {[function]} $q [implementation of promises/deferred objects]
* @return {[object]} [asked data]
*/
function arrFac($http, $q){
var Factory = {
getData: function(){
var defer = $q.defer();
$http.get('app/data/data.json')
.success(function(data, status){
defer.resolve(data);
})
.error(function(data, status){
defer.reject(data);
});
return defer.promise;
},
getArrData: function(num){
var defer = $q.defer();
$http.get('app/data/data.json')
.success(function(data, status){
defer.resolve(data[num]);
})
.error(function(data, status){
defer.reject(data);
});
return defer.promise;
}
}
return Factory;
};
angular
.module('datavizApp')
.factory('arrFac', arrFac);
|
import * as d3 from 'd3'
let margin = { top: 30, left: 30, right: 30, bottom: 30 }
let height = 450 - margin.top - margin.bottom
let width = 1080 - margin.left - margin.right
let svg = d3
.select('#chart-5')
.append('svg')
.attr('height', height + margin.top + margin.bottom)
.attr('width', width + margin.left + margin.right)
.append('g')
.attr('transform', 'translate(' + margin.left + ',' + margin.top + ')')
let radiusScale = d3
.scaleLinear()
.domain([0, 100])
.range([30, 80])
let angleScale = d3.scaleBand().range([0, Math.PI * 2])
let line = d3
.radialArea()
.innerRadius(d => radiusScale(d.low_temp))
.outerRadius(d => radiusScale(d.high_temp))
.angle(d => angleScale(d.month_name))
let xPositionScale = d3
.scalePoint()
.range([0, width])
.padding(0.3)
d3.csv(require('./data/all-temps.csv'))
.then(ready)
.catch(err => console.log('Failed on', err))
function ready(datapoints) {
let months = datapoints.map(d => d.month_name)
angleScale.domain(months)
let cities = datapoints.map(d => d.city)
xPositionScale.domain(cities)
let nested = d3
.nest()
.key(d => d.city)
.entries(datapoints)
svg
.append('text')
.text('Average Monthly Temperatures')
.attr('text-anchor', 'middle')
.attr('font-size', 30)
.attr('y', 30)
.attr('x', width / 2)
.attr('font-weight', '600')
svg
.append('text')
.text('in cities around the world')
.attr('text-anchor', 'middle')
.attr('font-size', 20)
.attr('y', 55)
.attr('x', width / 2)
svg
.selectAll('.small-charts')
.data(nested)
.enter()
.append('g')
.attr('class', 'small-charts')
.attr('height', height + margin.top + margin.bottom)
.attr('width', width + margin.left + margin.right)
.attr('transform', d => {
return `translate(${xPositionScale(d.key)}, ${height / 2})`
})
.each(function(d) {
let svg = d3.select(this)
let datapoints = d.values
datapoints.push(datapoints[0])
svg
.append('path')
.datum(datapoints)
.attr('d', line)
.attr('fill', 'red')
.attr('stroke', 'none')
.attr('opacity', 0.5)
let bands = [20, 40, 60, 80, 100]
let bandsNumbers = [20, 60, 100]
svg
.selectAll('.scale-band')
.data(bands)
.enter()
.append('circle')
.attr('r', d => radiusScale(d))
.attr('fill', 'none')
.attr('stroke', 'lightgrey')
.attr('cx', 0)
.attr('cy', 0)
.lower()
svg
.selectAll('.scale-text')
.data(bandsNumbers)
.enter()
.append('text')
.attr('class', 'scale-text')
.text(d => d + '°')
.attr('text-anchor', 'middle')
.attr('x', 0)
.attr('y', d => -radiusScale(d))
.attr('dy', -2)
.attr('font-size', 12)
svg
.append('text')
.text(d.key)
.attr('text-anchor', 'middle')
.attr('font-size', 15)
.attr('y', 0)
.attr('font-weight', '600')
})
}
|
/*Debemos lograr tomar Los numeros por ID ,
transformarlos a enteros (parseInt) y Sumarlos.
Mostar el resulto por medio de "ALERT"*/
function sumar()
{
var numUno;
var numDos;
numUno=document.getElementById('numeroUno').value;
numDos=document.getElementById('numeroDos').value;
resultado=parseInt(numUno)+parseInt(numDos);
alert("La suma es: "+resultado);
}
|
/*
* Combines a list of reducers.
*
* @param {object} reducers - An object with keys and reducers as values.
* @returns {function} A new reducer that will only pass and update the state
* under the corresponding key to each combined reducer.
*/
import mapObjIndexed from 'ramda/src/mapObjIndexed'
const combine = (reducers) => (state = {}, action) => {
state = mapObjIndexed((reducer, namespace) => (
reducer(state[namespace], action, state)
), reducers)
return state
}
export default combine
|
import React, { useState, useEffect } from "react";
import { useSelector } from "react-redux";
import Logo from "../resources/logo.png";
import { getLocalStream } from "../utils/webRTC";
import LocalVideoPreview from "./LocalVideoPreview";
import RemoteVideoPreview from "./RemoteVideoPreview";
import CallingDialog from "../CallDialogs/CallingDialog";
import IncomingCallDialog from "../CallDialogs/IncomingCallDialog";
import CallRejectedDialog from "../CallDialogs/CallRejectedDialog";
import * as constants from "../constants";
import ActiveUsersList from "./ActiveUsersList";
import ConversationButtons from "./CoversationButtons";
import { AiOutlineMenu, AiOutlineClose } from "react-icons/ai";
import notificationSound from "../resources/notification_sound.mp3";
import GroupCallRoomList from "./GroupCallRoomList";
import GroupCall from "./GroupCall";
import { connectWithMyPeer } from "../utils/webRTC/webRTCGroupCallHandler";
import { disconnectUser } from "../utils/wssConnection";
const Dashboard = (props) => {
const {
callerUsername,
calleeUsername,
callingDialogVisible,
callState,
callRejected,
remoteStream,
groupCallActive,
} = useSelector((state) => state.call);
const { username, activeUsers } = useSelector((state) => state.dashboard);
const [isOpend, setIsOpend] = useState(false);
const [showDrawer, setShowDrawer] = useState(false);
const [showRedDot, setShowRedDot] = useState(false);
useEffect(() => {
if (username) {
getLocalStream();
connectWithMyPeer();
}
}, [username]);
useEffect(() => {
if (activeUsers.length > 1) {
setShowRedDot(true);
}
}, [activeUsers.length]);
const openDrawer = () => {
setIsOpend(true);
setShowDrawer(true);
};
const closeDrawer = () => {
setIsOpend(false);
setTimeout(() => {
setShowDrawer(false);
}, 150);
};
return (
<>
{!username && props.history.push("/")}
{callingDialogVisible && (
<CallingDialog calleeUsername={calleeUsername} />
)}
{callState === constants.callState.CALL_REQUESTED && (
<IncomingCallDialog callerUsername={callerUsername} />
)}
{callRejected.rejected && (
<CallRejectedDialog reason={callRejected.reason} />
)}
<div className="h-full flex flex-col">
<div className="block md:hidden h-24 bg-customBlack flex justify-between items-center px-4">
<img src={Logo} alt="logo video talker" className="h-10" />
<button className="relative" onClick={() => openDrawer(true)}>
<AiOutlineMenu className="h-8 w-8 text-customWhite" />
{showRedDot && (
<div className="absolute w-3 h-3 bg-red-500 rounded-full top-0 right-0">
<audio autoPlay>
<source src={notificationSound} type="audio/mpeg" />
</audio>
</div>
)}
</button>
</div>
{showDrawer ? (
<div
className={`w-3/6 absolute md:hidden right-0 ${
isOpend ? "open" : "close"
} bg-customBlack z-10 `}
>
<div className="h-screen">
<div className="h-16 flex justify-start items-center">
<button
className="ml-4"
onClick={() => {
closeDrawer();
setShowRedDot(false);
}}
>
<AiOutlineClose className="h-8 w-8 text-customWhite" />
</button>
</div>
<div className="overflow-y-auto">
<ActiveUsersList closeDrawer={closeDrawer} />
</div>
</div>
</div>
) : null}
<div className="h-5/6 w-full flex">
<div className="w-full bg-customBlue flex">
<div className="w-full relative">
{<GroupCall />}
{!groupCallActive ? (
remoteStream &&
callState === constants.callState.CALL_IN_PROGRESS ? (
<RemoteVideoPreview />
) : (
<div className=" h-full flex flex-col justify-center px-4 md:px-8">
<h1 className="text-customWhite text-4xl md:text-6xl">
Hello {username},Welcome To Video Talker
</h1>
<p className="text-gray-300 mt-3 text-sm md:text-xl">
You can start a call calling directly to a user from a
list or you can create or join group call...
</p>
</div>
)
) : null}
<div className="absolute top-5 right-5 block lg:hidden h-40 w-40">
<LocalVideoPreview />
</div>
{callState === constants.callState.CALL_IN_PROGRESS &&
!callingDialogVisible && <ConversationButtons />}
</div>
<div className="w-1/6 p-2 hidden lg:block">
<div>
<LocalVideoPreview />
</div>
</div>
</div>
<div className="w-2/6 xl:w-1/6 bg-customBlack overflow-y-auto hidden md:block ">
<ActiveUsersList />
</div>
</div>
<div className="h-1/6 w-full flex">
<GroupCallRoomList />
<div className="w-2/6 xl:w-1/6 hidden md:block bg-customBlack hover:bg-customBlue cursor-pointer ">
<div className="h-full flex justify-center items-center">
<img src={Logo} alt="logo video talker" className="w-3/6 " />
</div>
</div>
</div>
</div>
</>
);
};
export default Dashboard;
|
// window.addEventListener('message', function(e) {
// console.log(e.data)
// if (e.data == "click") {
// document.body.click()
// }
// if (e.data == "ready") {
// app.ready()
// }
// })
var TWO_PI = Math.PI * 2
var DEG_TO_RAD = Math.PI/180
var RAD_TO_DEG = 180/Math.PI
function gray(n) {
var s = Math.round(n * 255).toString(16) + ""
if (s.length == 1) s = "0" + s
return "#" + s + s + s
}
function sanitize (s){ return (s || "").replace(new RegExp("[<>&]", 'g'), "") }
function rand(n){ return (Math.random()*n) }
function randint(n){ return rand(n)|0 }
function randrange(a,b){ return a + rand(b-a) }
function randsign(){ return Math.random() > 0.5 ? 1 : -1 }
function choice(a){ return a[randint(a.length)] }
function clamp(n,a,b){ return n<a?a:n<b?n:b }
function lerp(n,a,b){ return (b-a)*n+a }
function avg(m,n,a){ return (m*(a-1)+n)/a }
function mod(n,m){ return n-(m * Math.floor(n/m)) }
function quantize(a,b){ return Math.round(a/b)*b }
function dist(x0,y0,x1,y1){
var dx = x1-x0
var dy = y1-y0
return Math.sqrt(dx*dx + dy*dy)
}
function angle(x0,y0,x1,y1){ return Math.atan2(y1-y0,x1-x0) }
function pluck(h,a){
var hh = {}
if (typeof a == "string") a = a.split(" ");
a.forEach(function(s){ hh[s] = h[s] })
return hh
}
function shuffle(a){
for (var i = a.length; i > 0; i--){
var r = randint(i)
var swap = a[i-1]
a[i-1] = a[r]
a[r] = swap
}
return a
}
function defaults (dest, src) {
dest = dest || {}
for (var i in src) {
dest[i] = typeof dest[i] == 'undefined' ? src[i] : dest[i]
}
return dest
}
function getFirstTouch(fn){
return function(e){
e.preventDefault()
var touch = e.touches[0]
fn(touch)
}
}
function offsetFromPoint(event, element) {
function a(width) {
var l = 0, r = 200;
while (r - l > 0.0001) {
var mid = (r + l) / 2;
var a = document.createElement('div');
a.style.cssText = 'position: absolute;left:0;top:0;background: red;z-index: 1000;';
a.style[width ? 'width' : 'height'] = mid.toFixed(3) + '%';
a.style[width ? 'height' : 'width'] = '100%';
element.appendChild(a);
var x = document.elementFromPoint(event.clientX, event.clientY);
element.removeChild(a);
if (x === a) {
r = mid;
} else {
if (r === 200) {
return null;
}
l = mid;
}
}
return mid;
}
var l = a(1),
t = a(0);
return l && t ? {
left: l / 100,
top: t / 100,
toString: function () {
return 'left: ' + l + '%, top: ' + t + '%';
}
} : null;
}
// Check if supports 3D transforms
function has3d(){
var el = $('<p>')[0], $iframe = $('<iframe>'), has3d, t,
transforms = {
'webkitTransform': '-webkit-transform',
'OTransform': '-o-transform',
'msTransform': '-ms-transform',
'transform': 'transform'
};
// Add it to the body to get the computed style
// Sandbox it inside an iframe to avoid Android Browser quirks
$iframe.appendTo('body').contents().find('body').append( el );
for (t in transforms) {
if (el.style[t] !== undefined) {
el.style[t] = 'translate3d(1px,1px,1px)';
has3d = window.getComputedStyle(el).getPropertyValue(transforms[t]);
}
}
$iframe.remove();
return has3d !== undefined && has3d.length > 0 && has3d !== "none";
}
// Identify browser based on useragent string
;(function( ua ) {
ua = ua.toLowerCase();
var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
/(msie) ([\w.]+)/.exec( ua ) ||
ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
[];
var matched = {
browser: match[ 1 ] || "",
version: match[ 2 ] || "0"
};
browser = {};
if ( matched.browser ) {
browser[ matched.browser ] = true;
browser.version = matched.version;
}
// Chrome is Webkit, but Webkit is also Safari.
if ( browser.chrome ) {
browser.webkit = true;
} else if ( browser.webkit ) {
browser.safari = true;
}
if (window.$) $.browser = browser;
return browser;
})( navigator.userAgent );
// Naive useragent detection pattern
var is_iphone = (navigator.userAgent.match(/iPhone/i)) || (navigator.userAgent.match(/iPod/i))
var is_ipad = (navigator.userAgent.match(/iPad/i))
var is_android = (navigator.userAgent.match(/Android/i))
var is_mobile = is_iphone || is_ipad || is_android
var is_desktop = ! is_mobile;
var transformProp = browser.safari ? "WebkitTransform" : "transform";
if (is_mobile) {
$("html").addClass("mobile")
}
else {
$("html").addClass("desktop")
}
// rAF shim
;(function() {
var lastTime = 0;
var vendors = ['ms', 'moz', 'webkit', 'o'];
for(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
window.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame']
|| window[vendors[x]+'CancelRequestAnimationFrame'];
}
if (!window.requestAnimationFrame)
window.requestAnimationFrame = function(callback, element) {
var currTime = new Date().getTime();
var timeToCall = Math.max(0, 16 - (currTime - lastTime));
var id = window.setTimeout(function() { callback(currTime + timeToCall); },
timeToCall);
lastTime = currTime + timeToCall;
return id;
};
if (!window.cancelAnimationFrame)
window.cancelAnimationFrame = function(id) {
clearTimeout(id);
};
}());
|
window.App = {};
const domFromStr = (str) => Object.assign(document.createElement('DIV'), {innerHTML: str.trim()}).childNodes;
const qsa = (selectors, _root) => (_root || document).querySelectorAll(selectors);
const componentBuilders = {
canv: (opts) => {
const templates = {
root: (v) => `<div data-component-canv class="componentCanv">
<canvas class="componentCanv-canvas" data-canvas></canvas>
</div>`
};
const _root = domFromStr(templates.root())[0];
const _canvas = qsa('[data-canvas]', _root)[0];
const context = _canvas.getContext('2d');
const getSize = () => ({x: _canvas.width, y: _canvas.height});
const setSize = (size) => {
_canvas.width = size.x;
_canvas.height = size.y;
_canvas.style.width = `${size.x.toString()}px`;
_canvas.style.height = `${size.y.toString()}px`;
return instance;
};
const getDataLength = () => {
const size = getSize();
return size.x * size.y * 4;
};
const buildEmptyData = () => new Uint8ClampedArray(getDataLength());
const getData = () => {
const size = getSize();
return context.getImageData(0, 0, size.x, size.y).data;
};
const putData = (data, size, position) => {
const imageData = new ImageData(size.x, size.y);
imageData.data.set(data);
context.putImageData(imageData, position.x, position.y);
return instance;
};
const toDataURL = (type, encoderOptions) => _canvas.toDataURL(type, encoderOptions);
const fromURL = (url) => new Promise((resolve) => {
const image = new Image();
image.addEventListener('load', (e) => {
setSize({x: image.width, y: image.height});
context.drawImage(image, 0, 0);
resolve();
});
image.src = url;
});
const instance =
{_root, _canvas, context, getSize, setSize, getDataLength, buildEmptyData, getData, putData, toDataURL, fromURL};
return instance;
},
ctrl: (opts) => {
const templates = {
root: (v) => `
<div data-component-ctrl class="componentCtrl"></div>
`,
button: (v) => `
<button class="componentCtrl-button"></button>
`,
fileInput: (v) => `
<input type="file" style="display:none;" />
<button class="componentCtrl-button"></button>
`
};
const itemTypes = {
button: (opts) => {
const _items = domFromStr(templates.button());
const {0: _button} = _items;
_button.addEventListener('click', (e) => {
const currState = _button.dataset['state'];
opts.states[currState].onClick(setState);
});
const setState = (state) => {
const stateOpts = opts.states[state];
_button.setAttribute('data-state', state.toString());
_button.setAttribute('title', stateOpts.title);
_button.innerHTML = stateOpts.value;
}
setState(opts.initialState);
const iface = {
setEnabled: (mode) => {
if (mode) {
_button.removeAttribute('disabled');
} else {
_button.setAttribute('disabled', 'disabled');
}
}
};
return {_items, iface};
},
fileInput: (opts) => {
const _items = domFromStr(templates.fileInput());
const {0: _input, 2: _button} = _items;
_button.setAttribute('title', opts.title);
_button.innerHTML = opts.value;
_button.addEventListener('click', (e) => _input.click());
_input.addEventListener('change', (e) => {
const reader = new FileReader();
reader.onload = (e) => {
_input.value = '';
opts.onLoad(e.target.result);
};
const method = {
arrayBuffer: 'readAsArrayBuffer',
binaryString: 'readAsBinaryString',
dataURL: 'readAsDataURL',
test: 'readAsText'
}[opts.method];
reader[method](_input.files[0]);
});
const iface = {};
return {_items, iface};
}
};
const _root = domFromStr(templates.root())[0];
const ifaces = {};
const setTemplate = (html) => {
if (_root.firstChild !== null) {
_root.removeChild(_root.firstChild);
}
const parsedHtml = html
.replace(/{{(.*?)}}/g, (match, p1) => `<div data-attachpoint="${p1}"></div>`);
domFromStr(parsedHtml).forEach((_item) => _root.appendChild(_item));
return instance;
};
const add = (items) => items.forEach(({name, type, attachPoint, opts}) => {
const _attachElement = qsa(`[data-attachpoint="${attachPoint}"]`, _root)[0];
const {_items, iface} = itemTypes[type](opts);
ifaces[name] = iface;
_items.forEach((_item) => _attachElement.parentNode.insertBefore(_item, _attachElement));
_attachElement.parentNode.removeChild(_attachElement);
return instance;
});
const instance = {_root, ifaces, setTemplate, add};
return instance;
},
edit: (opts) => {
const templates = {
root: (v) => `
<div data-component-edit class="componentEdit">
<div class="componentEdit-tabs" data-tabs></div>
<div class="componentEdit-controls" data-controls>
<button class="componentEdit-controls-item" data-control="back"
title="${v.literals.backTitle}">${v.literals.backValue}</button>
<button class="componentEdit-controls-item" data-control="forw"
title="${v.literals.forwTitle}">${v.literals.forwValue}</button>
<button class="componentEdit-controls-item" data-control="setv"
title="${v.literals.setvTitle}">${v.literals.setvValue}</button>
</div>
<textarea class="componentEdit-editor" data-editor spellcheck="false"></textarea>
</div>
`,
tab: (v) => `
<div class="componentEdit-tabs-tab" data-name="${v.name}">
<a class="componentEdit-tabs-tab-link" href="editor-${v.name}">${v.text}</a>
</div>
`
};
const _root = domFromStr(templates.root({literals: opts.literals}))[0];
const _tabs = qsa('[data-tabs]', _root)[0];
const _controls = qsa('[data-controls', _root)[0];
const _editor = qsa('[data-editor]', _root)[0];
const tabsArr = [];
const setElementEnabled = (_element, mode) => {
if (mode) {
_element.removeAttribute('disabled');
} else {
_element.setAttribute('disabled', 'disabled');
}
};
const setControlsEnabledMode = () => {
if (Object.keys(editors).length === 0) {
Object.keys(controls).forEach((key) => setElementEnabled(controls[key], false));
} else {
const activeEditor = editors[activeEditorName];
setElementEnabled(controls._back,
activeEditor.historyIndex !== null && activeEditor.historyIndex > 0);
setElementEnabled(controls._forw,
activeEditor.historyIndex !== null && activeEditor.historyIndex < activeEditor.history.length - 1);
}
};
const controls = ['back', 'forw', 'setv'].reduce((controls, name) => {
controls[`_${name}`] = qsa(`[data-control="${name}"]`, _controls)[0];
return controls;
}, {});
controls._back.addEventListener('click', (e) => {
const activeEditor = editors[activeEditorName];
activeEditor.historyIndex --;
_editor.value = activeEditor.history[activeEditor.historyIndex];
setControlsEnabledMode();
});
controls._forw.addEventListener('click', (e) => {
const activeEditor = editors[activeEditorName];
activeEditor.historyIndex ++;
_editor.value = activeEditor.history[activeEditor.historyIndex];
setControlsEnabledMode();
});
controls._setv.addEventListener('click', (e) => {
const activeEditor = editors[activeEditorName];
activeEditor.set(_editor.value);
});
_editor.addEventListener('keydown', (e) => {
if (! e.shiftKey && e.keyCode === 9) {
e.preventDefault();
const start = Number(_editor.selectionStart),
end = Number(_editor.selectionEnd);
_editor.value = _editor.value.substring(0, start) + '\t' + _editor.value.substring(end);
_editor.selectionStart = (start + 1).toString();
_editor.selectionEnd = (start + 1).toString();
}
});
let activeEditorName = null;
const editors = [];
const presentationAttributes = ['value', 'selectionStart', 'selectionEnd', 'scrollTop'];
const setActiveEditor = (name) => {
if (activeEditorName !== null) {
const activeEditor = editors[activeEditorName];
presentationAttributes.forEach((item) => activeEditor.presentation[item] = _editor[item]);
}
activeEditorName = name;
const newActiveEditor = editors[activeEditorName];
presentationAttributes.forEach((item) => _editor[item] = newActiveEditor.presentation[item]);
setControlsEnabledMode();
tabsArr.forEach((tab) => tab.classList.toggle('top', tab.dataset['name'] === activeEditorName));
_editor.focus();
};
const addEditor = (name) => {
const editor = {
name,
maxHistoryLength: Infinity,
history: [],
historyIndex: null,
presentation: {
value: null,
selectionStart: null,
selectionEnd: null,
scrollTop: null
},
get: () => editor.history[editor.history.length - 1],
set: (str) => {
editor.history.push(str);
if (editor.history.length > editor.maxHistoryLength) {
editor.history.shift();
editor.historyIndex = Math.max(0, editor.historyIndex - 1);
}
editor.historyIndex = editor.history.length - 1;
setControlsEnabledMode();
editor.presentation.value = str;
if (name === activeEditorName) {
_editor.value = str;
}
editor.onSet.forEach((item) => item(editor));
},
onSet: []
};
editors[name] = editor;
const _tab = domFromStr(templates.tab({name, text: name.charAt(0).toUpperCase() + name.substr(1)}))[0];
tabsArr.push(_tab);
_tabs.appendChild(_tab);
const _a = qsa('a', _tab)[0];
_a.addEventListener('click', (e) => e.preventDefault());
_tab.addEventListener('click', (e) => setActiveEditor(name));
if (Object.keys(editors).length === 1) {
setActiveEditor(name);
}
};
const addEditors = (names) => names.forEach(addEditor);
const getActiveEditorName = () => activeEditorName;
const instance = {_root, editors, addEditors, getActiveEditorName};
return instance;
}
};
document.addEventListener('DOMContentLoaded', () => {
const components = {
canv: componentBuilders.canv(),
ctrl: componentBuilders.ctrl(),
edit: componentBuilders.edit({literals: window.App.literals.edit})
};
components.ctrl
.setTemplate(`
{{rand}}
{{frsr}}
{{step}}
{{srst}}
{{genr}}
{{rein}}
{{auto}}
{{mous}}
{{fill}}
{{resz}}
{{load}}
{{save}}
`.trim())
.add([
{
name: 'rand',
type: 'button',
attachPoint: 'rand',
opts: {
initialState: 'rand',
states: {
rand: {
title: window.App.literals.ctrl.randTitle,
value: window.App.literals.ctrl.randValue,
onClick: (setState) => {
const wasOn = drawingLoop.on();
drawingLoop.stop();
drawingLoop.init();
components.edit.editors['inpt'].set(window.App.config.initialEditorValues['inpt']);
canvasFill(window.App.config.initialFillColorValue);
randGenerate();
if (wasOn) {
drawingLoop.strt();
}
}
}
}
}
},
{
name: 'frsr',
type: 'button',
attachPoint: 'frsr',
opts: {
initialState: 'frsr',
states: {
frsr: {
title: window.App.literals.ctrl.frsrTitle,
value: window.App.literals.ctrl.frsrValue,
onClick: (setState) => {
const wasOn = drawingLoop.on();
drawingLoop.stop();
drawingLoop.init();
components.edit.editors['inpt'].set(window.App.config.initialEditorValues['inpt']);
canvasFill(window.App.config.initialFillColorValue);
if (wasOn) {
drawingLoop.strt();
}
}
}
}
}
},
{
name: 'step',
type: 'button',
attachPoint: 'step',
opts: {
initialState: 'step',
states: {
step: {
title: window.App.literals.ctrl.stepTitle,
value: window.App.literals.ctrl.stepValue,
onClick: (setState) => drawingLoop.step()
}
}
}
},
{
name: 'srst',
type: 'button',
attachPoint: 'srst',
opts: {
initialState: 'strt',
states: {
strt: {
title: window.App.literals.ctrl.strtTitle,
value: window.App.literals.ctrl.strtValue,
onClick: (setState) => (drawingLoop.strt(), setState('stop'))
},
stop: {
title: window.App.literals.ctrl.stopTitle,
value: window.App.literals.ctrl.stopValue,
onClick: (setState) => (drawingLoop.stop(), setState('strt'))
}
}
}
},
{
name: 'genr',
type: 'button',
attachPoint: 'genr',
opts: {
initialState: 'genr',
states: {
genr: {
title: window.App.literals.ctrl.genrTitle,
value: window.App.literals.ctrl.genrValue,
onClick: (setState) => randGenerate()
}
}
}
},
{
name: 'rein',
type: 'button',
attachPoint: 'rein',
opts: {
initialState: 'rein',
states: {
rein: {
title: window.App.literals.ctrl.reinTitle,
value: window.App.literals.ctrl.reinValue,
onClick: (setState) => {
const message = window.App.literals.actions.rein.confirmMessage;
if (window.confirm(message)) {
drawingLoop.init();
}
}
}
}
}
},
{
name: 'auto',
type: 'button',
attachPoint: 'auto',
opts: {
initialState: 'auon',
states: {
auon: {
title: window.App.literals.ctrl.auonTitle,
value: window.App.literals.ctrl.auonValue,
onClick: (setState) => {
setState('auof');
autoRand.on();
}
},
auof: {
title: window.App.literals.ctrl.auofTitle,
value: window.App.literals.ctrl.auofValue,
onClick: (setState) => {
setState('auon');
autoRand.off();
}
}
}
}
},
{
name: 'mous',
type: 'button',
attachPoint: 'mous',
opts: {
initialState: 'mson',
states: {
mson: {
title: window.App.literals.ctrl.msonTitle,
value: window.App.literals.ctrl.msonValue,
onClick: (setState) => {
setState('msof');
canvasMousetrack.track(true);
}
},
msof: {
title: window.App.literals.ctrl.msofTitle,
value: window.App.literals.ctrl.msofValue,
onClick: (setState) => {
setState('mson');
canvasMousetrack.track(false);
}
}
}
}
},
{
name: 'fill',
type: 'button',
attachPoint: 'fill',
opts: {
initialState: 'fill',
states: {
fill: {
title: window.App.literals.ctrl.fillTitle,
value: window.App.literals.ctrl.fillValue,
onClick: (setState) => {
const promptMessage = window.App.literals.actions.fill.promptMessage;
const promptDefault = ['r', 'g', 'b', 'a'].map((item) =>
window.App.config.initialFillColorValue[item].toString()).join(', ');
const promptResStr = window.prompt(promptMessage, promptDefault);
if (promptResStr !== null) {
const colorValueArr = promptResStr.split(',').map((item) => item.trim()).map((item) => Number(item));
if (colorValueArr
.filter((item) => ! isNaN(item) && (item | 0) === item && item >= 0 && item < 256).length === 4) {
const colorValue = {r: colorValueArr[0], g: colorValueArr[1], b: colorValueArr[2], a: colorValueArr[3]};
canvasFill(colorValue);
} else {
const invalidMessage = window.App.literals.actions.fill.invalidMessage
.replace('{{promptResStr}}', `'${promptResStr}'`);
alert(invalidMessage);
}
}
}
}
}
}
},
{
name: 'resz',
type: 'button',
attachPoint: 'resz',
opts: {
initialState: 'resz',
states: {
resz: {
title: window.App.literals.ctrl.reszTitle,
value: window.App.literals.ctrl.reszValue,
onClick: (setState) => {
const currentSize = components.canv.getSize()
const currentSizeStr = `${currentSize.x}, ${currentSize.y}`;
const colorValueStr = `{${['r', 'g', 'b', 'a'].map((item) =>
`${item}: ${window.App.config.initialFillColorValue[item].toString()}`).join(', ')}}`;
const promptMessage = window.App.literals.actions.resz.promptMessage
.replace('{{sizeStr}}', currentSizeStr)
.replace('{{colorValue}}', colorValueStr);
const promptDefault = currentSizeStr;
const promptResStr = window.prompt(promptMessage, promptDefault);
if (promptResStr !== null) {
const newSizeArr = promptResStr.split(',').map((item) => item.trim()).map((item) => Number(item));
if (newSizeArr
.filter((item) => ! isNaN(item) && (item | 0) === item && item >= 0).length === 2) {
const newSize = {x: newSizeArr[0], y: newSizeArr[1]};
const drawingLoopOn = drawingLoop.on();
drawingLoop.stop();
drawingLoop.init();
components.canv.setSize(newSize);
canvasFill(window.App.config.initialFillColorValue);
if (drawingLoopOn) {
drawingLoop.strt();
}
} else {
const invalidMessage = window.App.literals.actions.resz.invalidMessage
.replace('{{promptResStr}}', `'${promptResStr}'`);
alert(invalidMessage);
}
}
}
}
}
}
},
{
name: 'load',
type: 'fileInput',
attachPoint: 'load',
opts: {
title: window.App.literals.ctrl.loadTitle,
value: window.App.literals.ctrl.loadValue,
method: 'dataURL',
onLoad: (result) => {
const wasOn = drawingLoop.on();
drawingLoop.stop();
drawingLoop.init();
components.canv.fromURL(result).then(() => {
if (wasOn) {
drawingLoop.strt();
}
});
}
}
},
{
name: 'save',
type: 'button',
attachPoint: 'save',
opts: {
initialState: 'save',
states: {
save: {
title: window.App.literals.ctrl.saveTitle,
value: window.App.literals.ctrl.saveValue,
onClick: (setState) => {
const dataURL = components.canv.toDataURL('image/png', 1);
const _a = domFromStr(`<a></a>`)[0];
_a.href = dataURL;
_a.download = window.App.literals.actions.save.filename;
_a.click();
}
}
}
}
}
]);
const drawingLoop = (() => {
let on;
let timeoutID = null;
const func = () => {
if (on === true) {
drawingLoop.hndl.forEach((item) => item(drawingLoop));
const drawFunc = editorValues['draw'];
drawFunc(drawingLoop.stepCount ++, drawingLoop.globals, components.canv, editorValues['inpt']);
timeoutID = setTimeout(func, 0);
}
if (on === false) {
if (timeoutID !== null) {
clearTimeout(timeoutID);
timeoutID = null;
}
}
};
const drawingLoop = {
on: () => on,
stepCount: null,
globals: null,
hndl: [],
init: () => (drawingLoop.stepCount = 0, drawingLoop.globals = {}),
step: () => (on = true, func(), on = false),
strt: () => (on = true, func()),
stop: () => (on = false, func())
};
drawingLoop.stop();
drawingLoop.init();
return drawingLoop;
})();
const autoRand = (() => {
let steps = null;
const handler = () => {
if (steps === null) {
const autoRandInterval = confValRes.autoRandInterval;
steps = Math.floor(Math.random() * (autoRandInterval.max - autoRandInterval.min)) + autoRandInterval.min;
}
if (steps === 0) {
randGenerate();
steps = null;
} else {
steps --;
}
};
const autoRand = {
on: () => drawingLoop.hndl.push(handler),
off: () => (steps = null, drawingLoop.hndl.splice(drawingLoop.hndl.indexOf(handler), 1))
};
return autoRand;
})();
const canvasMousetrack = (() => {
const _canvas = components.canv._canvas;
const propagate = (type, e) => {
const {left, top, width, height} = _canvas.getBoundingClientRect();
const position = {
x: ((e.clientX - left) / width) * 2 - 1,
y: ((e.clientY - top) / height) * 2 - 1
};
canvasMousetrack.handlers.forEach((item) => item(type, position));
};
const listenerTypes = ['mousedown', 'mouseup', 'mousemove'];
const listeners = listenerTypes.reduce((listeners, item) =>
(listeners[item] = (e) => propagate(item, e), listeners), {});
const canvasMousetrack = {
track: (mode) => {
listenerTypes.forEach((item) =>
_canvas[mode ? 'addEventListener' : 'removeEventListener'](item, listeners[item]));
_canvas.classList.toggle('mousetracking', mode);
},
handlers: []
};
return canvasMousetrack;
})();
const canvasFill = (colorValue) => {
const colorValueArr = [colorValue.r, colorValue.g, colorValue.b, colorValue.a];
const data = components.canv.buildEmptyData();
for (let i = 0; i < data.length; i ++) {
data[i] = colorValueArr[i % 4];
}
components.canv.putData(data, components.canv.getSize(), {x: 0, y: 0});
};
const randGenerate = () => components.edit.editors['draw'].set(editorValues['genr']());
components.edit.addEditors(['inpt', 'draw', 'genr', 'conf']);
Object.keys(components).forEach((key) => qsa(`[data-area-${key}]`)[0].appendChild(components[key]._root));
const editorValues = Object.keys(components.edit.editors).reduce((editorValues, key) => {
const editor = components.edit.editors[key];
editor.onSet.push((editor) => {
const editorStr = editor.get();
try {
const evalRes = eval(editorStr);
editorValues[key] = evalRes;
} catch (err) {
editorValues[key] = null;
const alertMessage = window.App.literals.editorValuesInvalidMessage
.replace('{{err}}', err.toString());
alert(alertMessage);
}
});
return editorValues;
}, {});
let confValRes;
components.edit.editors['draw'].onSet.push((editor) => ['step', 'srst'].forEach((item) =>
components.ctrl.ifaces[item].setEnabled(editorValues['draw'] !== null)));
components.edit.editors['draw'].onSet.push((editor) => drawingLoop.init());
components.edit.editors['genr'].onSet.push((editor) => ['genr'].forEach((item) =>
components.ctrl.ifaces[item].setEnabled(editorValues['genr'] !== null)));
components.edit.editors['conf'].onSet.push((editor) => confValRes = editorValues['conf']());
components.edit.editors['conf'].onSet.push((editor) =>
Object.values(components.edit.editors)
.forEach((editor) => editor.maxHistoryLength = confValRes.editorsMaxHistoryLength[editor.name]));
components.canv.setSize(window.App.config.initialCanvasSize);
Object.keys(window.App.config.initialEditorValues)
.forEach((item) => {
if (window.App.config.initialEditorValues[item] !== null) {
components.edit.editors[item].set(window.App.config.initialEditorValues[item]);
}
});
canvasMousetrack.handlers.push((() => {
let mouseIsDown = false;
return (type, position) => {
if (type === 'mouseup') {
mouseIsDown = false;
}
if (type === 'mousedown') {
mouseIsDown = true;
}
if (type === 'mouseup' || type === 'mousedown' || (type === 'mousemove' && mouseIsDown)) {
const newInptStr = confValRes.mouseInputHandler(position, editorValues['inpt']);
components.edit.editors['inpt'].set(newInptStr);
}
}
})());
canvasFill(window.App.config.initialFillColorValue);
randGenerate();
});
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import withStyles from 'isomorphic-style-loader/lib/withStyles';
import {
Modal as BSModal,
FormGroup,
FormControl,
ControlLabel,
Button,
} from 'react-bootstrap';
import { toastr } from 'react-redux-toastr';
import { addFavouriteChart } from '../../actions/pairs';
import s from './AddPair.css';
import Modal from '../Modal';
class AddPair extends React.Component {
constructor(props) {
super(props);
this.state = {
showAddingPairModal: false,
pairId:
props.pairs.length > 0
? props.pairs.filter(
pair => !props.favouriteCharts.includes(pair.id),
)[0].id
: null,
};
this.handleAddingPair = this.handleAddingPair.bind(this);
this.closeAddingPairModal = this.closeAddingPairModal.bind(this);
}
componentWillReceiveProps(nextProps) {
if (nextProps.favouriteCharts.length === 5)
this.setState({
showAddingPairModal: false,
});
this.setState({
pairId: nextProps.pairs.filter(
pair => !nextProps.favouriteCharts.includes(pair.id),
)[0].id,
});
}
handleAddingPair() {
if (!this.state.pairId) {
toastr.warning('Select Pair', 'Please select a token pair.');
return;
}
this.props.onPairAdd(this.state.pairId);
}
closeAddingPairModal() {
this.setState({
showAddingPairModal: false,
});
}
render() {
return (
<React.Fragment>
<div
data-tut="addPair"
role="presentation"
className={this.props.float ? s.floatRoot : s.root}
style={{ height: this.props.height || 160 }}
onClick={() => {
this.setState({ showAddingPairModal: true });
}}
>
<i
className="fa fa-plus-circle"
style={this.props.float ? { marginLeft: 5 } : { marginBottom: 5 }}
/>
<span>Add Pair</span>
</div>
<Modal
show={this.state.showAddingPairModal}
onHide={this.closeAddingPairModal}
>
<BSModal.Header closeButton />
<BSModal.Body style={{ padding: 40, paddingTop: 15 }}>
<p className={s.headerTitle}>Add Pair History Chart</p>
<FormGroup
className={s.customInput}
style={{ width: '100%', marginTop: 15 }}
>
<ControlLabel>Select Pair</ControlLabel>
<FormControl
name="pairId"
onChange={event =>
this.setState({ pairId: Number(event.target.value) })
}
componentClass="select"
placeholder="Select Pair"
>
{/* <option value="">...</option> */}
{this.props.pairs &&
this.props.pairs
.filter(
pair => !this.props.favouriteCharts.includes(pair.id),
)
.map(item => (
<option key={item.id} value={item.id}>
{item.name}
</option>
))}
</FormControl>
</FormGroup>
<br />
<Button
onClick={this.handleAddingPair}
className={s.customBtn}
style={{ width: '100%' }}
block
>
Add Chart
</Button>
</BSModal.Body>
</Modal>
</React.Fragment>
);
}
}
AddPair.propTypes = {
pairs: PropTypes.arrayOf(PropTypes.object).isRequired,
favouriteCharts: PropTypes.arrayOf(PropTypes.number).isRequired,
onPairAdd: PropTypes.func.isRequired,
height: PropTypes.number,
float: PropTypes.bool,
};
AddPair.defaultProps = {
float: false,
height: 160,
};
const mapState = state => ({
pairs: state.pairs,
favouriteCharts: state.userInfo.favouriteCharts,
});
const mapDispatch = dispatch => ({
onPairAdd(pairId) {
dispatch(addFavouriteChart(pairId));
},
});
export default connect(
mapState,
mapDispatch,
)(withStyles(s)(AddPair));
export const WithoutRedux = withStyles(s)(AddPair);
|
angular.module('Hotel.Room', ['Hotel.Common']);
|
// 云函数入口文件
const cloud = require('wx-server-sdk')
cloud.init()
// 云函数入口函数
exports.main = async (event, context) => {
// const {value} = event;
const {fileID} = event;
const res = await cloud.downloadFile({
fileID:fileID
})
const buffer = res.fileContent;
try{
let result = await cloud.openapi.security.imgSecCheck({
media: {
header: {'Content-Type': 'application/octet-stream'},
contentType: 'image/png',
value:buffer
}
})
return result;
}catch(err){
return err;
}
// try {
// const res = await cloud.openapi.security.imgSecCheck({
// media: {
// header: {'Content-Type': 'application/octet-stream'},
// contentType: 'image/png',
// value:Buffer.from(value)
// }
// })
// return res;
// } catch (err) {
// return err;
// }
}
|
/**
* Generates the Table
* For this to function an element with the ID 'table-holder' must be present in the DOM tree
*
* @param {Object} options
*/
function generateTable(options) {
const { columns, title, sortableColumns, addItemOptions, actions, draggable, onDrop, search } = options;
let { collection } = options;
// for indentifying if an item is currently being added
let addingItem = false;
if (!validateCollection()) {
throw 'Invalid Collection Supplied';
}
const tableHolder = document.getElementById('table-holder');
clearChildren(tableHolder);
const table = document.createElement('table');
table.className = "table"
if (!columns) {
const sample = collection[0];
const generatedColumns = [];
Object.keys(sample).forEach(key => generatedColumns.push({name: key, type: typeof sample[key], prop: key, accessor: obj => obj[key] }));
columns = generatedColumns;
}
generateTableTop();
generateTableHeader();
// If we have search enabled and it is persistent, we need to check if there is a search value saved and apply it if it exists
if( search && search.enabled && search.persistent) {
const searchValue = localStorage.getItem('search');
if (searchValue) {
document.getElementById('table-search-input').value = searchValue;
searchItem(searchValue);
} else {
generateTableRows();
}
} else {
generateTableRows();
}
tableHolder.appendChild(table);
generateTableFooter();
function generateTableHeader() {
const header = document.createElement('tr');
header.className = "table-header-row";
columns.forEach( col => {
const th = document.createElement('th');
const isSortable = (sortableColumns ? typeof sortableColumns === 'boolean' || sortableColumns.includes(col.name) : false);
if(isSortable) th.onclick = () => {sortColumn(col,'asc')};
th.className = `table-header-data ${isSortable ? 'clickable' : ''}`;
th.id = `table-header-${col.name}`;
appendText(th,`${col.name} ${isSortable ? '▲' : ''}`);
header.appendChild(th);
});
if ( actions && actions.length > 0 ) {
const th = document.createElement('th');
th.className= "table-header-data align-right";
appendText(th, 'Actions', 'right');
header.appendChild(th);
}
table.appendChild(header);
}
function generateTableRows(customCollection) {
clearRows();
const collectionToIterate = customCollection && Array.isArray(customCollection) ? customCollection : collection;
collectionToIterate.forEach((obj, index) => {
const tr = document.createElement('tr');
tr.id = `table-row-${index}`;
if (draggable) {
addDragNDrop(tr, obj)
}
tr.className = "table-row-data";
if (!obj.inEdit) {
columns.forEach(col => {
const td = document.createElement('td');
appendText(td, formatText(col, obj));
tr.appendChild(td);
});
} else {
columns.forEach(col => {
const td = document.createElement('td');
const input = document.createElement('input');
input.value = col.accessor(obj);
input.id = `edit-table-input-${col.name}`;
input.className= "table-input";
input.type = col.type;
input.placeholder=`${col.name}...`;
td.appendChild(input);
tr.appendChild(td);
});
}
// Generates the actions for the row if they exist
generateRowActions(tr, index);
table.appendChild(tr);
});
}
/**
* Adds drag and drop functionalty to a row.
* If an onDrop function is passed in the table parameters it is executed
* at the end of each drop.
* @param {Node} row
* @param {Object} object
*/
function addDragNDrop(row, object) {
row.draggable = true;
row.addEventListener('dragstart', e => {
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/html', row.innerHTML);
dragSrcEl = row;
}, false);
row.addEventListener('dragover', e => {
if (e.preventDefault) {
e.preventDefault();
}
e.dataTransfer.dropEffect = 'move';
return false;
}, false);
row.addEventListener('drop', e => {
if (e.stopPropagation) {
e.stopPropagation();
}
if (dragSrcEl != row) {
const targetPosition = Number(dragSrcEl.id.split('-')[2]);
const currentPosition = collection.indexOf(object);
const objCopy = JSON.parse(JSON.stringify(object));
collection[currentPosition] = collection[targetPosition];
collection[targetPosition] = objCopy;
// Calls an onDrop function that might be used to store the new position in the database
if (typeof onDrop === 'function') onDrop(targetPosition, object);
dragSrcEl.innerHTML = row.innerHTML;
row.innerHTML = e.dataTransfer.getData('text/html');
//FIXME: this is just a quick fix change this
generateTableRows();
}
return false;
}, false);
}
/**
* Takes the current row and object, and maps the actions
*/
function generateRowActions(row, index) {
const object = collection[index];
if(!object) return;
if ( actions ) {
const actionElem = document.createElement('td');
actions.forEach(action => {
actionElem.className = "align-right action";
const actionButton = document.createElement('button');
actionButton.className = "table-action";
// Switch case for different action types
switch(action) {
case 'delete':
// If we're currently editing an item we will not show the delete button, in an effort to not confuse the user.
if(!object.inEdit) {
actionButton.innerText = '🗑️';
actionButton.onclick = () => deleteItem(index);
actionElem.appendChild(actionButton);
}
break;
case 'edit':
// If the object is being edited we need to show confirm and cancel buttons
if (object.inEdit) {
const buttonHolder = document.createElement('div');
const cancelButton = document.createElement('button');
cancelButton.className = "table-action";
cancelButton.innerText = '✗';
// Since we know that if the item is currently being edited the toggleEditItem(..) method turns of the edit mode
// we can simply call that method here instead of creating one for canceling the edit.
cancelButton.onclick = () => toggleEditItem(index);
actionButton.onclick = () => saveItem(index);
actionButton.innerText = '🗸';
buttonHolder.appendChild(actionButton);
buttonHolder.appendChild(cancelButton);
actionElem.appendChild(buttonHolder);
} else {
actionButton.innerText = '📑';
actionButton.onclick = () => toggleEditItem(index)
actionElem.appendChild(actionButton);
}
default: break;
}
row.appendChild(actionElem);
});
}
}
function formatText(col, obj) {
if (typeof col.accessor === 'function') {
return col.accessor(obj) || '---';
} else {
return obj[col.name];
}
}
function appendText(node, text, alignment = 'left') {
if(!node || !text)
return;
const textNode = document.createElement('div');
textNode.innerText = text;
textNode.className = alignment === 'left' ? "align-left" : "align-right";
node.appendChild(textNode);
}
/**
* Generates the top of the table, which includes the table title, search input and add button.
*
*/
function generateTableTop() {
const topContainer = document.createElement('div');
topContainer.className="table-top-container";
if (title) {
const titleNode = document.createElement('span');
titleNode.className = 'table-title';
appendText(titleNode, title);
topContainer.appendChild(titleNode);
}
// This container is here so we can bundle all our options on the right side
const rightContainer = document.createElement('div');
rightContainer.className = "table-top-right-container";
if(search && search.enabled) {
rightContainer.appendChild(generateTableSearch());
}
if(addItemOptions) {
rightContainer.appendChild(generateAddButton());
}
topContainer.appendChild(rightContainer);
tableHolder.appendChild(topContainer);
}
function generateTableFooter() {
const footerContainer = document.createElement('div');
footerContainer.className = "table-footer-container";
footerContainer.appendChild(generateItemCreation());
tableHolder.appendChild(footerContainer);
}
function generateAddButton() {
const addButton = document.createElement('button');
addButton.className = 'table-add-button';
if (addItemOptions.type === 'inline') {
addButton.onclick = () => toggleAddItem()
} else if (typeof addItemOptions.onCreate === 'function'){
addButton.onclick = () => addItemOptions.onCreate;
}
return addButton;
}
function toggleAddItem() {
const addItem = document.getElementById('table-inline-item-creation');
addItem.style.display = addingItem ? 'flex' : 'none';
addingItem = !addingItem;
}
/**
* Shows a row at the bottom of the table where a new item can be created
*/
function generateItemCreation() {
const addItem = document.createElement('div');
addItem.id = "table-inline-item-creation";
addItem.style.display = 'none';
columns.forEach(col => {
const input = document.createElement('input');
input.id = `table-input-${col.name}`;
input.className= "table-input table-creation";
input.type = col.type;
input.placeholder=`${col.name}...`;
addItem.appendChild(input);
});
const saveButton = document.createElement('button');
const cancelButton = document.createElement('button');
saveButton.innerText = '🗸';
cancelButton.innerText = '✗';
saveButton.style.color = 'green';
cancelButton.style.color = 'red';
saveButton.onclick = () => createItem();
cancelButton.onclick = () => toggleAddItem();
addItem.appendChild(saveButton);
addItem.appendChild(cancelButton);
return addItem;
}
/**
* Creates the input for searching elements, according to the primary Column.
*/
function generateTableSearch() {
const container = document.createElement('div');
container.className = 'table-search-input-container';
const input = document.createElement('input');
input.id = "table-search-input"
input.placeholder = 'Search...';
input.oninput = event => searchItem(event.target.value);
container.appendChild(input);
return container;
}
function searchItem(value) {
// If the user doesn't assign a primary column the first will be assumed as one.
const primaryColumn = columns.find(col => col.primaryColumn) || columns[0];
if(search.persistent) {
localStorage.setItem('search', value);
}
if (typeof search.onSearch === 'function') {
// If the user passes a custom onSearch function it will be ran here.
// Can be used for example to query an API.
search.onSearch(value, primaryColumn);
} else {
if(value !== '') {
generateTableRows(collection.filter(item => String(primaryColumn.accessor(item)).includes(value)));
} else {
// if the search input is empty we will render all the items
generateTableRows();
}
}
}
/**
* Deletes an item from the collection.
*/
function deleteItem(index) {
if (index !== -1) {
collection.splice(index, 1);
generateTableRows();
}
}
function toggleEditItem(index) {
const object = collection[index];
if(!object) return;
object.inEdit = !object.inEdit;
// Generate the table rows again in order to update the rendered information.
generateTableRows();
}
function saveItem(index) {
const updatedObject = extractInputValues(true);
collection[index] = { ...collection[index], ...updatedObject, inEdit: false };
generateTableRows();
}
function extractInputValues(inEdit) {
const obj = {};
columns.forEach(col => {
const input = document.getElementById(`${inEdit ? 'edit-' : ''}table-input-${col.name}`);
const curvalue = input && input.value;
if (curvalue) {
obj[col.prop || col.name.toLowerCase()] = curvalue;
}
});
return obj;
}
/**
* Gets the current values in the creation inputs, creates the object, adds it to the collection
* And then re-renders the table rows.
*/
function createItem() {
const obj = extractInputValues(false);
if (Object.keys(obj).length > 0) {
collection.push(obj);
generateTableRows();
toggleAddItem();
clearCreationInputs();
if(search && search.enabled)
clearSearch();
}
}
/**
* Removes all child nodes from the supplied node
* @param {Node} node
*/
function clearChildren(node) {
const children = node.childNodes;
children.forEach(child => node.removeChild(child));
}
function clearSearch() {
//TODO
}
/**
* Clears all table rows
*/
function clearRows() {
const rows = document.getElementsByClassName('table-row-data');
while(rows[0]) {
rows[0].parentNode.removeChild(rows[0]);
}
}
/**
* Clears values from the item creation inputs
*/
function clearCreationInputs() {
columns.forEach(col => {
document.getElementById(`table-input-${col.name}`).value = '';
});
}
/**
* Validates the incoming table data to see if it is in a correct format
* @param {Array} collection
*/
function validateCollection() {
if(!collection || collection.length <= 0)
return false;
return true;
}
function sortColumn(column, direction) {
const node = document.getElementById(`table-header-${column.name}`);
node.innerHTML = '';
node.onclick = () => {sortColumn(column,direction === 'asc' ? 'desc' : 'asc')};
appendText(node,`${column.name} ${direction === 'asc' ? '▲' : '▼'}`);
collection = collection.sort((a,b) => {
const aCol = column.accessor(a);
const bCol = column.accessor(b);
if(direction === 'asc') {
if (aCol < bCol) return -1;
if (aCol > bCol) return 1;
} else {
if (aCol > bCol) return -1;
if (aCol < bCol) return 1;
}
return 0;
});
generateTableRows();
}
}
function test() {
generateTable(
{
collection: [{name: 'bob', age: 20, address: '123 fake street' },
{name: 'trudy', age: 21 },
{name: 'alice', age: 30, address: 'sample street' },
{name: 'tom', age: 21, address: 'sample street' },
],
columns: [
{
prop: 'name',
name: 'Name',
accessor: obj => obj.name,
type: 'string',
primaryColumn: true,
},
{
prop: 'age',
name: 'Age',
accessor: obj => obj.age,
type: 'number',
},
{
prop: 'address',
name: 'Address',
accessor: obj => obj.address,
type: 'string',
},
],
search: {
enabled: true,
persistent: false,
onSearch: null,
},
actions: ['edit', 'delete'],
title: 'Users',
sortableColumns: ['Name'],
draggable: true,
addItemOptions: {
type: 'inline',
},
},
);
}
|
uploadImageVersions = function(blob, objectCollection, objectId, index, objectExists, callback) {
var directiveEndings = ['Thumbnail', 'Optimized', 'Original']
var imageUrls = {}
// TODO possible collisions. Ideally copy images over once a property is created.
if(!objectId)
objectId = Random.id()
_.each(directiveEndings, function(ending) {
var directiveName = objectCollection + ending
var uploader = new Slingshot.Upload(directiveName, {
index: index, objectId: objectId
})
var reactiveUploaders
// Add uploader to global reactive var
// objectExist=true if edit form, false if new form
if(objectExists) {
if(objectCollection === "Properties") {
reactiveUploaders = MANAGE_PROPERTY_UPLOADERS
} else {
reactiveUploaders = MANAGE_SPACE_UPLOADERS
}
} else {
if(objectCollection === "Properties") {
reactiveUploaders = NEW_PROPERTY_UPLOADERS
} else {
reactiveUploaders = NEW_SPACE_UPLOADERS
}
}
uploaders = reactiveUploaders.get()
uploaders[index] = uploader
reactiveUploaders.set(uploaders)
if(ending === "Original") {
upload(blob, uploader, imageUrls, ending, callback)
} else if(ending === "Optimized") {
// Resize and upload as optimized
resizeImage(blob, {
maxWidth: 1000,
// minWidth: 1000,
maxHeight: 300,
crop: true,
canvas: true
}, function(error, blob) {
upload(blob, uploader, imageUrls, ending, callback)
})
} else if(ending === "Thumbnail") {
// Resize and upload as thumbnail
resizeImage(blob, {
maxWidth: 300,
// minWidth: 300,
maxHeight: 200,
crop: true,
canvas: true
}, function(error, blob) {
upload(blob, uploader, imageUrls, ending, callback)
})
}
})
}
attachUploadedImages = function(type, objectId) {
for(let i = 1; i <= NUM_IMAGES_ALLOWED; i++) {
var sessionIdLookup
var objectCollection
if(type === "Properties") {
sessionIdLookup = propertyUploadedImageId
objectCollection = "Storefronts"
} else if(type === "Spaces") {
sessionIdLookup = spaceUploadedImageId
objectCollection = "Products"
}
var imageUrls = Session.get(sessionIdLookup(i))
if(imageUrls) {
var image = _.extend(imageUrls, {
objectCollection: objectCollection,
objectId: objectId,
index: i
})
Mart.Images.insert(image)
}
}
}
var upload = function(blob, uploader, imageUrls, ending, callback) {
uploader.send(blob, function(error, downloadUrl) {
if(error) {
callback(error)
} else {
var key = ending.toLowerCase() + "Url"
imageUrls[key] = downloadUrl
if(_.keys(imageUrls).length === 3) {
callback(undefined, imageUrls)
}
}
})
}
// return blob
resizeImage = function(file, options, callback) {
var fileData = {
name: file.name,
type: file.type
};
// Get image metadata.
loadImage.parseMetaData(file, function(data) {
var orientation = 1;
if (data.exif) {
orientation = data.exif.get('Orientation');
if (orientation) {
options.orientation = orientation;
}
}
// Resize image with orientation metadata.
loadImage(file, function(canvas) {
canvas.toBlob(function(blob) {
fileData.data = blob
fileData.data.type = file.type;
var resizedImage = _.extend(fileData.data, {name: fileData.name}, data.exif ? data.exif.getAll() : {});
callback(null, resizedImage)
}, file.type, Mart.Image.ImageQuality)
}, options);
},
{
maxMetaDataSize: 262144,
disableImageHead: false
});
}
Meteor.startup(function(){
if( !HTMLCanvasElement.prototype.toBlob ) {
Object.defineProperty( HTMLCanvasElement.prototype, 'toBlob', {
value: function( callback, type, quality ) {
const bin = atob( this.toDataURL( type, quality ).split(',')[1] ),
len = bin.length,
len32 = len >> 2,
a8 = new Uint8Array( len ),
a32 = new Uint32Array( a8.buffer, 0, len32 );
for( var i=0, j=0; i < len32; i++ ) {
a32[i] = bin.charCodeAt(j++) |
bin.charCodeAt(j++) << 8 |
bin.charCodeAt(j++) << 16 |
bin.charCodeAt(j++) << 24;
}
let tailLength = len & 3;
while( tailLength-- ) {
a8[ j ] = bin.charCodeAt(j++);
}
callback( new Blob( [a8], {'type': type || 'image/png'} ) );
}
});
}
});
|
import React from 'react';
// Import Framer Motion
import {motion} from 'framer-motion';
import {pageAnimation, titleAnimation} from "../animation";
// Import Styled Components
import styled from 'styled-components';
const ContactMe = () => {
return(
<ContactStyle
variants={pageAnimation}
initial="hidden"
animate="show"
exit="exit"
style={{background: "#fff"}}
>
<StyledTitle>
<Hide>
<motion.h2 variants={titleAnimation}>Get in touch.</motion.h2>
</Hide>
</StyledTitle>
<div>
<Hide>
<Social variants={titleAnimation}>
<Circle/>
<h3><h2>Github</h2>https://github.com/shenalt</h3>
</Social>
</Hide>
<Hide>
<Social variants={titleAnimation}>
<Circle/>
<h3><h2>Email</h2>tisserashenal@gmail.com</h3>
</Social>
</Hide>
<Hide>
<Social variants={titleAnimation}>
<Circle/>
<h3><h2>LinkedIn</h2>https://www.linkedin.com/in/shenalt/</h3>
</Social>
</Hide>
</div>
</ContactStyle>
);
};
const ContactStyle = styled(motion.div)`
padding: 5rem 10rem;
color: #353535;
min-height: 90vh;
@media (max-width: 1150px){
padding: 2rem;
font-size: 1rem;
}
`;
const StyledTitle = styled.div`
margin-bottom: 4rem;
color: black;
@media (max-width: 1150px){
margin-top: 5rem;
}
`;
const Hide = styled.div`
overflow: hidden;
`;
const Circle = styled.div`
border-radius: 50%;
width: 3rem;
height: 3rem;
background: #353535;
`;
const Social = styled(motion.div)`
display: flex;
align-items: center;
h3{
margin: 2rem;
color: black;
}
`;
export default ContactMe;
|
({
doInit : function (component, event, helper) {
helper.prepareAllInfo(component);
},
addOffice : function (component, event, helper) {
},
})
|
var condition = false
if (condition) {
alert("yes")
} else {
alert("no")
}
|
//Bot client-side actions called upon by the Natural Language Processors (currently Wit.ai)
'use strict'
const {defineIntent, clearContext} = require('./helpers/context')
const {aboutError} = require('./helpers/about-error');
const {isHelpful} = require('./helpers/isHelpful');
//defining Natural Language Processor actions
const actions = {
defineIntent: defineIntent,
aboutError: aboutError,
clearContext: clearContext,
isHelpful: isHelpful,
}
module.exports = actions
|
import React, { memo } from 'react';
import { bool, arrayOf, number, func } from 'prop-types';
import { useTranslation } from 'react-i18next';
import { FlyToInterpolator } from 'react-map-gl';
import { makeStyles } from '@material-ui/styles';
import { Autocomplete } from '@material-ui/lab';
import { TextField, Typography } from '@material-ui/core';
import { ExpandMoreRounded } from '@material-ui/icons';
import { currentLanguage } from '../utils/i18n';
import { initialPosition } from '../utils/geography';
import useGeocoder from '../hooks/useGeocoder';
import useGeocoderResult from '../hooks/useGeocoderResult';
import useEvent from '../hooks/useEvent';
import { WIDTH as LEFT_DRAWER_WIDTH } from './LeftDrawer';
import Logo from './Logo';
const propTypes = {
loaded: bool,
center: arrayOf(number.isRequired).isRequired,
getMap: func.isRequired,
onViewportChange: func.isRequired,
};
const defaultProps = {
loaded: false,
};
const useStyles = makeStyles(theme => ({
root: {
position: 'absolute',
top: 0,
left: 0,
zIndex: theme.zIndex.drawer + 1,
display: 'flex',
alignItems: 'center',
background: theme.palette.background.paper,
[theme.breakpoints.up('md')]: {
height: 72,
width: LEFT_DRAWER_WIDTH,
padding: theme.spacing(2),
borderBottomStyle: 'solid',
borderBottomWidth: 1,
borderBottomColor: theme.palette.grey[200],
},
[theme.breakpoints.down('sm')]: {
width: `calc(100% - ${theme.spacing(2)}px)`,
margin: theme.spacing(1),
padding: theme.spacing(1),
borderRadius: theme.shape.borderRadius,
boxShadow: theme.shadows[4],
},
},
logoContainer: {
position: 'absolute',
top: 0,
left: 0,
height: '100%',
paddingLeft: theme.spacing(2),
display: 'flex',
alignItems: 'center',
zIndex: theme.zIndex.drawer + 2,
[theme.breakpoints.down('sm')]: {
paddingLeft: theme.spacing(1),
},
},
autocomplete: {
width: '100%',
},
input: {
paddingLeft: theme.spacing(6),
},
paper: {
maxHeight: '50vh',
boxShadow: theme.shadows[4],
margin: theme.spacing(1.25, 0),
[theme.breakpoints.down('sm')]: {
margin: theme.spacing(2, -1),
},
'& > ul': {
maxHeight: '50vh',
},
},
listbox: {
padding: 0,
},
result: {
width: '100%',
},
text: {
fontWeight: theme.typography.fontWeightBold,
},
}));
const TRANSITION_PROPS = {
transitionInterpolator: new FlyToInterpolator(),
transitionDuration: 3000,
};
const Geocoder = ({ loaded, center, getMap, onViewportChange }) => {
const { i18n, t } = useTranslation();
const language = currentLanguage(i18n);
const createEvent = useEvent();
const classes = useStyles();
const { loading, inputValue, onInputChange, options } = useGeocoder({
language,
center,
});
const getViewport = useGeocoderResult(getMap);
const handleResult = (_event, result) => {
if (!result) return;
onViewportChange({
...getViewport(result),
...TRANSITION_PROPS,
});
createEvent({
category: 'Navigation',
action: 'Searched a place',
label: `Searched ${result.place_name || result.text}`,
});
};
const handleLogoClick = event => {
onInputChange(event, '');
onViewportChange({
...initialPosition,
...TRANSITION_PROPS,
});
createEvent({
category: 'Navigation',
action: 'Clicked logo',
label: 'Logo click',
});
};
const getOptionLabel = option =>
typeof option === 'string' ? option : option.text;
const groupBy = option => {
if (!!option.zoom) {
// Only quick looks have a zoom prop.
// Group key is used as group title.
return t('Popular search');
}
// Don't group search results.
return null;
};
const filterOptions = x => x;
const renderInput = params => (
<TextField
{...params}
aria-label={t('Search...')}
placeholder={t('Search...')}
InputProps={{
...params.InputProps,
disableUnderline: true,
}}
fullWidth
/>
);
const renderOption = option => (
<div className={classes.result}>
<Typography className={classes.text} noWrap>
{option.text}
</Typography>
{option.place_name && option.place_name !== option.text && (
<Typography noWrap variant="body2" color="textSecondary">
{option.place_name}
</Typography>
)}
</div>
);
return (
<div className={classes.root}>
<div className={classes.logoContainer}>
<Logo loaded={loaded} onClick={handleLogoClick} />
</div>
<Autocomplete
autoComplete
autoHighlight
includeInputInList
clearOnEscape
classes={{
root: classes.autocomplete,
inputRoot: classes.input,
paper: classes.paper,
listbox: classes.listbox,
}}
disabled={!loaded}
loading={loading}
loadingText={t('Loading...')}
popupIcon={<ExpandMoreRounded />}
openText={t('Open')}
closeText={t('Close')}
clearText={t('Clear')}
noOptionsText={t('No options')}
inputValue={inputValue}
renderInput={renderInput}
options={options}
filterOptions={filterOptions}
getOptionLabel={getOptionLabel}
renderOption={renderOption}
groupBy={groupBy}
onInputChange={onInputChange}
onChange={handleResult}
/>
</div>
);
};
export default memo(Geocoder);
Geocoder.propTypes = propTypes;
Geocoder.defaultProps = defaultProps;
|
const _ = require('lodash')
const anyTemplate = require('gulp-any-template')
const asyncReplace = require('async-replace')
const autoprefixer = require('autoprefixer')
const check = require('check-types')
const cssnano = require('cssnano')
const elm = require('node-elm-compiler')
const elmCss = require('elm-css')
const fs = require('fs-extra')
const path = require('path')
const postcss = require('postcss')
const postcssUrl = require('postcss-url')
const uglify = require('uglify-js')
const urljoin = require('url-join')
const xxh = require('xxhashjs')
const tmp = require('tmp-promise')
const defaults = require('../defaults').build
const { initializeSpinner, installPackages, validateParam } = require('./utils')
const LOCAL_ASSET_URL = '(?!http|data)(.*)'
const JS_MANIFEST_FILE = 'js-manifest.json'
const CSS_MANIFEST_FILE = 'css-manifest.json'
// global reference to CLI spinner
const spinner = initializeSpinner()
const getHash = contents =>
xxh
.h32(0)
.update(String(contents), 'utf-8')
.digest()
.toString(16)
.substr(0, 8)
const basenameWithoutExt = file => path.basename(file, path.extname(file))
const filenameWithHash = (contents, file) =>
`${basenameWithoutExt(file)}.${getHash(contents)}${path.extname(file)}`
const writeAsset = (outDir, file) => {
validateParam('string', 'outDir', outDir)
validateParam('string', 'file', file)
return fs.readFile(file).then(contents => {
const newFile = filenameWithHash(contents, file)
return fs
.outputFile(path.join(outDir, newFile), contents)
.then(() => newFile)
.catch(console.error)
})
}
const writeBundle = (
outDir,
matcher,
replacer,
transformer,
file,
cwd = process.cwd()
) => {
validateParam('string', 'outDir', outDir)
validateParam('function', 'replacer', replacer)
validateParam('function', 'transformer', transformer)
validateParam('string', 'file', file)
validateParam('string', 'cwd', cwd, false)
return new Promise((resolve, reject) => {
return fs.readFile(file).then(contents => {
asyncReplace(
contents.toString(),
matcher,
(match, url, offset, string, done) =>
writeAsset(outDir, path.join(cwd, url)).then(hash => {
done(null, replacer(hash))
}),
(err, contents) =>
err
? reject(err)
: transformer(contents).then(result => {
const newFile = filenameWithHash(result, file)
const manifest = { [path.basename(file)]: newFile }
fs
.outputFile(path.join(outDir, newFile), result)
.then(() => resolve(manifest))
.catch(reject)
})
)
})
})
}
const writeManifest = (file, manifests) => {
validateParam('string', 'file', file)
validateParam('array', 'manifests', manifests)
check.assert.array.of.object(manifests)
return new Promise((resolve, reject) => {
const json = manifests.reduce(
(acc, manifest) => Object.assign(acc, manifest),
{}
)
fs.outputJson(file, json, { spaces: 2 }).then(() => resolve(json))
})
}
const buildCss = (
stylesheets,
outputPath,
publicPath,
minify = true,
cwd = process.cwd()
) => {
validateParam('string', 'stylesheets', stylesheets)
validateParam('string', 'outputPath', outputPath)
validateParam('string', 'publicPath', publicPath)
validateParam('boolean', 'minify', minify, false)
validateParam('string', 'cwd', cwd, false)
return new Promise((resolve, reject) => {
const matcher = new RegExp(`url\\(${LOCAL_ASSET_URL}\\)`, 'g')
const replacer = url => `url(${urljoin(publicPath, url)})`
const transformer = css =>
new Promise((resolve, reject) => {
const plugins = [autoprefixer]
if (minify) {
plugins.push(cssnano)
}
postcss(plugins)
.process(css, {})
.then(result => resolve(result.css))
.catch(reject)
})
tmp
.dir({ unsafeCleanup: true })
.then(dir =>
// compile the stylesheet file
elmCss(cwd, stylesheets, dir.path)
// read css file names
.then(() => fs.readdir(dir.path))
// write the bundle for each file
.then(files =>
Promise.all(
files.map(file =>
writeBundle(
outputPath,
matcher,
replacer,
transformer,
path.join(dir.path, file),
cwd
)
)
)
)
// write the manifest
.then(manifests =>
writeManifest(path.join(outputPath, CSS_MANIFEST_FILE), manifests)
)
// cleanup and resolve with manifest object
.then(manifest => {
dir.cleanup()
resolve(manifest)
})
)
.catch(console.error)
})
}
const elmCompile = (outDir, file, cwd = process.cwd()) => {
validateParam('string', 'outDir', outDir)
validateParam('string', 'file', file)
validateParam('string', 'cwd', cwd)
return new Promise((resolve, reject) => {
const newFile = path.join(
outDir,
path.basename(file).replace('.elm', '.js')
)
elm
.compile(path.join(cwd, file), {
output: newFile,
cwd: cwd,
yes: true,
processOpts: {
stdio: 'inherit',
},
})
.on('close', exitCode => {
if (exitCode === 0) {
resolve(newFile)
} else {
reject('node-elm-compiler Errored with exit code 1')
}
})
})
}
const buildMain = (
main,
outputPath,
publicPath,
assetTag,
minify = true,
cwd = process.cwd()
) => {
validateParam('string', 'main', main)
validateParam('string', 'outputPath', outputPath)
validateParam('string', 'publicPath', publicPath)
validateParam('string', 'assetTag', assetTag)
validateParam('boolean', 'minify', minify, false)
validateParam('string', 'cwd', cwd, false)
return new Promise((resolve, reject) => {
const matcher = new RegExp(`${assetTag}\\('${LOCAL_ASSET_URL}'\\)`, 'g')
const replacer = url => `${assetTag}('${urljoin(publicPath, url)}')`
const transformer = js =>
new Promise((resolve, reject) => {
if (minify) {
const result = uglify.minify(js)
if (result.error) {
reject(result.error)
} else {
resolve(result.code)
}
} else {
resolve(js)
}
})
tmp
.dir({ unsafeCleanup: true })
.then(dir =>
// compile the elm file
elmCompile(dir.path, main, cwd)
// write the bundle
.then(file =>
writeBundle(outputPath, matcher, replacer, transformer, file, cwd)
)
// write the manifest
.then(manifest =>
writeManifest(path.join(outputPath, JS_MANIFEST_FILE), [manifest])
)
// cleanup and resolve with manifest object
.then(manifest => {
dir.cleanup()
resolve(manifest)
})
)
.catch(console.error)
})
}
const buildHtml = (
html,
outputPath,
publicPath,
cssManifest,
jsManifest,
cwd = process.cwd()
) => {
validateParam('string', 'html', html)
validateParam('string', 'outputPath', outputPath)
validateParam('string', 'publicPath', publicPath)
validateParam('object', 'cssManifest', cssManifest)
validateParam('object', 'jsManifest', jsManifest)
validateParam('string', 'cwd', cwd, false)
return new Promise((resolve, reject) => {
fs.readFile(path.join(cwd, html)).then(contents => {
const compiler = anyTemplate.compiler({ path: html, contents })
if (compiler) {
compiler({
title: 'My Application',
environment: 'production',
jsManifest,
cssManifest,
outputPath,
publicPath,
})
.then(result =>
fs.outputFile(path.join(outputPath, 'index.html'), result)
)
.then(resolve)
.catch(reject)
} else {
reject(`*${path.extname(html)} template not supported`)
}
})
})
}
const build = options => {
const opts = _.merge(defaults, options)
// CLI spinner
spinner.space()
spinner.next('cleaning old builds...')
return fs
.emptyDir(opts.outputPath)
.then(() => {
spinner.succeed('cleaned old builds')
spinner.next('installing elm-packages')
return installPackages().catch(e => {
throw 'installing elm-package failed'
})
})
.then(() => {
spinner.succeed('installed elm-packages')
spinner.next('compiling stylesheets...')
return buildCss(
opts.stylesheets,
opts.outputPath,
opts.publicPath,
opts.minify,
opts.cwd
).catch(e => {
throw 'compiling stylesheets failed'
})
})
.then(cssManifest => {
spinner.succeed('compiled stylesheets')
spinner.next('compiling main application...')
return buildMain(
opts.main,
opts.outputPath,
opts.publicPath,
opts.assetTag,
opts.minify,
opts.cwd
)
.then(jsManifest => ({
cssManifest,
jsManifest,
}))
.catch(e => {
throw 'compiling main application failed'
})
})
.then(({ cssManifest, jsManifest }) => {
spinner.space()
spinner.succeed('compiled main application')
spinner.next('compiling html templates...')
return buildHtml(
opts.html,
opts.outputPath,
opts.publicPath,
cssManifest,
jsManifest,
opts.cwd
).catch(e => {
throw 'html failed to compile'
})
})
.then(() => {
spinner.succeed('compiled html')
})
.catch(e => {
console.log(e)
spinner.space()
spinner.fail(e, false)
throw e
})
}
module.exports = {
getHash,
buildCss,
buildMain,
build,
}
|
import React, {Component} from 'react';
import {Card } from 'reactstrap';
import {connect} from 'react-redux';
import {withRouter , Link} from 'react-router-dom';
const mapStateToProps = state => {
return{
products: state.products
}
}
const RenderAntiMalarials = ({ product }) => {
const antiMalarials = product.map(antiMalarial => {
return (
<div className='m-3'>
<Link to={`/antiMalarials/${antiMalarial.productId}`}>
<Card className='productCard'>
<img src={antiMalarial.src} alt={antiMalarial.brandName} width='300' height='300' />
</Card>
</Link>
<div className='d-flex justify-content-center text-center'>
<h4>{antiMalarial.brandName} <br /> ₦{antiMalarial.price}</h4>
</div>
</div >
)
})
return (
antiMalarials
)
}
class AntiMalarials extends Component {
render() {
console.log(this.props.products);
return (
<div className='container'>
<div className='row offset-2 mt-3'>
<h2>Anti-malarials</h2>
</div>
<hr className='offset-1'></hr>
<div className='row offset-1'>
<RenderAntiMalarials product={this.props.products.antiMalarials} />
</div>
</div>
)
}
}
export default withRouter(connect(mapStateToProps)(AntiMalarials));
|
require("../common/vendor.js"), (global.webpackJsonp = global.webpackJsonp || []).push([ [ "pages/building/_components/_bottom_consult" ], {
"3eee": function(n, e, t) {
t.r(e);
var o = t("70ab"), i = t("bda3");
for (var a in i) [ "default" ].indexOf(a) < 0 && function(n) {
t.d(e, n, function() {
return i[n];
});
}(a);
t("4e98");
var u = t("f0c5"), r = Object(u.a)(i.default, o.b, o.c, !1, null, "c402554e", null, !1, o.a, void 0);
e.default = r.exports;
},
4177: function(n, e, t) {},
"4e98": function(n, e, t) {
var o = t("4177");
t.n(o).a;
},
"70ab": function(n, e, t) {
t.d(e, "b", function() {
return o;
}), t.d(e, "c", function() {
return i;
}), t.d(e, "a", function() {});
var o = function() {
var n = this;
n.$createElement;
n._self._c, n._isMounted || (n.e0 = function(e) {
e.stopPropagation(), n.show = !1;
});
}, i = [];
},
bda3: function(n, e, t) {
t.r(e);
var o = t("e4f9"), i = t.n(o);
for (var a in o) [ "default" ].indexOf(a) < 0 && function(n) {
t.d(e, n, function() {
return o[n];
});
}(a);
e.default = i.a;
},
e4f9: function(n, e, t) {
function o(n) {
return n && n.__esModule ? n : {
default: n
};
}
function i(n, e, t, o, i, a, u) {
try {
var r = n[a](u), c = r.value;
} catch (n) {
return void t(n);
}
r.done ? e(c) : Promise.resolve(c).then(o, i);
}
function a(n) {
return function() {
var e = this, t = arguments;
return new Promise(function(o, a) {
function u(n) {
i(c, o, a, u, r, "next", n);
}
function r(n) {
i(c, o, a, u, r, "throw", n);
}
var c = n.apply(e, t);
u(void 0);
});
};
}
Object.defineProperty(e, "__esModule", {
value: !0
}), e.default = void 0;
var u = o(t("a34a")), r = o(t("b4fd")), c = t("d8e2"), s = {
props: {
building_detail_passively: Object
},
data: function() {
return {
show: !1
};
},
watch: {
building_detail_passively: {
handler: function(n) {
var e = this;
n.timeout && setTimeout(function() {
e.show = !0;
}, 1e3 * n.timeout);
},
immediate: !0
}
},
methods: {
goConsultantByUser: function(n) {
var e = this;
return a(u.default.mark(function n() {
var t, o;
return u.default.wrap(function(n) {
for (;;) switch (n.prev = n.next) {
case 0:
return t = e.$root.$mp.query.building_id, n.next = 3, r.default.getRecommendConsultant({
scene: "building_detail_passively",
building_id: t
});
case 3:
o = n.sent, e.$sendCtmEvtLog("楼盘详情页面——向置业顾问提问按钮"), (0, c.navigateToChat)(o.id, {
from: "building_detail_passively"
}), e.show = !1;
case 7:
case "end":
return n.stop();
}
}, n);
}))();
}
}
};
e.default = s;
}
} ]), (global.webpackJsonp = global.webpackJsonp || []).push([ "pages/building/_components/_bottom_consult-create-component", {
"pages/building/_components/_bottom_consult-create-component": function(n, e, t) {
t("543d").createComponent(t("3eee"));
}
}, [ [ "pages/building/_components/_bottom_consult-create-component" ] ] ]);
|
const HTMLErrorBuilder = function () {
this.htmlTemplate = function (errorData) {
let htmlString = `<h4>${errorData.titleKey}</h4>`
if (errorData.bodyKey) {
htmlString += `<p>${errorData.bodyKey}</p>`
}
if (errorData.scope) {
htmlString += `<p>${errorData.scope}</p>`
}
if (errorData.level) {
htmlString += `<p>${errorData.level}</p>`
}
if (errorData.createdOn) {
htmlString += `<p style="font-size:smaller">createdOn: ${errorData.createdOn} UTC</p>`
}
return htmlString
}
this.extractPatternsFromString = function (regex, string) {
let patternMap = {}
let m
while ((m = regex.exec(string)) !== null) {
if (m.index === regex.lastIndex) {
regex.lastIndex++
}
m.forEach((match, groupIndex) => {
if (groupIndex === 1) {
patternMap[match] = match
}
})
}
return Object.keys(patternMap)
}
this.searchValue = function (key, aJsonObject) {
let keysToRetrieve = key.slice(1, key.length - 1).split('.')
let value = aJsonObject
let index = 0
while (index < keysToRetrieve.length && value !== null && value !== undefined) {
value = value[keysToRetrieve[index]]
index++
}
if (value === null || value === undefined) {
console.warn(`Could not find data for key "${key}" on "${JSON.stringify(aJsonObject)}"`)
}
return value
}
this.replaceValues = function (regex, templateString, receivedArgumentsData) {
let stringToWorkOn = templateString
let keysToReplace = this.extractPatternsFromString(regex, stringToWorkOn)
if (receivedArgumentsData) {
for (let i = 0; i < keysToReplace.length; i++) {
let valueRetrieved = this.searchValue(keysToReplace[i], receivedArgumentsData)
if (valueRetrieved !== null && valueRetrieved !== undefined) {
stringToWorkOn = stringToWorkOn.replace(keysToReplace[i], valueRetrieved)
}
}
}
return stringToWorkOn
}
this.doBuild = function (errorData) {
errorData.bodyKey = this.replaceValues(/(?=({[\w.]+}).*)/g, errorData.bodyKey, errorData.arguments)
errorData.titleKey = this.replaceValues(/(?=({[\w.]+}).*)/g, errorData.titleKey, errorData.arguments)
return this.htmlTemplate(errorData)
}
this.initialize = function () {
}
this.buildFor = function (errorData) {
this.initialize()
let buildedString = this.doBuild(errorData)
this.initialize()
return buildedString
}
}
export default function (Vue, options) {
let attributeName = (options && options.htmlErrorBuilderNameInApp) || 'ErrorBuilder'
Vue.prototype[attributeName] = new HTMLErrorBuilder()
Vue[attributeName] = Vue.prototype[attributeName]
}
|
console.log(222)
Creating a new branch is quick.
branch master test1
no-ff
|
angular.module("app")
.factory("ReviewsService",function($http){
//변수 선언
const BASE_URL = "http://localhost:8080/reviews";
//서비스 객체를 리턴
return {
list: function(pageNo=1, review_score, searchType, searchContent){
const promise=$http.get(BASE_URL,{params:{pageNo, review_score, searchType, searchContent}});
return promise;
},
// listByFilter: function(pageNo=1, review_score){
// const promise=$http.get(BASE_URL + "/filter" ,{params:{pageNo, review_score}});
// console.log("review_score:" + review_score)
// console.log("promise:" + promise)
// return promise;
// },
// listBySearch: function(pageNo=1, searchType, searchContent){
// const promise=$http.get(BASE_URL + "/search" ,{params:{pageNo, searchType, searchContent}});
// console.log("searchType:" + searchType)
// console.log("searchContent:" + searchContent)
// console.log("promise:" + promise)
// return promise;
// },
read: function(review_id) {
const promise = $http.get(BASE_URL + "/" + review_id); //**
return promise;
},
update: function(review) {
const promise = $http.put(BASE_URL, review);
return promise;
}
}
});
|
const scrollToCocktails = () => {
const $cocktailsList = $('#cocktails');
const $heroBtn = $('.js-hero-scroll');
if ($cocktailsList && $heroBtn) {
$heroBtn.on('click', e => {
e.preventDefault();
$('html, body').animate({
scrollTop: $cocktailsList.offset().top
});
$heroBtn.blur();
});
}
};
export { scrollToCocktails };
|
import React from 'react';
import { MemoryRouter } from 'react-router-dom';
import { mount } from 'enzyme';
import chai, { expect } from 'chai';
import sinon from 'sinon';
import sinonChai from 'sinon-chai';
import { ProcessSegmentsPage } from './processSegmentsPage';
import { SegmentsFilter } from '../components/segmentsFilter';
import { SegmentsList } from '../components/segmentsList';
import * as statusTypes from '../constants/status';
import history from '../store/history';
import * as hashUtils from '../utils/hashUtils';
import * as validateUUID from '../utils/uuidUtils';
chai.use(sinonChai);
describe('<ProcessSegmentsPage />', () => {
let validateHashStub;
let validateUUIDStub;
beforeEach(() => {
validateHashStub = sinon.stub(hashUtils, 'validateHash');
validateHashStub.returns(true);
validateUUIDStub = sinon.stub(validateUUID, 'default');
validateUUIDStub.returns(true);
});
afterEach(() => {
validateHashStub.restore();
validateUUIDStub.restore();
});
const requiredProps = {
agent: '',
process: '',
segments: {},
pathname: '',
filters: {},
search: '',
fetchSegments: () => {}
};
const renderComponent = props =>
mount(
<MemoryRouter>
<ProcessSegmentsPage {...requiredProps} {...props} />
</MemoryRouter>
);
let historyStub;
beforeEach(() => {
historyStub = sinon.stub(history, 'push');
});
afterEach(() => {
historyStub.restore();
});
it('calls fetch on mount', () => {
const props = {
fetchSegments: sinon.spy()
};
renderComponent(props);
expect(props.fetchSegments.callCount).to.equal(1);
});
it('renders a segments filter and a segments list', () => {
const props = {
fetchSegments: sinon.spy(),
segments: { status: statusTypes.LOADED }
};
const processSegmentsPage = renderComponent(props);
expect(props.fetchSegments.callCount).to.equal(1);
expect(processSegmentsPage.find(SegmentsFilter)).to.have.length(1);
expect(processSegmentsPage.find(SegmentsList)).to.have.length(1);
});
it('re-renders when agent or process props changes', () => {
const props = {
fetchSegments: sinon.spy(),
agent: 'foo',
process: 'bar',
segments: { status: statusTypes.LOADED, details: [] }
};
const processSegmentsPage = mount(
<ProcessSegmentsPage {...requiredProps} {...props} />
);
processSegmentsPage.setProps({ ...props, agent: 'crazy' });
expect(props.fetchSegments.callCount).to.equal(2);
expect(props.fetchSegments.getCall(1).args[0]).to.equal('crazy');
expect(props.fetchSegments.getCall(1).args[1]).to.equal('bar');
processSegmentsPage.setProps({ ...props, process: 'crazy' });
expect(props.fetchSegments.callCount).to.equal(3);
expect(props.fetchSegments.getCall(2).args[0]).to.equal('foo');
expect(props.fetchSegments.getCall(2).args[1]).to.equal('crazy');
});
it('does not re-render when other props changes', () => {
const props = {
fetchSegments: sinon.spy(),
agent: 'foo',
process: 'bar',
segments: { status: statusTypes.LOADED, details: [] }
};
const processSegmentsPage = mount(
<ProcessSegmentsPage {...requiredProps} {...props} />
);
processSegmentsPage.setProps({ ...props, something: 'else' });
expect(props.fetchSegments.callCount).to.equal(1);
});
it('pushes to history on filter change', () => {
const props = {
pathname: 'foo/bar',
filters: {
mapIds: ['aaa', 'bbb'],
prevLinkHash: 'xyz',
tags: ['foo', 'bar']
}
};
const processSegmentsPage = renderComponent(props);
const segmentsFilter = processSegmentsPage.find(SegmentsFilter);
expect(segmentsFilter).to.have.lengthOf(1);
const mapIdsInput = processSegmentsPage.find('[label="Map IDs"]');
expect(mapIdsInput).to.have.lengthOf(1);
mapIdsInput.find('input').simulate('change', {
target: { value: [...props.filters.mapIds, 'ccc'].join(' ') }
});
expect(historyStub.callCount).to.equal(1);
expect(historyStub.getCall(0).args[0]).to.equal(
'foo/bar?mapIds%5B%5D=aaa&mapIds%5B%5D=bbb&mapIds%5B%5D=ccc&tags%5B%5D=foo&tags%5B%5D=bar&prevLinkHash=xyz'
);
});
it('pushes to history on segment filters clear', () => {
const props = {
pathname: 'foo/bar',
filters: {
mapIds: ['aaa', 'bbb'],
prevLinkHash: 'xyz',
tags: ['foo', 'bar']
}
};
const processSegmentsPage = renderComponent(props);
const segmentsFilter = processSegmentsPage.find(SegmentsFilter);
expect(segmentsFilter).to.have.lengthOf(1);
const clearButton = segmentsFilter.find('Button[type="clear"]');
expect(clearButton).to.have.lengthOf(1);
clearButton.simulate('click');
expect(historyStub.callCount).to.equal(1);
expect(historyStub.getCall(0).args[0]).to.equal('foo/bar?');
});
});
|
'use strict';
var async = require('async'),
uuid = require('uuid'),
batch = require("./batch"),
string = require('string');
var notification = function(db, io) {
var db = db;
var io = io;
var valueToString = function(value) {
if(value === null || value === undefined) {
return value;
}
return value.toString();
};
var getObject = function(key, callback) {
if (!key) {
return callback();
}
db.collection('objects').findOne({_key: key}, {_id: 0, _key: 0}, callback);
};
var setObject = function(key, data, callback) {
callback = callback || function() {};
if (!key) {
return callback();
}
db.collection('objects').update({_key: key}, {$set: data}, {upsert: true, w: 1}, function(err) {
callback(err);
});
};
var sortedSetAddBulk = function(key, scores, values, callback) {
if (!scores.length || !values.length) {
return callback();
}
if (scores.length !== values.length) {
return callback('数据错误,长度不对等');
}
values = values.map(valueToString);
var bulk = db.collection('objects').initializeUnorderedBulkOp();
for(var i=0; i<scores.length; ++i) {
bulk.find({_key: key, value: values[i]}).upsert().updateOne({$set: {score: parseInt(scores[i], 10)}});
}
bulk.execute(function(err, result) {
callback(err);
});
};
var sortedSetAdd = function(key, score, value, callback) {
callback = callback || function() {};
if (!key) {
return callback();
}
if (Array.isArray(score) && Array.isArray(value)) {
return sortedSetAddBulk(key, score, value, callback);
}
value = valueToString(value);
db.collection('objects').update({_key: key, value: value}, {$set: {score: parseInt(score, 10)}}, {upsert:true, w: 1}, function(err) {
callback(err);
});
};
var sortedSetsAdd = function(keys, score, value, callback) {
callback = callback || function() {};
if (!Array.isArray(keys) || !keys.length) {
return callback();
}
value = valueToString(value);
var bulk = db.collection('objects').initializeUnorderedBulkOp();
for(var i=0; i<keys.length; ++i) {
bulk.find({_key: keys[i], value: value}).upsert().updateOne({$set: {score: parseInt(score, 10)}});
}
bulk.execute(function(err, result) {
callback(err);
});
};
var sortedSetsRemove = function(keys, value, callback) {
callback = callback || function() {};
if (!Array.isArray(keys) || !keys.length) {
return callback();
}
value = valueToString(value);
db.collection('objects').remove({_key: {$in: keys}, value: value}, function(err, res) {
callback(err);
});
};
var sortedSetsRemoveRangeByScore = function(keys, min, max, callback) {
callback = callback || function() {};
if (!Array.isArray(keys) || !keys.length) {
return callback();
}
var query = {_key: {$in: keys}};
if (min !== '-inf') {
query.score = {$gte: min};
}
if (max !== '+inf') {
query.score = query.score || {};
query.score.$lte = max;
}
db.collection('objects').remove(query, function(err) {
callback(err);
});
};
var pushToUids = function(uids, notification, callback) {
var oneWeekAgo = Date.now() - 604800000;
var unreadKeys = [];
var readKeys = [];
async.waterfall([
function (next) {
next(null, {notification: notification, uids: uids})
},
function (data, next) {
uids = data.uids;
notification = data.notification;
uids.forEach(function(uid) {
unreadKeys.push('uid:' + uid + ':notifications:unread');
readKeys.push('uid:' + uid + ':notifications:read');
});
sortedSetsAdd(unreadKeys, notification.datetime, notification.nid, next);
},
function (next) {
sortedSetsRemove(readKeys, notification.nid, next);
},
function (next) {
sortedSetsRemoveRangeByScore(unreadKeys, '-inf', oneWeekAgo, next);
},
function (next) {
sortedSetsRemoveRangeByScore(readKeys, '-inf', oneWeekAgo, next);
},
function (next) {
uids.forEach(function(uid) {
io.in('uid_' + uid).emit('event:new_notification', notification);
});
next();
}
], callback);
}
var create = function(data, callback) {
if (!data.nid) {
return callback('no-notification-id: notification 没有 ID');
}
data.importance = data.importance || 5;
getObject('notifications:' + data.nid, function(err, oldNotification) {
if (err) {
return callback(err);
}
if (oldNotification) {
if (parseInt(oldNotification.pid, 10) === parseInt(data.pid, 10) && parseInt(oldNotification.importance, 10) > parseInt(data.importance, 10)) {
return callback();
}
}
var now = Date.now();
data.datetime = now;
async.parallel([
function(next) {
sortedSetAdd('notifications', now, data.nid, next);
},
function(next) {
setObject('notifications:' + data.nid, data, next);
}
], function(err) {
callback(err, data);
});
});
};
var push = function(notification, uids, callback) {
callback = callback || function() {};
if (!notification.nid) {
return callback();
}
if (!Array.isArray(uids)) {
uids = [uids];
}
uids = uids.filter(function(uid, index, array) {
return parseInt(uid, 10) && array.indexOf(uid) === index;
});
if (!uids.length) {
return callback();
}
setTimeout(function () {
batch.processArray(uids, function (uids, next) {
pushToUids(uids, notification, next);
}, { interval: 1000 }, function (err) {
if (err) {
LOG.error(err.stack);
}
});
}, 1000);
callback();
};
this.notice = function(post, callback) {
async.waterfall([
function(callback){
db.collection("objects").findOne({_key:'topic:' + post.tid}, callback);
},
function(topic, callback) {
var msg = (post.pid == topic.mainPid) ? topic.title : 'RE: ' + topic.title;
var notification = {
bodyShort: '[[kernel:notification.post_done, ' + msg + ']]',
nid: 'kernel:post:' + post.pid + ':uid:' + post.uid + ":id:" + uuid.v1(),
path: '/post/' + post.pid,
pid : post.pid,
datetime: Date.now()
};
return callback(null, notification);
},
function(notification, callback) {
create(notification, callback);
},
function(notification, callback) {
push(notification, post.uid, callback);
}
], callback);
};
}
module.exports = notification;
|
import { Part } from './part.mjs'
import { getProps } from './utils.mjs'
export const Stack = (props) => {
const { stack, gist, updateGist, unsetGist, showInfo } = props
return (
<g {...getProps(stack)}>
{[...stack.parts].map((part) => (
<Part
{...{ gist, updateGist, unsetGist, showInfo }}
key={part.name}
partName={part.name}
part={part}
/>
))}
</g>
)
}
|
import React, { Component } from 'react';
import axios from "axios";
import Button from "@material-ui/core/Button";
import {fakeAuth} from '../auth';
class Logout extends Component {
logoutbtn(){
axios.post("/api/logout",
{}
).then(res => {
console.log(res.data);
if(res.data){
if(res.data.message===true){
alert('登出成功');
localStorage.removeItem('auth');
window.location = "/Login";
}else{
alert('登出失敗');
}
}
})
}
btn_click=e=>{
e.preventDefault();
this.logoutbtn();
}
render(){
return (
<div description="logout" >
<Button onClick={this.btn_click}
style={{display:"inline-block",
position:"relative",
width:"10vw",
margin:"0",
flexGrow:"2",
color:"#6AFFC6",
fontSize:"1.5rem",
fontWeight:"bold",
textDecoration:"none"}}
className="noHoverBg">Logout</Button>
</div>
);
}
}
/*const Logout = (e) => {
alert("logout successfully!") //for test
/*e.preventDefault();
axios.post("/api/logout",
{}
).then(res => {
console.log(res.data);
if(res.data){
if(res.data.message===true){
alert('登出成功');
window.location = "/Login";
}else{
alert('登出失敗');
}
}
})*/
//}
export default Logout
|
/*global alert: true, console: true, ODSA */
// Written by Bailey Spell and Jesse Terrazas
$(document).ready(function() {
// "use strict";
// Declare and initialize state variables
var config = ODSA.UTILS.loadConfig(),
interpret = config.interpreter;
$(function() {
$(window).bind("storage", () => {
$(".secretMsg").val(localStorage.secretMsg);
});
});
function encryptMessage() {
var crypt = new JSEncrypt();
var publicKey = $(".publicKey").val();
crypt.setPublicKey(publicKey);
localStorage.publicKey = publicKey;
var secretMsg = $(".secretMsg").val();
var cipherText = crypt.encrypt(secretMsg);
localStorage.encryptedText = cipherText;
$(".encryptMsg").val(cipherText);
}
$(".encrypt").click(encryptMessage);
});
|
import * as api from '../../api';
import{
GET_POSTS,
ADD_NEWSLETTER,
CLEAR_NEWSLETTER,
GET_POSTS_BY_ID,
CLEAR_POSTS_BY_ID,
SEND_MESSAGE
} from '../types';
// POST
export const getPosts=(homePost, page, order, limit)=>({
type: GET_POSTS,
payload: api.getPosts(homePost, page, order, limit)
})
export const getPostById =(id) =>({
type: GET_POSTS_BY_ID,
payload: api.getPostById(id)
})
export const clearPostById =() =>({
type: CLEAR_POSTS_BY_ID,
payload: {}
})
// user
export const addNewLetter=(data)=>({
type: ADD_NEWSLETTER,
payload: api.addNewLetter(data)
})
export const clearNewsletter = ()=>({
type: CLEAR_NEWSLETTER,
payload: {
newsletter : false,
email: []
}
})
export const sendMessage =(data)=>({
type: SEND_MESSAGE,
payload: api.sendMessage(data)
})
|
$(document).ready(function(){
$(window).resize(function(){
var width = $(window).width();
var height = $(window).height();
var height_percent = height/100;
var height_col = height-height_percent*4;
var height_dir = height_col/6;
var height_drop = height_dir/3;
var height_conv = height_col*(1/2);
var height_box = height_col/4;
var height_profil = height_col*(3/5);
var height_map = document.getElementById("localVideo").offsetHeight;
// ou width / 1.33
document.getElementById("common-repository-area").style.height= height_dir+"px";
document.getElementById("dataChannelReceive").style.height= height_conv+"px";
document.getElementById("map_canvas").style.height= height_box+"px";
document.getElementById("historical-container-area").style.height= height_box+"px";
document.getElementById("profils-container").style.height= height_profil+"px";
document.getElementById("map_canvas").style.height= height_map+"px";
document.getElementById("col-left").style.height= (height_col)+"px";
document.getElementById("col-center").style.height= (height_col)+"px";
document.getElementById("col-right").style.height= (height_col)+"px";
document.getElementById("droppableZone-container").style.height= height_drop+"px";
document.getElementById("droppableZone").style.height= height_drop+"px";
});
/*
$("#localVideo").webcam({
mode: "callback",
swffile: "/download/jscam_canvas_only.swf",
onTick: function() {},
onSave: function() {},
onCapture: function() {},
debug: function() {},
onLoad: function() {}
});*/
});
|
/*
arr = [1, 2, 3]
sum = 5
sets = [[]]
Step 1: Add 1 to the power set
[[], [1]]
Step 2: Add 2 to the power set
[[], [1], [1, 2], [2]]
Step 3: Add 3 to the power set
[[], [1], [1, 2], [2], [1, 3], [2, 3], [1, 2, 3], [3]]
*/
function ArrayAdditionI(arr) {
// get largest number and remove it from array
var sum = Math.max.apply(null, arr);
console.log('sum first=' + sum);
arr.splice(arr.indexOf(sum), 1);
// power set
var sets = [[]];
// generate the power set and for each new set
// check if the temporary sum equals our sum above
for (var i = 0; i < arr.length; i++) {
for (var j = 0, len = sets.length; j < len; j++) {
var temp = sets[j].concat(arr[i]);
sets.push(temp);
console.log(sets);
var s = temp.reduce(function(p, c) { return p + c; });
if (s === sum) { return "true";
}
}
}
return "false";
}
console.log(ArrayAdditionI([1,2,3]));
//This algorithm runs in O(2n) time because in the worse case, we need to create every possible subset of the array to check if any of them equal the goal sum, and there are 2n possible sets.
|
import React from 'react';
import { withRouter } from 'react-router-dom';
import {
MenuItemContainer,
BackgroundImage,
ContentContainer,
Title,
SubTitle,
} from './menu-item.styles';
const MenuItem = ({ history, match, ...otherProps }) => {
const [hovered, setHovered] = React.useState(false);
const { title, imageUrl, size, linkUrl } = otherProps;
return (
<MenuItemContainer
onMouseEnter={() => setHovered(true)}
onMouseLeave={() => setHovered(false)}
large={size}
onClick={() => history.push(`${match.url}${linkUrl}`)}
>
<BackgroundImage
hovered={hovered}
style={{
backgroundImage: `url(${imageUrl})`,
}}
/>
<ContentContainer hovered={hovered}>
<Title>{title}</Title>
<SubTitle>Shop Now</SubTitle>
</ContentContainer>
</MenuItemContainer>
);
};
export default withRouter(MenuItem);
|
import Ember from 'ember';
import Sortable from 'ui/mixins/sortable';
import FilterState from 'ui/mixins/filter-state';
const showKinds = ['user','admin'];
export default Ember.Controller.extend(FilterState, Sortable, {
access: Ember.inject.service(),
sortableContent: Ember.computed.alias('filteredByKind'),
sortBy: 'name',
sorts: {
state: ['stateSort','name','id'],
name: ['name','id'],
username: ['username','id'],
kind: ['kind','name','id'],
ip: ['displayIp','name','id'],
image: ['imageUuid','id'],
command: ['command','name','id'],
},
filteredByKind: function() {
return this.get('filtered').filter((row) => {
var kind = (row.get('kind')||'').toLowerCase();
return showKinds.indexOf(kind) !== -1;
});
}.property('filtered.@each.kind'),
isLocal: function() {
return this.get('access.provider') === 'localauthconfig';
}.property('access.provider'),
});
|
// components/activePop/activePop.js
const app = getApp();//获取应用实例
const route = require('../../utils/tool/router.js');
Component({
/**
* 组件的属性列表
*/
properties: {
popType:{
type:String,
value:0
}
},
/**
* 组件的初始数据
*/
data: {
IMGSERVICE: app.globalData.IMGSERVICE,
popShow:true
},
/**
* 组件的方法列表
*/
methods: {
otherAct(){
this.closePop()
route.jump_nav({ url:'/pages/activity_list/activity_list'})
},
closePop(){
//this.setData({ popShow:false})
this.triggerEvent("close")
},
AuthBannerJump(e) {
if (!e.detail.userInfo) return
// let obj = {};
// obj.headimg = e.detail.userInfo.avatarUrl;
// obj.nickname = e.detail.userInfo.nickName;
this.setData({popShow:false})
this.triggerEvent('getParme', e.detail);
},
bindCarer(){
this.closePop()
route.jump_nav({ url:'/pages/o_love_car/o_love_car?pageType=back'});
},
goggl() {
route.jump_red({ url: `/pages/binding/owner/owner?activity_id=57` })
},
goback() {
route.jump_back();
}
},
})
|
import { Genre } from './models.js';
export const reviews = [
['John', 5, 'It is my fovarite book'],
['Anna', 3, 'I expected more from it'],
['Sherlock', 0, 'I don\'t read this'],
];
export const author = {
firstName: 'Ivan',
lastName: 'Denisovich',
rating: 4,
};
export const notepad = {
price: 40,
getProductDescription: () => {
return 'Notepad 50 pages';
}
};
export const genreMapping = {
[Genre.adventure]: 'Adventure',
[Genre.fantasy]: 'Fantasy',
[Genre.horror]: 'Horror',
};
|
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const Table_1 = __importDefault(require("./Table"));
const Column_1 = __importDefault(require("./Column"));
const MySQL = require("mysql");
// console.log(MySQL);
function computeJavaType(data_type, column_type) {
if (data_type === "int")
return "Integer";
else if (data_type === "char" || data_type === "varchar" || data_type == "long")
return "String";
else if (data_type === "tinyint") {
if (column_type === "tinyint(1)")
return "boolean";
else
return "Byte";
}
else if (data_type === "numeric" || data_type === "decimal" || data_type === "number")
return "BigDecimal";
else if (data_type === "bit")
return "boolean";
else if (data_type === "smallint")
return "short";
else if (data_type === "bigint")
return "long";
else if (data_type === "real")
return "float";
else if (data_type === "double")
return "double";
else if (data_type === "date")
return "Date";
else if (data_type === "time")
return "time";
else if (data_type === "timestamp" || data_type === "datetime")
return "Timestamp";
else if (data_type === "clob")
return "Clob";
else if (data_type === "blob")
return "Blob";
else
return "";
}
class Help {
static getTable(client, database) {
return new Promise((resolve, reject) => {
let tables = [];
let connection = MySQL.createConnection(client);
connection.connect((err) => {
if (err)
reject(err);
});
connection.query("use information_schema", (err) => {
if (err)
reject(err);
});
//2. query
connection.query(SQL.LIST_TABLES, [database], (err, rts) => {
connection.destroy();
if (err)
reject(err);
else {
//seal data
rts.forEach((rt) => {
let table = new Table_1.default();
table.table_name = rt.TABLE_NAME;
table.table_rows = rt.TABLE_ROWS;
table.table_type = rt.TABLE_TYPE;
table.create_time = rt.CREATE_TIME;
table.update_time = rt.UPDATE_TIME;
table.version = rt.TABLE_VERSION;
tables.push(table);
});
resolve(tables);
}
});
});
}
static getVersion(client) {
return new Promise((resolve, reject) => {
let connection = MySQL.createConnection(client);
connection.connect((err) => {
if (err)
reject(err);
});
connection.query(SQL.VERSION, (err, rts) => {
//TODO: you must remember this connection
connection.destroy(); //remember destroy the connection
if (err)
reject(err);
else
resolve(rts[0]["version()"]);
});
});
}
static getColumns(client, database, table, withPrimaryKey = true) {
return new Promise((resolve, reject) => {
let connection = MySQL.createConnection(client);
connection.connect((err) => {
if (err)
reject(err);
});
//chnange to information_schema
let columns = [];
connection.query("use information_schema", (err) => {
if (err)
reject(err);
});
connection.query(SQL.LIST_COLUMNS, [database, table], (err, rts) => {
connection.destroy();
if (err)
reject(err);
else {
rts.forEach((rt) => {
let column = new Column_1.default();
column.col_name = rt.COLUMN_NAME;
column.col_type = rt.COLUMN_TYPE;
column.col_comment = rt.COLUMN_COMMENT;
column.data_type = rt.DATA_TYPE;
column.java_type = computeJavaType(rt.DATA_TYPE, rt.COLUMN_TYPE);
let key = rt.COLUMN_KEY;
if (key === "PRI") {
column.isPrimary = true;
if (withPrimaryKey) {
columns.push(column);
}
}
else {
columns.push(column);
}
});
//end each
resolve(columns);
}
});
});
}
static getDbs(client, withSystemDBs = false) {
return new Promise((resolve, reject) => {
let connection = MySQL.createConnection(client);
connection.connect((err) => {
if (err)
reject(err);
});
let databases = [];
connection.query(SQL.SHOWDB, (err, rts) => {
connection.destroy();
if (err)
reject(err);
else {
let excludes = ["sys", "mysql", "information_schema", "performance_schema"];
rts.forEach((rt) => {
if (excludes.includes(rt.Database)) {
if (withSystemDBs)
databases.push(rt.Database);
}
else {
databases.push(rt.Database);
}
});
resolve(databases);
}
});
});
}
static getprimaryKey(client, database, table) {
return new Promise((resolve, reject) => {
let connection = MySQL.createConnection(client);
connection.connect((err) => {
if (err)
reject(err);
});
connection.query("use information_schema", (err) => {
if (err)
reject(err);
});
connection.query(SQL.FIND_PRIMARY, [database, table], (err, rts) => {
connection.destroy();
if (err)
reject(err);
else {
// console.log(rts);
// if (rts.length === 0) resolve(null);
let column = new Column_1.default();
column.col_name = rts[0].COLUMN_NAME;
column.col_type = rts[0].COLUMN_TYPE;
column.col_comment = rts[0].COLUMN_COMMENT;
column.data_type = rts[0].DATA_TYPE;
column.java_type = computeJavaType(rts[0].DATA_TYPE, rts[0].COLUMN_TYPE);
column.isPrimary = true;
// console.log(column,"此时的column")
resolve(column);
}
});
});
}
}
const SQL = {
SHOWDB: "SHOW DATABASES",
VERSION: "select version()",
LIST_TABLES: "select table_name,table_type,table_rows,create_time,update_time,table_comment from tables where table_schema= ?",
LIST_COLUMNS: "select column_name,is_nullable,data_type,column_type,column_key,column_comment,column_default from columns where table_schema= ? and table_name= ?",
FIND_PRIMARY: 'select column_name,is_nullable,data_type,column_type,column_comment,column_default from columns where table_schema= ? and table_name= ? and column_key="PRI"',
};
exports.default = Help;
|
/**
* @param {string} a
* @param {string} b
* @return {string}
*/
var addBinary = function(a, b) {
if (b.length > a.length) {
return addBinary(b, a);
}
let result = "";
let add = 0;
for (let i = a.length - 1; i >= 0; i--) {
// 1,0,0,1 + 1,1
let valA = a[i];
let valB = 0;
for (let j = b.length - 1 - result.length; j >= 0; j--) {
valB = b[j];
break;
}
let val = parseInt(valA) + parseInt(valB) + add;
let rem = val % 2;
result = rem + result;
if (val >= 2) {
add = 1;
} else {
add = 0;
}
}
if (add == 1) {
result = add + result;
}
return result;
};
console.log(addBinary("1010", "1011"));
|
var redis = require('redis');
var listener;
var sender;
var evts = require('events');
var messenger = new evts.EventEmitter();
var myName;
var sendQueue = [];
var registering = false;
messenger.send = function(to, eventName, content){
if(!myName){
sendQueue.push({
to: to,
data: {
content:content,
eventName: eventName
}
});
var emsg = registering ? 'In the process of registering.' : "Cannot send without registering.";
emsg += " Messages will automatically be sent when registered.";
console.error(emsg);
return new Error(emsg);
}
sender.publish(to, JSON.stringify({
content: content,
eventName: eventName,
from: myName,
}));
};
// checks if a channel is still open
messenger.isAlive = function(id, callback){
getChannels(function(channels){
if(channels.indexOf(id) === -1){
callback(false);
return;
}
callback(true);
});
};
// idea: create/return a new client for join?
messenger.join = function(channel){
listener.subscribe(channel);
};
messenger.leave = function(channel){
listener.unsubscribe(channel);
};
messenger.register = function(me, cb){
registering = true;
if(!me){
me = makeId();
console.log("No name given, generating random name: ", me);
}
getChannels(function(channels){
if(channels.indexOf(me) !== -1){
var newMe = !!me ? ""+me+makeId() : makeId();
console.log("Warning: a channel with name \""+me+"\" already Exists... Created new channel: ", newMe);
if(channels.indexOf(newMe) !== -1){
throw new Error("Could not randomize unique channel name");
}
me = newMe;
}
myName = me;
listener.subscribe(me);
console.log('Registered as '+myName);
flushSendQueue();
if(cb){
cb(myName);
}
});
};
// using this function will prevent messenger from receiving events on its channel
messenger.unregister = function(){
listener.unsubscribe(myName);
};
messenger.whoAmI = function(){
return myName;
};
module.exports = {
create: function(port, host, options){
listener = redis.createClient(port||6379, host||'127.0.0.1', options||{});
sender = redis.createClient(port||6379, host||'127.0.0.1', options||{});
listener.on('message', function(channel, message){
var msg;
try {
msg = JSON.parse(message);
} catch(e){
console.error(e);
return console.error("Message Contents:", message);
}
messenger.emit(msg.eventName, msg.content, msg.from, channel);
});
return messenger;
}
};
// misc functions
function flushSendQueue(){
sendQueue.forEach(function(msg){
msg.data.from = myName;
console.log('flushing: ', msg);
sender.publish(msg.to, JSON.stringify(msg.data));
});
sendQueue = [];
}
function getChannels(callback){
sender.pubsub('channels', function(a, channels){
callback(channels || []);
});
}
function makeId(){
return Math.random().toString(36).substring(2);
}
|
function getMetaContent(property) {
const metas = document.querySelectorAll('meta')
for (let i = 0; i < metas.length; i++) {
const prop = metas[i].getAttribute('property')
if (prop === property) return metas[i].getAttribute('content')
}
return ''
}
export default getMetaContent
|
const expect = require('chai').expect;
const settings = require('../../src/exports/settings');
const config = require('../../src/config');
const logger = require('../../src/adapters/logger');
describe('Settings', () => {
it('setSnapshotDirectoryPath', () => {
settings.setSnapshotDirectoryPath('new/path');
expect(config.snapshot.dir).equals('new/path');
});
it('setLogger', () => {
settings.setLogger(logger);
});
it('setJsonLikeAdapter', () => {
settings.setJsonLikeAdapter(require('../../src/adapters/json.like'));
});
it('setJsonMatchAdapter', () => {
settings.setJsonMatchAdapter(require('../../src/adapters/json.match'));
});
it('setJsonSchemaAdapter', () => {
settings.setJsonSchemaAdapter(require('../../src/adapters/json.schema'));
});
after(() => {
settings.setSnapshotDirectoryPath('.pactum/snapshots');
});
});
|
import React from 'react';
const StyleInfo = require('../less/style.less');
export default class StyleComponent extends React.Component {
constructor(){
super();
this.state = {
changeStyle: true
}
}
changeStyle(){
this.setState({
changeStyle: !this.state.changeStyle
})
}
render() {
// 不推荐
// const style = {
// height: (this.state.changeStyle) ? '100px' : '200px',
// background: '#333',
// color: '#fff',
// fontSize: '20px'
// }
return(
<div className={StyleInfo.style} /*style={style}*/ onClick={this.changeStyle.bind(this)} >
<h1 className="text">这里演示 style </h1>
<hr />
</div>
)
}
}
|
'use strict';
(function () {
var adForm = document.querySelector('.ad-form');
var adInputs = adForm.querySelectorAll('input');
var adSelects = adForm.querySelectorAll('select');
var showError = function (elem) {
if (elem.validity.valid) {
elem.style.boxShadow = 'none';
} else {
elem.reportValidity();
elem.style.boxShadow = '0 0 2px 2px red';
}
};
window.sendAdds = function (onSuccess, onError) {
var adFields = Array.from(adInputs).concat(Array.from(adSelects));
for (var i = 0; i < adFields.length; i++) {
showError(adFields[i]);
if (adFields[i].checkValidity() === false) {
showError(adFields[i]);
var stopSubmit = true;
}
}
if (!stopSubmit) {
var xhr = new XMLHttpRequest();
xhr.addEventListener('load', function () {
if (xhr.status === 200) {
onSuccess();
} else {
onError();
}
});
xhr.open('POST', window.constants.SEND_URL);
xhr.send(new FormData(adForm));
}
};
})();
|
import React from 'react';
import "../App.css"
import Message from "./Message"
class Chat extends React.Component {
getUserInfo(message) {
if (message.id === "notification") {
return {id: "notification", username: "", color: "#696969"}
}
if (message.username) {
return {id: "disconnected user", username: message.username + " (disconnected)", color: "#696969"}
}
if (this.props.users){
const user = this.props.users.find(u => message.id === u.id);
if (user) {
return user;
} else {
return {id: "disconnected user", username: "disconnected user", color: "#696969"}
}
} else {
return {username: "err", color: "#FF0000"};
}
}
scrollToBottom = () => {
this.end.scrollIntoView({ behavior: "smooth" });
}
componentDidMount() {
this.scrollToBottom();
}
componentDidUpdate() {
this.scrollToBottom();
}
render() {
return (
<div className="messages-container">
{this.props.messages.map((message, index) => {
if (message.id === sessionStorage.getItem("id"))
return <Message key={index} type="outgoing-message" message={message} user={this.getUserInfo(message)}></Message>
else if (message.id !== "notification")
return <Message key={index} type="incoming-message" message={message} user={this.getUserInfo(message)}></Message>
else
return <Message key={index} type="notification" message={message} user={this.getUserInfo(message)}> </Message>
})}
<div ref={(el) => { this.end = el; }}></div>
</div>
);
}
}
export default Chat;
|
export const updateObjectInArray = (items, itemId, objPropName, newObjProps) => {
return items.map(u => {
if(u[objPropName] === itemId) {
return {...u, ...newObjProps}
}
return u;
})
}
export const getCountPages = (totalItemsCount, pageSize=10, portionSize = 10) => {
const pagesCount = Math.ceil(totalItemsCount / pageSize);
const portionCount = Math.ceil(pagesCount / portionSize);
const pages = [];
for (let i = 1; i <= pagesCount; i++) {
pages.push(i);
}
return {pages, portionCount, pagesCount};
}
export const delElementFromArray = (array, element) => {
const indexElement = array.indexOf(element);
array.splice(indexElement,1);
}
export const getFullDate = (date) => {
const month = new Date(date).getMonth();
switch (month) {
case 0:
return "января";
case 1:
return "февраля";
case 2:
return "марта";
case 3:
return "апреля";
case 4:
return "мая";
case 5:
return "июня";
case 6:
return "июля";
case 7:
return "августа";
case 8:
return "сентября";
case 9:
return "октября";
case 10:
return "ноября";
case 11:
return "декабря";
default:
return month;
}
}
|
/**
* Created by xuwusheng on 15/12/12.
*/
define(['../../../app'], function (app) {
app.factory('cannibalizingDetail', ['$http','$q','HOST',function ($http,$q,HOST) {
return {
getThead: function () {
return [
{name:'序号',type:'pl4GridCount'},
{field:'taskId',name:'调出库名称'},
{field:'fhtime',name:'调出库区域'},
{field:'chuHuoName',name:'调出库地域'},
{field:'clientName',name:'调入库名称'},
{field:'orderTypeName',name:'调入库区域'},
{field:'inGoodsStateName',name:'调入库地域'},
{field:'origGoodCount',name:'品类'},
{field:'origGoodCount',name:'品牌'},
{field:'origGoodCount',name:'商品编码'},
{field:'origGoodCount',name:'商品名称'},
{field:'origGoodCount',name:'规格型号'},
{field:'origGoodCount',name:'出厂编码'},
{field:'origGoodCount',name:'单位'},
{field:'origGoodCount',name:'调拨入库实际入库数量'},
{field:'origGoodCount',name:'调拨出库拣货确认数量'},
{field:'origGoodCount',name:'调拨在途数量'},
{field:'origGoodCount',name:'调拨回退数量'},
{field:'origGoodCount',name:'出库单价'},
{field:'origGoodCount',name:'出库金额'},
{field:'origGoodCount',name:'库存流水单号'},
{field:'origGoodCount',name:'出入库时间'},
{field:'origGoodCount',name:'调拨单号'},
{field:'origGoodCount',name:'调拨状态'},
]
},
getDataTable: function (data) {
//将parm转换成json字符串
data.param=$filter('json')(data.param);
var deferred=$q.defer();
$http.get(HOST+'/pl4/rest/pl4/ckTaskIn/ckTaskInList',{params:data})
.success(function (data) {
deferred.resolve(data);
})
.error(function (e) {
deferred.reject('error:'+e);
});
return deferred.promise;
}
}
}]);
});
|
import productRepository from '../repositories/productRepository.js'
const productsController = () => ({
getProducts: async (req, res) => {
try {
const products = await productRepository.get()
res.json(products)
} catch (error) {
res.status(400).json({
message: 'Unable to list products.'
})
}
},
getProductBySlug: async (req, res) => {
try {
const { slug } = req.params
const product = await productRepository.getBySlug(slug)
if (!product) throw new Error()
res.json(product)
} catch (error) {
res.status(404).json({
message: 'Product not found.'
})
}
},
getProductById: async (req, res) => {
try {
const { id } = req.params
const product = await productRepository.getById(id)
if (!product) throw new Error()
res.json(product)
} catch (error) {
res.status(404).json({
message: 'Product not found.'
})
}
},
getProductByTag: async (req, res) => {
try {
const { tag } = req.params
const product = await productRepository.getByTag(tag)
if (!product) throw new Error()
res.json(product)
} catch (error) {
res.status(404).json({
message: 'Product not found.'
})
}
},
createProduct: async (req, res) => {
try {
const savedProduct = await productRepository.createProduct(req.body)
res.status(201).json(savedProduct)
} catch (error) {
res.status(400).json({
message: 'Unable to create a product.'
})
}
},
updateProduct: async (req, res) => {
try {
const { id } = req.params
const { title, description, slug, price } = req.body
const updatedProduct = await productRepository.updateProduct(
id,
title,
description,
slug,
price
)
if (!updatedProduct) throw new Error()
res.json(updatedProduct)
} catch (error) {
res.status(400).json({
message: 'Unable to updates product.'
})
}
},
deleteProduct: async (req, res) => {
try {
const { id } = req.params
const deletedProduct = await productRepository.deleteProduct(id)
if (!deletedProduct) throw new Error()
res.json({
message: 'Product deleted'
})
} catch (error) {
res.status(400).json({
message: 'Unable to deletes product.'
})
}
}
})
export default productsController()
|
export class Storage {
saveModel(name, modelData) {
window.localStorage.setItem('clooca.v3.model.' + name, JSON.stringify(modelData))
}
loadModel(name) {
let stringifiedModelData = window.localStorage.getItem('clooca.v3.model.' + name)
return JSON.parse(stringifiedModelData)
}
}
|
/**
* Created by lenovo on 2016/12/26.
* status:1正确
*/
app.get('/getMore', function(req, res) {
var start = req.query.start;
//console.log(start); //'3'
//console.log(typeof start); //string
var len = req.query.len;
//console.log(typeof len);//string
var data = [];
//console.log(len); //一定要将json字符串用parseInt()转为数值，要不就会出错。
for (var i = parseInt(start); i < parseInt(start) + parseInt(len); ++i) {
data.push(i);
//console.log(i);
}
res.send({
status: 1,
msg: data
});
});
|
/*
WindowUtilities File
Da includere nella head delle pagine che utilizzano WebDialogWindow
14/01/2011 : SVA
*/
//+----------------------------------------------------------------------------
//
// openDefaultEditor
//
// Description: open editor in new mode
//
//-----------------------------------------------------------------------------
function openDefaultEditor() {
var strURL = "?MODALITA=NEW";
if (document.location.href.lastIndexOf("?") != -1) {
strURL = document.location.href.substring(document.location.href.lastIndexOf("/") + 1, document.location.href.lastIndexOf("?")).replace("_MSB_", "_MSE_") + strURL;
}
else {
strURL = document.location.href.substr(document.location.href.lastIndexOf("/") + 1).replace("_MSB_", "_MSE_") + strURL;
}
openEditor(strURL);
}
//+----------------------------------------------------------------------------
//
// openDefaultEditor
//
// Description: open editor in Edit mode
//
//-----------------------------------------------------------------------------
var msgConfUscita = "";
function onCompletegetDizionarioUI(result) {
msgConfUscita = result;
}
function openEditor(strURL, IdDialog) {
//Verifico se la URL ha già la redirezione. Dovrebbe succedere solo per:
//1) Chiamata dal pulsante "M" - modifica dei Browser
//2) Chiamata da un browser secondario della maschera (struttura Master/Detail)
if (strURL.indexOf("../") == -1) {
//estraggo il nome della cartella contenente Browser/Editor
var pathEditor = top.frames['frameContent'].document.location.href;
var col_array = pathEditor.split("/");
var strFolder = col_array[col_array.length - 2];
strURL = "../" + strFolder + "/" + strURL
}
var d = new Date();
var rs = d.getTime();
if (strURL.indexOf("?") != -1) {
strURL += "&rs=" + rs;
}
else {
strURL += "?rs=" + rs;
}
//var dialogWindow = $(top.window).find('editorDialog');
var dialogWindow = $(top).find('editorDialog');
var dialogFrame = $(top).find('frameEditorDialog');
//var dialogWindow = top.document.getElementById('editorDialog');
if (dialogWindow) {
if (dialogFrame) {
$('#frameEditorDialog').attr("src", strURL);
}
setTimeout("showDialog();", 500);
}
}
//function openEditor(strURL) {
// var d = new Date();
// var rs = d.getTime();
// if (strURL.indexOf("?") != -1) {
// strURL += "&rs=" + rs;
// }
// else {
// strURL += "?rs=" + rs;
// }
// var dialogWindow = $find('editorDialog');
// dialogWindow.get_contentPane().set_contentUrl(strURL);
// setTimeout("showDialog('editorDialog');", 1);
// //Chiamo ajax metodo che riempie la variabile
// PageMethods.getDizionarioUI("USCITA_SENZA_SALVARE", onCompletegetDizionarioUI);
//}
//SVA:inserita per aprire nella stessa pagina 2 webdialog di diverse dimensioni.
//nel caso capire come passare le dimensioni a una funzione sola e cambiarle.
//function openEditorMedium(strURL) {
// var d = new Date();
// var rs = d.getTime();
// if (strURL.indexOf("?") != -1) {
// strURL += "&rs=" + rs;
// }
// else {
// strURL += "?rs=" + rs;
// }
// var dialogWindow = $find('editorDialogMedium');
// dialogWindow.get_contentPane().set_contentUrl(strURL);
// setTimeout("showDialog('editorDialogMedium');", 1);
// //Chiamo ajax metodo che riempie la variabile
// PageMethods.getDizionarioUI("USCITA_SENZA_SALVARE", onCompletegetDizionarioUI);
//}
function showDialog() {
windowResize();
$('#editorDialog').dialog("open");
}
//function showDialog(id) {
// var dialogWindow = $find(id);
// dialogWindow.show();
//}
//function editorDialog_WindowStateChanging(sender, e) {
//
// if (e.get_newWindowState() == 3) {
// var objIframe = $find("editorDialog").get_contentPane().get_iframe().contentWindow;
//
// if (objIframe.$("#form2").FormObserve_changedForm()) {
// e.set_cancel(!confirm(msgConfUscita));
// }
// else {
// document.location.href = document.location.href;
// }
// }
//}
function hideEditorDialog(IdDialog) {
if (IdDialog == undefined)
IdDialog = "editorDialog";
var dialogWindow = $(top).find('editorDialog');
var dialogFrame = $(top).find('frameEditorDialog');
if (dialogFrame) {
alert('tete');
//$('#frameEditorDialog').attr("src", '../Home/blank.aspx');
//dialogFrame.attr("src", '../Home/blank.aspx');
//$('#frameEditorDialog').src = '../Home/blank.aspx';
//$('#frameEditorDialog').src = '/Web/Home/blank.aspx';
//dialogFrame.attr("src", 'http://www.google.it');
//alert($('#frameEditorDialog').style.border);
if(document.getElementById('frameEditorDialog'))
alert(document.getElementById('frameEditorDialog').style.border);
}
if (dialogWindow) {
//alert('xxx');
//$('#editorDialog').dialog("close");
}
}
//function hideEditorDialog(IdDialog) {
// if (IdDialog == undefined)
// IdDialog = "editorDialog";
// var dialogWindow = $(top).find('editorDialog');
// var dialogFrame = $(top).find('frameEditorDialog');
// if (dialogWindow) {
// $('#editorDialog').dialog("close");
// }
// if (dialogFrame) {
// $('#frameEditorDialog').attr("src", '../Home/blank.aspx');
// }
//}
function windowResize() {
var newHeight = $("#frameEditorDialog").contents().find("#dialogHeight").val();
var newWidth = $("#frameEditorDialog").contents().find("#dialogWidth").val();
//Nel caso che risulti "undefined" metto un default
if (newHeight == undefined)
newHeight = 500
if (newWidth == undefined)
newWidth = 600
var dialog = $(top).find("editorDialog");
if (dialog != null) {
$('#editorDialog').dialog("option", "height", newHeight);
$('#editorDialog').dialog("option", "width", newWidth);
$('#editorDialog').dialog("option", "position", "center");
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.