text
stringlengths 7
3.69M
|
|---|
const newsFeedItemTemplate = (title, index) => ({
block: 'li',
cls: 'news-feed__item',
content: title,
attrs: {
'data-id': index,
},
})
const newsFeedTemplate = function(news) {
return {
block: 'ul',
cls: 'news-feed',
content: news.reverse().map(newsFeedItemTemplate),
};
};
export { newsFeedTemplate, newsFeedItemTemplate };
|
import React from "react";
import { withStyles, makeStyles } from "@material-ui/core/styles";
import Table from "@material-ui/core/Table";
import TableBody from "@material-ui/core/TableBody";
import TableCell from "@material-ui/core/TableCell";
import TableHead from "@material-ui/core/TableHead";
import TableRow from "@material-ui/core/TableRow";
import Paper from "@material-ui/core/Paper";
import Button from "@material-ui/core/Button";
import ButtonGroup from "@material-ui/core/ButtonGroup";
import Chip from "@material-ui/core/Chip";
import CircularProgress from "@material-ui/core/CircularProgress";
import LinearProgress from "@material-ui/core/LinearProgress";
import Typography from "@material-ui/core/Typography";
import FormControlLabel from "@material-ui/core/FormControlLabel";
import Switch from "@material-ui/core/Switch";
import ArrowDropDownIcon from "@material-ui/icons/ArrowDropDown";
import RightArrowIcon from "@material-ui/icons/ArrowRightAlt";
import CheckIcon from "@material-ui/icons/CheckCircle";
import SwapIcon from "@material-ui/icons/SwapHoriz";
import TimeIcon from "@material-ui/icons/WatchLater";
import ErrorIcon from "@material-ui/icons/Error";
import TerminateIcon from "@material-ui/icons/NotInterested";
import { green, blue, yellow, red, grey } from "@material-ui/core/colors";
const StyledTableCell = withStyles(theme => ({
head: {
backgroundColor: "#eee",
color: theme.palette.common.black
}
}))(TableCell);
const useStyles = makeStyles(theme => ({
root: {
width: "100%",
marginTop: theme.spacing(3),
overflowX: "auto"
},
table: {
minWidth: 650,
"& td, & th": {
/* */
}
},
button: {
textTransform: "none"
},
sourceIcon: {
fontSize: 16
},
statusIconDoneSmall: {
fontSize: 16,
color: green[400]
},
statusIconScheduledSmall: {
fontSize: 16,
color: blue[400]
},
finishedChip: {
color: "#fff",
backgroundColor: green[400]
},
scheduledChip: {
color: "#fff",
backgroundColor: blue[400]
},
errorChip: {
color: "#fff",
backgroundColor: red[400]
},
terminatedChip: {
color: "#fff",
backgroundColor: grey[600]
},
progressSmall: {
color: "#fff",
borderRadius: "50%",
padding: "0.3rem",
backgroundColor: yellow[800]
},
ongoing64: {
"& div": {
backgroundColor: yellow[800]
}
},
ongoingText: {
fontSize: "0.9rem"
},
customOngoing: {
fontFamily: theme.typography.fontFamily,
fontSize: theme.typography.pxToRem(13),
display: "inline-flex",
flexDirection: "column",
alignItems: "center",
justifyContent: "center",
height: 50,
color: theme.palette.getContrastText(theme.palette.grey[700]),
backgroundColor: theme.palette.grey[600],
borderRadius: 24 / 2,
whiteSpace: "nowrap",
transition: theme.transitions.create(["background-color", "box-shadow"]),
// label will inherit this from root, then `clickable` class overrides this for both
cursor: "default",
// We disable the focus ring for mouse, touch and keyboard users.
outline: "none",
textDecoration: "none",
border: "none", // Remove `button` border
padding: 0, // Remove `button` padding
verticalAlign: "middle",
boxSizing: "border-box"
},
labelSmall: {
paddingLeft: 8,
paddingRight: 8
}
}));
export default function SimpleTable() {
const classes = useStyles();
const [dense, setDense] = React.useState(false);
function handleChangeDense(event) {
setDense(event.target.checked);
}
return (
<div>
<FormControlLabel
control={<Switch checked={dense} onChange={handleChangeDense} />}
label="Dense padding"
/>
<Paper className={classes.root}>
<Table className={classes.table} size={dense ? "small" : "medium"}>
<TableHead>
<TableRow>
<StyledTableCell>ID</StyledTableCell>
<StyledTableCell>Source</StyledTableCell>
<StyledTableCell>Status</StyledTableCell>
<StyledTableCell>Duration</StyledTableCell>
<StyledTableCell>Downloads</StyledTableCell>
</TableRow>
</TableHead>
<TableBody>
<TableRow key="1356">
<TableCell component="th" scope="row" align="right">
<a href="#">1356</a>
</TableCell>
<TableCell>
<RightArrowIcon className={classes.sourceIcon} /> Bulk
</TableCell>
<TableCell>
<CheckIcon className={classes.statusIconDoneSmall} />
</TableCell>
<TableCell>00:00:56</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1355">
<TableCell component="th" scope="row" align="right">
<a href="#">1355</a>
</TableCell>
<TableCell>
<RightArrowIcon className={classes.sourceIcon} /> Bulk
</TableCell>
<TableCell>
<Chip
size="small"
label="Finished"
className={classes.finishedChip}
/>
</TableCell>
<TableCell>00:00:47</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1354">
<TableCell component="th" scope="row" align="right">
<a href="#">1354</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<Chip
icon={<CheckIcon />}
size="small"
color="primary"
label="Finished"
className={classes.finishedChip}
/>
</TableCell>
<TableCell>00:01:04</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1353">
<TableCell component="th" scope="row" align="right">
<a href="#">1353</a>
</TableCell>
<TableCell>
<RightArrowIcon className={classes.sourceIcon} /> Bulk
</TableCell>
<TableCell>
<TimeIcon className={classes.statusIconScheduledSmall} />
</TableCell>
<TableCell />
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1352">
<TableCell component="th" scope="row" align="right">
<a href="#">1352</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<Chip
size="small"
label="Scheduled"
className={classes.scheduledChip}
/>
</TableCell>
<TableCell />
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1351">
<TableCell component="th" scope="row" align="right">
<a href="#">1351</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<Chip
icon={<TimeIcon />}
size="small"
color="primary"
label="Scheduled"
className={classes.scheduledChip}
/>
</TableCell>
<TableCell />
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1350">
<TableCell component="th" scope="row" align="right">
<a href="#">1350</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<CircularProgress
className={classes.progressSmall}
size="0.8rem"
/>
</TableCell>
<TableCell />
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1349">
<TableCell component="th" scope="row" align="right">
<a href="#">1349</a>
</TableCell>
<TableCell>
<RightArrowIcon className={classes.sourceIcon} /> Bulk
</TableCell>
<TableCell>
<Typography className={classes.ongoingText}>
Ongoing: 169/241
</Typography>
<LinearProgress
variant="determinate"
value="64"
className={classes.ongoing64}
/>
</TableCell>
<TableCell />
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1348">
<TableCell component="th" scope="row" align="right">
<a href="#">1348</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<Chip
icon={<ErrorIcon />}
size="small"
color="primary"
label="Error"
className={classes.errorChip}
/>
</TableCell>
<TableCell>00:43:52</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="1347">
<TableCell component="th" scope="row" align="right">
<a href="#">1347</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<Chip
icon={<TerminateIcon />}
size="small"
color="primary"
label="Terminated"
className={classes.terminatedChip}
/>
</TableCell>
<TableCell>01:15:33</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
<TableRow key="666">
<TableCell component="th" scope="row" align="right">
<a href="#">666</a>
</TableCell>
<TableCell>
<SwapIcon className={classes.sourceIcon} /> PerSecurity
</TableCell>
<TableCell>
<section className={classes.customOngoing}>
<span className={classes.labelSmall}>Ongoing: 169/241</span>
<LinearProgress
variant="determinate"
value="64"
className={classes.ongoing64}
/>
</section>
</TableCell>
<TableCell>01:15:33</TableCell>
<TableCell>
<ButtonGroup
variant="outlined"
color="primary"
size="small"
aria-label="Split button"
>
<Button className={classes.button}>Filename.type</Button>
<Button color="primary" variant="outlined" size="small">
<ArrowDropDownIcon />
</Button>
</ButtonGroup>
</TableCell>
</TableRow>
</TableBody>
</Table>
</Paper>
</div>
);
}
|
class BusInfo {
items = [];
callback = null;
//https://v0.ovapi.nl/line/
constructor(onItemsRecieved) {
var getUrl = window.location;
this.baseUrl = getUrl.protocol + "//" + getUrl.host + "/";
this.callback = onItemsRecieved;
}
render(targetDomObject) {
targetDomObject.empty();
for (let currentItem of this.items) {
targetDomObject.append('<div class="item bg-primary rounded p-2 mb-2 text-white"><div class="row"><div class="col-4 col-sm-4">' + currentItem.value.DataOwnerCode + '</div><div class="col-8 col-sm-8 tableQrName">'+currentItem.value.LineName+'</div></div></div>');
};
}
dbDownloadItems() {
return new Promise((resolve, reject) => {
$.ajax({
url: this.baseUrl + "api/bus",
type: 'GET',
success: function (result) {
resolve(result);
},
error: function (error) {
reject(error)
},
});
});
}
download() {
this.dbDownloadItems()
.then((data) => {
this.items = data;
this.callback();
})
.catch((error) => {
console.error(error)
})
}
}
|
var config = {};
/* Web Application settings */
config.url = 'http://azulloft.com:8081'
config.appname = 'Azulloft'
config.locale = 'pt-BR';
/* Sport settings */
config.sports = {};
config.sports.on = 'on';
config.sports.off = 'off';
config.sports.tennis = 'tennis';
config.sports.bascketball = 'bascketball';
config.sports.soccer = 'soccer';
config.sports.volleyball = 'volleyball';
config.lights = {
status: {},
room: {}
};
config.lights.status.on = 'on';
config.lights.status.off = 'off';
config.lights.room.kitchen = 'kitchen';
config.lights.room.bedroom = 'bedroom';
config.lights.room.living_room = 'living_room';
config.lights.room.outside = 'outside';
config.commands = {};
config.commands.curtain = {
open: {
name: 'curtain_open',
description: 'Abrir cortinas',
img: '/img/curtains_bathroom-128.png'
},
close: {
name: 'curtain_close',
description: 'Fechar cortinas',
img: '/img/curtains_bathroom-close-128.png'
}
};
config.commands.alarm = {
name: 'alarm',
description: 'Tocar despertador',
img: '/img/clock_32.png'
};
config.commands.coffe = {
name: 'make_coffe',
description: 'Ligar cafeteira',
img: '/img/coffe.png'
};
/* Arduino settings */
//TODO deixar de um jeito melhor isso
config.arduino = {};
config.arduino.portName = '/dev/ttyACM0'; // you can get this value from Arduino IDE > Tools > Serial Port.
config.arduino.courtTurnOn = '1';
config.arduino.courtTurnOff = '0';
config.arduino.courtSportTennis = '2';
config.arduino.courtSportBascketball = '3';
config.arduino.courtSportSoccer = '4';
config.arduino.courtSportVolleyball = '5';
config.arduino.curtainOpen = '6';
config.arduino.curtainClose = '7';
config.arduino.doBuzz = '8';
config.arduino.makeCoffe = '9';
config.arduino.kitchen_on = '10';
config.arduino.kitchen_off = '11';
config.arduino.bedroom_on = '12';
config.arduino.bedroom_off = '13';
config.arduino.living_room_on = '14';
config.arduino.living_room_off = '15';
config.arduino.outside_on = '16';
config.arduino.outside_off = '17';
module.exports = config;
|
import Product from "../../models/Product";
import * as Notifications from "expo-notifications";
export const DELETE_PRODUCT = "DELETE_PRODUCT";
export const UPDATE_PRODUCT = "UPDATE_PRODUCT";
export const CREATE_PRODUCT = "CREATE_PRODUCT";
export const SET_PRODUCT = "SET_PRODUCT";
import AsyncStorage from "@react-native-async-storage/async-storage";
import ENV from "../../ENV";
export const fetchProducts = () => {
return async (dispatch, getState) => {
const userId = getState().auth.localId;
const token = getState().auth.idToken;
try {
//async function goes here
const response = await fetch(
`${ENV.databaseURL}product.json?auth=${token}`
);
if (!response.ok) {
const err = await response;
throw new Error("Something went wrong!");
}
const resData = await response.json();
const loadedData = [];
for (const key in resData) {
loadedData.push(
new Product(
key,
userId,
resData[key].title,
resData[key].imageUrl,
resData[key].description,
+resData[key].price,
resData[key].pushToken,
)
);
}
return dispatch({ type: SET_PRODUCT, product: loadedData });
} catch (err) {
throw new Error(err.message);
}
};
};
export const deleteProduct = (productId) => {
return async (dispatch, getState) => {
let token = getState().auth.idToken;
const asyncData = async () => {
try {
const authData = await AsyncStorage.getItem("@storage_Key");
return authData !== null ? JSON.parse(authData) : null;
} catch (err) {
console.log(err);
}
};
if (typeof token === "undefined") {
const { idToken } = await asyncData();
token = idToken;
}
await fetch(`${ENV.databaseURL}product/${productId}.json?auth=${token}`, {
method: "DELETE",
});
return dispatch({ type: DELETE_PRODUCT, productId: productId });
};
};
export const updateProduct = (product) => {
return async (dispatch, getState) => {
let token = getState().auth.idToken;
const asyncData = async () => {
try {
const authData = await AsyncStorage.getItem("@storage_Key");
return authData !== null ? JSON.parse(authData) : null;
} catch (err) {
console.log(err);
}
};
if (typeof token === "undefined") {
const { idToken } = await asyncData();
token = idToken;
}
try {
const response = await fetch(
`${ENV.databaseURL}product/${product.id}.json?auth=${token}`,
{
method: "PATCH",
headers: { "content-type": "application/json" },
body: JSON.stringify(product),
}
);
if (!response.ok) {
throw new Error("Something went wrong!");
}
return dispatch({ type: UPDATE_PRODUCT, product });
} catch (err) {
throw err;
}
};
};
export const createProduct = (product) => {
return async (dispatch, getState) => {
let token = getState().auth.idToken;
const asyncData = async () => {
try {
const authData = await AsyncStorage.getItem("@storage_Key");
return authData !== null ? JSON.parse(authData) : null;
} catch (err) {
console.log(err);
}
};
if (typeof token === "undefined") {
const { idToken } = await asyncData();
token = idToken;
}
const userId = getState().auth.localId;
// async function goes here
try {
const pushToken = (await Notifications.getExpoPushTokenAsync()).data;
const response = await fetch(
`${ENV.databaseURL}product.json?auth=${token}`,
{
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
...product,
ownerId: userId,
pushToken: pushToken,
}),
}
);
if (!response.ok) {
const error = await response.json();
throw new Error("Something went wrong!");
}
const resData = await response.json();
return dispatch({
type: CREATE_PRODUCT,
product: { ...product, id: resData.name, ownerId: userId },
});
} catch (err) {
throw err;
}
};
};
|
import {seedToNumber} from "./seedToNumber";
const synonymProcessor = function (text, seed) {
let i = 0;
text = text.replace(/\[([^\]]*)\]/g, function (match, group) {
let synonymGroup = group.split("|");
if (synonymGroup.length == 1) return group;
const randomIndex = seedToNumber(seed, i, synonymGroup.length);
i += 1;
return synonymGroup[randomIndex];
});
return text;
};
export {synonymProcessor};
|
/*jshint browser:true, devel:true */
/*global document */
var WPMLLanguageSwitcherDropdownClick = (function() {
"use strict";
var isOpen = false;
var toggle = function(switcher) {
var subMenu;
if (switcher !== undefined) {
subMenu = switcher.getElementsByClassName('wpml-ls-sub-menu')[0];
}
if(subMenu.style.visibility === 'visible'){
subMenu.style.visibility = 'hidden';
document.removeEventListener('click', close);
}else{
subMenu.style.visibility = 'visible';
document.addEventListener('click', close);
isOpen = true;
}
return false;
};
var close = function(){
if(!isOpen){
var switchers = document.getElementsByClassName('js-wpml-ls-legacy-dropdown-click');
for(var i=0;i<switchers.length;i++){
var altLangs = switchers[i].getElementsByClassName('wpml-ls-sub-menu')[0];
altLangs.style.visibility = 'hidden';
}
}
isOpen = false;
};
return {
'toggle': toggle
};
})();
|
var Promise = require('bluebird'),
sinon = require('sinon');
module.exports = function() {
sinon.stub.resolves = function(value) {
return this.returns(Promise.resolve(value));
};
sinon.stub.rejects = function(err) {
if (typeof err === 'string') {
err = new Error(err);
}
return this.returns(Promise.resolve(null).then(function() {
return Promise.reject(err)
}));
};
};
|
import React, { Component } from 'react';
import styled from 'styled-components';
import bgDesktop from './image/bgDesktop.png';
import bgMobile from './image/bgMobile.png';
const BgDinamic = styled.div`
position: fixed;
top: 0;
bottom: 0;
left: 0;
right: 0;
width: 80%;
margin: 0 auto;
`;
const BgDesktopTag = styled.div`
position: absolute;
left: 0;
right: 0;
top: 30px;
width: 100%;
height: 100%;
max-width: 850px;
margin: 0 auto;
background-size: contain;
background-repeat: no-repeat;
background-image: url(${bgDesktop});
@media (max-width: 768px) {
top: 25%;
}
`;
const BgMobileTag = styled.div`
position: absolute;
right: 160px;
top: 10px;
width: 100%;
height: 100%;
max-width: 400px;
background-size: contain;
background-repeat: no-repeat;
background-image: url(${bgMobile});
@media (max-width: 768px) {
right: 0;
top: 60px;
}
`;
class About extends Component {
render() {
return (
<BgDinamic>
<BgDesktopTag className="bgDesktop" />
<BgMobileTag className="bgMobile" />
</BgDinamic>
);
}
}
export default About
|
import { createStackNavigator, createNavigationContainer } from 'react-navigation';
//LOCAL
import Splash from './src/screens/Splash';
import SignIn from './src/screens/SignIn';
const stackNavigator = createStackNavigator(
{
Splash: { screen: Splash },
SignIn: { screen: SignIn }
},
{
headerMode: 'none'
}
);
export default createNavigationContainer(stackNavigator);
|
import React from 'react'
import { BrowserRouter, Route, Switch } from 'react-router-dom'
// Base components
import Menu from './components/Menu'
import Header from './components/Header'
import Main from './components/Main'
// Pages/Views
import Welcome from './views/Welcome'
import Form from './views/Form'
import Table from './views/Table'
export default function Routes({ children }) {
return (
<BrowserRouter>
<Menu />
<Header />
<Main>
<Switch>
<Route path="/" exact component={Welcome} />
<Route path="/form" component={Form} />
<Route path="/table" component={Table} />
<Route path="/logout" component={Welcome} />
<Route component={Error404} />
</Switch>
</Main>
</BrowserRouter>
)
}
function Error404({ location }) {
return (
<div>
<h1>Erro 404</h1>
<p>
Página não encontrada <code>{location.pathname}</code>
</p>
</div>
)
}
|
import React, { Component, Fragment } from 'react';
import { Grid, CircularProgress } from '@material-ui/core';
import { Portal } from 'react-portal';
import styled from 'styled-components'
const StyledGrid = styled(Grid)`
position: fixed;
top: 0;
bottom: 0;
left: 0;
right: 0;
background-color: rgba(0, 0, 0, 0.5);
color: #fff;
`
class Loader extends Component {
render() {
return (
<Fragment>
{this.props.isOpen && (
<Portal>
<StyledGrid
container
alignItems="center"
justify="center"
direction="row"
>
<Grid item>
<CircularProgress size={80} />
</Grid>
</StyledGrid>
</Portal>
)}
</Fragment>
);
}
}
export default Loader;
|
import React, { Component } from 'react';
import { Provider } from 'react-redux';
import { Switch } from 'react-router-dom';
import { ConnectedRouter } from 'connected-react-router';
import store, { history } from './core/store';
import Login from './authentication/screens/Login';
import Signup from './authentication/screens/Signup';
import BoardPicker from './board/screens/BoardPicker';
import Account from './user/screens/Account';
import ProtectedRoute from './core/components/ProtectedRoute';
import './App.css';
import Dashboard from './board/screens/Dashboard';
import events from './core/events';
import MessageBox from './core/components/MessageBox';
class App extends Component {
// These events handle document click.
// If any part of the site is clicked, an event will be fired, with the clicked node passed.
// This is used to close certain elements, when the user clicks off of them.
componentDidMount() {
window.studyplanner.container.addEventListener('click', this.handleDocumentClick);
}
componentWillUnmount() {
window.studyplanner.container.removeEventListener('click', this.handleDocumentClick);
}
handleDocumentClick = (event) => {
events.fire('document_click', event);
}
render() {
return (
<div className="App">
<Provider store={store}>
<ConnectedRouter history={history}>
<Switch>
<ProtectedRoute withNavBar path="/dashboard" ProtectedComponent={Dashboard} />
<ProtectedRoute withNavBar path="/profile" ProtectedComponent={Account} />
<ProtectedRoute path="/boards" ProtectedComponent={BoardPicker} />
<ProtectedRoute path="/login" PublicComponent={Login} />
<ProtectedRoute path="/signup" PublicComponent={Signup} />
<ProtectedRoute path="" />
</Switch>
<MessageBox/>
</ConnectedRouter>
</Provider>
</div>
);
}
}
export default App;
|
$(document).ready(function(){
//paķer text area tekstu
$("#register-form").validate({
// validācijas likumi
rules: {
name:{
required: true,
rangelength: [2, 6]
},
address: "required",
email: {
required: true,
email: true
},
username: "required",
password: {
required: true,
minlength: 5
},
password2: {
equalTo: "#password"
}
},
// Paziņojumi
messages: {
name: "ievadit no diviem līdz sešiem simbloiem",
address: "Ievadiet adresi",
email: "Ievadiet epastu",
username: "Ievadiet lietotājvārdu",
password: {
required: "Nepieciešam parole",
minlength: "Parolei nepieciešams būt garākai par 5 simboliem."
},
password2: "Parolei jāsakrīt"
},
submitHandler: function(form) {
form.submit();
}
});
});
|
import React from 'react'
import firebase, { db } from '../firebase'
import Footer from '../Components/Footer'
import './log.css'
import VerticalTabs from './tabs'
import MappBar from '../Components/mAppBar'
import HelpPage from './mobile-profile'
export default class Login extends React.Component {
state = {
signed: null,
}
componentDidMount() {
firebase.auth().onAuthStateChanged(user => {
if (user) {
this.setState({ signed: user })
}
})
}
handleLogin = () => {
var provider = new firebase.auth.GoogleAuthProvider();
firebase.auth().signInWithPopup(provider).then(function (result) {
// The signed-in user info.
//var user = result.user;firebase
}).catch(function (error) {
// Handle Errors here.
var errorMessage = error.message;
// The email of the user's account used.
var email = error.email;
// The firebase.auth.AuthCredential type that was used.
var credential = error.credential;
db.collection("LoginErrors").doc(email).set(
{
errorMessage: errorMessage,
email: email,
credential: credential
}
)
});
}
render() {
if (this.state.signed !== null ) {
return (
<div>
<div className="desktop">
<div className="wrap" >
<div className="log-header" >
<div>
<div className="profile-image profile-image-div" style={{ height: '100%', boxShadow: "none" }} >
<img alt="" src={this.state.signed.photoURL} className="profile-image" />
</div>
<div className="display-name">
{this.state.signed.displayName}
</div>
<div className='display-email' >
{this.state.signed.email}
</div>
</div>
</div>
</div>
<div className="wrap" >
<div style={{width:"1000px",padding:"30px 0px",display:"flex"}} >
<VerticalTabs/>
</div>
</div>
</div>
<div className="mobile" >
<MappBar/>
<div className="wrap" >
<div className="log-header" >
<div>
<div className="profile-image profile-image-div" style={{ height: '100%', boxShadow: "none" }} >
<img alt="" src={this.state.signed.photoURL} className="profile-image" />
</div>
<div className="display-name">
{this.state.signed.displayName}
</div>
<div className='display-email' >
{this.state.signed.email}
</div>
</div>
</div>
</div>
<HelpPage/>
</div>
<Footer/>
</div>
)
}
return(
<div className="wrap" >
Please Wait...
</div>
)
}
}
|
var dynamic = $(".mid_col #dynamic");
var cardForm = dynamic.find("#cardForm");
var checkForm = dynamic.find("#checkForm");
var commonForm = dynamic.find("#commonFormInfo");
//append the common form (contact info) to both payment forms
cardForm.html(cardForm.html() + "\n" + commonForm.prop('outerHTML'));
checkForm.html(checkForm.html() + "\n" + commonForm.prop('outerHTML'));
//save the HTML for the card and check forms
var cardFormHTML = dynamic.find("#cardForm").prop('outerHTML');
var checkFormHTML = dynamic.find("#checkForm").prop('outerHTML');
dynamic.html(""); //visually remove all fields
//show the card form HTML if the card button is selected
$(".mid_col #payOnline").click(function() {
updateDynamic(cardFormHTML);
});
//show the check form HTML if the check button is selected
$(".mid_col #payCheck").click(function() {
updateDynamic(checkFormHTML);
});
//slowly replace the payment selection area with the given form HTML
function updateDynamic(html)
{
dynamic.hide();
dynamic.html(html);
dynamic.fadeIn("slow");
$(".mid_col #paymentChoice").html("");
}
//copy the customer's first and last name from billing (card) to shipping (common)
function copyName()
{
var first = $("input[name=x_first_name]").val();
var last = $("input[name=x_last_name]").val();
$("input[name=x_ship_to_first_name]").val(first);
$("input[name=x_ship_to_last_name]").val(last);
}
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { Query } from 'react-apollo';
import debounce from 'debounce';
import CurrencyInput from '../CurrencyInput/CurrencyInput';
import SliderInput from '../SliderInput/SliderInput';
import DisplayGraph from '../DisplayGraph/DisplayGraph';
import RadioSelector from '../RadioSelector/RadioSelector';
import getCompoundInterestQuery from '../../graphql/queries/compoundInterest';
import './CompoundInterestGraph.css';
export default class CompoundInterestGraph extends Component {
constructor(props) {
super(props);
this.interestFrequencyOptions = [{
label: 'Monthly',
value: 1
}, {
label: 'Quarterly',
value: 3
}, {
label: 'Yearly',
value: 12
}];
this.state = {
initialSavings: 0,
monthlySavings: 0,
interestRate: 0,
interestFrequency: 1
};
}
/*
handleValueUpdate(propName, value) {
console.log('a');
const parsedValue = parseFloat(value);
this.setState({ [propName]: parsedValue });
}
*/
handleValueUpdate = debounce((propName, value) => {
console.log('a');
const parsedValue = parseFloat(value);
this.setState({ [propName]: parsedValue });
}, 200);
render() {
const { initialSavings, monthlySavings, interestRate, interestFrequency } = this.state;
const compoundInterestQuery = getCompoundInterestQuery(initialSavings, monthlySavings, interestRate, interestFrequency);
return (
<div>
<div className="financial-inputs">
<p className="input-label">How much have you saved?</p>
<CurrencyInput defaultValue={this.state.initialSavings}
propName={'initialSavings'}
onUpdate={this.handleValueUpdate.bind(this)}
/>
<p className="input-label">How much will you save each month?</p>
<CurrencyInput defaultValue={this.state.monthlySavings}
propName={'monthlySavings'}
onUpdate={this.handleValueUpdate.bind(this)}
/>
<p className="input-label">How much interest will you earn per year?</p>
<SliderInput defaultValue={this.state.interestRate}
propName={'interestRate'}
onUpdate={this.handleValueUpdate.bind(this)}
/>
</div>
<div className="financial-inputs">
<p className="input-label">How often will the interest be paid?</p>
<RadioSelector options={this.interestFrequencyOptions}
propName={'interestFrequency'}
onUpdate={this.handleValueUpdate.bind(this)}
/>
</div>
<Query query={compoundInterestQuery}>
{({ loading, error, data }) => {
if (error) {
return <div>Error</div>;
}
if (!data || !data.compoundInterest) {
return <div>No data available</div>;
}
return (
<div className="financial-display">
<DisplayGraph data={data.compoundInterest.values} />
</div>
);
}}
</Query>
</div>
);
}
}
CompoundInterestGraph.propTypes = {
initialSavings: PropTypes.number,
monthlySavings: PropTypes.number,
interestRate: PropTypes.number
};
|
/* eslint-disable react/jsx-props-no-spreading */
import React, { useReducer, useEffect } from 'react';
import { ThemeProvider } from 'styled-components';
import { DataTableProvider } from '../DataTableContext';
import { tableReducer } from '../../reducer/tableReducer';
import TableRow from '../TableRow';
import TableCol from '../TableCol';
import TableHeader from '../TableHeader';
import Loader from '../Loader';
import NoData from './NoDataWrapper';
import TableColCheckbox from '../TableColCheckbox';
import { propTypes, defaultProps } from './propTypes';
import {
isEmpty, sort, decorateColumns, getSortDirection, isRowSelected,
} from '../../../util';
import TableStyle, {
ResponsiveWrapper, TableBody, TableHead, TableHeadRow, TableWrapper,
} from './styled';
import { createStyles } from './theme';
const InteractiveTable = ({
data,
columns,
title,
keyField,
selectableRows,
selectableRowsHighlight,
selectableRowSelected,
className,
style,
responsive,
overflowY,
overflowYOffset,
isLoading,
isLoadingMore,
disabled,
fixedHeader,
fixedHeaderScrollHeight,
sortIcon,
defaultSortField,
defaultSortAsc,
clearSelectedRows,
theme,
onRowClick,
}) => {
const initialState = {
allSelected: false,
selectedCount: 0,
selectedRows: [],
sortColumn: defaultSortField,
selectedColumn: {},
sortDirection: getSortDirection(defaultSortAsc),
};
const [{
selectedRows,
allSelected,
selectedCount,
sortColumn,
sortDirection,
}, dispatch] = useReducer(tableReducer, initialState);
const columnsConfig = decorateColumns(columns);
const currentTheme = () => createStyles(theme);
useEffect(() => {
dispatch({ type: 'CLEAR_SELECTED_ROWS', selectedRowsFlag: clearSelectedRows });
}, [clearSelectedRows]);
const sortingColumns = () => sort(data, sortColumn, sortDirection);
const sortedData = sortingColumns();
const init = {
dispatch,
data,
allSelected,
selectedRows,
selectedCount,
sortColumn,
sortDirection,
keyField,
selectableRowSelected,
};
const showTableHead = () => data.length > 0 && !isLoading;
return (
<ThemeProvider theme={currentTheme}>
<DataTableProvider initialState={init}>
<ResponsiveWrapper
responsive={responsive}
className={className}
style={style}
overflowYOffset={overflowYOffset}
overflowY={overflowY}
>
{title && <TableHeader title={title} />}
<TableWrapper>
<TableStyle disabled={disabled}>
{showTableHead() && (
<TableHead>
<TableHeadRow
disabled={isLoading || data.length === 0}
>
{selectableRows && <TableColCheckbox />}
{columnsConfig.map((column) => (
<TableCol
key={`col-${Math.random()}`}
column={column}
sortIcon={sortIcon}
/>
))}
</TableHeadRow>
</TableHead>
)}
{!data.length > 0 && !isLoading && (
<NoData />
)}
{isLoading && (
<Loader />
)}
{!isLoading && data.length > 0 && (
<TableBody
fixedHeader={fixedHeader}
fixedHeaderScrollHeight={fixedHeaderScrollHeight}
hasOffset={overflowY}
id="tablebody"
offset={overflowYOffset}
>
{sortedData.map((row, i) => {
const id = isEmpty(row[keyField]) ? i : row[keyField];
const selected = isRowSelected(row, selectedRows, keyField);
return (
<TableRow
id={id}
key={id}
keyField={keyField}
row={row}
columns={columnsConfig}
selectableRows={selectableRows}
selected={selected}
selectableRowsHighlight={selectableRowsHighlight}
rowIndex={i}
onRowClick={onRowClick}
/>
);
})}
</TableBody>
)}
{isLoadingMore && (
<Loader />
)}
</TableStyle>
</TableWrapper>
</ResponsiveWrapper>
</DataTableProvider>
</ThemeProvider>
);
};
InteractiveTable.propTypes = propTypes;
InteractiveTable.defaultProps = defaultProps;
export default InteractiveTable;
|
import React from 'react';
import { Link } from 'react-router-dom';
const AdminPanel = () => (
<header className="intro">
<h2>What would you like to do?</h2>
<div className="buttons">
<Link className="linkBtn dashboardBtn" to="/classroom/manage">
<i className="fa fa-th-large" />
<p>Classrooms</p>
</Link>
<Link className="linkBtn dashboardBtn" to="topics">
<i className="fa fa-th-list" />
<p>Topics</p>
</Link>
<Link className="linkBtn dashboardBtn" to="course-templates">
<i className="fa fa-file-text" />
<p>Course Templates</p>
</Link>
<Link className="linkBtn dashboardBtn" to="instructors">
<i className="fa fa-graduation-cap" />
<p>Instructors</p>
</Link>
<Link className="linkBtn dashboardBtn" to="members">
<i className="fa fa-users" />
<p>Members</p></Link>
<Link className="linkBtn dashboardBtn" to="media">
<i className="fa fa-file-image-o" />
<p>Media</p>
</Link>
<Link className="linkBtn dashboardBtn" to="questions">
<i className="fa fa-check-square-o" />
<p>Questions</p>
</Link>
<Link className="linkBtn dashboardBtn flagged" to="issues">
{ /* {this.state.numOfIssues !== 0 ? showNotification : null} */ }Fix Me
<i className="fa fa-inbox" />
<p>Flagged Notes</p>
</Link>
</div>
</header>
);
export default AdminPanel;
|
"use strict"
var co = require('co')
, EJSON = require('mongodb-extended-json')
, ReadPreference = require('mongodb').ReadPreference
, ERRORS = require('../errors')
, okFalse = require('../util').okFalse;
class Command {
constructor() {
}
handle(connection, mongoClient, bson, originalOp, op, liveQueryHandler, options) {
options = options || {};
if(!options.promoteLongs) options.promoteLongs = false;
return new Promise(function(resolve, reject) {
co(function*() {
// Split the name space
var ns = op.find;
var parts = op.find.split('.');
var db = parts.shift();
var collection = parts.join('.');
// Do we have a live query
var liveQuery = op.liveQuery || false;
var liveQueryId = op.liveQueryId;
// Remove the fields not compatible with the find command
delete op['liveQuery'];
delete op['liveQueryId'];
// If we don't have a liveQueryId error out
if(liveQuery && typeof liveQueryId != 'number') {
return reject({
ok:false, code: ERRORS.LIVE_QUERY_ID_ILLEGAL, message: 'liveQueryId not provided or not an integer', op: op
});
}
// If we don't have a liveQueryId error out
if(liveQuery && liveQueryHandler == null) {
return reject({
ok:false, code: ERRORS.NO_LIVE_QUERY_CHANNEL_HANDLER, message: 'no liveQuery channel handler registered', op: op
});
}
// Do we have a read Preference specified
if(op.readPreference) {
options.readPreference = new ReadPreference(op.readPreference.mode, op.readPreference.tags);
delete op.readPreference;
}
// No pomoteLong set then default to false
if(options.promoteLongs == null) {
options.promoteLongs = true;
}
// Get the full result
options.fullResult = true;
// Execute the command
var result = yield mongoClient.db(db).command(Object.assign(op, {
find: collection
}), options);
// Check if we have a raw response
if(options.raw && result.documents[0].slice(0, 64).indexOf(okFalse) != -1) {
var errorMessage = bson.deserialize(result.documents[0]);
// Reject the command
return reject({
ok:false, code: errorMessage.code, message: errorMessage.errmsg, op: op
});
}
// Create extended EJSON if don't have a raw query
if(!options.raw) {
result.documents[0] = JSON.parse(EJSON.stringify(result.documents[0]));
}
// Register the live query
if(liveQuery) {
liveQueryHandler.register(connection, ns, liveQueryId, originalOp);
}
// Return response
resolve({connection: result.hashedName, result: result.documents[0]});
}).catch(reject);
});
}
}
module.exports = Command;
|
import styled from 'styled-components';
import { Cell } from '../TableCell/styled';
const TableColStyle = styled(Cell)`
${(props) => props.column.button && 'text-align: center'};
`;
export const ColumnSortable = styled.div`
display: inline-flex;
align-items: center;
height: 100%;
line-height: 1;
user-select: none;
${(props) => (props.theme.headCells && (props.sortActive ? props.theme.headCells.activeSortStyle : props.theme.headCells.inactiveSortStyle))};
&:hover {
${({ column }) => column.sortable && 'cursor: pointer'};
${({ column, theme }) => column.sortable && theme.headCells && theme.headCells.activeStyle};
span {
${({ sortActive, column }) => !sortActive && column.sortable && 'opacity: 1'};
}
}
`;
export default TableColStyle;
|
import React from 'react';
import Link from '@docusaurus/Link';
import MailingListForm from '@site/src/components/MailingListForm';
import SVG from 'react-inlinesvg';
import classnames from 'classnames';
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import useBaseUrl from '@docusaurus/useBaseUrl';
import styles from './styles.module.css';
function FooterLink({ to, href, label, ...props }) {
const toUrl = useBaseUrl(to);
return (
<Link
className="footer__link-item"
{...(href
? {
target: '_blank',
rel: 'noopener noreferrer',
href
}
: {
to: toUrl
})}
{...props}
>
{label}
</Link>
);
}
const FooterLogo = ({ url, alt }) => (
<SVG className="footer__logo" alt={alt} src={url} />
);
function Footer() {
const context = useDocusaurusContext();
const { siteConfig = {} } = context;
const { themeConfig = {} } = siteConfig;
const { footer } = themeConfig;
const { copyright, links = [], logo = {} } = footer || {};
const logoUrl = useBaseUrl(logo.src);
if (!footer) {
return null;
}
return (
<footer
className={classnames('footer', {
'footer--dark': footer.style === 'dark'
})}
>
<div className="container">
{links && links.length > 0 && (
<div className="row footer__links">
<div className="col col--5 footer__col">
<div className="margin-bottom--md">
<h4>Subscribe to newsletter</h4>
</div>
<div className="margin-bottom--md">
<MailingListForm description={false} />
</div>
<div>
<a
href="https://twitter.com/dalexhdyt"
target="_blank"
rel="noopener noreferrer"
>
<i className="feather icon-twitter" alt="DalexHD's Twitter" />
</a>
<a
href="https://gitter.im/dwyl"
target="_blank"
rel="noopener noreferrer"
>
<i
className="feather icon-message-circle"
alt="SteamSpeak's Chat"
/>
</a>
<a
href="https://github.com/dalexhd/SteamSpeak"
target="_blank"
rel="noopener noreferrer"
>
<i
className="feather icon-github"
alt="SteamSpeak's Github Repo"
/>
</a>
</div>
</div>
{links.map((linkItem, i) => (
<div key={i} className="col footer__col">
{linkItem.title != null ? (
<h4 className="footer__title">{linkItem.title}</h4>
) : null}
{linkItem.items != null &&
Array.isArray(linkItem.items) &&
linkItem.items.length > 0 ? (
<ul className="footer__items">
{linkItem.items.map((item, key) =>
item.html ? (
<li key={key} className="footer__item">
{item.html}
</li>
) : (
<li key={item.href || item.to} className="footer__item">
<FooterLink {...item} />
</li>
)
)}
</ul>
) : null}
</div>
))}
</div>
)}
{(logo || copyright) && (
<div className="text--center">
{logo && logo.src && (
<div>
{logo.href ? (
<a
href={logo.href}
target="_blank"
rel="noopener noreferrer"
className={styles.footerLogoLink}
>
<FooterLogo alt={logo.alt} url={logoUrl} />
</a>
) : (
<FooterLogo alt={logo.alt} url={logoUrl} />
)}
</div>
)}
{copyright}
<br />
<small>
<a
href="https://github.com/dalexhd/SteamSpeak/security/policy"
target="_blank"
rel="noopener noreferrer"
>
Security Policy
</a>
•
<a
href="https://github.com/dalexhd/SteamSpeak/blob/master/PRIVACY.md"
target="_blank"
rel="noopener noreferrer"
>
Privacy Policy
</a>
</small>
</div>
)}
</div>
</footer>
);
}
export default Footer;
|
const webpack = require('webpack')
const WebpackDevServer = require('webpack-dev-server')
const config = require('../webpack.config')
const options = {
publicPath: config.output.publicPath,
hot: true,
inline: true,
historyApiFallback: true,
stats: {
colors: true,
hash: false,
timings: true,
chunks: false,
chunkModules: false,
modules: false
}
}
const compiler = webpack(config)
const server = new WebpackDevServer(compiler, options)
server.listen(4000)
|
import React from "react";
import { useDispatch, useSelector } from "react-redux";
import { Checkbox, InputNumber } from "antd";
import { InputRangeContainer } from "../style";
import {
UPDATE_ANY_LENGTH,
UPDATE_DIMENSIONS_LENGTH_MIN_FT,
UPDATE_DIMENSIONS_LENGTH_MAX_FT,
UPDATE_DIMENSIONS_LENGTH_MIN_IN,
UPDATE_DIMENSIONS_LENGTH_MAX_IN,
} from "../../../actions/types";
const LengthRange = () => {
const dispatch = useDispatch();
const anyLength = useSelector((state) => state.filters.length.any);
return (
<InputRangeContainer>
<strong>Length:</strong>
<div style={{ borderBottom: "1px solid #E9E9E9", marginBottom: "3px" }}>
<Checkbox
onChange={() =>
dispatch({ type: UPDATE_ANY_LENGTH, payload: !anyLength })
}
checked={anyLength}
>
Any Length
</Checkbox>
</div>
<div
onClick={() => {
dispatch({ type: UPDATE_ANY_LENGTH, payload: false });
}}
style={{ display: "inline-block", marginRight: "10px" }}
>
<InputNumber
size='small'
disabled={anyLength}
style={{ cursor: "pointer" }}
formatter={(value) =>
`${value}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",")
}
parser={(value) => value.replace(/\$\s?|(,*)/g, "")}
min={0}
max={25}
onChange={(value) =>
dispatch({ type: UPDATE_DIMENSIONS_LENGTH_MIN_FT, payload: value })
}
style={{ width: "50px" }}
/>{" "}
ft.
<InputNumber
size='small'
disabled={anyLength}
style={{ cursor: "pointer" }}
formatter={(value) =>
`${value}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",")
}
parser={(value) => value.replace(/\$\s?|(,*)/g, "")}
min={0}
max={12}
onChange={(value) =>
dispatch({ type: UPDATE_DIMENSIONS_LENGTH_MIN_IN, payload: value })
}
style={{ width: "50px" }}
/>{" "}
in.
</div>
-
<div
onClick={() => dispatch({ type: UPDATE_ANY_LENGTH, payload: false })}
style={{ display: "inline-block", marginLeft: "10px" }}
>
<InputNumber
size='small'
disabled={anyLength}
formatter={(value) =>
`${value}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",")
}
parser={(value) => value.replace(/\$\s?|(,*)/g, "")}
min={0}
max={25}
onChange={(value) => {
dispatch({ type: UPDATE_DIMENSIONS_LENGTH_MAX_FT, payload: value });
}}
style={{ width: "50px" }}
/>{" "}
ft.
<InputNumber
size='small'
disabled={anyLength}
formatter={(value) =>
`${value}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",")
}
parser={(value) => value.replace(/\$\s?|(,*)/g, "")}
min={0}
max={12}
onChange={(value) => {
dispatch({ type: UPDATE_DIMENSIONS_LENGTH_MAX_IN, payload: value });
}}
style={{ width: "50px" }}
/>{" "}
in.
</div>
</InputRangeContainer>
);
};
export default LengthRange;
|
/**
* Server side for Banking Application.
* It implements Chain Replication algo
*/
/* Custom includes */
var reply = require('./Reply.js');
var request = require('./Request.js');
var logger = require('./logger.js');
var util = require('./util.js');
/* Config File include */
var config;
/* System includes */
var http = require('http');
var sys = require('sys');
var Fiber = require('fibers');
/* Data Structures */
var Outcome = {
Processed: 0,
InconsistentWithHistory: 1,
InsufficientFunds: 2,
InTransit: 3
}
var Operation = {
GetBalance: 0,
Deposit: 1,
Withdraw: 2,
Transfer: 3
}
var ServerRelation = {
Successor: 0,
Predecessor: 1
}
var ServerType = {
Head: 0,
Internal: 1,
Tail: 2
}
var serverType = '';
var successor = {};
var predecessor = {};
var serverId = '';
var hostname = '';
var port = '';
var bankId = '';
var serverLifeTime = {};
var serverStartupDelay = '';
var heartBeatDelay;
var fail;
var bankServerMap = {};
var sentReq = [];
var historyReq = {};
var accDetails = {};
var lastSentReq = '';
var lastHistReq = '';
var totalSentCnt = 0;
var totalRecvCnt = 0;
var globalSeqNum = 0;
var transferAck = -1;
/* General functions */
function loadServerConfig(bId, sId) {
// config = require('./config.json');
config = require('./config_extendChain.json');
// var config = require('./config_headFailure.json');
// var config = require('./config_tailFailure.json');
heartBeatDelay = config.master.heartBeatDelay;
var details = util.parseServerInfo(bId, sId);
//logger.info('Fetched details using util: ' + JSON.stringify(details));
bankId = bId;
serverId = sId;
hostname = details.hostname;
port = details.port;
serverType = details.type
serverLifeTime = details.serverLifeTime;
serverStartupDelay = details.serverStartupDelay;
fail = details.fail;
// logger.info('ServerId: '+ serverId + ' Successor: ' + JSON.stringify(details.successor) + ' Predecessor: ' + JSON.stringify(details.predecessor));
successor = details.successor;
predecessor = details.predecessor;
logger.info('ServerId: '+ serverId + ' ServerType: ' + serverType);
}
/**
* check whether the reqId is already been served
*
* @reqId: request Id to be checked
*/
function checkRequest(reqId) {
return historyReq[reqId];
/*
if (reqId in historyReq) {
return true;
}
else {
return false;
}
*/
}
/**
* Check whether the MaxService limit is reached
*/
function checkMaxServiceLimit() {
if(serverLifeTime.RecvNum && serverLifeTime.RecvNum == totalRecvCnt) {
logger.info('ServerId: '+ serverId + ' RECV request limit reached. Terminating server.');
process.exit(0);
}
else if(serverLifeTime.SendNum && serverLifeTime.SendNum == totalSentCnt) {
logger.info('ServerId: '+ serverId + ' SEND request limit reached. Terminating server.');
process.exit(0);
}
}
/**
* Update the local history with the request payload
* Returns "true" when the update is successful
* else returns "false"
*
* @payload: received payload
*/
function applyUpdate(payload) {
var reqId = payload.reqId;
// logger.info('ServerId: '+ serverId + ' history: ' + JSON.stringify(historyReq) + ' RequestId: ' + reqId);
// logger.info('ServerId: '+ serverId + ' payload for sync req: ' + JSON.stringify(payload));
if (payload.payload.update) {
var accNum = payload.payload.update.accNum;
}
// TODO: this should be generic logic. shouldn't be dealt differently for update n transfer
else if(payload.payload.transfer) {
var accNum = payload.accNum;
}
if(!checkRequest(reqId)) {
historyReq[reqId] = {
'payload' : payload.payload,
'response' : payload
};
lastHistReq = reqId;
accDetails[accNum] = payload.currBal;
return true;
}
else {
logger.error("Request Inconsistent with history" + JSON.stringify(payload));
return false;
}
}
/**
* add the payload to the sentReq list
* to be used while handling the failures
* When the ack is received from the tail, then all the requests
* smaller the ack'ed reqId will be deleted
*
* @payload: payload to be appended to the sentReq
*/
function appendSentReq(payload) {
var reqId = payload.reqId;
sentReq.push(payload);
lastSentReq = reqId;
}
/**
* fetch balance corresponding to the account number
*
* @accNum: account number
*/
function getBalance(accNum) {
return accDetails[accNum];
}
/**
* perform the transaction on the account
*
* @accNum: account number on which to perform the update
* @amount: amount to be used in transaction
* @oper: operation type
*/
function performUpdate(accNum, amount, oper) {
logger.info('ServerId: '+ serverId + ' Performing update opr ' + accNum + ' ' + amount + ' ' + oper +' ' + accDetails[accNum] + ' ' + getBalance(accNum));
logger.info('ServerId: '+ serverId + ' Account info: ' + JSON.stringify(accDetails));
switch(oper) {
case Operation.Deposit:
accDetails[accNum] = accDetails[accNum] + amount;
// logger.info('After deposit acc Details: ' + JSON.stringify(accDetails));
return Outcome.Processed;
case Operation.Withdraw:
if(accDetails[accNum] < amount) {
logger.info('Insufficient funds acc Details: ' + JSON.stringify(accDetails));
return Outcome.InsufficientFunds;
}
else {
accDetails[accNum] = accDetails[accNum] - amount;
// logger.info('After withdraw acc Details: ' + JSON.stringify(accDetails));
return Outcome.Processed;
}
default:
logger.error('Operation not permitted' + oper);
return Outcome.InconsistentWithHistory;
}
}
/**
* generic function to send request to destination entity
* destination could be client, master or some other server in chain
*
* @data: data to sent as body of the request
* @dest: address(hostname:port) of the destination entity
* @context: context info (who's invoking the function)
*/
function send(data, dest, context) {
logger.info("ServerId: " + serverId + ' ' + JSON.stringify(dest) + ' ' + context);
var options =
{
'host': dest.hostname,
'port': dest.port,
'path': '/',
'method': 'POST',
'headers' : { 'Content-Type' : 'application/json'}
};
var req = http.request(options, function(response) {
var str = '';
response.on('data', function(data) {
str += data;
});
response.on('end', function(){
logger.info("ServerId: " + serverId + ' ' + context + ': Acknowledgement received' + str);
if(data.deposit == 1 && data.withdraw == 1) {
recAck = JSON.parse(str);
transferAck = recAck.transferAck;
}
});
});
req.write(JSON.stringify(data));
req.on('error', function(e){
logger.error("ServerId: " + serverId + ' ' + context + ': Problem occured while requesting' + e)
});
req.end();
}
sendTransferReq = Fiber(function (tmp) {
logger.info("ServerId: " + serverId + ' in function: Sending data to dest bank: ' + JSON.stringify(tmp));
var transferData = tmp.data;
var destBankId = transferData.transfer.destBankId;
var context = tmp.context;
var currResend = 0;
var dest = {
'hostname' : bankServerMap[destBankId].headServer.hostname,
'port' : bankServerMap[destBankId].headServer.port
};
send(transferData, dest, context);
totalSentCnt++;
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while processing transfer request');
process.exit(0);
}
// Wait for the ack to come back from the dest bank head
// else resend the transfer request
// right now the num retries is hard coded assuming the channel
// is reliable
while(currResend < 5) {
for (var i =0; transferAck == -1;) {
util.sleep(1000);
i++;
if(i== 6)
break;
}
if(transferAck == 1) {
logger.info('ServerId: '+ serverId + ' transfer request ack received from th head ');
historyReq[transferData.transfer.reqId]['ack'] = 1;
var ack = {
'ack' : 1,
'reqId' : reqId,
'serverId' : serverId
};
send(ack, predecessor, 'sendAck');
transferAck = -1;
break;
}
else if(transferAck == -1){
logger.info('ServerId: '+ serverId + ' transfer request ack not received. Sending the request again ' + transferData.transfer.reqId);
dest = {
'hostname' : bankServerMap[destBankId].headServer.hostname,
'port' : bankServerMap[destBankId].headServer.port
}
send(transferData, dest, 'TransferToDestBank');
currResend++;
}
}
if (currResend == 3) {
logger.info('ServerId: '+ serverId + ' retry limit reached. Aborting ' + transferData.transfer.reqId);
}
});
/**
* process the sync request from the predecessor server.
*
* @payload: payload recieved from the sync request
*/
function sync(payload) {
logger.info('ServerId: '+ serverId + ' Processing sync request: ' + JSON.stringify(payload));
var reqId = payload.reqId;
if(payload.fail && fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while receiving updates');
process.exit(0);
}
applyUpdate(payload);
appendSentReq(payload);
if(serverType == 2 && payload.payload.transfer && payload.payload.withdraw == 1) {
// it is the source bank tail
// forward the request to the head of the dest bank
logger.info('ServerId: '+ serverId + ' Transfer request reached till the tail of src bank' + JSON.stringify(payload));
if (payload.outcome == Outcome.InsufficientFunds) {
var dest = {
'hostname' : payload.payload.transfer.hostname,
'port' : payload.payload.transfer.port
};
var response = {
'reqId' : payload.reqId,
'outcome' : payload.outcome,
'currBal' : payload.currBal,
'accNum' : payload.accNum
};
if(payload.payload.transfer.simFail == 2) {
// response NOT SENT
// this will simulate the failure condition
// the packet dropped on the server <--> client channel
logger.info('ServerId: '+ serverId + ' Simulating msg failure between Server-Client');
}
else {
send(response, dest, 'sendResponse');
totalSentCnt++;
}
}
else {
var destBankId = payload.payload.transfer.destBankId;
var data = {};
data['transfer'] = payload.payload.transfer;
data['srcCurrBal'] = payload.currBal;
data['srcAccNum'] = payload.accNum;
data['deposit'] = 1;
data['withdraw'] = 0;
if(payload.payload.transfer.simFail == 2) {
// response NOT SENT
// this will simulate the failure condition
// the packet dropped on the server <--> client channel
logger.info('ServerId: '+ serverId + ' Simulating msg failure between Server-Client');
}
else {
// send the req to dest bank head and also
// manage the resend logic
var tmp = {
'data' : data,
'context' : 'TransferToDestBank'
};
logger.info('ServerId: '+ serverId + ' in tail: sending data to dest bank ' + JSON.stringify(tmp));
sendTransferReq.run(tmp);
}
}
// send the ack msg up-stream
var ack = {
'ack' : 1,
'reqId' : reqId,
'serverId' : serverId
};
send(ack, predecessor, 'sendAck');
}
else if(serverType == 2 && payload.payload.transfer && payload.payload.deposit == 1) {
// It is the dest bank tail
// Send the reply back to the client
logger.info('ServerId: '+ serverId + ' Transfer request reached till the tail of dest bank' + JSON.stringify(payload));
// logger.info('ServerId: '+ serverId + ' Bank Server Map' + JSON.stringify(bankServerMap));
var bankId = payload.payload.transfer.bankId;
var dest = {
'hostname' : payload.payload.transfer.hostname,
'port' : payload.payload.transfer.port
}
var data = {
'reqId' : payload.reqId,
'outcome' : payload.outcome,
'destCurrBal' : payload.currBal,
'destAccNum' : payload.accNum,
'srcCurrBal' : payload.payload.srcCurrBal,
'srcAccNum' : payload.payload.srcAccNum,
'complete' : 1,
'outcome' : payload.outcome
};
if(payload.payload.transfer.simFail == 2) {
// response NOT SENT
// this will simulate the failure condition
// the packet dropped on the server <--> client channel
logger.info('ServerId: '+ serverId + ' Simulating msg failure between Server-Client');
}
else {
// It is required to verify successfull transfer req.
// sends its acc bal, but added here to verify.
logger.info('ServerId: '+ serverId + ' Transfer being notified to the client' + JSON.stringify(data));
send(data, dest, 'sendTransferComplete');
totalSentCnt++;
}
// send the ack msg up-stream
var ack = {
'ack' : 1,
'reqId' : reqId,
'serverId' : serverId
};
send(ack, predecessor, 'sendAck');
}
else if(serverType == 2 && payload.payload.update) {
logger.info('ServerId: '+ serverId + ' Sending the response back to client');
// send the response back to the client
var dest = {
'hostname' : payload.payload.update.hostname,
'port' : payload.payload.update.port
};
var response = {
'reqId' : payload.reqId,
'outcome' : payload.outcome,
'currBal' : payload.currBal,
'accNum' : payload.accNum
};
if(payload.payload.update.simFail == 2) {
// response NOT SENT
// this will simulate the failure condition
// the packet dropped on the server <--> client channel
logger.info('ServerId: '+ serverId + ' Simulating msg failure between Server-Client');
}
else {
send(response, dest, 'sendResponse');
totalSentCnt++;
}
// send the ack msg up-stream
var ack = {
'ack' : 1,
'reqId' : reqId,
'serverId' : serverId
};
send(ack, predecessor, 'sendAck');
}
else {
send(payload, successor, 'sendSyncReq');
totalSentCnt++;
}
var response = {
'genack' : 1,
'reqId' : reqId,
'outcome' : Outcome.Processed
};
logger.info('ServerId: '+ serverId + ' Sync request processed');
// logger.info('ServerId: '+ serverId + ' acc details: ' + JSON.stringify(accDetails));
return response;
}
/**
* query the exiting account details for the balance
* query is performed at the tail
* the response is sent to the client
*
* @payload: payload received in the query request
*/
function query(payload) {
logger.info('ServerId: '+ serverId + ' Processing the query request: ' + JSON.stringify(payload));
var reqId = payload.query.reqId
var accNum = payload.query.accNum;
if(historyReq[reqId]) {
var history = historyReq[reqId];
logger.info('ServerId: '+ serverId + ' history: ' + JSON.stringify(history));
if(history.payload.query.accNum == accNum) {
var response = history.response;
logger.info('ServerId: '+ serverId + ' Query request already exists in history: ' + JSON.stringify(response));
return response;
}
else {
var response = {
'reqId' : reqId,
'outcome' : Outcome.InconsistentWithHistory,
'currBal' : 0,
'accNum' : accNum
};
logger.info('ServerId: '+ serverId + ' Query request Inconsistent with history: ' + JSON.stringify(response));
return response;
}
}
var bal = getBalance(accNum);
if(bal == undefined) {
logger.error('ServerId: '+ serverId + ' Account number not found: ' + accNum);
logger.info('ServerId: '+ serverId + ' Creating a new account with the given account number');
// don't create an account on tail, if one doesn't exist
// accDetails[accNum] = 0;
bal = 0;
}
// logger.info('ServerId: '+ serverId + ' Account info: ' + JSON.stringify(accDetails));
var response = {
'reqId' : reqId,
'outcome' : Outcome.Processed,
'currBal' : bal,
'accNum' : accNum
};
// add the payload and response to historyReq
var history = {
'payload' : payload,
'response' : response
};
historyReq[reqId] = history;
lastHistReq = reqId;
logger.info('ServerId: '+ serverId + ' Query request processed: ' + JSON.stringify(response));
return response;
}
/**
* perform the update transaction using the payload
* also forward the sync request to the predecessor server
* in the chain
* the update is performed at the head server
*
* @payload: payload received in the upadate request
*/
function update(payload) {
logger.info('ServerId: '+ serverId + ' Processing the update request ' + JSON.stringify(payload));
var reqId = payload.update.reqId;
var accNum = payload.update.accNum;
var amount = payload.update.amount;
var oper = payload.update.operation;
if(historyReq[reqId]) {
var history = historyReq[reqId];
logger.info('ServerId: '+ serverId + ' history: ' + JSON.stringify(history));
if(history.payload.update.accNum == accNum && history.payload.update.amount == amount && history.payload.update.operation == oper) {
var response = history.response;
// delete response['payload'];
// delete response['sync'];
logger.info('ServerId: '+ serverId + ' Updated response: ' + JSON.stringify(history.response));
logger.info('ServerId: '+ serverId + ' Update request already exists in history: ' + JSON.stringify(response));
return response;
}
else {
var response = {
'reqId' : reqId,
'outcome' : Outcome.InconsistentWithHistory,
'currBal' : 0,
'accNum' : accNum
};
logger.info('ServerId: '+ serverId + ' Update request Inconsistent with history: ' + JSON.stringify(response));
return response;
}
}
var currBal = getBalance(accNum);
if(currBal == undefined) {
logger.error('ServerId: '+ serverId + ' Account number not found: ' + accNum);
logger.info('ServerId: '+ serverId + ' Creating a new account with the given account number');
accDetails[accNum] = 0;
bal = 0;
}
var outcome = performUpdate(accNum, amount, oper);
currBal = getBalance(accNum);
logger.info('ServerId: '+ serverId + ' Transaction Outcome: ' + outcome + ' Current Bal: ' + currBal);
var response = {
'reqId' : reqId,
'outcome' : outcome,
'currBal' : currBal,
'accNum' : accNum,
'payload' : payload,
'sync' : 1
};
// add the payload and response to historyReq
var history = {
'payload' : payload,
'response' : response
};
appendSentReq(response);
historyReq[reqId] = history;
lastHistReq = reqId;
logger.info('ServerId: '+ serverId + ' Processed the update request');
return response;
}
function transfer(payload) {
var reqId = payload.transfer.reqId;
var accNum = payload.transfer.accNum;
var amount = payload.transfer.amount;
var oper = payload.transfer.operation;
var destAccNum = payload.transfer.destAccNum;
var destBankId = payload.transfer.destBankId;
var response;
// If the req already exists, send back the same reply.
logger.info('ServerId: '+ serverId + ' Processing the transfer request from SRC acc ' + accNum + ' to DST acc ' + destAccNum);
if(historyReq[reqId]) {
var history = historyReq[reqId];
logger.info('ServerId: '+ serverId + ' history: ' + JSON.stringify(history));
if(history.payload.transfer.accNum == accNum && history.payload.transfer.amount == amount && history.payload.transfer.destAccNum == destAccNum && history.payload.transfer.operation == oper) {
var response = history.response;
logger.info('ServerId: '+ serverId + ' Transfer request already exists in history: ' + JSON.stringify(response));
return response;
}
else { // Else the request is InconsistentWithHistory
var response = {
'reqId' : reqId,
'outcome' : Outcome.InconsistentWithHistory,
'currBal' : 0, // Should this balance be 0??
'accNum' : accNum,
'destAccNum' : destAccNum
};
logger.info('ServerId: '+ serverId + ' Transfer request Inconsistent with history: ' + JSON.stringify(response));
return response;
}
}
logger.info('ServerId: ' + serverId + ' payload.withdraw = ' + payload.withdraw + ' payload.deposit = ' + payload.deposit);
if (payload.withdraw == 1) { // on source bank's head
logger.info('ServerId: '+ serverId + ' Transfer request ' + reqId + ' received on source bank. Src acc no: ' + accNum);
var currBal = getBalance(accNum);
// Transfer cannot be made if no account exists or the currBal is less than the amt to be transferred
if(currBal == undefined) {
logger.error('ServerId: '+ serverId + ' Account number not found: ' + accNum);
logger.info('ServerId: '+ serverId + ' Transfer cannot be performed.');
// create the account with 0 balance if one doesn't exist
accDetails[accNum] = 0;
bal = 0;
}
var outcome = performUpdate(accNum, amount, Operation.Withdraw);
currBal = getBalance(accNum);
logger.info('ServerId: '+ serverId + ' Transfer request, withdraw happened at source bank with outcome ' + outcome + ' Current Bal: ' + currBal);
response = {
'reqId' : reqId,
'outcome' : outcome,
'currBal' : currBal,
'accNum' : accNum,
'payload' : payload,
'sync' : 1
};
}
else if (payload.deposit == 1) { // on dest bank's server
logger.info('ServerId: '+ serverId + ' Transfer request received on destination bank. Dest acc no: ' + destAccNum);
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while processing transfer request');
process.exit(0);
}
var currBal = getBalance(destAccNum);
if(currBal == undefined) {
logger.error('ServerId: '+ serverId + ' Account number not found: ' + destAccNum);
logger.info('ServerId: '+ serverId + ' Creating a new account with the given account number');
accDetails[destAccNum] = 0;
}
var outcome = performUpdate(destAccNum, amount, Operation.Deposit);
currBal = getBalance(destAccNum);
logger.info('ServerId: '+ serverId + ' Transfer request, deposit happened at destination bank.' + outcome + ' Current Bal: ' + currBal);
response = {
'reqId' : reqId,
'outcome' : outcome,
'currBal' : currBal,
'accNum' : destAccNum,
'payload' : payload,
'sync' : 1
};
}
logger.info('ServerId: '+ serverId + ' Transfer request processed. ' + JSON.stringify(response));
//add the payload and response to historyReq
var history = {
'payload' : payload,
'response' : response
};
appendSentReq(response);
historyReq[reqId] = history;
lastHistReq = reqId;
logger.info('ServerId: '+ serverId + ' Processed the update request');
return response;
}
/**
* handle acknowledgement from the predecessor server
*
* @reqId: request Id
* @serverId: server Id of predecessor
*/
function handleAck(payload) {
logger.info('ServerId: '+ serverId + ' Processing the acknowledgement ' + JSON.stringify(payload));
var reqId = payload.reqId;
var i = 0;
// logger.info(sentReq.length);
for(i = 0; i < sentReq.length; i++) {
logger.info('ServerId: '+ serverId + ' Handle Ack SentReq: ' + JSON.stringify(sentReq[i]));
if(reqId == sentReq[i].reqId) {
break;
}
}
sentReq.splice(0, i + 1);
/*
var nums = reqId.split('.');
for(i = 0; i < nums[1]; i++) {
key = nums[0] + '.' + i;
if(sentReq[key]) {
delete sentReq[key]
// sentReq.remove(key);
}
}
*/
if(serverType != 0) {
send(payload, predecessor, 'ack');
}
var response = {
'genack' : 1,
'reqId' : reqId,
'outcome' : Outcome.Processed
};
logger.info('ServerId: '+ serverId + ' Processed the acknowledgement');
return response;
}
/**
* handle the failure use case
* update the server type in case of head/tail failure
* update the succ/pred in case of internal failure
*/
function handleChainFailure(payload) {
logger.info('ServerId: '+ serverId + ' handling the server failure');
var server = payload.failure.server;
var type = payload.failure.type;
if(type == 'head') { // change server type
serverType = 0;
logger.info('ServerId: '+ serverId + ' updated the server type to HEAD');
}
else if (type == 'tail') { // change server type
serverType = 2;
logger.info('ServerId: '+ serverId + ' updated the server type to TAIL');
// handle the transfer requests from the sentReq list
logger.info('ServerId: '+ serverId + ' probing the sent list to find any transfer request');
for(i = 0; i < sentReq.length; i++) {
logger.info('ServerId: '+ serverId + ' handle transfer SentReq: ' + JSON.stringify(sentReq[i]));
if(sentReq[i].payload.transfer) {
// its the transfer request whose ack is not received yet
// from the old tail
logger.info('ServerId: '+ serverId + ' found a transfer request ' + sentReq[i].reqId);
var data = {
'transfer' : sentReq[i].payload.transfer,
'srcCurrBal' : sentReq[i].currBal,
'srcAccNum' : sentReq[i].accNum,
'deposit' : 1,
'withdraw' : 0
};
var tmp = {
'data' : data,
'context' : 'TransferToDestBank'
};
logger.info('ServerId: '+ serverId + ' in tail failure: sending data to dest bank: ' + JSON.stringify(tmp));
sendTransferReq.run(tmp);
}
}
}
else if(type == 'successor') { // change successor: this is pred
successor = server;
logger.info('ServerId: '+ serverId + ' updated the successor server');
handleNewSucc(payload.failure.seqNum)
if(fail == 0) {
var payload = { // this is just a place holder to avoid null error at master
'seqNum' : lastSentReq // nothing specific to logic
};
logger.info('ServerId: '+ serverId + ' sending ack to master') // don't take it seriously :)
return payload;
}
}
else if(type == 'predecessor') { // change predecessor: this is succ
predecessor = server;
var payload = {};
if (serverType == 2) {
payload['seqNum'] = lastHistReq;
}
else {
payload['seqNum'] = lastSentReq;
}
logger.info('ServerId: '+ serverId + ' updated the predecessor server');
return payload;
}
}
/**
* handle internal server failure and resolve
* sentReq anomalies by synchronizing the sentReq
*/
function handleNewSucc(lastSeqSucc) {
logger.info('ServerId: '+ serverId + ' sending sync requests to the new successor');
var flag = false;
var i = 0;
for(i = 0; i < sentReq.length; i++) {
// logger.info(JSON.stringify(sentReq[i]));
if(sentReq[i].reqId == lastSeqSucc) {
flag = true;
break;
}
}
if(!flag) {
for(i = 0; i < sentReq.length; i++) {
var reqId = sentReq[i].reqId;
// logger.info(JSON.stringify(successor) + ' ' +JSON.stringify(historyReq[reqId].response));
historyReq[reqId].response['fail'] = 1;
send(historyReq[reqId].response, successor, 'sendSyncReq');
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while sending updates to Successor');
process.exit(0);
}
}
}
else {
for(var j = i; j < sentReq.length; j++) {
var reqId = sentReq[j].reqId;
// logger.info(reqId);
// logger.info(JSON.stringify(successor) + ' ' +JSON.stringify(historyReq[reqId].response));
historyReq[reqId].response['fail'] = 1;
send(historyReq[reqId].response, successor, 'sendSyncReq');
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while sending updates to Successor');
process.exit(0);
}
}
}
logger.info('ServerId: '+ serverId + ' sync requests sent');
return true;
}
/**
* handle the extend chain functionality of the server
* NewTail: Either set ack the master of getting added to the chain
* OldTail: Or update the new successor and send the sync to the new tail
*
* @payload: attributes received from master
*/
function handleExtendChain(payload) {
logger.info('ServerId: '+ serverId + ' Processing extend chain');
if(payload.extendChain == 3) {
logger.info('ServerId: '+ serverId + ' Starting to sync with the old tail ' + JSON.stringify(payload));
if(payload.accDetails) {
accDetails[payload.key] = payload.accDetails;
logger.info('ServerId: '+ serverId + ' accDetails: ' + JSON.stringify(accDetails));
}
else if (payload.sentReq) {
logger.info('ServerId: '+ serverId + ' sentReq: ' + JSON.stringify(sentReq));
sentReq.push(payload.sentReq)
logger.info('ServerId: '+ serverId + ' sentReq: ' + JSON.stringify(sentReq));
}
else if(payload.historyReq) {
historyReq[payload.key] = payload.historyReq;
logger.info('ServerId: '+ serverId + ' historyReq: ' + JSON.stringify(historyReq));
}
if(payload.done == 1) {
logger.info('ServerId: '+ serverId + ' Sync completed with the old tail');
send( {'ack' : 2 }, config.master, 'SyncComplete');
}
}
else if(payload.extendChain == -1) { // extend chain failed
serverType = 2;
logger.info('ServerId: '+ serverId + ' Old tail reverted back');
}
else if(payload.type == 2) { // its the new tail
serverType = 2;
predecessor = payload.predecessor;
logger.info('ServerId: '+ serverId + ' Activating new tail and updating the predecessor');
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while sending updates to Successor');
process.exit(0);
}
return { 'ack' : 1 };
}
else if(payload.type == 1) { // its the old tail
logger.info('ServerId: '+ serverId + ' Updating new successor and sync data with new tail');
serverType = 1;
successor = payload.successor;
// sync the DB i.e. accDetails
// sync the history
// sync the sentReq as sync requests
// logger.info("AccDetails: " + JSON.stringify(accDetails));
// logger.info("History: " + JSON.stringify(historyReq));
// logger.info("SentReq: " + JSON.stringify(sentReq));
// logger.info("AccDetails: length " + accDetails.length);
if(fail == 1) {
logger.info('ServerId: '+ serverId + ' exiting while sending updates to Successor');
process.exit(0);
}
for(var key in accDetails) {
var data = {
'extendChain' : 3,
'accDetails' : accDetails[key],
'key' : key,
'done' : 0
};
send(data, successor, 'extendChain');
}
for(var i = 0; i < sentReq.length; i++) {
var data = {
'extendChain' : 3,
'sentReq' : sentReq[i],
'done' : 0
};
send(data, successor, 'extendChain');
}
for(var key in historyReq) {
var data = {
'extendChain' : 3,
'historyReq' : historyReq[key],
'key' : key,
'done' : 0
};
send(data, successor, 'extendChain');
}
var data = {
'extendChain' : 3,
'done' : 1
}
send(data, successor, 'extendChain');
logger.info('ServerId: '+ serverId + ' Updated new successor and sync data with new tail');
}
logger.info('ServerId: '+ serverId + ' processed extend chain request');
}
/**
* check if the req has already been processed
*/
function checkLogs(payload) {
logger.info('ServerId: '+ serverId + ' Processing check Logs request');
var reqId = payload.reqId;
var history = checkRequest(reqId);
var response = {};
if(history && history.payload.transfer) {
response['reqId'] = reqId;
response['checkLog'] = 1;
response['transfer'] = 1;
}
else if(history && (history.payload.update || history.payload.query)) {
var response = history['response'];
response['checkLog'] = 1;
}
else {
response = {
'checkLog' : 0,
'reqId' : reqId,
};
}
logger.info('ServerId: '+ serverId + ' Check logs request processed');
logger.info(JSON.stringify(response));
return response;
}
function contactMaster(payload) {
logger.info('ServerId: '+ serverId + ' contacting master to extend chain');
var data = { 'extendChain' : payload };
send(data, config.master, 'AddToChain');
logger.info('ServerId: '+ serverId + ' Extend chain done');
}
var arg = process.argv.splice(2);
logger.info('ServerId: '+ arg[1] + ' Retrieve cmd line args: ' + arg[0] + ' ' + arg[1]);
if(arg[2]) {
logger.info('ServerId: '+ arg[1] + ' Got the the new server config arg');
config = require(arg[2]);
heartBeatDelay = config.master.heartBeatDelay;
bankId = arg[0];
serverId = arg[1];
hostname = config.server.hostname;
port = config.server.port;
serverLifeTime = config.server.serverLifeTime;
serverType = config.server.type;
fail = config.server.fail;
contactMaster(config.server);
}
else {
loadServerConfig(arg[0], arg[1]);
}
prepareBankServerMap();
function prepareBankServerMap() {
// logger.info('ServerId: '+ serverId + ' Preparing the bank Server Map' + config.bank);
for(var i = 0; i < config.bank.length; i++) {
var serverDetails = {
"headServer" : config.bank[i].headServer,
"tailServer" : config.bank[i].tailServer
};
var bankId = config.bank[i].bankId;
bankServerMap[bankId] = serverDetails;
}
// logger.info('ServerId: '+ serverId + ' Bank Server Map: ' + JSON.stringify(bankServerMap));
}
/*
* create the server and start it
*/
var server = http.createServer(
function(request, response) {
response.writeHead(200, {'Content-Type': 'text/plain'});
// call request handler
// this function will handle all the events
// 1. sync request
// 2. query/update operation
// 3. failure (internal or head/tail)
// 4. acknowledgement
// 5. checkLogs
// logger.info('ServerId: '+ serverId + ' Request received');
if(request.method == 'POST') {
var fullBody ='';
var res = {};
var flag = false;
// if it is a POST request then load the full msg body
request.on('data', function(chunk) {
// logger.info('got data');
fullBody += chunk;
});
request.on('end', function() {
// logger.info('got end');
// parse the msg body to JSON once it is fully received
var payload = JSON.parse(fullBody);
// logger.info(payload);
// sequester the request based upon the element present
// in the message body
if(payload.sync) {
totalRecvCnt++;
res['result'] = sync(payload);
// flag = true; // ommitting gen ack msg, due to flooding
}
else if(payload.query) {
totalRecvCnt++;
res = query(payload);
if(payload.query.simFail == 2) {
// response NOT SENT
// this will simulate the failure condition
// the packet dropped on the server <--> client channel
logger.info('ServerId: '+ serverId + ' Simulating msg failure between Server-Client');
}
else {
flag = true;
}
}
else if(payload.update) {
totalRecvCnt++;
syncRes = update(payload);
logger.info('ServerId: '+ serverId + ' Update req response: ' + JSON.stringify(syncRes));
if(syncRes.sync) {
logger.info('ServerId: '+ serverId + ' Sending sync request from update');
send(syncRes, successor, 'sendSyncReq');
res['result'] = Outcome.InTransit;
}
else {
logger.info('ServerId: '+ serverId + ' Sending response from update');
res = syncRes;
flag = true;
}
}
else if(payload.transfer) {
totalRecvCnt++;
logger.info('ServerId: '+ serverId + ' Transfer req received: ' + JSON.stringify(payload));
if(payload.withdraw == 1 || payload.deposit == 1) {
syncRes = transfer(payload);
if(syncRes.sync) {
logger.info('ServerId: '+ serverId + ' Sending sync request from transfer');
send(syncRes, successor, 'sendSyncReq');
// if it is dest bank head, send ack response
// to the source bank tail
if(payload.deposit == 1) {
res['transferAck'] = 1;
flag = true;
}
}
}
/*
* This is obsolete code. Not required since the destination bank tail is sending the response back to the client.
else if(payload.complete == 1) {
// On src bank's tail
logger.info('ServerId: '+ serverId + ' Transfer successfully completed.' + JSON.stringify(payload));
hist = historyReq[payload.transfer.reqId];
res = hist.response;
var dest = {}
dest['hostname'] = res.payload.transfer.hostname;
dest['port'] = res.payload.transfer.port;
res['destAccBal'] = payload.destAccBal;
res['transferComplete'] = 1;
send(res, dest, 'TransferCompleteToClient');
res['result'] = Outcome.InTransit;
}
*/
}
else if (payload.failure) {
// logger.info('ServerId: '+ serverId + ' handling the server failure ' + JSON.stringify(payload));
// Update the bank Server Map
bankId = payload.failure.bankId;
if(payload.other) {
if (payload.failure.type == 'tail') {
logger.info('ServerId: '+ serverId + ' Updating the new tail server ' + JSON.stringify(payload));
bankServerMap[bankId].tailServer.hostname = payload.failure.server.hostname;
bankServerMap[bankId].tailServer.port = payload.failure.server.port;
}
else if (payload.failure.type == 'head') {
logger.info('ServerId: '+ serverId + ' Updating the new head server ' + JSON.stringify(payload));
bankServerMap[bankId].headServer.hostname = payload.failure.server.hostname;
bankServerMap[bankId].headServer.port = payload.failure.server.port;
}
}
else {
res['result'] = handleChainFailure(payload);
}
if (payload.failure.type == "predecessor" || payload.failure.type == "successor") {
flag = true;
}
}
else if(payload.extendChain) {
res['result'] = handleExtendChain(payload);
var bankId = payload.extendChain.bankId;
if(payload.extendChain.type == 'tail') {
bankServerMap[bankId].tailServer.hostname = payload.extendChain.server.hostname;
bankServerMap[bankId].tailServer.port = payload.extendChain.server.port;
}
if(payload.type == 2 && payload.predecessor) {
flag = true;
}
}
else if(payload.ack) {
res['result'] = handleAck(payload);
}
else if(payload.checkLog) {
res = checkLogs(payload);
flag = true;
}
else if (payload.genack){
logger.info('ServerId: '+ serverId + ' Gen request payload: ' + fullBody);
}
if(flag) {
logger.info('ServerId: '+ serverId + ' Response: ' + JSON.stringify(res));
response.end(JSON.stringify(res));
flag = false;
if(!payload.sync && !payload.failure) { // dont increment if sync request
totalSentCnt++;
}
}
else {
response.end();
}
});
}
}
);
server.listen(port);
logger.info('Server running at http://127.0.0.1:' + port);
/**
* Send heart beat signals to master
*
* using Fiber to sleep on a thread
*/
Fiber(function() {
while(true) {
var payload = {
'heartBeat' : 1,
'serverId' : serverId,
'bankId' : bankId,
'type' : serverType
};
// logger.info('HeartBeat: ' + JSON.stringify(payload));
// check for serverLifeTime limit IF NOT UNBOUNDED
// before sending the heartbeat signal
if (!serverLifeTime.UNBOUND) {
checkMaxServiceLimit();
}
send(payload, config.master, 'sendHeartBeat');
// sleep for delat time
util.sleep(3000);
}
}).run();
|
/**
* @flow
*/
import LqInputWithKeyboardScene from './LqInputWithKeyboardScene';
import React from 'react'
import {
extractNativeValue,
} from './LqUtils';
type Props = {
onSet: (v: any) => void,
value: any,
editable?: boolean,
placeholder: string,
};
let LqStringEditScene = ({value, onSet, placeholder, editable}: Props) => (
<LqInputWithKeyboardScene
color="#9C664A"
placeholder={placeholder || "Empty text"}
onChange={onSet}
editable={editable}
value={extractNativeValue(value)}
/>
);
module.exports = LqStringEditScene;
|
require("dotenv").config();
var keys = require('./keys.js')
// NPM module for Twitter API
var Twitter = require("twitter");
// NPM module for Twitter API
var Spotify = require("node-spotify-api");
// NPM module for OMDB API
var request = require("request");
// NPM module used to read the random.txt file
var fs = require("fs");
// Output files for logs
var filename = "./logs.txt";
// NPM module used for logging solution
var log = require("simple-node-logger").createSimpleFileLogger(filename);
// All log information printed to log.txt
// log.SetLevel("all");
// Parameters and Controller
// ---------
// Declaring variables for omdb/spotify switch statement
var movieTitle;
var songTitle;
// Action request
var action = process.argv[2];
// Request specific information based on action
var argument = "";
var spotify = new Spotify(keys.spotify);
var client = new Twitter(keys.twitter);
// Controller function - which action is taken
//function doSomething(action, argument) {
// Defines specific data relating to the action
argument = getThirdArgument();
switch (action) {
//Get tweet list
//case for switch statement
case "my-tweets":
getMyTweets();
// ends case statement
break;
//get spotify info
case "spotify-this-song":
songTitle = argument;
// Default to specific song if no argument
// if (songTitle === "") {
// lookupSpecificSong();
// //Else look up song based ont title
// } else {
//song info from spotify
getSongInfo(songTitle);
//}
break;
//Gets movie information
case "movie-this":
//First gets movie title argument
movieTitle = argument;
// default movie if no movie title provided
if (movieTitle === "") {
getMovieInfo("Mr. Nobody");
} else {
getMovieInfo(movieTitle);
}
break;
// Gets text inside file, and uses it to do something
case "do-what-it-says":
doWhatItSays();
break;
}
//}
// Return third argument - i.e. song title when requesting song information
function getThirdArgument() {
console.log("3rdarg")
//All arguments in an array
argumentArray = process.argv;
// Loops through words in node argument
for (i = 3; i < argumentArray.length; i++) {
argument += argumentArray[i];
}
return argument;
}
// Last 20 tweets function
function getMyTweets() {
//Passes Twitter keys into call to Twitter API
var client = new Twitter(twitterKeysFile.twitterKeys);
//Search parameters for last 20 tweets
var params = {q: "@JivovAlexander", count: 20};
//Shows up to last 20 tweets in terminal
client.get("search/tweets", params, function (error, tweets, response) {
if (!error) {
//Prints tweet text + creation date in loop
for (i = 0; i < tweets.statuses.length; i++) {
var tweetText = tweets.statuses[i].text;
logOutput("Tweet Text: " + tweetText);
var tweetCreationDate = tweets.statuses[i].text;
logOutput("Tweet Creation Date: " + tweetCreationDate);
}
} else {
logOutput(error);
}
});
}
// Calls Spotify Api to retrieve song info
function getSongInfo(songTitle) {
console.log(songTitle)
//Spotify AP gets track
spotify.search({ type: "track", query: songTitle }).then(function(response) {
var artistsArray = response.tracks.items[0].album.artists;
//Array to hold artist names when more than one artist exists for a song
var artistsNames = [];
// Pushes artists for track to array.
for (var i = 0; i < artistsArray.length; i++) {
artistsNames.push(artistsArray[i].name);
}
//Makes artists array into a string to print cleaner
var artists = artistsNames.join(", ");
//prints actual song response - artists, song name, preview url, and album
logOutput("Artist(s): " + artists);
logOutput("Song: " + response.tracks.items[0].name);
logOutput("Spotify Preview URL: " + response.tracks.items[0].preview_url);
logOutput("Album Name: " + response.tracks.items[0].album.name);
})
.catch(function(err) {
console.log(err);
})
// function (err, response) {
// if (err) {
// logOutput(err)
// }
// limit Spotify modules returns from 20 to 1 song.
//});
};
//When no song title provided, defaults to No Brainer - Justin Bieber
//function lookupSpecificSong();
//Calls Spotify API to retrieve basic song
// spotify.search({ type: "track", id: "5WvAo7DNuPRmk4APhdPzi8" },
// function (err, data) {
// if (err) {
// logOutput.error(err);
// return
// }
// logOutput("Artist: " + data.artists[0].name);
// logOutput("Song: " + data.name);
// logOutput("Spotify Preview URL: " + data.preview_url);
// logOutput("Album Name: " + data.album.name);
// });
// Use fs to take the text inside random.txt and do something
/* function doWhatItSays() {
fs.readFile("random.txt", "utf8", function (err, data) {
if (err) {
logOutput(error);
} else {
//Creates array with data
var randomArray = data.split(",");
//Sets action to first Array item
action = randomArray[0];
//third argument is second array item
argument = randomArray[1];
//Main controller call to do something based on action/arg
doSomething(action, argument);
}
});
}
//Logs data to the terminal and output to a text file*/
function logOutput(logText) {
log.info(logText);
console.log(logText);
}
// doSomething(action)
|
// Copyright 2016 Zipscene, LLC
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
const express = require('express');
const bodyParser = require('body-parser');
const _ = require('lodash');
const XError = require('xerror');
const APIInterface = require('./api-interface');
const utils = require('./utils');
const zstreams = require('zstreams');
const pasync = require('pasync');
const KeepAlive = require('./keep-alive');
const CrispHooks = require('crisphooks');
const objtools = require('objtools');
/**
* API interface base class for APIs with JSON responses. Contains utility methods for such APIs.
*
* @class APIInterfaceJSONBase
* @constructor
* @extends APIInterface
* @param {Object} [options={}]
* @param {Boolean} [options.includeErrorStack=false] - Whether to include stack traces in error responses.
* @param {Boolean} [options.sendHeaderEarly] - If true, sends the header before executing call middleware. This
* means that the header cannot depend on the middleware results. It is required for keepalive.
*/
class APIInterfaceJSONBase extends APIInterface {
constructor(options = {}) {
super();
this.options = options;
// List of middlewares run before the API call
this.preMiddleware = [];
// List of middlewares that modify the result or error
this.postMiddleware = [];
// Express router
this.router = express.Router({ caseSensitive: true, strict: false }); // eslint-disable-line new-cap
}
sendHeader(ctx) {
// Send the HTTP response header
}
/**
* Called to handle an API call, and returning the response, after parameters have been parsed.
*
* Note: This function returns immediately but continues to handle the API call.
*
* @method handleAPICall
* @param {Request} req
* @param {Response} res
* @param {Object} options - register() options
* @param {Object} params - Parsed parameters to method
* @param {Function...} middleware
*/
handleAPICall(req, res, options, params, ...middleware) {
// Set up the parameters on the request
let ctx = req.zapi = {
method: options.method,
req,
res,
version: options.version,
params,
routeOptions: options
};
// Because multiple API calls can use the same socket (HTTP keepalive), we need
// to remove any previous socket handlers added by yaar before adding new ones.
let eventNames = [ 'close', 'error', 'timeout', 'end' ];
for (let eventName of eventNames) {
for (let listener of res.socket.listeners(eventName)) {
if (listener._isYaarHandler) {
res.socket.removeListener(eventName, listener);
}
}
}
// Add 'connection-closed' hook to ctx.
CrispHooks.addHooks(ctx);
let connectionClosedTriggered = false;
const triggerConnectionClosed = () => {
if (!connectionClosedTriggered) {
connectionClosedTriggered = true;
ctx.trigger('connection-closed').catch(pasync.abort);
}
};
triggerConnectionClosed._isYaarHandler = true;
res.on('close', triggerConnectionClosed);
res.socket.on('error', triggerConnectionClosed);
res.socket.on('timeout', triggerConnectionClosed);
// Set up keep-alive
let keepAlive = null;
if (
(options.keepAlive === undefined || !!options.keepAlive) &&
!options.manualResponse &&
this.options.sendHeaderEarly
) {
keepAlive = new KeepAlive(res, options.keepAliveInterval);
}
if (!options.manualResponse && this.options.sendHeaderEarly) {
this.sendHeader(ctx);
// Start keep-alive.
if (keepAlive) keepAlive.start();
}
// Run pre-middleware
utils.runCallMiddleware(ctx, false, this.preMiddleware)
// Emit request begin event
.then((ctx) => {
return this.apiRouter._triggerRequestBegin(ctx).then(() => ctx);
})
// Register event handlers in case of manualResponse
.then((ctx) => {
if (options.manualResponse) {
const socketEndHandler = () => {
this.apiRouter._triggerRequestEnd(ctx, true).catch(pasync.abort);
};
socketEndHandler._isYaarHandler = true;
const socketErrorHandler = (err) => {
err = new XError(XError.REQUEST_ERROR, err);
this.apiRouter._triggerRequestError(ctx, err, true).catch(pasync.abort);
};
socketErrorHandler._isYaarHandler = true;
res.socket.on('end', socketEndHandler);
res.socket.on('error', socketErrorHandler);
}
return ctx;
})
// Run api call middleware
.then((ctx) => utils.runCallMiddleware(ctx, false, middleware))
// Run post middleware
.then((ctx) => utils.runCallMiddleware(ctx, true, this.postMiddleware))
// Process result of the call chain
.then((ctx) => {
// Send header
if (!options.manualResponse && !this.options.sendHeaderEarly) {
this.sendHeader(ctx);
}
if (ctx.error) {
if (keepAlive) keepAlive.stop();
this.apiRouter._triggerRequestEnd(ctx, true).catch(pasync.abort);
if (options.streamingResponse) {
this.sendStreamEnd(res, ctx.error);
} else {
this.sendErrorRes(ctx);
}
} else if (options.manualResponse) {
return undefined;
} else if (options.streamingResponse) {
res.socket.setTimeout(0);
let resStream = ctx.result;
// Duck type the result to ensure it's a stream
if (!resStream || typeof resStream.pipe !== 'function') {
ctx.error = new XError(
XError.INTERNAL_ERROR,
'Expected streaming response route to return a zstream'
);
this.sendErrorRes(ctx);
}
resStream = zstreams(resStream);
let origResStream = resStream;
// Stream ending and cleanup logic
let sentFinalResult = false;
let cleanedUp = false;
let cleanup = (resError) => {
if (cleanedUp) return;
cleanedUp = true;
if (keepAlive) keepAlive.stop();
resStream.unpipe();
let blackhole = new zstreams.BlackholeStream();
blackhole.on('chainerror', (error) => {
console.error('Unexpected error during stream chain cleanup:');
console.error(error);
});
resStream.pipe(blackhole);
if (!sentFinalResult) {
// Trigger full zstreams cleanup
origResStream.abortChain();
}
if (resError) {
this.apiRouter._triggerRequestError(ctx, resError, true).catch(pasync.abort);
}
};
let sendFinalResult = (err) => {
// without the timeout, the last couple rows seem to get cut off
setTimeout(() => {
if (sentFinalResult) return;
sentFinalResult = true;
cleanup();
this.apiRouter._triggerRequestEnd(ctx, true).catch(pasync.abort);
this.sendStreamEnd(res, err);
}, 1);
};
resStream = resStream.through((chunk) => {
if (Buffer.isBuffer(chunk)) chunk = chunk.toString();
if (typeof chunk !== 'string') chunk = JSON.stringify(chunk);
if (chunk[chunk.length - 1] !== '\n') chunk += '\n';
// Restart keep-alive timer.
if (keepAlive) keepAlive.start();
return chunk;
});
// Make sure we're in a clean state if the connection ends
const streamingSocketErrorHandler = (error) => cleanup(new XError(XError.REQUEST_ERROR, error));
streamingSocketErrorHandler._isYaarHandler = true;
const streamingSocketEndHandler = () => cleanup(
new XError(XError.REQUEST_ERROR, 'Request client hung up unexpectedly')
);
streamingSocketEndHandler._isYaarHandler = true;
res.socket.on('error', streamingSocketErrorHandler);
res.socket.on('end', streamingSocketEndHandler);
resStream.on('end', () => sendFinalResult());
resStream.on('chainerror', function(err) {
// Prevent zstreams default cleanup, otherwise res will be ended
// before the final success/failure object can be sent.
this.ignoreError();
sendFinalResult(err);
});
resStream.pipe(res, { end: false });
} else { // success
if (ctx.result && options.responseSchema) {
// Normalize to response schema
let normalizeOptions = {
removeUnknownFields: true,
allowMissingFields: true,
serialize: true,
ignoreDefaults: true
};
try {
ctx.result = options.responseSchema.normalize(ctx.result, normalizeOptions);
} catch (err) {
console.error('Error normalizing yaar API call result:', err);
ctx.result = 'API call result normalization error';
}
}
if (keepAlive) keepAlive.stop();
this.apiRouter._triggerRequestEnd(ctx, true).catch(pasync.abort);
this.sendSuccessRes(ctx);
}
})
.catch(pasync.abort);
}
/**
* Registers middleware that executes before all API calls for this registrar.
* See parent class for detailed documentation
*
* @method registerPreMiddleware
* @param {Object} options
* @param {Function} ...middleware
* @since v1.0.0
*/
registerPreMiddleware(options, ...middleware) {
this.preMiddleware.push(...middleware);
}
/**
* Registers middleware that executes after API calls return a result or error.
* See parent class for detailed documentation
*
* @method registerPostMiddleware
* @param {Object} options
* @param {Function} ...middleware
* @since v1.0.0
*/
registerPostMiddleware(options, ...middleware) {
this.postMiddleware.push(...middleware);
}
/**
* Send response with error
* @method sendErrorRes
*/
sendErrorRes(ctx) {
// Override me
}
sendSuccessRes(ctx) {
}
/**
* Send object indicating success/failure for streaming response, and end response.
* @method sendStreamEnd
* @param {Object} res - express response object
* @param {object} error - error object, if any.
*/
sendStreamEnd(res, error) {
let dataObj;
if (error) {
dataObj = {
success: false,
error: this.formatErrorResponse(error)
};
} else {
dataObj = { success: true };
}
res.end(
JSON.stringify(dataObj) + '\n',
'utf8'
);
}
formatErrorResponse(error) {
if (!XError.isXError(error)) error = XError.fromObject(error);
return error.toObject({
includeStack: this.options.includeErrorStack,
extraFields: [ 'id' ]
});
}
}
module.exports = APIInterfaceJSONBase;
|
const router = require('express').Router()
const { parser, requireSignin, userMiddleware } = require('../common-middlewares')
const { claimPayout, claimFooditems, changeLevel, paidUsers, paidUsersFood } = require('../controllers/admin')
const { register, userProfile,userProfile2,makePayment,updateContactDets,updateBankDets, login, updatePersonalDets, users, userDownlines, resetpassword, reset, resetPasswordChange, requestWithdrawal, pendingPayouts, userProfile1, requestWithdrawalFood } = require('../controllers/user')
router.post('/register',register)
router.post('/login',login)
router.get('/profile/:id',userProfile)
router.get('/profile/:username/second',userProfile1)
router.get('/downlines/:username',userDownlines)
router.get('/profile/logged/in',requireSignin,userProfile2)
router.post('/makepayment/:id',parser,makePayment)
router.patch('/update/personaldatails',requireSignin,parser,updatePersonalDets)
router.patch('/update/bankdatails',requireSignin,updateBankDets)
router.patch('/update/contactdets',requireSignin,updateContactDets)
router.get('/users',users)
router.post('/claim/payout',requireSignin,userMiddleware,claimPayout)
router.post('/claim/fooditems',requireSignin,userMiddleware,claimFooditems)
router.post('/change/plan/upgrade',requireSignin,userMiddleware,changeLevel)
router.post('/password/reset-request',resetpassword)
router.post('/password/reset/:token',reset)
router.post('/password/change/:token',resetPasswordChange)
router.post('/request/withdrawal',requireSignin,userMiddleware,requestWithdrawal)
router.post('/request/withdrawalfood',requireSignin,userMiddleware,requestWithdrawalFood)
router.get('/paid',paidUsers)
router.get('/paidfood',paidUsersFood)
module.exports=router
|
// API key
const API_KEY = "pk.eyJ1Ijoia21pY2tleSIsImEiOiJja21oemZmZ2gwYzhpMnZxb2ptMHg5ZDNlIn0.IeFLAz65xBxny4I0I-jUWQ";
|
const safeHasOwnProperty = {}.hasOwnProperty;
export function getInt(value) {
if (typeof value === 'number' && value % 1 === 0) {
return value;
}
const strValue = String(value);
if (strValue.search(/^[+-]?[0-9]+$/) !== -1) {
return parseInt(strValue, 10);
}
return null;
}
export function getRandomInt(min, max) {
const maxValue = max - min;
return Math.floor(Math.random() * (maxValue + 1 + min));
}
export function hasValue(value) {
return (
typeof value !== 'undefined' && value !== null && (Array.isArray(value) || String(value) !== '')
);
}
export function inspectValue(value) {
if (typeof value === 'undefined' || value === null) {
return value;
}
if (Array.isArray(value)) {
return value;
}
const strValue = String(value);
if (strValue === '' || strValue === 'true') {
return true;
}
if (strValue === 'false') {
return false;
}
const intValue = getInt(value);
if (intValue !== null) {
return intValue;
}
if (strValue.search(/^[+-]?[0-9]*\.[0-9]+$/) !== -1) {
return parseFloat(strValue);
}
return value;
}
export function isAssociativeArray(value) {
return (
typeof value === 'object' &&
value !== null &&
!(
value instanceof String ||
value instanceof Boolean ||
value instanceof Number ||
Array.isArray(value)
)
);
}
export function arrayRm(array, item) {
if (!Array.isArray(array)) {
return false;
}
const index = array.indexOf(item);
if (index > -1) {
array.splice(index, 1);
return true;
}
return false;
}
export function checkArrayOf(array, type, message) {
if (typeof array === 'undefined') {
return [];
}
if (typeof type === 'undefined') {
throw new Error('type is undefined in checkArrayOf');
}
if (array instanceof type) {
return [array];
}
if (
!Array.isArray(array) ||
array
.map(source => source instanceof type)
.reduce((previous, current) => !current || previous, false)
) {
throw new Error(message || 'array contains objects differents than required');
}
return array;
}
export function extend(destination, append) {
const destinationExtended = destination;
if (!(isAssociativeArray(destination) && isAssociativeArray(append))) {
throw new Error(`Invalid extend between <${destination}> and <${append}>`);
}
Object.keys(append).forEach(key => {
if (!safeHasOwnProperty.apply(append, [key])) {
return;
}
if (
safeHasOwnProperty.apply(destinationExtended, [key]) &&
isAssociativeArray(destinationExtended[key]) &&
isAssociativeArray(append[key])
) {
extend(destinationExtended[key], append[key]);
} else {
destinationExtended[key] = append[key];
}
});
return destinationExtended;
}
export function stringify(obj, replacer, space) {
const objectCache = [];
const whiteList = Array.isArray(replacer) ? replacer : false;
return JSON.stringify(
obj,
(key, value) => {
if (key !== '' && whiteList && whiteList.indexOf(key) === -1) {
return undefined;
}
if (typeof value === 'object' && value !== null) {
if (objectCache.indexOf(value) !== -1) {
return '[Circular]';
}
objectCache.push(value);
}
return value;
},
space,
);
}
export function asyncifyCallback(fn, bind) {
return (...args) =>
new Promise((resolve, reject) => {
args.push((err, res) => {
if (err) {
reject(err);
return;
}
resolve(res);
});
fn.apply(bind || null, args);
});
}
|
import getWeb3 from "../utils/getWeb3"
import PAY_CONTRACT_ABI from "../abi/PayContractABI.json"
import ERC20_ABI from "../abi/IERC20ABI.json"
import { tokenInfo } from "../utils/tokenInfo"
import currency from 'currency.js'
export const PAY_CONTRACT_ADDRESS = "0x0a3c2723381573fedc238f0bb68a1899eb437384"
export const generatePayContract = () => new Promise(async (resolve, reject) => {
try {
const web3 = await getWeb3()
const contract = new web3.eth.Contract(PAY_CONTRACT_ABI, PAY_CONTRACT_ADDRESS)
resolve(contract)
} catch (err) {
console.log(err)
reject(err)
}
})
export const getPaymentsHistory = (address) => new Promise(async(resolve, reject) => {
try{
const contract = await generatePayContract()
const history = await contract.getPastEvents('payment', {filter:{payer:address},fromBlock:9328805,toBlock: 'latest'})
resolve(history)
}catch(err){
console.log(err)
reject(err)
}
})
export const generateErc20Contract = tokenAddress => new Promise(async (resolve, reject) => {
try {
const web3 = await getWeb3()
const contract = new web3.eth.Contract(ERC20_ABI, tokenAddress)
resolve(contract)
} catch (err) {
console.log(err)
reject(err)
}
})
export const getErc20Balance = (tokenAddress, balanceAddress) => new Promise(async (resolve, reject) => {
try {
const web3 = await getWeb3()
const contract = new web3.eth.Contract(ERC20_ABI, tokenAddress)
const balance = await contract.methods.balanceOf(balanceAddress).call()
resolve(balance)
} catch (err) {
console.log(err)
reject(err)
}
})
export const getBalances = (balanceAddress) => new Promise(async (resolve, reject) => {
try{
const balances = tokenInfo.map(async (token) => {
const balance = await getErc20Balance(token.address, balanceAddress)
return currency(balance).divide(token.divider).format()
})
const result = await Promise.all(balances)
resolve(result)
}catch(err){
reject(err)
}
})
export const getEtherBalance = (balanceAddress) => new Promise(async(resolve, reject) => {
try{
const web3 = await getWeb3()
const weiBalance = await web3.eth.getBalance(balanceAddress)
const balance = await web3.utils.fromWei(weiBalance, 'ether')
resolve(balance)
}catch(err){
console.log(err)
reject(err)
}
})
|
const gameContainer = document.querySelector('.color-memory');
const gameStates = ['intro', 'phase1', 'phase2', 'phase3', 'results'];
const beginButton = document.querySelector('.color-memory__intro--cta');
const colorChoicesElem = document.querySelector('.color-memory__phase3--choices');
let correctColor = null;
beginButton.addEventListener('click', startGame);
function startGame() {
resetGameState();
gameContainer.classList.add(gameStates[1]);
selectDifficulty();
}
function selectDifficulty() {
const easyButton = document.querySelector('.color-memory__phase1--easy');
const normalButton = document.querySelector('.color-memory__phase1--normal');
const hardButton = document.querySelector('.color-memory__phase1--hard');
easyButton.addEventListener('click', selectEasyGame);
normalButton.addEventListener('click', selectNormalGame);
hardButton.addEventListener('click', selectHardGame);
}
function selectEasyGame() {
resetGameState();
gameContainer.classList.add(gameStates[2]);
createRandomColor('easy');
}
function selectNormalGame() {
resetGameState();
gameContainer.classList.add(gameStates[2]);
createRandomColor('normal');
}
function selectHardGame() {
resetGameState();
gameContainer.classList.add(gameStates[2]);
createRandomColor('hard');
}
function createRandomColor(difficulty) {
let rgbChars = [];
for (i = 0; i < 3; i++) {
rgbChars.push(Math.floor(Math.random() * 256));
}
let newColor = 'rgb(' + rgbChars[0] + ',' + rgbChars[1] + ',' + rgbChars[2] + ')';
document.querySelector('.color-memory__phase2--swatch').style.background = newColor;
setProgressBar('.color-memory__phase2--countdown', '5s', newColor);
for (i = 0; i < 5; i++) {
if (difficulty == 'easy') {
let variance = 80;
let relativeColor = createMoreRelativeColors(rgbChars, variance);
colorChoicesElem.innerHTML += '<input type="radio" id="color-' + i + '" name="color-choice" class="color-choice" data-color="' + relativeColor+ '"><label for="color-' + i + '" style="background-color: ' + relativeColor + ';"></label>';
} else if (difficulty == 'normal') {
let variance = 40;
let relativeColor = createMoreRelativeColors(rgbChars, variance);
colorChoicesElem.innerHTML += '<input type="radio" id="color-' + i + '" name="color-choice" class="color-choice" data-color="' + relativeColor+ '"><label for="color-' + i + '" style="background-color: ' + relativeColor + ';"></label>';
} else if (difficulty == 'hard') {
let variance = 20;
let relativeColor = createMoreRelativeColors(rgbChars, variance);
colorChoicesElem.innerHTML += '<input type="radio" id="color-' + i + '" name="color-choice" class="color-choice" data-color="' + relativeColor+ '"><label for="color-' + i + '" style="background-color: ' + relativeColor + ';"></label>';
}
}
colorChoicesElem.innerHTML += '<input type="radio" id="color-' + i + '" name="color-choice" class="color-choice" data-color="' + newColor + '"><label for="color-' + i + '" style="background-color:' + newColor + ';"></label>';
correctColor = newColor;
shuffleChoices();
}
function createMoreRelativeColors(colorArray, variance) {
let relativeColorArray = [];
colorArray.forEach(function(i){
calculateMinMaxVariance(i, variance);
relativeColorArray.push(Math.round(Math.random() * (finalMinMax[1] - finalMinMax[0]) + finalMinMax[0]));
});
return 'rgb(' + relativeColorArray[0] + ',' + relativeColorArray[1] + ',' + relativeColorArray[2] + ')';
}
function calculateMinMaxVariance(colorValue, variance) {
let minMaxValues = [],
addToMax = 0,
addToMin = 0;
// Set Minimum value
if (colorValue - variance <= 0) {
addToMax = (colorValue - variance) * -1;
minMaxValues.push(0);
} else {
minMaxValues.push(colorValue - variance);
}
// Set maximum value
if (colorValue + variance >= 255) {
addToMin = (colorValue + variance) - 255;
minMaxValues.push(255)
} else {
minMaxValues.push(colorValue + variance);
}
// Add in extra values if needed
let min = minMaxValues[0] + addToMin,
max = minMaxValues[1] + addToMax;
finalMinMax = [min, max];
return finalMinMax;
}
function resetGameState() {
gameContainer.className = 'color-memory';
}
function setProgressBar(elem, duration, color) {
var progressBarElem = document.querySelector(elem);
var progressBarInner = document.querySelector('.progress')
progressBarInner.style.background = color;
progressBarInner.style.animationDuration = duration;
progressBarElem.appendChild(progressBarInner);
progressBarInner.style.animationPlayState = 'running';
progressBarInner.addEventListener('animationend', showColorChoices);
}
function showColorChoices() {
resetGameState();
gameContainer.classList.add(gameStates[3]);
determineResults();
}
function shuffleChoices() {
var ul = colorChoicesElem;
for (var i = ul.children.length; i >= 0; i--) {
ul.appendChild(ul.children[Math.random() * i | 0]);
}
}
function determineResults() {
var choices = document.querySelectorAll('.color-choice');
var choice = null;
for (i = 0; i < choices.length; i++) {
choices[i].onclick = function() {
choice = this.dataset.color;
let choiceAsArray = choice.substring(4,choice.length - 1).split(',');
let correctColorAsArray = correctColor.substring(4,choice.length - 1).split(',');
if (choice == correctColor) {
document.querySelector('.color-memory__results--condition').innerHTML =
'<h2 class="heading">Congratulations, you chose the correct color!</h2>\
<div class="color-group">\
<span class="label">Correct Color</span>\
<span class="color-swatch" style="background-color:' + correctColor + '"></span>\
</div>\
<div class="color-group">\
<span class="label">Chosen Color</span>\
<span class="color-swatch" style="background-color:' + choice + '"></span>\
</div>'
} else {
const redOffByValue = choiceAsArray[0] - correctColorAsArray[0];
const greenOffByValue = choiceAsArray[1] - correctColorAsArray[1];
const blueOffByValue = choiceAsArray[2] - correctColorAsArray[2];
document.querySelector('.color-memory__results--condition').innerHTML = '<h2 class="heading">Sorry, you chose the wrong color.</h2>\
<p>Your red value was off by ' + redOffByValue + '</p>\
<p>Your green value was off by ' + greenOffByValue + '</p>\
<p>Your blue value was off by ' + blueOffByValue + '</p>\
<div class="color-group">\
<span class="label">Correct Color</span>\
<span class="color-swatch" style="background-color:' + correctColor + '"></span>\
</div>\
<div class="color-group">\
<span class="label">Chosen Color</span>\
<span class="color-swatch" style="background-color:' + choice + '"></span>\
</div>'
}
resetGameState();
gameContainer.classList.add(gameStates[4]);
document.querySelector('.color-memory__results--cta').addEventListener('click', startGame);
console.log(choice, correctColor);
document.querySelector('.color-memory__phase3--choices').innerHTML = '';
}
}
}
|
// Delay function to pause execution to next line
const delay = ms => new Promise(res => setTimeout(res, ms));
const time = 300; // 5 hours
// Stay logged in button prompt
const stayLoggedInButton = $(".mat-focus-indicator.mat-btn-lg.btn-block.btn-brand-orange.mat-raised-button.mat-button-base");
// Boolean to check if continue button is disabled
const isContinueButtonDisabled = $('.mat-focus-indicator.btn.mat-btn-lg.btn-block.btn-brand-orange.mat-raised-button.mat-button-base').attr('disabled');
(async () => {
// Click the dropdown for choosing a VFS center
$(".mat-form-field-infix.ng-tns-c58-9").trigger("click");
// Wait for 1 second
await delay(1000);
// Select New delhi center
$("#mat-option-27").trigger('click');
// Wait for 3 seconds
await delay(3000);
// Loop for `time` in minutes
for(let i=0; i <= time; i++) {
if(stayLoggedInButton){
// Click to stay logged in
stayLoggedInButton.trigger('click');
}
// Click Visa category dropdown
$("#mat-select-8").trigger('click');
// Wait for 5 seconds
await delay(5000);
// Scroll to bottom of page, just for keeping continue button in screen area
window.scrollTo(0, 1000);
// Select visa category self employment(whatever you don't want to book for)
$("#mat-option-38").trigger('click');
// Wait for 3 seconds
await delay(3000);
// Click Visa category dropdown again
$("#mat-select-8").trigger('click');
// Wait for 10 seconds
await delay(10000);
// Select visa subcategory Blue card(whatever you want to book for)
$("#mat-option-35").trigger('click');
// Wait for 10 seconds
await delay(10000);
// Select Visa sub-category
$(".mat-form-field-flex.ng-tns-c58-13").trigger('click');
// Wait for 10 seconds
await delay(10000);
$("#mat-option-45").trigger('click');
await delay(19000);
// If continue button is enabled(slot is enabled) for chosen category
if(!isContinueButtonDisabled && $("#mat-select-8").children()[0].innerText == 'Blue Card and its Dependents\t') {
// Play loud music
window.open("https://youtu.be/bRJKrwCrfY0?t=29");
alert("Slot is available, book now")
return true;
};
}
})();
|
'use strict';
var assert = require('chai').assert,
Chess = require('../chess'),
testData = require('./data/empty-board-moves-generation');
describe('Empty board moves', function () {
var pieces = Object.keys(testData);
pieces.forEach(testPieceMoves);
function testPieceMoves(pieceToken) {
describe('generate correct moves for ' + pieceToken, function () {
var squares = testData[pieceToken];
Object.keys(squares).forEach(function (square) {
it('placed on ' + square, function () {
var moves = squares[square],
chess = new Chess(),
piece = chess.placePiece(pieceToken, square),
generatedMoves = piece.generateTargetSquareNames();
assert.sameMembers(generatedMoves, moves);
});
});
});
}
});
|
$(document).ready(function(){
$('#message').faneIn('slow');
});
|
import React from 'react';
import { Flex, Text } from 'app/components/primitives';
import { useThemeContext } from '../../state/theme.state';
export default function DetailView({ navigation, route }) {
const { params } = route;
if (params) {
navigation.setOptions(params);
}
const [theme] = useThemeContext();
return (
<Flex
style={{ backgroundColor: theme.primary, paddingBottom: 50 }}
flex={1}
justifyContent='center'
alignItems='center'
>
<Text color={theme.accent} size={34}>
Detail View
</Text>
</Flex>
);
}
|
const auth = require('basic-auth')
const Credentials = require('../models/schema').Person
module.exports = function(request, response, next)
{
let user = auth(request);
if(user===undefined) response.status(403).send('Tienes que autenticarte')
pass = Buffer.from(user.pass).toString('base64')
Credentials.findOne({n: user.name, password: pass})
.then((p)=>{
if(!p.name) Promise.reject;
response.set('www-Authenticate', 'Basic realm="person"');
return next()
})
.catch((err)=>{response.sendStatus(401);})
}
|
/* Exercício 1 */
function daisyGame(petalas){
if(petalas.constructor === Array){
if (petalas % 2 === 0){
return 'Love me not';
} else {
return 'Love me';
}
}
};
/* Exercício 2 */
function maiorTexto(textos)){
var maiorPalavra = textos[0];
for(var i = 1; i < textos.length; i++){
if(maiorPalavra.length < textos[i].length){
maiorPalavra = textos[i];
}
}
return maiorPalavra;
};
/* Exercício 3 */
function imprime(array, funcao){
if(typeof funcao === "function"){
for(var i = 0; i < array.length; i++){
funcao(array[i]);
}
}
};
/* Exercício 4 */
function fiboSum(n){
var phi = 1.618033988749895;
var fibo = Math.round(Math.pow(phi, n) / Math.sqrt(5));
if(n == 1){
return 1;
}else{
return fibo + fiboSum(n-1);
}
};
/* Exercício 5 */
var excelis = function(referencia) {
referencia = referencia.toUpperCase();
for (var i=0, soma=0, len=referencia.length; i < len; i++) {
soma = soma * 26 + (referencia.charCodeAt(i) - 64);
}
return soma;
};
|
const Util = {};
Util.inherits = function (subClass,superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
}
Util.randomVec = function (length) {
let rand_ang = 2*Math.PI*Math.random();
let x_comp = length * Math.sin(rand_ang);
let y_comp = length * Math.cos(rand_ang);
return [x_comp,y_comp];
}
module.exports = Util;
|
import alt from '../alt';
class ItemActions {
refreshItems() {
return "";
}
updateItems(items) {
return items;
}
newItem(item) {
return item;
}
updateItem(item) {
return item;
}
deleteItem(item) {
return item;
}
}
module.exports = alt.createActions(ItemActions);
|
/*!
* Loceo Javascript Library 1.0.1
* Copyright 2012 All rights reserved.
* Use of this source code is governed by a BSD-style license that can be found at https://loceo.se
*/
(function($){
var mets = {
"init":function(opt){
},
"city":function(opt,callback){
return this.each(function(){
var synclock=false,timer=null;
$(this).keyup(function(){
if(timer){
clearTimeout(timer);
}
var len=$(this).val().length;
if(len>4&&len<10){
var args={'q':$(this).val()};
if(opt.key){
args.key=opt.key;
}
if(synclock==false){
timer = setTimeout(function() {
synclock=true;
var jqxhr = $.getJSON("https://api.loceo.se/v1/geocoding/city?callback=?", args,
function(data){
if(typeof callback=='function' && data!=null){
callback.call(this,data);
}
synclock=false;
});
if(jqxhr.error){
jqxhr.error(function(){synclock=false;});
}
}, 200);
}
}
});
});
},
"postalcode":function(opt,callback){
return this.each(function(){
var synclock=false,timer=null;
$(this).keyup(function(){
if(timer){
clearTimeout(timer);
}
var len=$(this).val().length;
if(len>2&&len<30){
var args={'q':$(this).val()};
if(opt.key){
args.key=opt.key;
}
if(synclock==false){
timer = setTimeout(function() {
synclock=true;
var jqxhr = $.getJSON("https://api.loceo.se/v1/geocoding/postalcode?callback=?", args,
function(data){
if(typeof callback=='function' && data!=null){
callback.call(this,data);
}
synclock=false;
});
if(jqxhr.error){
jqxhr.error(function(){synclock=false;});
}
}, 400);
}
}
});
});
}
};
$.fn.loceo = function(m) {
if ( mets[m] ) {
return mets[m].apply( this, Array.prototype.slice.call( arguments, 1 ));
} else if ( typeof m === 'object' || ! m ) {
return mets.init.apply(this,arguments);
} else {
$.error('Method '+m+' does not exist on jQuery.loceo' );
}
};
})(jQuery);
|
import Price from './Price'
export {
Price,
}
|
// example/demo06-cocos-across-react/react-with-cocos/src/app.jsx
import { useCallback } from 'react';
import cs from './app.module.scss';
function App() {
const onCloseMusic = useCallback(() => {
document.querySelector('iframe').contentWindow.document.dispatchEvent(new CustomEvent('onCloseMusic'));
}, []);
const onKangLongYouHui = useCallback(() => {
document.querySelector('iframe').contentWindow.document.dispatchEvent(new CustomEvent('onKangLongYouHui'))
console.log(document.querySelector('iframe').contentWindow.document)
}, []);
return (
<div className={cs.app}>
<iframe className={cs.iframe} src='./web-mobile/index.html'></iframe>
<h1 className={cs.h1}>下面是React框架里面的代码</h1>
<div className={cs.tool}>
<div className={cs.btn} onClick={onCloseMusic}>关闭音乐</div>
<div className={cs.btn} onClick={onKangLongYouHui}>亢龙有悔</div>
</div>
</div>
)
}
export default App
|
import HexLinks from './HexLinks';
export default HexLinks;
|
"use strict"
class User {
constructor(name, password) {
this.name = name
this.passwordHash = CryptoJS.MD5(password).toString()
this.pictureUrl = null
this.balance = 0
}
checkPassword(password) {
return this.passwordHash === CryptoJS.MD5(password).toString()
}
setPicture(url) {
this.pictureUrl = url
}
deposit(amount) {
this.balance += amount
return this.balance
}
withdraw(amount) {
if(amount > this.balance) throw new NotEnoughMoneyError(this.name, amount)
this.balance -= amount
return this.balance
}
}
|
// The Vue build version to load with the `import` command
// (runtime-only or standalone) has been set in webpack.base.conf with an alias.
import Vue from 'vue'
import App from './App';
import Home from './components/Home';
import TaskList from './components/TaskList';
// import LoginWithCredentials from './components/login/LoginPageCredentials'
import LoginMainPage from './components/login/LoginPage';
import LoginWithCredentials from './components/login/LoginPageCredentials';
import LoginWithFacebook from './components/login/LoginPageFacebook.vue'
import SignUpPage from './components/login/Signup';
import TasksPane from './components/products/TasksPane';
import TaskCard from './components/products/TaskCard';
import HomePage from './components/layout/HomePage';
import VueRouter from 'vue-router';
import VueResource from 'vue-resource';
Vue.use(VueRouter);
Vue.use(VueResource);
import auth from './auth';
Vue.config.productionTip = false;
const routes = [
{
path: '/login',
component: LoginMainPage,
children: [ { path: 'credentials', component: LoginWithCredentials },
{ path: 'signup', component: SignUpPage },
{ path: 'facebook', component: LoginWithFacebook }
]
},
{ path: '/home', component: HomePage, props: {userName: ''} },
{ path: '/getTasks', component: TaskList }
];
// TODO: check how to do redirecting, something like:
// router.redirect({
// '*': '/home'
// })
export const router = new VueRouter({
routes
});
// Check the user's auth status when the app starts
auth.checkAuth();
const app = new Vue({
el: '#app',
template: '<App/>',
components: { App },
router: router
}).$mount('#app');
|
const a = [3,5,6,1,23,9,21,123,3];
function bubble (arr) {
for (let i = arr.length - 1; i > 1; i--) {
for (let j = 0; j < i; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
}
bubble(a);
console.log(a);
|
import {
SIGN_UP,
SIGN_UP_SUCCESS,
SIGN_UP_ERROR,
SIGN_IN,
SIGN_IN_SUCCESS,
SIGN_IN_ERROR,
MAKE_POST_SUCCESS,
FETCH_POSTS_SUCCESS,
FETCH_COMMENTS_SUCCESS,
FETCH_COMMENTS_ERROR,
LOG_OUT,
LOAD_SESSION,
FETCH_COMMENTS,
SEND_COMMENT_SUCCESS,
EDIT_POST_SUCCESS,
EDIT_COMMENT_SUCCESS,
DELETE_COMMENT_SUCCESS,
DELETE_POST_SUCCESS,
} from './actions';
const reducer = (prevState, action) => {
console.log(action)
const { type, payload } = action;
switch (type) {
case SIGN_UP:
case SIGN_IN:
case FETCH_COMMENTS:
return { ...prevState, isFetching: !payload.background };
case SIGN_UP_SUCCESS:
return {
...prevState,
isFetching: false,
isSignUpSuccessful: true,
errors: ['Registration successful! Use your e-mail and password to sign in.']
};
case SIGN_UP_ERROR:
case SIGN_IN_ERROR:
case FETCH_COMMENTS_ERROR:
return { ...prevState, isFetching: false, errors: payload.error };
case SIGN_IN_SUCCESS:
return { ...prevState, isFetching: false, authHeaders: payload.headers, userData: payload.data };
case LOG_OUT:
return { ...prevState, authHeaders: null };
case LOAD_SESSION:
return { ...prevState, ...payload };
case MAKE_POST_SUCCESS:
return {
...prevState,
posts: [
...prevState.posts,
{
...payload,
id: payload.id,
date: new Date(payload.created_at),
comments: []
}
]
}
case FETCH_POSTS_SUCCESS:
return { ...prevState, isFetching: false, ...payload}
case FETCH_COMMENTS_SUCCESS:
let { comments } = payload;
let cachedComments = { post: {}, comment: {} };
comments.sort((a, b) => new Date(a.created_at)-new Date(b.created_at))
.forEach(comment => {
let { commentable_id, commentable_type } = comment;
if (!cachedComments[commentable_type.toLowerCase()][commentable_id]){
cachedComments[commentable_type.toLowerCase()][commentable_id] = [];
}
cachedComments[commentable_type.toLowerCase()][commentable_id].push(comment);
});
return { ...prevState, isFetching: false, cachedComments: cachedComments };
case SEND_COMMENT_SUCCESS:
case EDIT_COMMENT_SUCCESS:
case DELETE_COMMENT_SUCCESS:
let type = payload.commentable_type.toLowerCase();
let newCommentable = [...(prevState.cachedComments[type][payload.commentable_id] || [])];
if (action.type !== SEND_COMMENT_SUCCESS) {
newCommentable = newCommentable.filter((comment) => comment.id !== payload.id);
}
if (action.type !== DELETE_COMMENT_SUCCESS) {
newCommentable.push(payload);
}
return { ...prevState,
cachedComments: {
...prevState.cachedComments,
[type]: {
...prevState.cachedComments[type],
[payload.commentable_id]: newCommentable,
}
}
};
case EDIT_POST_SUCCESS:
return {
...prevState,
posts: [...prevState.posts.filter((post) => post.id !== payload.id), payload]
};
case DELETE_POST_SUCCESS:
return {
...prevState,
posts: [...prevState.posts.filter((post) => post.id !== payload.id)]
}
default:
return { ...prevState };
}
}
export default reducer;
|
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const marcaSchema = new Schema({
nombre: {
type:String,
required:true
},
descripcion:{
type:String,
required: false
},
imagen: String,
fechaAlta: {
type: String,
required: true
},
fechaBaja: {
type: String,
required: false
},
brand:{
type:Schema.Types.ObjectId,
ref:"Brand"
},
total:{
type:Number,
min:0,
default:0
}
},{
timestamps: {
createdAt: 'created_at',
updatedAt: 'updated_at'
}
});
module.exports = mongoose.model('Marca', marcaSchema);
// ES EL MODELO PARA LAS MARCAS QUE LOS BRANDS TENDRAN, LAS MARCAS QUE SE TENDRAN QUE VENDER EN LAS DINAMICAS
// LAS MARCAS PERTENECEN A UN BRAND, UN BRAND SOLO PODRA VER SUS MARCAS, EXCEPTO EL BRAND DE 1PUNTOCINCO, ESE BRAND PUEDE VERLO TODO
|
const scraper = require('../scraper');
const {Spreadsheet} = require('adapters');
const main = async () =>
{
const adapter = new Spreadsheet(
{
data: 'data.xlsx',
parsingOptions:
{
type: 'file'
},
worksheets:
[
{
id: 0,
columns:
[
{
id: 0
}
]
}
]
});
await scraper({adapter, readOptions: {batchSize: 1}, updateOptions: {save: true}});
}
main();
|
export default [
'汉语 / Manderin',
'英语(美国) / English(US)',
'英语(英国) / English(UK)',
'英语(加拿大) / English(Canada)',
'英语(澳大利亚) / English(Australia)',
'英语(印度) / English(India)',
'英语(新西兰) / English(New Zealand)',
'英语(新加坡) / English(Singapore)',
'法语(法国) / French(France)',
'法语(北非) / French(North Africa)',
'法语(加拿大) / French(Canada)',
'德语 / German',
'西班牙语(西班牙) / Spanish(Spain)',
'葡萄牙语(葡萄牙) / Portuguese(Portugal)',
'意大利语 / Italian',
'阿拉伯语 / Arabic',
'泰语 / Thai Language',
'韩语 / Korean',
'日语 / Japanese',
'俄语 / Russian',
'西班牙语(墨西哥) / Spanish(Mexico)',
'法语(法国) / French(France)',
'法语(北非) / French(North Africa)',
'法语(加拿大) / French(Canada)',
'冰岛语 / Icelandic',
'丹麦语 / Danish',
'瑞典语 / Swedish Language',
'挪威语 / Norwegian Language',
'芬兰语 / Finnish',
'荷兰语 / Dutch',
'加泰洛尼亚语 / Catalana',
'捷克语 / Czech',
'匈牙利语 / Hungarian',
'波兰语 / Polishh',
'希腊语 / Greek Language',
'爱尔兰语 / Irish Language',
'波斯语 / Farsi',
'希伯来语 / Hebrew',
'哈萨克语 / Kazak',
'维语 / Uighur Language',
'藏语 / Tibetan Language',
'蒙语 / Mongolian',
'马来语 / Malay Language',
'印尼语 / Indonesian',
'越南语 / Vietnamese Language',
'柬埔寨语 / Cambodian',
'缅甸语 / Burmese',
'老挝语 / Lao Language',
'乌克兰语 / Ukrainian',
'印地语(印度) / Hindi',
'巴基斯坦语 / Urdu',
'尼泊尔 / Nepali',
'斯里兰卡 / Sri Lankan',
'泰米尔语(印度) / Tamil',
'埃塞俄比亚语 / Ethiopian',
'尼日利亚语 / Nigerian',
'毛利语 / Maori',
'葡萄牙语(巴西) / Portuguese(Brazil)',
'粤语 / Cantonese',
'斯瓦西里语(乌干达) / Kiswahili(Uganda)',
'斯瓦西里语(坦桑尼亚) / Kiswahili(Tanzania)',
'泰卢固语(印度) / Telugu(India)',
'马拉泰语(印度) / Marathi(India)',
'孟加拉语 / Bangali',
'古吉拉特语(印度) / Gujarati(India)',
'上海话 / Shanghai dialect'
]
|
import Ember from 'ember';
export default Ember.Route.extend({
model(params) {
return Ember.RSVP.hash({
request: this.get('store').findRecord('contactRequest', params.request_id),
profiles: this.get('store').findAll('userProfile')
});
},
actions: {
goBack() {
this.replaceWith('contact_requests.index');
},
shareProfile(profile) {
let request = this.controller.get('model.request'),
store = this.get('store'),
that = this;
request.acceptRequest({ profile_id: profile.get('id') }).then(function(data) {
store.pushPayload(data);
that.transitionTo('contact_requests.index');
});
}
}
});
|
"use strict";
var _interopRequireWildcard = require("/Users/GemmaGarciaLopez/Desktop/parts_detect_repo/client/node_modules/@babel/runtime/helpers/interopRequireWildcard");
var _interopRequireDefault = require("/Users/GemmaGarciaLopez/Desktop/parts_detect_repo/client/node_modules/@babel/runtime/helpers/interopRequireDefault");
var _react = _interopRequireDefault(require("react"));
var _reactDom = _interopRequireDefault(require("react-dom"));
var _App = _interopRequireDefault(require("./components/App"));
var _store = _interopRequireDefault(require("./state/store"));
var _reactRedux = require("react-redux");
var serviceWorker = _interopRequireWildcard(require("./serviceWorker"));
var state = window.__INITIAL_STATE__;
var store = (0, _store.default)({
state: state
});
_reactDom.default.render(_react.default.createElement(_reactRedux.Provider, {
store: store
}, _react.default.createElement(_App.default, null)), document.getElementById('root')); // If you want your app to work offline and load faster, you can change
// unregister() to register() below. Note this comes with some pitfalls.
// Learn more about service workers: https://bit.ly/CRA-PWA
serviceWorker.unregister();
|
import React from 'react';
import styles from '../styles/styles';
import {WIDTH, HEIGHT, HEADER_STYLE} from '../styles/styles';
import {
View,
Image,
ScrollView,
ImageBackground
} from 'react-native';
import Text from '../components/animalText';
export default class VisitorsScene extends React.Component {
constructor(props) {
super(props);
}
static navigationOptions = {
title: 'Pro návštěvníky',
...HEADER_STYLE,
}
render() {
const MIN_ZOOM = 0.5;
const MAX_ZOOM = 5.0;
return (
<ScrollView minimumZoomScale={MIN_ZOOM} maximumZoomScale={MAX_ZOOM}
style={[styles.contentView, {backgroundColor: undefined}]}>
<View style={styles.headerWithImage}>
<Text style={{fontWeight: '900', paddingTop: 10, textAlign:'center', fontSize: WIDTH/15}}>
Kdy máme otevřeno?
</Text>
<Image style={{width: WIDTH/5, height: HEIGHT/8, top:-5}} source={require('../images/orloj.png')}/>
</View>
<View style={{flexDirection: 'row'}}>
<View style={{flex: 1}} />
<Text style={{fontSize: WIDTH/20, textAlign: 'left', color:'#446E5C', fontWeight:'700', flex: 2}}>
Listopad-Únor{"\n"}
Březen, Říjen{"\n"}
Duben-Září
</Text>
<Text style={{fontSize: WIDTH/20, textAlign: 'right', flex: 1}}>
9-16{"\n"}
9-17{"\n"}
9-18
</Text>
<View style={{flex: 1}} />
</View>
<View style={styles.headerWithImage}>
<Text style={{fontWeight: '900', paddingTop: 20, textAlign:'center', fontSize: WIDTH/15}}>
Jak se k nám dostat?
</Text>
<Image style={{width: WIDTH/5, height: HEIGHT/10, marginTop:5,}} source={require('../images/icons/tramvaj.png')}/>
</View>
<View style={{flexDirection: 'row'}}>
<View style={{flex: 1}} />
<Text style={{fontSize: WIDTH/20, color:'#446E5C', fontWeight:'700',textAlign: 'left', flex: 2}}>
Trolejbus{"\n"}
Tramvaj{"\n"}
Autobus
</Text>
<Text style={{fontSize: WIDTH/20, textAlign: 'left', flex: 1.5}}>
30{"\n"}
1, 3, 11{"\n"}
50, 52, 54
</Text>
<View style={{flex: 1}} />
</View>
<View style={styles.headerWithImage}>
<Text style={{fontWeight: '900', paddingTop: 10, textAlign:'center', fontSize:WIDTH/15}}>
Jak se s námi spojit?
</Text>
<Image style={{width: WIDTH/5, height: HEIGHT/10, marginTop:10,}} source={require('../images/icons/telefon.png')}/>
</View>
<Text style={{fontSize: WIDTH/20, textAlign: 'center'}}>
zoo@zoobrno.cz {"\n"}
546 432 311
</Text>
<Text style={{fontSize: WIDTH/20, textAlign: 'center', paddingTop: 40, paddingBottom: 100, fontWeight:'700'}}>
Zoo Brno a stanice zájmových činností, příspěvková organizace {"\n"}
U Zoologické zahrady 46 {"\n"}
635 00 Brno
</Text>
</ScrollView>
);
}
}
|
import React from 'react';
function ExchangeRateOption({currency}) {
return (
<option value={currency}>{currency}</option>
);
}
export default ExchangeRateOption;
|
// import something here
import {auth} from 'firebase'
import {getMisCursos, getMisTemas} from './firebase'
import {setCursosWithTemas, setTemas, deleteDB, setUser} from './dexie'
export async function downloadCurso(curso){
await setCursoToMisCursos(curso)
await setCursoWithTemas(curso)
return curso
}
export async function createCurso(curso){
return setCurso(curso)
}
export async function deleteMiCurso(curso){
await deleteMiCurso(curso)
await deleteCursoWithTemas(curso)
return curso
}
export async function deleteCurso(curso){
await deleteCurso(curso)
await deleteCursoWithTemas(curso)
return curso
}
export async function searchCurso(curso){
return await searchLocalCurso(curso)
}
export async function downloadMisCursos(uid){
return getMisCursos(uid).then(cursos => {
console.log('MIS CURSOS', cursos);
return setCursos(cursos)
})
}
export async function downloadMisTemas(uid){
return getMisTemas(uid).then(temas => {
let temas_listos = []
temas.forEach(temasUnidos => {
temasUnidos.forEach(temas_separados => {
temas_listos.push(temas_separados)
})
})
return setTemas(temas_listos)
})
}
export async function getAll(uid){
return deleteDB().then(() => {
auth().onAuthStateChanged(user => {
setUser(user)
})
return getMisCursos(uid).then(cursos => {
return setCursosWithTemas(cursos)
})
// let promiseGet = [ downloadMisCursos(uid), downloadMisTemas(uid) ]
// return Promise.all(promiseGet)
})
}
// "async" is optional
// export default async ({ /* app, router, Vue, ... */ }) => {
// // something to do
// }
|
document.write('the current version od the io.js' + process.version)
|
var myArrayOne = [];
var myArrayTwo =[];
function addTo() {
myArrayOne.push(document.getElementById("userinput").value);
//window.alert(myArray + " has been added to the array");
//The following line clears the text field after the input has been added to the array.
document.getElementById('userinput').value = '';
}
function listMe() {
var text = "";
var i;
for (i = 0; i < myArrayOne.length; i++) {
text += myArrayOne[i] + "<br>";
}
document.getElementById("arrayListOne").innerHTML = text;
}
//NOW WE BEGIN THE SECOND LIST!!!!//
function addTo2() {
myArrayTwo.push(document.getElementById("userinput2").value);
document.getElementById('userinput2').value = '';
}
function listMe2() {
var text2 = "";
var i;
for (i = 0; i < myArrayTwo.length; i++) {
text2 += myArrayTwo[i] + "<br>";
}
document.getElementById("arrayListTwo").innerHTML = text2;
}
//Now we generate the randomization of two names
function giveName() {
fname = [Math.floor(Math.random() * myArrayOne.length)];
lname = [Math.floor(Math.random() * myArrayTwo.length)];
document.getElementById('yourName').innerHTML = myArrayOne[fname] + " " + myArrayTwo[lname];
}
|
const input = document.getElementById('imageUpload')
let canvas;
canvas = faceapi.createCanvasFromMedia(input)
let fullFaceDescriptions = await faceapi.detectAllFaces(input).withFaceLandmarks().withFaceDescriptors()
|
/* eslint-disable no-return-await,no-undef */
module.exports = class extends think.Model {
get relation () {
return {
metas: {
type: think.Model.HAS_MANY,
model: 'appmeta',
fKey: 'app_id'
}
};
}
async findByOrgId (orgId) {
const list = await this.where({org_id: orgId}).field(['id', 'org_id', 'domain', 'subdomain']).select()
_formatMeta(list)
return list
}
async get(appId) {
let apps = await think.cache('apps')
if (think.isEmpty(apps)) {
apps = await this.list()
}
const app = await think._.find(apps, ['id', appId.toString()])
if (!think.isEmpty(app)) {
// _formatOneMeta(app)
return app
} else {
return null
}
}
/**
* 全部应用列表
* @returns {Promise.<*>}
*/
async list() {
const apps = await this.select()
_formatMeta(apps)
for (let app of apps) {
if (!think.isEmpty(app.meta.info)) {
app = Object.assign(app, app.meta.info)
}
Reflect.deleteProperty(app, 'meta')
}
await think.cache('apps', apps)
return apps
}
}
|
import {createStore,combineReducers,applyMiddleware} from 'redux'
import thunk from 'redux-thunk'
import postReducer from '../reducer/postReducer'
const configureStore=()=>{
const store=createStore(combineReducers({
post:postReducer
}),applyMiddleware(thunk))
return store
}
export default configureStore
|
var map; //GoogleMap
var geocoder; //解析經緯度、地址工具
var clickMarker = []; //用戶手動點擊的Marker
var tempBound; //記錄Map邊界是否改變
var markers = []; //從服務器獲取的其它景點Marker陣列
var infowindow; //Marker的資訊視窗
var infowinCurMarker; //資訊視窗當前所使用的Marker
window.onload = function(){
document.getElementById("preIntroBtn").onclick = function(){
var cur = document.getElementById("introTextarea").currentIntroNum;
if(cur > 0){
document.getElementById("introTextarea").currentIntroNum = cur - 1;
document.getElementById("introTextarea").innerHTML = infowinCurMarker.intros[cur-1];
}else{ return; }
}
document.getElementById("nextIntroBtn").onclick = function(){
var cur = document.getElementById("introTextarea").currentIntroNum;
if(cur < infowinCurMarker.intros.length){
document.getElementById("introTextarea").currentIntroNum = cur + 1;
document.getElementById("introTextarea").innerHTML = infowinCurMarker.intros[cur+1];
}else{ return; }
}
};
function initMap() {
map = new google.maps.Map(document.getElementById('map'), {
zoom: 15,
center: {lat: 25, lng: 121.5}
});
geocoder = new google.maps.Geocoder();
document.getElementById("search").addEventListener('click', function() { //點擊查詢按鈕
geocodeAddress(geocoder, map);
});
boundChangeGetMarker();
}
function geocodeAddress(geocoder, resultsMap) { //依照address查詢對應位置，並放上Maker
var address = document.getElementById('addressSearch').value;
geocoder.geocode({'address': address}, function(results, status) {
if (status === google.maps.GeocoderStatus.OK) {
resultsMap.setCenter(results[0].geometry.location);
marker = new google.maps.Marker({
map: resultsMap,
position: results[0].geometry.location,
optimized: false
});
clickMarker.push(marker);
} else {
alert('Geocode was not successful for the following reason: ' + status);
}
});
}
function boundChangeGetMarker(){ //每隔2秒偵測Map邊界是否改變，若Map邊界改變，向服務器獲取其它景點
setTimeout(function(){
boundChangeGetMarker();
google.maps.event.trigger(map, 'resize'); //避免GoogleMap在Dialog中無法顯示
if(tempBound != map.getBounds() && map.getZoom() >= 11){
tempBound = map.getBounds();
getBoundLandscapeMarker();
}
}, 2000);
}
function getBoundLandscapeMarker(){ //放置Map邊界內景點Maker
var latLng = map.getBounds(); //取得Map邊界
//根據Map邊界向服務器查詢邊界內景點
$.post("/GetMapMarkerSerlvet", {"SW_lat": latLng.getSouthWest().lat(), "NE_lat": latLng.getNorthEast().lat(), "SW_lng" :latLng.getSouthWest().lng(), "NE_lng" : latLng.getNorthEast().lng()},
function(data){
if(data.length == 0) return;
//alert(data);
var landscape = eval("(" + data +")");
for(var i = 0; landscape[i] != undefined ;i++){ //設定Marker資訊
var latLng = {lat: landscape[i].lat, lng: landscape[i].lng };
var imgurls = new Object();
for(var j = 0; landscape[i].imgurls[j] != undefined; j++){
imgurls[j] = landscape[i].imgurls[j].imgurl;;
}
var intros = new Object();
for(var j = 0; landscape[i].intros[j] != undefined; j++){
intros[j] = landscape[i].intros[j].intro;
intros.length = j;
}
var marker = new google.maps.Marker({
position: latLng,
map: map,
optimized: false,
landscapeId: landscape[i].id,
name: landscape[i].name,
location: landscape[i].location,
contact: landscape[i].contact,
operateTime: landscape[i].operatetime,
possibleCost: landscape[i].possiblecost,
sugStayTime: landscape[i].sugstaytime,
traffic: landscape[i].traffic,
refweb: landscape[i].refweb,
score: landscape[i].score,
author: landscape[i].author,
imgurls: imgurls,
intros: intros
});
markers.push(marker);
console.dir(marker);
}
for(var i = 0; markers[i] != undefined; i++){ //設置Marker點擊事件
markers[i].addListener('click', function(event) {
showInfo(map, this);
});
}
});
}
function showInfo(mapObj , markerObj){//開啟資訊視窗
if (infowindow){ infowindow.close();}
infowindow = new google.maps.InfoWindow({ //設定InfoWindow內容
content: '<div class="media">' +
'<a class="media-left media-heading" href="#">' +
'<img id="markerImg" src="/ImgServlet?imgurl='+ markerObj.imgurls[0] +'">' +
'</a>' +
'<div class="media-body">' +
'<p class="media-heading"><b>'+ markerObj.name +'</b></p>' +
'連絡方式:'+ markerObj.contact +'<br>' +
'參考網站:'+ markerObj.refweb +'<br>' +
'<button type="button" class="btn btn-warning btn-sm" onclick="showInfoDialog()" style="float: right">選擇景點</button>' +
'</div>' +
'</div>'
});
infowindow.open(mapObj,markerObj); //打開資訊視窗
setInfoDialog(markerObj);
}
//關閉Google Map 開啟資訊視窗
function showInfoDialog(){
$('#googleMapDialog').modal('hide');
$('#LandscapeInfoDialog').modal('show');
}
function setInfoDialog(marker){
//設定InfoDialog中的資訊
document.getElementById("landscapeName").setAttribute("value", marker.name);
document.getElementById("address").setAttribute("value", marker.location);
document.getElementById("contact").setAttribute("value", marker.contact);
document.getElementById("operateTime").setAttribute("value", marker.operateTime);
document.getElementById("possibleCost").setAttribute("value", marker.possibleCost);
document.getElementById("sugStayTime").setAttribute("value", marker.sugStayTime);
document.getElementById("traffic").setAttribute("value", marker.traffic);
document.getElementById("refWeb").setAttribute("value", marker.refweb);
//設定輪撥牆圖片
$("#slideImg").empty(); //清空輪播牆中的圖片
for(var i = 0;; i++){
if(marker.imgurls[i] == undefined) break;
//創建圖片DOM
var itemDiv = document.createElement("div");
if(i == 0){
itemDiv.className = "item active";
}else{
itemDiv.className = "item";
}
var img = document.createElement("img");
img.src = '/ImgServlet?imgurl=' + marker.imgurls[i];
var addBtnDiv = document.createElement("div");
addBtnDiv.className = 'carousel-caption';
var addBtn = document.createElement("button");
addBtn.className = 'btn btn-warning info-img-btn addImg';
addBtn.innerHTML = '+';
addBtn.addEventListener("click", addInfoText);
addBtnDiv.appendChild(addBtn);
itemDiv.appendChild(img);
itemDiv.appendChild(addBtnDiv);
//將圖片DOM添加到輪播牆中
document.getElementById("slideImg").appendChild(itemDiv);
}
//設定景點介紹
document.getElementById("introTextarea").innerHTML = marker.intros[0];
document.getElementById("introTextarea").currentIntroNum = 0;
//將InfoWindow當前所使用的Marker設為全局變量
infowinCurMarker = marker;
}
function addOneFile(){
var div = document.createElement("div");
div.className = "form-inline";
div.style = "margin: 20px auto";
var fileDiv = document.createElement("div");
fileDiv.className = "col-sm-offset-2 col-sm-3";
var fileBtn = document.createElement("input");
fileBtn.className = "btn btn-primary";
fileBtn.type = "file";
fileBtn.name = "file1";
var delBtn = document.createElement("input");
delBtn.type = "button";
delBtn.className = "btn btn-danger col-sm-offset-4";
delBtn.value = "X";
delBtn.onclick = function(){delOneFile(this);};
fileDiv.appendChild(fileBtn);
div.appendChild(fileDiv);
div.appendChild(delBtn);
document.getElementById("fdiv").appendChild(div);
}
function delOneFile(obj){ //刪除一張相片
obj.parentNode.remove(this);
}
|
import React, { Component } from 'react';
import Avatar from '../../components/Avatar/Avatar';
import NavLinks from '../../components/NavLinks/NavLinks';
import ShareLinks from '../../components/ShareLinks/ShareLinks';
import profileShot from '../../assets/j_lucas_profile.png';
import './NavigationView.css';
class NavigationView extends Component {
constructor() {
super();
this.state = {
showMenu: true,
width: 0,
};
this.updateWindowDimensions = this.updateWindowDimensions.bind(this);
}
componentDidMount() {
this.updateWindowDimensions();
window.addEventListener('resize', this.updateWindowDimensions);
}
componentWillUnmount() {
window.removeEventListener('resize', this.updateWindowDimensions);
}
updateWindowDimensions() {
this.setState({ width: window.innerWidth });
}
render() {
const { showMenu, width } = this.state;
const rotate = showMenu ? '' : 'rotate-menu';
const display = width <= 770 && showMenu ? 'hide' : 'active';
const user = {
name: 'Jason Lucas',
profileImg: profileShot,
};
return (
<header className="nav-wrapper">
<Avatar user={user} />
<button className={`menu-btn ${rotate}`} onClick={() => this.setState({ showMenu: !showMenu })} />
<NavLinks display={display} />
<ShareLinks display={display} />
</header>
);
}
}
export default NavigationView;
|
var myVar;
function myFunction() {
myVar = setTimeout(showPage, 3000);
}
function showPage() {
document.getElementById("load").style.display = "none";
document.getElementById("memew").style.display = "block";
}
$('.anim').hover(function () {
$(this).fadeOut({
height: "100px",
width: "100px"
});
}, function () {
$(this).animate({
height: "200px",
border: "3px solid gray",
width: "100%"
});
});
count = 0
$(".animation").click(function () {
if (count % 2 == 0) {
$(this).animate({
height: "300px",
width: "300px",
});
count++;
} else {
$(this).animate({
height: "150px",
width: "200px",
});
count++;
}
});
$(document).ready(function () {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function (data) {
if (this.readyState == 4 && this.status == 200) {
data = JSON.parse(data.srcElement.responseText)
for (e of data) {
$("#myTable").append("<tr><td>" + e.hobbies + "</td><td>" + e.favF + "</td><td>" + e.friends + "</td></tr>");
}
}
};
xhttp.open("GET", "demo.json", true);
xhttp.send();
$("#myInput").on("keyup", function () {
var value = $(this).val().toLowerCase();
$("#myTable tr").filter(function () {
$(this).toggle($(this).text().toLowerCase().indexOf(value) > -1)
});
});
});
$("#pp").mouseenter(function () {
$("#pp-description").fadeToggle();
})
$("#pp").mouseleave(function () {
$("#pp-description").fadeToggle();
})
$("#pp").click(function () {
$(".onMouseClick").toggle();
})
$(".fpic").dblclick(function () {
window.location.href = $(this).data("link");
})
$("#btnAn").click(function () {
$(".fpic").animate({
height: "150px",
width: "200px"
});
})
$("#btnAn").dblclick(function () {
$(".fpic").animate({
height: "500px",
width: "500px"
});
})
$("#fpic1").click(function () {
$(".friend1").show();
})
$("#fpic2").click(function () {
$(".friend2").show();
})
function loadDoc() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function () {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML =
this.responseText;
}
};
xhttp.open("GET", "demo.txt", true);
xhttp.send();
}
|
import React, { Component } from 'react';
import { connect } from 'react-redux'
import { adicionarElemento } from './actions'
export class Adicionar extends Component {
state = {
titulo: '',
texto: '',
autor: ''
}
handleChange = e => {
let _obj = {}
_obj[e.target.name] = e.target.value
this.setState(_obj)
}
handleSubmit = e => {
e.preventDefault()
this.props.adicionarElemento(this.state)
this.setState({
titulo: '',
texto: '',
autor: ''
})
}
render() {
return (
<form onSubmit={this.handleSubmit}>
<label htmlFor="titulo">Titulo</label>
<br/>
<input id="titulo" name="titulo" type="text" onChange={this.handleChange} value={this.state.titulo}/>
<br/>
<label htmlFor="texto">Texto</label>
<br/>
<textarea id="texto" name="texto" type="text" onChange={this.handleChange} value={this.state.texto}/>
<br/>
<label htmlFor="autor">Autor</label>
<br/>
<input id="autor" name="autor" type="text" onChange={this.handleChange} value={this.state.autor}/>
<button type="submit" onClick={this.handleSubmit}>Adicionar</button>
</form>
);
}
}
export default connect(null, { adicionarElemento })(Adicionar);
|
import React from 'react'
import PropTypes from 'prop-types'
const StaffItem = ({ staff }) => {
return (
<tr>
<td>
{staff.Nm_User}
</td>
<td>
{staff.Fg_Admin === true ? (<p>Admin</p>) : (<p>Usuário</p>)}
</td>
</tr>
)
}
StaffItem.propTypes = {
staff: PropTypes.object.isRequired,
}
export default StaffItem
|
import { StatusBar } from "expo-status-bar";
import React from "react";
import { StyleSheet, Text, View, ScrollView } from "react-native";
import Info from "../../Componentes/info";
import BotonAzul from "../../Componentes/BotonAzul";
import { Icon } from "react-native-elements";
import { styles } from "./Perfil-Publico.module";
import BarraIconos from "../../Componentes/BarraIconos";
import Explorar from "../../Componentes/Explorar";
import Destacado from "../../Componentes/Destacado";
import Actividad from "../../Componentes/Actividad";
import Publicacion from "../../Componentes/Publicacion";
export default function PerfilPublico() {
return (
<ScrollView>
<View style={styles.container}>
<View style={styles.container1}>
<BarraIconos />
<View style={styles.titulo}>
<Text style={styles.tituloText}>Perfil profesional</Text>
<Icon name="forward" color="#4E31EB" size={20} />
</View>
<Info />
<View style={styles.botones}>
<BotonAzul ancho={177} alto={55.08} texto={"AGENDAR ASESORIA"} />{" "}
<BotonAzul
ancho={155}
alto={55.08}
texto={"MENSAGE"}
icon={"forum"}
/>
</View>
</View>
<View style={styles.container2}>
<Explorar titulo={"Contenido destacado"} />
<View style={styles.destacado}>
<Destacado />
<Destacado />
</View>
<Explorar titulo={"Actividad"} />
<View style={styles.actividad}>
<Actividad />
<Actividad />
</View>{" "}
<View style={styles.publicacion}>
<Publicacion />
</View>
</View>
</View>
</ScrollView>
);
}
|
var fs = require('fs')
, util = require('util')
, async = require('async')
, Connection = require('ssh2');
// TODO: escape
module.exports = connect;
function connect(username, host, key, callback) {
callback = callback || function() {};
var ssh = new SSH(username, host, key);
ssh.connect(function(err) {
if (err) return callback(err);
callback(null, ssh);
});
}
function SSH(username, host, key) {
this.username = username;
this.host = host;
this.key = key;
this.connection = new Connection();
}
SSH.prototype.connect = function(callback) {
callback = callback || function() {};
var self = this;
var listener = function(err) {
self.connection.removeListener('ready', listener);
self.connection.removeListener('close', listener);
self.connection.removeListener('error', listener);
callback(err);
};
this.connection.on('ready', listener);
this.connection.on('close', listener);
this.connection.on('error', listener);
this.connection.connect({
host: this.host,
port: 22,
username: this.username,
privateKey: this.key
});
}
SSH.prototype.exec = function() {
return this.connection.exec.apply(this.connection, arguments);
};
SSH.prototype.execWait = function(command, options, callback) {
if ('function' === typeof options) {
callback = options;
options = {};
}
return this.connection.exec(command, options, function(err, stream) {
if (err) return callback(err);
var data = '';
stream.on('data', function(chunk) {
data += chunk;
});
stream.on('exit', function(err) {
callback(err, data);
});
});
};
SSH.prototype.shell = function(win, callback) {
return this.connection.shell.apply(this.connection, arguments);
};
SSH.prototype.end = function() {
this.connection.end();
};
SSH.prototype.writeFile = function(filename, data, callback) {
this.connection.sftp(function(err, sftp) {
if (err) return callback(err);
function end(err) {
sftp.end();
callback(err);
}
var stream = sftp.createWriteStream(filename);
stream.on('error', end);
stream.end(data, end);
});
};
SSH.prototype.addUser = function(user, isSudoer, callback) {
if ('function' == typeof isSudoer) {
callback = isSudoer;
isSudoer = false;
}
var self = this
, username = user.username;
this.execWait('useradd -m -s /bin/bash ' + username, function(err) {
if (err) return callback(err);
// enable to connect with ssh
var sshPath = util.format('/home/%s/.ssh', username)
self.execWait('mkdir -p ' + sshPath, function(err) {
if (err) return callback(err);
async.parallel([
function(callback) {
var cmd = util.format('chown %s:%s %s', username, username, sshPath);
self.execWait(cmd, callback);
},
function(callback) {
self.execWait('chmod 700 ' + sshPath, callback);
}
], function(err) {
if (err) return callback(err);
// set authorized_keys
var keysPath = sshPath + '/authorized_keys';
self.writeFile(keysPath, user.pubkey, function(err) {
if (err) return callback(err);
async.parallel([
function(callback) {
var cmd = util.format('chown %s:%s %s', username, username, keysPath);
self.execWait(cmd, callback);
},
function(callback) {
self.execWait('chmod 600 ' + keysPath, callback);
}
], function(err) {
if (err) return callback(err);
if (!isSudoer) {
callback();
return;
}
// set up sudoers
var cmd = util.format('echo "%s ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers.d/%s', username, username);
self.execWait(cmd, function(err) {
if (err) return callback(err);
var cmd = util.format('chmod 440 /etc/sudoers.d/%s', username);
self.execWait(cmd, callback);
});
});
});
});
});
});
};
|
//This app starts a server and listens on port 9001 for connections. For every other path, it will respond with a 404 Not Found.
const express = require ('express')
const app = express()
const port = 3031
const morgan = require('morgan')
const upload = require('express-fileupload')
const cors = require('cors')
//const path = require('path')
//untuk membaca data HTTP POST, kita harus menggunakan modul simpul "body-parser". body-parser adalah sepotong middleware ekspres yang membaca input formulir dan menyimpannya sebagai objek javascript yang dapat diakses melaluireq.body
// const bodyParser = require('body-parser')
app.use(upload())
app.set('view engine','ejs')
app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }) )
app.use(express.json())
app.use(cors())
//app.use('/uploads', express.static(path.join(__dirname, 'uploads')))
app.listen(port,() => {console.log(`server berjalan di port : ${port }`) })
//Routing
const Router = require('./routes/routes')
app.use(Router)
//models
const ConnectionMongoDB = require('./models/connection')
ConnectionMongoDB()
|
$(function() {
//mobile-product-selected-list 商品篩選點擊展開樣式==========================
$('.product-selected-list > li > a').click(function () {
$(this).parent().toggleClass('active');
$(this).next('ul').toggleClass('active');
});
$('.product-selected-list > li > ul > li > a').click(function () {
$(this).parent().toggleClass('active');
});
//商品換圖
var startImg;
$('.product-img-nav-bar .product-img-nav-list').mouseover(function () {
startImg = $(this).parents('.product-infor-box').find('.product-img-box img').attr('src');
var mouseoverImg = $(this).children('img').attr('src');
$(this).parents('.product-infor-box').find('.product-img-box img').attr('src', mouseoverImg);
// .attr('src', mouseoverImg);
});
$('.product-img-nav-bar .product-img-nav-list').mouseout(function () {
$(this).parents('.product-infor-box').find('.product-img-box img').attr('src', startImg);
});
$('.product-img-nav-bar .product-img-nav-list').click(function () {
startImg = $(this).parents('.product-infor-box').find('.product-img-box img').attr('src');
$(this).parent().find('.product-img-nav-list').removeClass('active');
$(this).addClass('active');
});
//商品列表呈現方式=================================
$('.change-product-list-inventory-box > li').click(function () {
$('.change-product-list-inventory-box > li').removeClass('active');
$(this).addClass('active');
$('.product-list-inventory-box').toggleClass('single');
});
//商品篩選功能=====================================
$('.product-tool-box .filters').click(function () {
$('.wrap-product-selection').addClass('show');
$('.product-tool-box, .product-list-inventory-box, .product-list-wrap, .wrap-footer-search, .wrap-footer-copyright').addClass('mobile-filters-none');
});
$('.filter-results-btn').click(function () {
$('.wrap-product-selection').removeClass('show');
$('.product-tool-box, .product-list-inventory-box, .product-list-wrap, .wrap-footer-search, .wrap-footer-copyright').removeClass('mobile-filters-none');
});
// 列表顯示數量====================================
$('.view-quantity > a').click(function () {
$(this).parent().find('a').removeClass('active');
$(this).addClass('active');
});
//篩選 product-price
var html5Slider = document.getElementById('html5-nouislider');
noUiSlider.create(html5Slider, {
start: [ 0, 100 ],
connect: true,
range: {
'min': 0,
'max': 100
}
});
var startNumber = document.getElementById('start-number');
var endNumber = document.getElementById('end-number');
html5Slider.noUiSlider.on('update', function( values, handle ) {
var value = values[handle];
if ( !handle ) {
startNumber.value = value;
} else {
endNumber.value = value;
}
});
startNumber.addEventListener('change', function(){
html5Slider.noUiSlider.set([this.value, null]);
});
endNumber.addEventListener('change', function(){
html5Slider.noUiSlider.set([null, this.value]);
});
$(window).scroll(function () {
var wTop = $(this).scrollTop();
var pdtTop = $('.product-tool-fixed').offset().top;
// console.log(wTop);
// console.log(pdtTop);
if( wTop >= pdtTop){
console.log('remove');
$('.product-tool-fixed').addClass('mobile-filters-fixed');
} else if( wTop < pdtTop ) {
console.log('add');
$('.product-tool-fixed').removeClass('mobile-filters-fixed');
}
})
});
|
const baseURL = "https://api.mtb-connect.com:8080";
export default {
post(newUser) {
return fetch(`${baseURL}/register`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(newUser)
}).then(resp => resp.json());
}
};
|
const CATALOG = [
{
id: 'el1',
name: 'Электроакуститечкая гитара Yamaha SLG200N n',
img: 'https://muz.by/upload/resize_cache/iblock/61e/210_200_1/61ec3a306157b5d8a91ba8466b93dfbc.jpg',
price: 2350,
},
{
id: 'el2',
name: 'Электроакуститечкая гитара Sigma GMC-STE+',
img: 'https://muz.by/upload/resize_cache/iblock/4c8/210_200_1/4c812f2692ba063f017850316581d5f6.jpg',
price: 1220,
},
{
id: 'el3',
name: 'Электроакустическая гитара Yamaha CX-40',
img: 'https://muz.by/upload/resize_cache/iblock/f9d/210_200_1/f9d336759456b6f41115e5fa66b2f985.jpg',
price: 1500,
},
{
id: 'el4',
name: 'ТрансАкустическая гитара Yamaha FG-TA BS',
img: 'https://muz.by/upload/resize_cache/iblock/cd5/210_200_1/cd521b73a37c1d19c01b876679ca3716.jpg',
price: 560,
}
];
|
function solve(arr) {
let total = new Map();
for(let dataRow of arr) {
let [town, population] = dataRow.split(/\s*<->\s*/);
population = Number(population);
if(total.has(town)) {
total.set(town, total.get(town) + population);
} else {
total.set(town, population);
}
}
for(let [town, sum] of total) {
console.log(town + " : " + sum);
}
}
solve(['Sofia <-> 1200000', 'Montana <-> 20000', 'New York <-> 10000000',
'Washington <-> 2345000', 'Las Vegas <-> 1000000']);
|
import "./edit_profile_modal.html";
import "/imports/ui/components/user_profile_fields/user_profile_fields.js";
import {
getProfileFromFields,
setProfileFields
} from "/imports/ui/components/user_profile_fields/user_profile_fields.js";
import {updateUserProfile, currentUser} from "/imports/api/users/methods.js";
import * as Users from "/imports/api/users/users.js";
const ENTER_KEY = 13;
Template.edit_profile_modal.onRendered(function () {
let userId = Meteor.userId();
if (userId) {
setProfileFields(Template.instance(), currentUser());
$("#user_email").prop("disabled", true);
}
});
Template.edit_profile_modal.events({
"click #cancelBtn": function (evt) {
evt.preventDefault();
$("#edit_profile_modal").modal("hide");
},
"click #saveProfileBtn": function (evt, tmpl) {
evt.preventDefault();
onSaveProfile(tmpl);
},
"keydown #user_skills": function (evt, tmpl) {
if (evt.which == ENTER_KEY) {
evt.preventDefault();
onSaveProfile(tmpl);
}
}
});
function onSaveProfile(tmpl) {
let profile = getProfileFromFields(tmpl);
profile[Users.USER_ID] = Meteor.userId();
profile["countryCode"] = profile[Users.PROFILE_COUNTRY][Users.COUNTRY_CODE];
// updateUserProfile expects a slightly different format, country code should be root property
updateUserProfile.call({user: profile});
$("#edit_profile_modal").modal("hide");
}
|
const { join: joinPath } = require("path");
const sveltePreprocess = require("svelte-preprocess");
module.exports.preprocess = sveltePreprocess({
typescript: {
transpileOnly: true,
tsconfigFile: joinPath(__dirname, "tsconfig.json"),
compilerOptions: {
paths: {
"@mary-main/*": ["main/src/*"],
"@mary-web/*": ["renderer/src/*"],
"@mary-shared/*": ["shared/*"],
}
},
},
postcss: true
});
|
const { Model } = require('mongorito')
class User extends Model {}
module.exports = User
|
var cssAstFormatter = require('css')
var BASE64_ENCODE_PATTERN = /data:[^,]*base64,/
var _isTooLongBase64Encoded = function (declaration, maxEmbeddedBase64Length) {
return BASE64_ENCODE_PATTERN.test(declaration.value) && declaration.value.length > maxEmbeddedBase64Length
}
var _removeDataUrisFromRule = function (rule, maxEmbeddedBase64Length) {
if (rule.type === 'font-face') {
var hasSrc = false
rule.declarations = rule.declarations.filter(function (declaration) {
if (_isTooLongBase64Encoded(declaration, maxEmbeddedBase64Length)) {
return false
} else if (declaration.property === 'src') {
hasSrc = true
}
return true
})
if (!hasSrc) {
return null
}
} else if (rule.type === 'rule') {
rule.declarations = rule.declarations.filter(function (declaration) {
if (_isTooLongBase64Encoded(declaration, maxEmbeddedBase64Length)) {
return false
}
return true
})
} else if (rule.type === 'media') {
var rules = rule.rules.map(function (rule) { return _removeDataUrisFromRule(rule, maxEmbeddedBase64Length) })
rule.rules = rules.filter(function (rule) {
return !!rule
})
return rule
}
return rule
}
var embeddedbase64Remover = function (css, maxEmbeddedBase64Length) {
var ast = cssAstFormatter.parse(css)
var rules = ast.stylesheet.rules.map(function (rule) { return _removeDataUrisFromRule(rule, maxEmbeddedBase64Length) })
rules = rules.filter(function (rule) {
return !!rule
})
return cssAstFormatter.stringify({
stylesheet: {
rules: rules
}
})
}
module.exports = embeddedbase64Remover
|
const fs = require('fs');
const currentVersion = require('../package.json').version;
const run = async() => {
const changelog = (await fs.promises.readFile(__dirname + '/../CHANGELOG.md')).toString().split('\n');
let currentChangelog = [];
let end = false;
let releaseFound = false;
let currentVersionPattern = new RegExp(`^## v${currentVersion}$`, 'i');
let otherVersionPattern = new RegExp(`^## v?.*$`, 'i');
do {
const line = changelog.shift() ;
if (line.match(currentVersionPattern)) {
releaseFound = true;
currentChangelog.push(line);
} else if (releaseFound && line.match(otherVersionPattern)) {
end = true;
} else if (releaseFound) {
currentChangelog.push(line);
}
} while (changelog.length && !end)
console.log(currentChangelog.join('\n'));
};
run();
|
const tape = require('tape');
const search = require('../src/search.js');
tape('wordSearch returns and array', function(t){
t.equal(Array.isArray(search('Buffy')), true, "wordSearch returns an array");
t.end();
})
tape('wordSearch returns all items that contain all letters in string', function(t){
t.deepEqual(search('le'), ['Wesley', 'Giles'], 'wordSearch returns all items that contain all letters in string');
t.end();
})
tape('wordSearch results have capitalised first letters', function(t){
t.deepEquals(search('le'), ['Wesley', 'Giles'], 'wordSearch results have capitalised first letters');
t.end();
})
tape('wordSearch returns all items that contain all letters in string, regardless of capitalisation', function(t){
t.deepEquals(search('Le'), ['Wesley', 'Giles'], 'wordSearch returns all items that contain all letters in string, regardless of capitalisation');
t.end();
})
|
const expect = require('expect');
const rewire = require('rewire');
let app = rewire('./app');
describe('App', () => {
let db = {
saveUser: expect.createSpy()
};
// replace the db require in app.js
app.__set__('db', db);
it('should call saveUser with user object', () => {
const
username = 'Bob',
password = '123abc';
app.handleSignup(username, password);
expect(db.saveUser).toHaveBeenCalledWith({username, password});
});
});
|
//folder
export const CREATE_FOLDER = "CREATE_FOLDER";
export const UPDATE_FOLDER_NAME = "UPDATE_FOLDER_NAME";
export const UPDATE_FOLDER_COLOUR = "UPDATE_FOLDER_COLOUR";
export const CLOSE_CURRENT_FOLDER = "CLOSE_CURRENT_FOLDER";
//fetch_notes
export const SERVER_FETCH_NOTES = "SERVER_FETCH_NOTES";
export const SERVER_FETCH_NOTES_SUCCESS = "SERVER_FETCH_NOTES_SUCCESS";
export const SERVER_FETCH_NOTES_FAILURE = "SERVER_FETCH_NOTES_FAILURE";
export const LOCAL_FETCH_NOTES = "LOCAL_FETCH_NOTES";
// edit notes
export const CREATE_NOTE = "CREATE_NOTE";
export const REMOVE_NOTE = "REMOVE_NOTE";
export const UPDATE_NOTE_COLOUR = "UPDATE_NOTE_COLOUR";
export const UPDATE_NOTE_SIZE = "UPDATE_NOTE_SIZE";
export const UPDATE_NOTE_TEXT = "UPDATE_NOTE_TEXT";
export const UPDATE_NOTE_LOCATION = "UPDATE_NOTE_LOCATION";
export const UPDATE_NOTE_POSITION = "UPDATE_NOTE_POSITION";
|
/*
mColorPicker
Version: 1.0 r38
Copyright (c) 2010 Meta100 LLC.
http://www.meta100.com/
Licensed under the MIT license
http://www.opensource.org/licenses/mit-license.php
*/
// After this script loads set:
// $.fn.mColorPicker.init.replace = '.myclass'
// to have this script apply to input.myclass,
// instead of the default input[type=color]
// To turn of automatic operation and run manually set:
// $.fn.mColorPicker.init.replace = false
// To use manually call like any other jQuery plugin
// $('input.foo').mColorPicker({options})
// options:
// imageFolder - Change to move image location.
// swatches - Initial colors in the swatch, must an array of 10 colors.
// init:
// $.fn.mColorPicker.init.enhancedSwatches - Turn of saving and loading of swatch to cookies.
// $.fn.mColorPicker.init.allowTransparency - Turn off transperancy as a color option.
// $.fn.mColorPicker.init.showLogo - Turn on/off the meta100 logo (You don't really want to turn it off, do you?).
(function ($) {
var $o, $i, i, $b,
div = '<div>',
img = '<img>',
span = '<span>',
$document = $(document),
$mColorPicker = $(div),
$mColorPickerBg = $(div),
$mColorPickerTest = $(div),
$mColorPickerInput = $('<input>'),
rRGB = /^rgb[a]?\((\d+),\s*(\d+),\s*(\d+)(,\s*(\d+\.\d+)*)?\)/,
rHEX = /([a-f0-9])([a-f0-9])([a-f0-9])/,
rHEX3 = /#[a-f0-9]{3}/,
rHEX6 = /#[a-f0-9]{6}/;
$.fn.mColorPicker = function (options) {
var swatches = $.fn.mColorPicker.getCookie('swatches');
$o = $.extend($.fn.mColorPicker.defaults, options);
$.fn.mColorPicker.defaults.swatches.concat($o.swatches).slice(-10);
if ($i.enhancedSwatches && swatches) $o.swatches = swatches.split('||').concat($o.swatches).slice(0, 10) || $o.swatches;
if (!$("div#mColorPicker").length) $.fn.mColorPicker.drawPicker();
if (!$('#css_disabled_color_picker').length) $('head').prepend('<meta data-remove-me="true"/><style id="css_disabled_color_picker" type="text/css">.mColorPicker[disabled] + span, .mColorPicker[disabled="disabled"] + span, .mColorPicker[disabled="true"] + span {filter:alpha(opacity=50);-moz-opacity:0.5;-webkit-opacity:0.5;-khtml-opacity: 0.5;opacity: 0.5;cursor:default;}</style>');
$('meta[data-remove-me=true]').remove();
this.each($.fn.mColorPicker.drawPickerTriggers);
return this;
};
$.fn.mColorPicker.init = {
replace: '[type=color]',
index: 0,
enhancedSwatches: true,
allowTransparency: true,
slogan: 'Meta100 - Designing Fun',
showLogo: true
};
$.fn.mColorPicker.defaults = {
currentId: false,
currentInput: false,
currentColor: false,
changeColor: false,
color: false,
imageFolder: 'images/',
swatches: [
"#ffffff",
"#ffff00",
"#00ff00",
"#00ffff",
"#0000ff",
"#ff00ff",
"#ff0000",
"#4c2b11",
"#3b3b3b",
"#000000"
]
};
$.fn.mColorPicker.start = function () {
$('input[data-mcolorpicker!="true"]').filter(function () {
return ($i.replace == '[type=color]') ? this.getAttribute("type") == 'color' : $(this).is($i.replace);
}).mColorPicker();
};
$.fn.mColorPicker.events = function () {
$("#mColorPickerBg").live('click', $.fn.mColorPicker.closePicker);
$('.mColorPicker').live('keyup', function () {
try {
$(this).css({
'background-color': $(this).val()
}).css({
'color': $.fn.mColorPicker.textColor($(this).css('background-color'))
}).trigger('change');
} catch (r) { }
});
$('.mColorPickerTrigger').live('click', $.fn.mColorPicker.colorShow);
$('.mColor, .mPastColor').live('mousemove', function (e) {
if (!$o.changeColor) return false;
var $t = $(this),
offset = $t.offset(),
$e = $o.currentInput,
hex = $e.attr('data-hex') || $e.attr('hex');
$o.color = $t.css("background-color");
if ($t.hasClass('mPastColor')) $o.color = $.fn.mColorPicker.setColor($o.color, hex);
else if ($t.hasClass('mColorTransparent')) $o.color = 'transparent';
else if (!$t.hasClass('mPastColor')) $o.color = $.fn.mColorPicker.whichColor(e.pageX - offset.left, e.pageY - offset.top, hex);
$o.currentInput.mSetInputColor($o.color);
}).live('click', $.fn.mColorPicker.colorPicked);
$('#mColorPickerInput').live('keyup', function (e) {
try {
$o.color = $(this).val();
$o.currentInput.mSetInputColor($o.color);
if (e.which == 13) $.fn.mColorPicker.colorPicked();
} catch (r) { }
}).live('blur', function () {
$o.currentInput.mSetInputColor($o.color);
});
$('#mColorPickerWrapper').live('mouseleave', function () {
if (!$o.changeColor) return false;
$o.currentInput.mSetInputColor($o.currentColor);
});
};
$.fn.mColorPicker.drawPickerTriggers = function () {
var $t = $(this),
id = $t.attr('id') || 'color_' + $i.index++,
hidden = $t.attr('text') == 'hidden' || $t.attr('data-text') == 'hidden' ? true : false,
color = $.fn.mColorPicker.setColor($t.val(), ($t.attr('data-hex') || $t.attr('hex'))),
width = $t.width(),
height = $t.height(),
flt = $t.css('float'),
$c = $(span),
$trigger = $(span),
colorPicker = '',
$e;
$c.attr({
'id': 'color_work_area',
'class': 'mColorPickerInput'
}).appendTo($b)
$trigger.attr({
'id': 'mcp_' + id,
'class': 'mColorPickerTrigger'
}).css({
'display': 'inline-block',
'cursor': 'pointer'
}).insertAfter($t)
$(img).attr({
'src': '<%= WebResource("uComponents.DataTypes.TextImage.images.color.png") %>'
}).css({
'border': 0,
'margin': '0 0 0 3px',
'vertical-align': 'text-bottom'
}).appendTo($trigger);
$c.append($t);
colorPicker = $c.html().replace(/type="color"/gi, 'type="' + (hidden ? 'hidden' : 'text') + '"');
$c.html('').remove();
$e = $(colorPicker).attr('id', id).addClass('mColorPicker').val(color).insertBefore($trigger);
if (hidden) $trigger.css({
'border': '1px solid black',
'float': flt,
'width': width,
'height': height
}).addClass($e.attr('class')).html(' ');
$e.mSetInputColor(color);
return $e;
};
$.fn.mColorPicker.drawPicker = function () {
var $s = $(div),
$l = $('<a>'),
$f = $(div),
$w = $(div);
$mColorPickerBg.attr({
'id': 'mColorPickerBg'
}).css({
'display': 'none',
'background': 'black',
'opacity': .01,
'position': 'absolute',
'top': 0,
'right': 0,
'bottom': 0,
'left': 0
}).appendTo($b);
$mColorPicker.attr({
'id': 'mColorPicker',
'data-mcolorpicker': true
}).css({
'position': 'absolute',
'border': '1px solid #ccc',
'color': '#fff',
'width': '194px',
'height': '184px',
'font-size': '12px',
'font-family': 'times',
'display': 'none'
}).appendTo($b);
$mColorPickerTest.attr({
'id': 'mColorPickerTest'
}).css({
'display': 'none'
}).appendTo($b);
$w.attr({
'id': 'mColorPickerWrapper'
}).css({
'position': 'relative',
'border': 'solid 1px gray'
}).appendTo($mColorPicker);
$(div).attr({
'id': 'mColorPickerImg',
'class': 'mColor'
}).css({
'height': '136px',
'width': '192px',
'border': 0,
'cursor': 'crosshair',
'background-image': 'url(<%= WebResource("uComponents.DataTypes.TextImage.images.colorpicker.png") %>)'
}).appendTo($w);
$s.attr({
'id': 'mColorPickerSwatches'
}).css({
'border-right': '1px solid #000'
}).appendTo($w);
$(div).addClass(
'mClear'
).css({
'clear': 'both'
}).appendTo($s);
for (i = 9; i > -1; i--) {
$(div).attr({
'id': 'cell' + i,
'class': "mPastColor" + ((i > 0) ? ' mNoLeftBorder' : '')
}).css({
'background-color': $o.swatches[i].toLowerCase(),
'height': '18px',
'width': '18px',
'border': '1px solid #000',
'float': 'left'
}).html(
' '
).prependTo($s);
}
$f.attr({
'id': 'mColorPickerFooter'
}).css({
'background-image': 'url(<%= WebResource("uComponents.DataTypes.TextImage.images.grid.gif") %>)',
'position': 'relative',
'height': '26px'
}).appendTo($w);
$mColorPickerInput.attr({
'id': 'mColorPickerInput',
'type': 'text'
}).css({
'border': 'solid 1px gray',
'font-size': '10pt',
'margin': '3px',
'width': '80px'
}).appendTo($f);
if ($i.allowTransparency) $(span).attr({
'id': 'mColorPickerTransparent',
'class': 'mColor mColorTransparent'
}).css({
'font-size': '16px',
'color': '#000',
'padding-right': '30px',
'padding-top': '3px',
'cursor': 'pointer',
'overflow': 'hidden',
'float': 'right'
}).text(
'transparent'
).appendTo($f);
if ($i.showLogo) $l.attr({
'href': 'http://meta100.com/',
'title': $i.slogan,
'alt': $i.slogan,
'target': '_blank'
}).css({
'float': 'right'
}).appendTo($f);
$(img).attr({
'src': '<%= WebResource("uComponents.DataTypes.TextImage.images.meta100.png") %>',
'title': $i.slogan,
'alt': $i.slogan
}).css({
'border': 0,
'border-left': '1px solid #aaa',
'right': 0,
'position': 'absolute'
}).appendTo($l);
$('.mNoLeftBorder').css({
'border-left': 0
});
};
$.fn.mColorPicker.closePicker = function () {
$mColorPickerBg.hide();
$mColorPicker.fadeOut()
};
$.fn.mColorPicker.colorShow = function () {
var $t = $(this),
id = $t.attr('id').replace('mcp_', ''),
pos = $t.offset(),
$i = $("#" + id),
pickerTop = pos.top + $t.outerHeight(),
pickerLeft = pos.left;
if ($i.attr('disabled')) return false;
$o.currentColor = $i.css('background-color')
$o.changeColor = true;
$o.currentInput = $i;
$o.currentId = id;
// KEEP COLOR PICKER IN VIEWPORT
if (pickerTop + $mColorPicker.height() > $document.height()) pickerTop = pos.top - $mColorPicker.height();
if (pickerLeft + $mColorPicker.width() > $document.width()) pickerLeft = pos.left - $mColorPicker.width() + $t.outerWidth();
$mColorPicker.css({
'top': (pickerTop) + "px",
'left': (pickerLeft) + "px"
}).fadeIn("fast");
$mColorPickerBg.show();
if ($('#' + id).attr('data-text')) $o.color = $t.css('background-color');
else $o.color = $i.css('background-color');
$o.color = $.fn.mColorPicker.setColor($o.color, $i.attr('data-hex') || $i.attr('hex'));
$mColorPickerInput.val($o.color);
};
$.fn.mColorPicker.setInputColor = function (id, color) {
$('#' + id).mSetInputColor(color);
};
$.fn.mSetInputColor = function (color) {
var $t = $(this),
css = {
'background-color': color,
'background-image': (color == 'transparent') ? 'url(\'<%= WebResource("uComponents.DataTypes.TextImage.images.grid.gif") %>\')' : '',
'color': $.fn.mColorPicker.textColor(color)
};
if ($t.attr('data-text') || $t.attr('text')) $t.next().css(css);
$t.val(color).css(css).trigger('change');
$mColorPickerInput.val(color);
};
$.fn.mColorPicker.textColor = function (val) {
val = $.fn.mColorPicker.RGBtoHex(val);
if (typeof val == 'undefined' || val == 'transparent') return "black";
return (parseInt(val.substr(1, 2), 16) + parseInt(val.substr(3, 2), 16) + parseInt(val.substr(5, 2), 16) < 400) ? 'white' : 'black';
};
$.fn.mColorPicker.setCookie = function (name, value, days) {
var cookie_string = name + "=" + escape(value),
expires = new Date();
expires.setDate(expires.getDate() + days);
cookie_string += "; expires=" + expires.toGMTString();
document.cookie = cookie_string;
};
$.fn.mColorPicker.getCookie = function (name) {
var results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
if (results) return (unescape(results[2]));
else return null;
};
$.fn.mColorPicker.colorPicked = function () {
$o.changeColor = false;
$.fn.mColorPicker.closePicker();
$.fn.mColorPicker.addToSwatch();
$o.currentInput.trigger('colorpicked');
};
$.fn.mColorPicker.addToSwatch = function (color) {
if (!$i.enhancedSwatches) return false;
var swatch = []
i = 0;
if (typeof color == 'string') $o.color = color.toLowerCase();
if ($o.color != 'transparent') swatch[0] = $o.color.toLowerCase();
$('.mPastColor').each(function () {
var $t = $(this);
$o.color = $t.css('background-color').toLowerCase();
if ($o.color != swatch[0] && $.fn.mColorPicker.RGBtoHex($o.color) != swatch[0] && $.fn.mColorPicker.hexToRGB($o.color) != swatch[0] && swatch.length < 10) swatch[swatch.length] = $o.color;
$(this).css('background-color', swatch[i++])
});
if ($i.enhancedSwatches) $.fn.mColorPicker.setCookie('swatches', swatch.join('||'), 365);
};
$.fn.mColorPicker.whichColor = function (x, y, hex) {
var color = [255, 255, 255];
if (x < 32) {
color[1] = x * 8;
color[2] = 0;
} else if (x < 64) {
color[0] = 256 - (x - 32) * 8;
color[2] = 0;
} else if (x < 96) {
color[0] = 0;
color[2] = (x - 64) * 8;
} else if (x < 128) {
color[0] = 0;
color[1] = 256 - (x - 96) * 8;
} else if (x < 160) {
color[0] = (x - 128) * 8;
color[1] = 0;
} else {
color[1] = 0;
color[2] = 256 - (x - 160) * 8;
}
for (var n = 0; n < 3; n++) {
if (y < 64) color[n] += (256 - color[n]) * (64 - y) / 64;
else if (y <= 128) color[n] -= color[n] * (y - 64) / 64;
else if (y > 128) color[n] = 256 - (x / 192 * 256);
color[n] = Math.round(Math.min(color[n], 255));
if (hex == 'true') color[n] = $.fn.mColorPicker.decToHex(color[n]);
}
if (hex == 'true') return "#" + color.join('');
return "rgb(" + color.join(', ') + ')';
};
$.fn.mColorPicker.setColor = function (color, hex) {
if (hex == 'true') return $.fn.mColorPicker.RGBtoHex(color);
return $.fn.mColorPicker.hexToRGB(color);
}
$.fn.mColorPicker.colorTest = function (color) {
$mColorPickerTest.css('background-color', color);
return $mColorPickerTest.css('background-color');
}
$.fn.mColorPicker.decToHex = function (color) {
var hex_char = "0123456789ABCDEF";
color = parseInt(color);
return String(hex_char.charAt(Math.floor(color / 16))) + String(hex_char.charAt(color - (Math.floor(color / 16) * 16)));
}
$.fn.mColorPicker.RGBtoHex = function (color) {
var decToHex = "#",
rgb;
color = color ? color.toLowerCase() : false;
if (!color) return '';
if (rHEX6.test(color)) return color.substr(0, 7);
if (rHEX3.test(color)) return color.replace(rHEX, "$1$1$2$2$3$3").substr(0, 7);
if (rgb = color.match(rRGB)) {
for (var n = 1; n < 4; n++) decToHex += $.fn.mColorPicker.decToHex(rgb[n]);
return decToHex;
}
return $.fn.mColorPicker.colorTest(color);
};
$.fn.mColorPicker.hexToRGB = function (color) {
color = color ? color.toLowerCase() : false;
if (!color) return '';
if (rRGB.test(color)) return color;
if (rHEX3.test(color)) {
if (!rHEX6.test(color)) color = color.replace(rHEX, "$1$1$2$2$3$3");
return 'rgb(' + parseInt(color.substr(1, 2), 16) + ', ' + parseInt(color.substr(3, 2), 16) + ', ' + parseInt(color.substr(5, 2), 16) + ')';
}
return $.fn.mColorPicker.colorTest(color);
};
$i = $.fn.mColorPicker.init;
$document.ready(function () {
$b = $('body');
$.fn.mColorPicker.events();
if ($i.replace) {
$.fn.mColorPicker.start();
if (typeof $.fn.livequery == "function") $($i.replace).livequery($.fn.mColorPicker.start);
else $(document).live('ajaxSuccess.mColorPicker', $.fn.mColorPicker.start);
}
});
})(jQuery);
|
import React from "react";
import "./AccountSetting.css";
const AccountSetting = () => {
return(
<div>
<h4>Account Settings</h4>
<p className="text">You can only change your account number and account type</p>
<form className="setForm" id="form">
<input type="text" name="accountName" placeholder="Account Name" required/>
<input type="text" name="accountNumber" placeholder="Account Number" required/>
<input type="text" name="bank" placeholder="Bank" required/>
<input type="text" name="accountType" placeholder="Account Type" required/>
</form>
<button className="setBtn">Save Changes</button>
</div>
);
};
export default AccountSetting;
|
import merge from 'lodash/merge';
import { withClientState } from 'apollo-link-state';
import { userState } from './login-state';
import { todoState } from './todo-state';
const state = [userState, todoState];
const createClientState = (cache) => {
const { defaults, Mutation, Query } = merge(...state);
return withClientState({
cache,
defaults,
resolvers: {
Query,
Mutation,
}
});
};
export default createClientState;
|
import React, {Component } from 'react';
import axios from 'axios'
export default class CreateFact extends Component {
constructor(props) {
super(props)
this.state = {
body: '',
author: ''
}
this.onChangeBody = this.onChangeBody.bind(this);
this.onChangeAuthor = this.onChangeAuthor.bind(this);
this.onSubmit = this.onSubmit.bind(this);
}
onChangeBody(e) {
this.setState({
body: e.target.value
});
}
onChangeAuthor(e) {
this.setState({
author: e.target.value
})
}
onSubmit(e) {
e.preventDefault()
const newFact = {
body: this.state.body,
author: this.state.author
}
axios.post(
'https://interestsappserver.herokuapp.com/coins/'+this.props.params.id+'/facts',
newFact,
).then(res => console.log(res.data))
.catch(function(error) {
console.log(error)
})
this.setState({
body: '',
author: ''
})
this.props.history.push('/')
}
render() {
return (
<div className ='mt-2 container-fluid'>
<h3>Add New Fact</h3>
<form onSubmit={this.onSubmit}>
<div className="form-group">
<label htmlFor="author">author: </label>
<input type="text"
className="form-control"
value={this.state.author}
onChange={this.onChangeAuthor}
maxLength="100"
id="author"
required
/>
</div>
<div className="form-group">
<label htmlFor="factBody">Body </label>
<input type="text"
className="form-control"
value={this.state.body}
onChange={this.onChangeBody}
required
id="factBody"
maxLength="100"
/>
</div>
<div className="form-group">
<input type="submit" value="Add Fact" className="btn btn-primary btn-block" />
</div>
</form>
</div>
)
}
}
|
/**
* Authors: Diego Ceresuela, Luis Jesús Pellicer, Raúl Piracés.
* Date: 16-05-2016
* Name file: index.js
* Description: This file contains the main behaviour of the web app.
*
* Launches all the web services listed in webservices,js
* PORT = 3000
* STATIC_CONTENT = ./app
*/
(function() {
'use strict';
var express = require('express');
var session = require('express-session');
var mongoose = require('mongoose');
var bodyParser = require('body-parser');
var cookieParser = require('cookie-parser');
var methodOverride = require('method-override');
var _ = require('lodash');
var passport = require('passport');
var Cron = require('./common/cron');
// Create the application.
var app = express();
var request = require('request');
// Add Middleware necessary for REST API's
app.use(bodyParser.urlencoded({extended: true}));
app.use(bodyParser.json());
app.use(methodOverride('X-HTTP-Method-Override'));
var OAuth = require('oauth').OAuth;
// Connect to MongoDB, selects between environment variable (Heroku DB) or other (custom DB)
mongoose.connect(process.env.MONGODB_URI || 'mongodb://admin:mongomongo1@ds013981.mlab.com:13981/heroku_vw307h03');
mongoose.connection.once('open', function() {
// Load all the models
var webservices = require('./webservices');
webservices.forEach(function(ws){
app.models = _.extend(app.models,require('./'+ws+'/models/index'));
});
// Load passport module
require('./config/passport.config');
// Authentication configuration
app.use(session({
resave: false,
saveUninitialized: true,
name: "id",
jwt: null,
secret: process.env.MY_SECRET
}));
app.use(cookieParser());
app.use(passport.initialize());
app.use(passport.session());
// Load all the routes
var routes = {};
webservices.forEach(function(ws){
routes = _.extend(routes,require('./'+ws+'/routes'));
});
// Configure all the endpoints
_.each(routes, function(controller, route){
app.use(route,controller(app, route));
});
// Static content
app.use(express.static('app'));
// Listen in the port specified, environment variable for Heroku, or custom on localhost
app.listen(process.env.PORT || 3000);
console.log('Server has started...');
// Starts cron process for pending tweets
Cron.startCron();
});
})();
|
'use strict'
const WebSocket = require('ws')
const MetagameServer = require('../metagame')
const uuid = require('uuid')
const assert = require('assert')
const mongodb = require('mongodb')
const util = require('util')
const co = require('co')
const utils = require('../core/utils')
const config = require('../sample_game/config')
config.server.port = 0
config.server.tls.port = 0
config.sandbox = 'tests'
config.clustering.enabled = false
config.logging.verbosity = 'error'
config.mongodb.defaultWriteConcern = 1
config.geolocation.allowOverride = true
let currentServer
let initialised = false
function* createSocket()
{
const ws = new WebSocket('wss://localhost:' + currentServer.secureAddress.port, { rejectUnauthorized: false })
return new Promise(resolve =>
{
ws.on('open', () =>
{
resolve(ws)
})
})
}
function* createMongoConnection(dbName)
{
const connectionProfile = config.mongodb.connections[dbName]
const database = util.format('%s_%s_%s', config.sandbox, currentServer.platform.name, connectionProfile.database || dbName)
const connString = util.format('mongodb://%s:%d/%s', connectionProfile.host, connectionProfile.port, database)
return yield mongodb.MongoClient.connect(connString)
}
function* clearMongo(dbName)
{
const db = yield createMongoConnection(dbName)
yield db.dropDatabase()
}
function* clearMongoCollections(dbName)
{
const db = yield createMongoConnection(dbName)
const collectionQuery = db.listCollections()
const collectionNames = yield collectionQuery.toArray()
for (const collection of collectionNames)
{
if (!collection.name.startsWith('system'))
{
// we specifically want to remove all documents, not delete the collection itself
// we need to preserve indices that have already have an ensureIndex call
// eg matchmaking's geospatial 'pos' index
yield db.collection(collection.name).remove({})
}
}
}
function* boot()
{
if (currentServer)
{
currentServer.close()
}
currentServer = new MetagameServer(config)
yield currentServer.init()
if (!initialised)
{
initialised = true
for (const prop in config.mongodb.connections)
{
yield clearMongo(prop)
}
}
}
function assertError(name)
{
return res =>
{
assert.notEqual(res.error, null, 'Expected an error, got ' + JSON.stringify(res.data))
assert.strictEqual(res.error.name, name)
}
}
function assertOk(res)
{
assert.equal(res.error, null, 'Expected no error, got ' + JSON.stringify(res.error))
}
function request(ws, path, params, tests)
{
const correlation = uuid.v4()
const messageToSend = { path, params, correlation }
if (!tests)
{
tests = [ assertOk ]
}
else if (!Array.isArray(tests))
{
tests = [ tests ]
}
const promise = new Promise(resolve =>
{
ws.on('message', function gotMessage(message)
{
const response = JSON.parse(message)
if (response.correlation === correlation)
{
for (const test of tests)
{
test(response)
}
ws.removeListener('message', gotMessage)
resolve(response)
}
})
})
ws.send(JSON.stringify(messageToSend))
return promise
}
function* createAuthedSocket(userID, options)
{
options = options || {}
const ws = yield createSocket()
yield request(ws, '/auth/login', { userID: userID || 'ruan', client: options.client || 'game', coords: options.coords })
return ws
}
function* createServerSocket()
{
const ws = yield createSocket()
yield request(ws, '/auth/login', { server: true, client: 'game' })
return ws
}
module.exports = {
boot,
clearMongo,
clearMongoCollections,
createSocket,
createAuthedSocket,
createServerSocket,
request,
assertOk,
assertError,
}
|
import React, { useState } from 'react';
export default () => {
const [colorChecked, setColorChecked] = useState([true,true,true,true,true]);
const [positionChecked, setPositionChecked] = useState([true, true, true, true]);
const colors = [
'#808071', // taupe
'#4d3326', // brown
'#7e272b', // dark red
'#9b5836', // orange
'#e1e2d3', // cream
]
const data = [
[0,1,2,3],
[1,2,0,4],
[0,3,2,3],
[1,4,2,3],
[2,0,4,2],
[0,4,2,1],
[1,4,3,2],
[3,1,0,4],
[0,3,1,4],
[3,4,0,3],
[2,3,4,0],
[0,2,0,4],
[0,2,4,2],
[1,4,2,3],
[3,2,0,2],
[0,3,1,4],
[1,4,3,2],
[3,1,0,4],
[0,4,2,1],
[3,0,4,3],
[2,3,0,1],
[0,2,0,3],
[1,3,0,4],
[0,1,2,3],
]
const getStyle = (square, j) => {
let style = {};
const checked = colorChecked[square] && positionChecked[j];
style.width = (5 - j) * 20 - (j * 4) + 'px';
style.height = (5 - j) * 20 - (j * 4) + 'px';
style.top = j * 10 + (j * 2) + 'px';
style.left = j * 10 + (j * 2) + 'px';
style.background = checked ? colors[square] : '#fff';
style.border = checked ? '' : '1px solid #e6e6e6';
return style;
}
const handleColorChecked = (i) => {
colorChecked[i] = !colorChecked[i];
setColorChecked([...colorChecked]);
}
const handlePositionChecked = (i) => {
positionChecked[i] = !positionChecked[i];
setPositionChecked([...positionChecked]);
}
// (() => {
// let totals = [0,0,0,0,0];
// data.forEach((block, i) => {
// if (i % 4 === 0) {
// // console.log(totals)
// // totals = [0,0,0,0,0];
// }
// block.forEach((colorIndex, j) => {
// totals[colorIndex] += 4 - j;
// })
// })
// console.log(totals)
// })()
return (
<div className='pattern-finder'>
<a target='__blank' href='https://www.reddit.com/r/patterns/comments/jz1eed/i_cant_find_the_pattern_in_my_rug_and_it_is/'>
is there a pattern?
</a>
<div className='pattern-finder-checkboxes'>
<div className='pattern-finder-checkboxes-column'>
{['taupe', 'brown', 'dark red', 'orange', 'cream'].map((color, i) => {
return (
<label key={color}>
<input type='checkbox'
checked={colorChecked[i] === true}
onKeyDown={(e) => e.which === 13 || e.which === 32 ? handleColorChecked(i) : null }
onChange={() => handleColorChecked(i)}
/>
<span>
{color}
</span>
</label>
)
})}
</div>
<div className='pattern-finder-checkboxes-column'>
{['outer', 'second from outer', 'second from inner', 'inner'].map((position, i) => {
return (
<label key={position}>
<input type='checkbox'
checked={positionChecked[i] === true}
onKeyDown={(e) => e.which === 13 || e.which === 32 ? handlePositionChecked(i) : null }
onChange={() => handlePositionChecked(i)}
/>
<span>
{position}
</span>
</label>
)
})}
</div>
</div>
<div className='pattern-finder-squares'>
{data.map((block, i) => (
<div key={i} className='pattern-finder-square'>
{block.map((square,j) => (
<div key={`${square}_${j}`} style={getStyle(square, j)}>
</div>
))}
</div>
))}
</div>
</div>
)
}
|
var passport = require('passport'),
LocalStrategy = require('passport-local').Strategy,
smfAuth = require('./integration/smf-auth');
var users = {};
// Passport session setup.
// To support persistent login sessions, Passport needs to be able to
// serialize users into and deserialize users out of the session. Typically,
// this will be as simple as storing the user ID when serializing, and finding
// the user by ID when deserializing.
passport.serializeUser(function(user, done) {
done(null, user.username);
});
passport.deserializeUser(function(id, done) {
var user = users[id];
if (user) done(null, user);
else done(null, false);
});
passport.use(new LocalStrategy(
function(username, password, done) {
process.nextTick(function () {
smfAuth.authenticate(username, password, function(err, user) {
if (err) {
return done(err);
}
if (!user) {
return done(null, false);
}
else {
users[user.username] = user;
return done(null, user);
}
});
});
}
));
module.exports = passport;
|
const router = require('express').Router();
const authMiddleware = require('../../middlewares/authMiddleware');
const tiktokController = require('../../controllers/api/tiktokUsers/tiktokUsers.controller');
router.get('/',tiktokController.get);
router.get('/get-user/:id',tiktokController.getUser);
router.get('/search-users/:keyword',tiktokController.getUsers);
router.get('/get-user-listing/:user_id',tiktokController.getUserListing);
router.get('/get-user-posts/:user_id',tiktokController.getUserPosts);
router.get('/login',tiktokController.userLogin);
module.exports = {
router:router,
name:'users',
endpoint:'/api/tiktok'
};
|
function n_vi_code(msgt){
switch(msgt){
case "EXIST":dfv = "用户已存在";break;
case "UNAUTH":dfv = "非法访问";break;
case "INT":dfv = "内部错误";break;
case "NONE":dfv = "没有数据或长度过短";break;
case "EXT-1006":dfv="数据不合法";break;
case "EXT-1007":dfv="数据不完整";break;
default:dfv = "未知错误：ERR"+msgt;}
return dfv;
}
function getpos(){
if (loginxhr.readyState==4 && loginxhr.status==200)
{
if(loginxhr.responseText == "" || !loginxhr.response || loginxhr.responseText == null){
showd("无法读取登录信息");
}
var pdd = loginxhr.responseText;
if(pdd.slice(0,3)=="ERR"){
showd(n_errlogc(pdd.slice(3)));
}else if(pdd.slice(0,3)=="ULS"){
var sid = new Array();
sid = pdd.split("---");
if(sid[0] == "ULS" && sid[1].length == 80){
var out = n_set_cookie("ucid",1,sid[1]);
if(out == true){
setTimeout(chrr,3000);
}else{
var fq = n_cookerrt(out);
showd(fq);}
}else{
showd("无法识别登陆返回信息");}
}
}
if(loginxhr.readyState==2){
log_msg("正在响应");
}else if(loginxhr.readyState==3){
log_msg("正在处理");
}
if(loginxhr.readyState==4 && loginxhr.status == 404){
showd("很抱歉,<br>未找到登陆中心");
}
block = false;
}
function n_errlogc(ttt){
if(ttt.substr(0,3) == "INT" || ttt.substr(0,3) == "EXT") {
dfv = "内部错误" + ttt.substr(3);
return dfv;
}
switch (ttt){
case "NOUSN":dfv = "用户不存在";break;
case "UNAUTH":dfv = "非法访问";break;
case "LEN":dfv = "用户名或密码过短";break;
case "PASS":dfv = "密码不匹配";break;
default:dfv = "未知错误：ERR"+ttt;}
return dfv;
}
function n_showd(tex){
var scf;
if(!tex){top.location.href="/help/co.php?code=ERRTEX"}
showd(tex["code1"],tex["code2"],tex["show"]);
}
function n_reg_geterr(msgt){
if(ttt.substr(0,3) == "INT" || ttt.substr(0,3) == "EXT") {
dfv = "内部错误" + ttt.substr(3);
return dfv;
}switch (msgt){
case "NOUSN":dfv = "用户名不完整";break;
case "NOPSS":dfv = "密码不完整";break;
case "NOEMI":dfv = "邮箱不完整";break;
case "NOQQ":dfv = "QQ不完整";break;
case "UNAUTH":dfv = "非法访问";break;
case "LEN":dfv = "数据过短";break;
case "USNDU":dfv = "用户名已存在";break;
case "QQDU":dfv = "QQ已存在";break;
case "EMIDU":dfv = "邮箱已存在";break;
default:dfv = "未知错误：ERR"+ttt;}return dfv;
}
function n_set_cookie(cnn,cexp,cco){
var exdate=new Date();
if(cexp && cexp > 0){
exdate.setDate(exdate + cexp);
}else{
exdate.setDate(exdate + 1);
}
exdate.setDate(exdate + 1);
if(exdate.getHours() == 23){
exdate.setDate(exdate.getDate() + 1)
}else{
exdate.setHours(exdate.getHours()+1);
}
document.cookie = cnn + "=" +escape(cco)+";path=/";
return ((n_get_cookie(cnn) == cco)? true:n_get_cookie(cnn));
}
var E_NOSUB = 3094;
var E_NOANYCOOKIE = 3095;
function n_cookerrt(enums){
switch(enums){
case E_NOSUB:
return "值没有信息";
case E_NOANYCOOKIE:
return "没有cookie";
default:
return "未知COOK错误";
}
}
function n_get_cookie(cnn){
if (document.cookie.length>0){
c_start=document.cookie.indexOf(cnn+"=");
if (c_start==-1){return}
c_start=c_start + (cnn+"=").length;
c_end=document.cookie.indexOf(";",c_start);
if (c_end==-1){c_end=document.cookie.length}
//GET COOKIE
if(null == unescape(document.cookie.substring(c_start,c_end))){
return E_NOSUB;
}else{
return unescape(document.cookie.substring(c_start,c_end));
}
}else{
return E_NOANYCOOKIE;
}
}
|
const URL_MEMBER = ' https://api.trello.com/1/members/';
const URL_BOARDS = ' https://api.trello.com/1/boards/';
const URL_LISTS = ' https://api.trello.com/1/lists/';
const URL_CARDS = 'https://api.trello.com/1/cards';
const API_KEY = 'e327c3e08523d8b0c0efca2189a7b372';
const API_TOKEN =
'fbb3cb59c7c63472fc502a0b65fb79b99e8e5fc1aef520492ccbd9308f56b147';
const AUTH =
'?key=' +
'e327c3e08523d8b0c0efca2189a7b372' +
'&token=' +
'fbb3cb59c7c63472fc502a0b65fb79b99e8e5fc1aef520492ccbd9308f56b147';
const MEMBER_ID = 'roqueperalta2';
function getSaveCardUrl(listId, cardName) {
return (
this.URL_CARDS +
'?idList=' +
listId +
'&name=' +
cardName +
'&key=' +
API_KEY +
'&token=' +
API_TOKEN
);
}
export const config = {
URL_MEMBER,
URL_BOARDS,
URL_LISTS,
URL_CARDS,
AUTH,
MEMBER_ID,
getSaveCardUrl
};
|
import React from 'react';
import {Link, Container} from './Navigation.styled'
export default function Navigation() {
return (
<Container>
<Link to="/">Home</Link>
<Link to="/movies">Movies</Link>
</Container>
)
}
|
import React from 'react';
import {Card, Statistic, Image} from 'semantic-ui-react';
const UserCard = (props) =>{
const {name = 'lorem', date=Date.now(), answersAmount = 2222} = props || {};
const year = new Date(date).getFullYear();
return(
<Card>
<Image src='https://react.semantic-ui.com/images/avatar/large/daniel.jpg' wrapped ui={false} />
<Card.Content>
<Card.Header>{name}</Card.Header>
<Card.Meta>Joined in {year}</Card.Meta>
<Card.Description>
<Statistic horizontal>
<Statistic.Value>{answersAmount}</Statistic.Value>
<Statistic.Label>Answers</Statistic.Label>
</Statistic>
</Card.Description>
</Card.Content>
<Card.Content extra>
</Card.Content>
</Card>
)
}
export default UserCard;
|
export const COLUMN_REQUEST_ITEMS = [
{
header: "No.",
data: "externalId",
targets: [0],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Description",
data: "description",
targets: [1],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Quantity",
data: "quantity",
targets: [2],
width: "300px",
orderable: true,
className: "text-center"
},
{
header: "Unit",
data: "unitDescription",
targets: [3],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Unit Price",
data: "unitPrice",
targets: [4],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Sub Total",
data: "subTotal",
targets: [5],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "TAX",
data: "vatTotal",
targets: [6],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Currency",
data: "currency",
targets: [7],
width: "80px",
orderable: true,
className: "text-center"
},
{
header: "Site",
data: "site",
targets: [7],
width: "80px",
orderable: true,
className: "text-center"
}
];
|
const https = require('https')
// const fetch = require('fetch')
// const fetch = require('node-fetch');
exports.handler = function(event, context, callback) {
// console.log("From new lambda function");
// console.log(JSON.stringify(event));
var msg = JSON.parse(event.body);
var m1 = JSON.stringify(msg.message.text);
// console.log("message");
console.log(m1);
var str="";
for (var i = m1.length; i > 2; i--) {
str+=m1[i-2];
}
var reply = (str);
// var str = 'https://api.dictionaryapi.dev/api/v2/entries/en/'+m1;
// var reply="";
// // var d = https.get(str);
// // console.log(d);
// https.get(str, function(res){
// var body = '';
// res.on('data', function(chunk){
// body += chunk;
// });
// console.log(JSON.parse(body));
// console.log(JSON.stringify(body));
// res.on('end', function(){
// var Response = JSON.stringify(body);
// console.log("Got a response: ", Response);
// try {
// const parsedData = JSON.parse(body);
// console.log("parse data: "+JSON.stringify(parsedData));
// if (parsedData[0] == null){
// reply=parsedData.title;
// }
// else{
// reply=(parsedData[0].meanings[0].definitions[0].definition);
// }
// console.log("reply: "+reply);
// console.log(JSON.stringify(msg.message.from.id));
// var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=";
// url += JSON.stringify(msg.message.from.id)+"&text="+reply;
// var e = https.get(url);
// var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=1008250855";
// url += "&text="+m1+" "+reply;
// var e = https.get(url);
// } catch (e) {
// console.error(e.message);
// }
// });
// }).on('error', function(e){
// console.log("Got an error: ", e);
// });
// // https.get(str, (res) => {
// // // var { statusCode } = res;
// // // var contentType = res.headers['content-type'];
// // // let error;
// // // if (statusCode !== 200) {
// // // error = new Error('Request Failed.\n' +
// // // `Status Code: ${statusCode}`);
// // // } else if (!/^application\/json/.test(contentType)) {
// // // error = new Error('Invalid content-type.\n' +
// // // `Expected application/json but received ${contentType}`);
// // // }
// // // if (error) {
// // // console.error(error.message);
// // // // consume response data to free up memory
// // // res.resume();
// // // }
// // res.setEncoding('utf8');
// // let rawData = '';
// // res.on('data', (chunk) => {
// // rawData += chunk;
// // });
// // console.log(rawData);
// // res.on('end', () => {
// // try {
// // const parsedData = JSON.parse(rawData);
// // console.log("parse data: "+JSON.stringify(parsedData));
// // if (parsedData[0] == null){
// // reply=parsedData.title;
// // }
// // else{
// // reply=(parsedData[0].meanings[0].definitions[0].definition);
// // }
// // console.log("reply: "+reply);
// console.log(JSON.stringify(msg.message.from.id));
// var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=";
// url += JSON.stringify(msg.message.from.id)+"&text="+reply;
// var e = https.get(url);
// var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=1008250855";
// url += "&text="+m1+" "+reply;
// var e = https.get(url);
// } catch (e) {
// console.error(e.message);
// }
// });
// }).on('error', (e) => {
// console.error(`Got error: ${e.message}`);
// });
// console.log("msg "+m1);
// console.log("data: "+JSON.stringify(d));
var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=";
url += JSON.stringify(msg.message.from.id)+"&text="+reply;
var e = https.get(url);
// var url = "https://api.telegram.org/bot1162523716:AAFg3J5__o3LzNjdV3HqL0hXczZ6Xd31A88/sendMessage?chat_id=1008250855";
// url += "&text="+JSON.parse(d);
// var e = https.get(url);
// console.log("data: "+JSON.stringify(e));
};
|
$(document).ready(function() {
$( ".luke" ).click(function() {
$( ".luke" ).animate({
width: "40%",
fontSize: "3em",
borderWidth: "10px"
}, 1500 );
$( ".r2d2" ).animate({
width: "40%",
fontSize: "3em",
color: "red",
borderWidth: "10px"
}, 1500 );
});
});
var lukeskywalker = {
health: 100,
power: 20,
}
var r2d2 = {
health: 100,
power: 16,
}
function attack() {
var attackButton = document.getElementById("attackButton");
var restartButton = document.getElementById("restartButton");
var battleMessage = document.getElementById("battleMessage");
var playerAttack = attackDamage(lukeskywalker.power);
r2d2.health -= playerAttack;
attackinfo();
if (gameOver(r2d2.health)){
battleMessage.innerHTML = "Luke Skywalker demolished his opponent!";
attackButton.hidden = true;
restartButton.hidden = false;
return;
}
attackButton.disabled = true;
battleMessage.innerHTML = "R2D2 is about to attack with his popcorn strike attack!";
setTimeout(function() {
var opponentAttack = attackDamage(r2d2.power);
lukeskywalker.health -= opponentAttack;
attackinfo();
if (gameOver(lukeskywalker.health)){
battleMessage.innerHTML = "R2D2 fried his opponent!";
attackButton.hidden = true;
restartButton.hidden = false;
return;
}
attackButton.disabled = false;
}, 250);
}
function attackDamage (power){
return Math.floor(Math.random() * power);
}
function gameOver(health) {
return health <= 0;
}
function restart() {
lukeskywalker.health = 100;
r2d2.health = 100;
var attackButton = document.getElementById("attackButton").hidden = false;
var restartButton = document.getElementById("restartButton").hidden = true;
var battleMessage = document.getElementById("battleMessage").innerHTML = "";
attackinfo();
}
function attackinfo() {
document.getElementById("enemy-health").innerHTML = r2d2.health;
document.getElementById("player-health").innerHTML = lukeskywalker.health;
}
attackinfo();
|
"use strict";
exports.parse = function(fileName, data) {
var parser;
switch (fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase()) {
case "stl":
parser = new stl();
break;
case "ply":
parser = new ply();
break;
case "obj":
parser = new obj();
break;
default: break;
}
return parser.parse(data);
};
/* parsers
========================================================================== */
var stl = function() {
this.parse = function(data) {
var binData = ensureBinary(data);
return isBinary(binData) ? parseBinary(binData) : parseASCII(ensureString(data));
};
function parseBinary(data) {
var reader = new DataView(data);
var faces = reader.getUint32(80, true);
var dataOffset = 84;
var faceLength = 12 * 4 + 2;
var vertices = [];
var normals = [];
for (var face=0; face<faces; face++) {
var start = dataOffset + face * faceLength;
var normalX = reader.getFloat32(start, true);
var normalY = reader.getFloat32(start + 4, true);
var normalZ = reader.getFloat32(start + 8, true);
normals.push(normalX, normalY, normalZ);
for (var i=1; i<=3; i++) {
var vertexstart = start + i * 12;
vertices.push(reader.getFloat32(vertexstart, true));
vertices.push(reader.getFloat32(vertexstart + 4, true));
vertices.push(reader.getFloat32(vertexstart + 8, true));
}
}
if ((vertices.length == 0) || (normals.length == 0)) {
throw new Error("STL malformed");
}
return {
type: "stl",
vertices: vertices,
normals: normals
};
}
function parseASCII(data) {
var patternFace, patternNormal, patternVertex, result, text;
patternFace = /facet([\s\S]*?)endfacet/g;
var vertices = [];
var normals = [];
while ((result = patternFace.exec(data)) !== null) {
text = result[0];
patternNormal = /normal[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g; // lgtm [js/redos]
while ((result = patternNormal.exec(text)) !== null) {
normals.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
}
patternVertex = /vertex[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g; // lgtm [js/redos]
while ((result = patternVertex.exec(text)) !== null) {
vertices.push(parseFloat(result[1]), parseFloat(result[3]), parseFloat(result[5]));
}
}
if ((vertices.length == 0) || (normals.length == 0)) {
throw new Error("STL malformed");
}
return {
type: "stl",
vertices: vertices,
normals: normals
};
}
function ensureString(buf) {
if (typeof buf !== "string") {
var array_buffer = new Uint8Array(buf);
var strArray = [];
for (var i=0; i<buf.byteLength; i++) {
strArray.push(String.fromCharCode(array_buffer[i]));
}
return strArray.join("");
} else {
return buf;
}
}
function ensureBinary(buf) {
if (typeof buf === "string") {
var array_buffer = new Uint8Array(buf.length);
for (var i=0; i<buf.length; i++) {
array_buffer[i] = buf.charCodeAt(i) & 0xff;
}
return array_buffer.buffer || array_buffer;
} else {
return buf.buffer || buf;
}
}
function isBinary(binData) {
var expect, face_size, n_faces, reader;
reader = new DataView(binData);
face_size = (32 / 8 * 3) + ((32 / 8 * 3) * 3) + (16 / 8);
n_faces = reader.getUint32(80, true);
expect = 80 + (32 / 8) + (n_faces * face_size);
if (expect === reader.byteLength) {
return true;
}
var fileLength = reader.byteLength;
for (var i=0; i<fileLength; i++) {
if (reader.getUint8(i, false) > 127) {
return true;
}
}
return false;
}
};
var ply = function() {
this.parse = function (data) {
var geometry;
if (data instanceof ArrayBuffer) {
geometry = isASCII(data) ? parseASCII(bin2str(data)) : parseBinary(data);
} else {
geometry = parseASCII(data);
}
return geometry;
};
function isASCII(data) {
var header = parseHeader(bin2str(data));
return header.format === "ascii";
}
function bin2str( buf ) {
var array_buffer = new Uint8Array( buf );
var str = "";
for (var i=0; i<buf.byteLength; i++) {
str += String.fromCharCode(array_buffer[i] );
}
return str;
}
function parseHeader(data) {
var patternHeader = /ply([\s\S]*)end_header\s/;
var headerText = "";
var headerLength = 0;
var result = patternHeader.exec(data);
if (result !== null) {
headerText = result[1];
headerLength = result[0].length;
} else {
throw new Error("PLY malformed");
}
var header = {
comments: [],
elements: [],
headerLength: headerLength
};
var lines = headerText.split("\n");
var currentElement;
var lineType, lineValues;
function make_ply_element_property(propertValues) {
var property = {
type: propertValues[0]
};
if (property.type === "list") {
property.name = propertValues[3];
property.countType = propertValues[1];
property.itemType = propertValues[2];
} else {
property.name = propertValues[1];
}
return property;
}
for (var i=0; i<lines.length; i++) {
var line = lines[i];
line = line.trim();
if (line === "") {continue;}
lineValues = line.split(/\s+/);
lineType = lineValues.shift();
line = lineValues.join(" ");
switch (lineType) {
case "format":
header.format = lineValues[0];
header.version = lineValues[1];
break;
case "comment":
header.comments.push(line);
break;
case "element":
if (currentElement !== undefined) {
header.elements.push(currentElement);
}
currentElement = {};
currentElement.name = lineValues[0];
currentElement.count = parseInt(lineValues[1]);
currentElement.properties = [];
break;
case "property":
currentElement.properties.push(make_ply_element_property(lineValues));
break;
default:
console.log("unhandled", lineType, lineValues);
}
}
if (currentElement !== undefined) {
header.elements.push(currentElement);
}
return header;
}
function parseASCIINumber(n, type) {
switch (type) {
case "char": case "uchar": case "short": case "ushort": case "int": case "uint":
case "int8": case "uint8": case "int16": case "uint16": case "int32": case "uint32":
return parseInt(n);
case "float": case "double": case "float32": case "float64":
return parseFloat(n);
}
}
function parseASCIIElement(properties, line) {
var values = line.split(/\s+/);
var element = {};
for (var i=0; i<properties.length; i++) {
if (properties[i].type === "list") {
var list = [];
var n = parseASCIINumber(values.shift(), properties[i].countType);
for (var j=0; j<n; j++) {
list.push(parseASCIINumber(values.shift(), properties[i].itemType));
}
element[properties[i].name] = list;
} else {
element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);
}
}
return element;
}
function parseASCII(data) {
var buffer = {
type: "ply",
indices: [],
vertices: [],
normals: []
};
var result;
var header = parseHeader(data);
var patternBody = /end_header\s([\s\S]*)$/;
var body = "";
if ((result = patternBody.exec(data)) !== null) {
body = result [1];
} else {
throw new Error("PLY malformed");
}
var lines = body.split("\n");
var currentElement = 0;
var currentElementCount = 0;
for (var i=0; i<lines.length; i++) {
var line = lines[i];
line = line.trim();
if (line === "") {continue;}
if (currentElementCount >= header.elements[currentElement].count) {
currentElement ++;
currentElementCount = 0;
}
var element = parseASCIIElement(header.elements[currentElement].properties, line);
handleElement(buffer, header.elements[currentElement].name, element);
currentElementCount++;
}
return buffer;
}
function handleElement(buffer, elementName, element) {
if (elementName === "vertex") {
buffer.vertices.push(element.x, element.y, element.z);
if ("nx" in element && "ny" in element && "nz" in element) {
buffer.normals.push(element.nx, element.ny, element.nz);
}
} else if (elementName === "face") {
var vertex_indices = element.vertex_indices || element.vertex_index;
if (vertex_indices.length === 3) {
buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[2]);
} else if (vertex_indices.length === 4) {
buffer.indices.push(vertex_indices[0], vertex_indices[1], vertex_indices[3]);
buffer.indices.push(vertex_indices[1], vertex_indices[2], vertex_indices[3]);
}
}
}
function binaryRead(dataview, at, type, little_endian) {
switch (type) {
case "int8": case "char": return [dataview.getInt8(at), 1];
case "uint8": case "uchar": return [dataview.getUint8(at), 1];
case "int16": case "short": return [dataview.getInt16(at, little_endian), 2];
case "uint16": case "ushort": return [dataview.getUint16(at, little_endian), 2];
case "int32": case "int": return [dataview.getInt32(at, little_endian), 4];
case "uint32": case "uint": return [dataview.getUint32(at, little_endian), 4];
case "float32": case "float": return [dataview.getFloat32(at, little_endian), 4];
case "float64": case "double": return [dataview.getFloat64(at, little_endian), 8];
}
}
function binaryReadElement(dataview, at, properties, little_endian) {
var element = {};
var result, read = 0;
for (var i=0; i<properties.length; i++) {
if (properties[i].type === "list") {
var list = [];
result = binaryRead(dataview, at+read, properties[i].countType, little_endian);
var n = result[0];
read += result[1];
for (var j=0; j<n; j++) {
result = binaryRead(dataview, at+read, properties[i].itemType, little_endian);
list.push(result[0]);
read += result[1];
}
element[properties[i].name] = list;
} else {
result = binaryRead(dataview, at+read, properties[i].type, little_endian);
element[properties[i].name] = result[0];
read += result[1];
}
}
return [element, read];
}
function parseBinary(data) {
var buffer = {
type: "ply",
indices: [],
vertices: [],
normals: []
};
var header = parseHeader(bin2str(data));
var little_endian = (header.format === "binary_little_endian");
var body = new DataView(data, header.headerLength);
var result, loc = 0;
for (var currentElement=0; currentElement<header.elements.length; currentElement++) {
for (var currentElementCount=0; currentElementCount<header.elements[currentElement].count; currentElementCount++) {
result = binaryReadElement(body, loc, header.elements[currentElement].properties, little_endian);
loc += result[1];
var element = result[0];
handleElement(buffer, header.elements[currentElement].name, element);
}
}
return postProcess(buffer);
}
};
var obj = function() {
this.parse = function (text) {
text = text.toString();
var pattern = {
vertex: /^v\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/, // lgtm [js/regex/duplicate-in-character-class]
normal: /^vn\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/, //lgtm [js/regex/duplicate-in-character-class]
uv: /^vt\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/, // lgtm [js/regex/duplicate-in-character-class]
face_vertex: /^f\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)(?:\s+(-?\d+))?/, // lgtm [js/regex/duplicate-in-character-class]
face_vertex_uv: /^f\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+))?/, // lgtm [js/regex/duplicate-in-character-class]
face_vertex_uv_normal: /^f\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+)\/(-?\d+))?/, // lgtm [js/regex/duplicate-in-character-class]
face_vertex_normal: /^f\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)(?:\s+(-?\d+)\/\/(-?\d+))?/ // lgtm [js/regex/duplicate-in-character-class]
};
var controller = createController();
if (text.indexOf("\r\n") !== - 1) {
text = text.replace(/\r\n/g, "\n");
}
if (text.indexOf("\\\n") !== - 1) {
text = text.replace(/\\\n/g, "");
}
var lines = text.split("\n");
var line = "", lineFirstChar = "", lineSecondChar = "";
var lineLength = 0;
var result = [];
for (var i=0, l=lines.length; i<l; i++) {
line = lines[i].trim();
lineLength = line.length;
if (lineLength === 0) continue;
lineFirstChar = line.charAt(0);
if (lineFirstChar === "#") continue;
if (lineFirstChar === "v") {
lineSecondChar = line.charAt(1);
if (lineSecondChar === " " && (result = pattern.vertex.exec(line)) !== null) {
controller.verticesAux.push( // ["v 1.0 2.0 3.0"]
parseFloat(result[1]),
parseFloat(result[2]),
parseFloat(result[3])
);
} else if (lineSecondChar === "n" && (result = pattern.normal.exec(line)) !== null) {
controller.normalsAux.push( // ["vn 1.0 2.0 3.0"]
parseFloat(result[1]),
parseFloat(result[2]),
parseFloat(result[3])
);
} else if (lineSecondChar === "t" && (result = pattern.uv.exec(line)) !== null) { // lgtm [js/useless-assignment-to-local]
} else {
throw new Error("OBJ malformed");
}
} else if (lineFirstChar === "f") {
if ((result = pattern.face_vertex_uv_normal.exec(line)) !== null) {
controller.addFace( // f vertex/uv/normal vertex/uv/normal vertex/uv/normal -> ["f 1/1/1 2/2/2 3/3/3"]
result[1], result[4], result[7], result[10],
result[2], result[5], result[8], result[11],
result[3], result[6], result[9], result[12]
);
} else if ((result = pattern.face_vertex_uv.exec(line)) !== null) {
controller.addFace( // f vertex/uv vertex/uv vertex/uv -> ["f 1/1 2/2 3/3"]
result[1], result[3], result[5], result[7],
result[2], result[4], result[6], result[8]
);
} else if ((result = pattern.face_vertex_normal.exec(line)) !== null) {
controller.addFace( // f vertex//normal vertex//normal vertex//normal -> ["f 1//1 2//2 3//3"]
result[1], result[3], result[5], result[7],
undefined, undefined, undefined, undefined,
result[2], result[4], result[6], result[8]
);
} else if ((result = pattern.face_vertex.exec(line)) !== null) {
controller.addFace( // f vertex vertex vertex -> ["f 1 2 3"]
result[1], result[2], result[3], result[4]
);
} else {
throw new Error("OBJ malformed");
}
} else if (lineFirstChar === "l") {
var lineParts = line.substring(1).trim().split(" ");
var lineVertices = [];
if (line.indexOf("/") === - 1) {
lineVertices = lineParts;
} else {
for (var li = 0, llen = lineParts.length; li < llen; li ++) {
var parts = lineParts[li].split("/");
if (parts[0] !== "") lineVertices.push(parts[0]);
}
}
controller.addLineGeometry(lineVertices);
}
}
return {
type: "obj",
vertices: controller.vertices,
normals: controller.normals
};
};
function createController() {
var controller = {
verticesAux: [],
normalsAux: [],
vertices: [],
normals: [],
parseVertexIndex: function (value, len) {
var index = parseInt(value, 10);
return (index >= 0 ? index - 1 : index + len / 3) * 3;
},
parseNormalIndex: function (value, len) {
var index = parseInt(value, 10);
return (index >= 0 ? index - 1 : index + len / 3) * 3;
},
parseUVIndex: function (value, len) {
var index = parseInt(value, 10);
return (index >= 0 ? index - 1 : index + len / 2) * 2;
},
addVertex: function (a, b, c) {
var src = this.verticesAux;
var dst = this.vertices;
dst.push(src[a + 0]);
dst.push(src[a + 1]);
dst.push(src[a + 2]);
dst.push(src[b + 0]);
dst.push(src[b + 1]);
dst.push(src[b + 2]);
dst.push(src[c + 0]);
dst.push(src[c + 1]);
dst.push(src[c + 2]);
},
addVertexLine: function (a) {
var src = this.verticesAux;
var dst = this.vertices;
dst.push(src[a + 0]);
dst.push(src[a + 1]);
dst.push(src[a + 2]);
},
addNormal: function (a, b, c) {
var src = this.normalsAux;
var dst = this.normals;
dst.push(src[a + 0]);
dst.push(src[a + 1]);
dst.push(src[a + 2]);
dst.push(src[b + 0]);
dst.push(src[b + 1]);
dst.push(src[b + 2]);
dst.push(src[c + 0]);
dst.push(src[c + 1]);
dst.push(src[c + 2]);
},
addFace: function (a, b, c, d, ua, ub, uc, ud, na, nb, nc, nd) {
var vLen = this.verticesAux.length;
var ia = this.parseVertexIndex(a, vLen);
var ib = this.parseVertexIndex(b, vLen);
var ic = this.parseVertexIndex(c, vLen);
var id;
if (d === undefined) {
this.addVertex(ia, ib, ic);
} else {
id = this.parseVertexIndex(d, vLen);
this.addVertex(ia, ib, id);
this.addVertex(ib, ic, id);
}
if (na !== undefined) {
var nLen = this.normalsAux.length;
ia = this.parseNormalIndex(na, nLen);
ib = na === nb ? ia : this.parseNormalIndex(nb, nLen);
ic = na === nc ? ia : this.parseNormalIndex(nc, nLen);
if (d === undefined) {
this.addNormal(ia, ib, ic);
} else {
id = this.parseNormalIndex(nd, nLen);
this.addNormal(ia, ib, id);
this.addNormal(ib, ic, id);
}
}
},
addLineGeometry: function (verticesAux) {
this.type = "Line";
var vLen = this.verticesAux.length;
for (var vi=0, l=verticesAux.length; vi<l; vi++) {
this.addVertexLine(this.parseVertexIndex(verticesAux[vi], vLen));
}
}
};
return controller;
};
};
|
const gulp = require('gulp');
const webpack = require('webpack-stream');
const uglify = require('gulp-uglify');
const browserSync = require('browser-sync').create();
const sass = require('gulp-sass');
const autoprefixer = require('gulp-autoprefixer');
const imagemin = require('gulp-imagemin');
const imageminMozjpeg = require('imagemin-mozjpeg');
const imageResize = require('gulp-image-resize');
const rename = require('gulp-rename');
const clean = require('gulp-clean');
const connect = require('gulp-connect');
const reload = browserSync.reload;
// complie sass files to css
gulp.task('styles', () =>
gulp
.src('./src/sass/**/*.scss')
.pipe(
sass({
outputStyle: 'compressed',
}).on('error', sass.logError),
)
.pipe(
autoprefixer({
browsers: ['last 2 versions'],
}),
)
.pipe(gulp.dest('./src/css'))
.pipe(browserSync.stream()),
);
// bundle scripts with webpack
gulp.task('scripts', () =>
gulp
.src('./src/scripts/**/*.js')
.pipe(webpack(require('./webpack.config.js')))
.pipe(uglify())
.pipe(gulp.dest('./src/js')),
);
// bundle service worker file with webpack
gulp.task('service-worker', () =>
gulp
.src('./src/service-worker.js')
.pipe(
webpack({
mode: 'production',
output: {
filename: 'sw.js',
},
module: {
rules: [
{
test: /\.js$/,
use: ['babel-loader'],
},
],
},
}),
)
.pipe(uglify())
.pipe(gulp.dest('./src')),
);
// optimize images
gulp.task('images', () => {
const sizes = [
{ width: 320, quality: 40, suffix: 'small' },
{ width: 480, quality: 60, suffix: 'medium' },
{ width: 800, quality: 80, suffix: 'large' },
];
let stream;
sizes.forEach((size) => {
stream = gulp
.src('./src/images/**/*.*')
.pipe(imageResize({ width: size.width }))
.pipe(
rename((path) => {
path.basename += `-${size.suffix}`;
}),
)
.pipe(
imagemin(
[
imageminMozjpeg({
quality: size.quality,
}),
],
{
verbose: true,
},
),
)
.pipe(gulp.dest('./src/img'));
});
return stream;
});
// serve files for development
gulp.task(
'serve',
gulp.series(['styles'], () => {
browserSync.init({
server: './src',
port: 8000,
});
gulp.watch('./src/sass/**/*.scss', gulp.series(['styles']));
gulp.watch('./src/*.html').on('change', reload);
gulp.watch('./src/*.json').on('change', reload);
gulp.watch('./src/service-worker.js', gulp.series(['service-worker'])).on('change', reload);
gulp.watch('./src/scripts/**/*.js', gulp.series(['scripts'])).on('change', reload);
}),
);
gulp.task('serve:dist', () =>
connect.server({
port: 8080,
root: 'dist',
}),
);
// copy files to dist folder
gulp.task('copy-images', () => gulp.src('./src/img/*').pipe(gulp.dest('./dist/img')));
gulp.task('copy-icons', () => gulp.src('./src/icons/*').pipe(gulp.dest('./dist/icons')));
gulp.task('copy-css', () => gulp.src('./src/css/**/*.css').pipe(gulp.dest('./dist/css')));
gulp.task('copy-js', () => gulp.src('./src/js/**/*.js').pipe(gulp.dest('./dist/js')));
gulp.task(
'copy-files',
gulp.series([
'copy-images',
'copy-icons',
'copy-js',
'copy-css',
() => gulp.src(['./src/*.html', './src/*.json', './src/sw.js']).pipe(gulp.dest('./dist')),
]),
);
// clean folders
gulp.task('clean', () =>
gulp
.src(['./src/img', './src/css', './src/js', './src/sw.js'], { read: false, allowEmpty: true })
.pipe(clean()),
);
gulp.task('clean:dist', () => gulp.src('./dist', { read: false, allowEmpty: true }).pipe(clean()));
gulp.task(
'dist',
gulp.series([
'clean',
'clean:dist',
'images',
'styles',
'service-worker',
'scripts',
'copy-files',
'serve:dist',
]),
);
gulp.task(
'default',
gulp.series(['clean', 'images', 'service-worker', 'styles', 'scripts', 'serve']),
);
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.