text
stringlengths 7
3.69M
|
|---|
angular.module('cashApp', ['ui.router', 'ngResource', 'ngCookies', 'ui.mask'])
.config(['$httpProvider', '$interpolateProvider',function($httpProvider, $interpolateProvider) {
$interpolateProvider.startSymbol('{[');
$interpolateProvider.endSymbol(']}');
$httpProvider.defaults.xsrfCookieName = 'csrftoken';
$httpProvider.defaults.xsrfHeaderName = 'X-CSRFToken';
$httpProvider.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=utf-8';
}])
.config(function($stateProvider, $urlRouterProvider ) {
$stateProvider
// route for the home page
.state('app', {
//abstract: true,
url:'/',
templateUrl : '/static/views/home.html',
//controller : 'IndexController'
});
$stateProvider
// route for the aboutus page
.state('account', {
url:'/account',
//abstract:true,
templateUrl : '/static/views/account.html',
resolve: {
first: function ($q, $http, $state) {
var deferred = $q.defer();
$http.get('/get_id').then(
function (response) {
if (angular.isUndefined(response.data.info)) {
$state.go('app');
deferred.reject(response.data);
} else {
deferred.resolve(response.data);
}
}
);
return deferred.promise;
}
},
})
.state('account.money', {
url:'/money',
views : {
'@': {
templateUrl : '/static/views/account.money.html'
},
}
//resolve: {
// first: function ($q, $http, $state) {
// var deferred = $q.defer();
// $http.get('/get_id').then(
// function (response) {
// if (angular.isUndefined(response.data.info)) {
// $state.go('app');
// deferred.reject(response.data)
// } else {
// deferred.resolve(response.data)
// }
// }
// );
// return deferred.promise;
//
// }
//},
})
;
$urlRouterProvider.otherwise('/');
})
;
|
import { connect } from 'react-redux';
import { createSlice, createSelector } from '@reduxjs/toolkit';
import { VISIBILITY, selectVisibility } from '../visibility/visibilitySlice';
import TodoList from './todoList';
let todoId = 0;
const generateId = () => {
todoId = todoId + 1;
return todoId;
};
const todosSlice = createSlice({
name: 'todos',
initialState: [],
reducers: {
addTodo: {
reducer: (state, action) => {
state.push({ id: action.payload.id, text: action.payload.text, completed: false });
},
prepare: (text) => {
return { payload: { id: generateId(), text } };
},
},
toggleTodo: (state, action) => {
const todo = state.find((e) => e.id === action.payload.id);
if (todo) {
todo.completed = !todo.completed;
}
},
},
});
export const { addTodo, toggleTodo } = todosSlice.actions;
export default todosSlice.reducer;
const selectTodos = (state) => state.todo.todos;
const selectVisibleTodos = createSelector([selectTodos, selectVisibility], (todos, visibility) => {
console.log('Filtering todos.');
switch (visibility) {
case VISIBILITY.ALL:
return todos;
case VISIBILITY.OPEN:
return todos.filter((e) => !e.completed);
case VISIBILITY.COMPLETED:
return todos.filter((e) => e.completed);
default:
return todos;
}
});
const mapStateToProps = (state) => ({
todos: selectVisibleTodos(state),
});
const mapDispatch = { toggleTodo };
export const TodoListContainer = connect(mapStateToProps, mapDispatch)(TodoList);
|
import React, {useState, useContext, useEffect, useRef, memo} from 'react';
import {
View,
StyleSheet,
Text,
Image,
ScrollView,
RefreshControl,
TouchableNativeFeedback,
FlatList,
} from 'react-native';
import Layout from '../Layout';
import ThemeContext from '../Context/ThemeContext';
import moment from 'moment';
import {useQuery} from 'react-apollo';
import gql from 'graphql-tag';
import LoadingComponent from '../components/LoadingComponent';
const NOTIFICATION_QUERY = gql`
query($offset: Int) {
notifications (offset: $offset) {
route
timestamp
isRead
message
}
}
`;
const NOTIFICATION_SUBSCRIPTION = gql`
subscription {
userNotificationsUpdated {
route
timestamp
isRead
message
}
}
`;
const notificationItem = ({msg, image, time, route, navigation}) => {
const {theme} = useContext(ThemeContext);
const date = new Date()
date.setTime(time)
const timeDifference = moment(date).fromNow();
return (
<TouchableNativeFeedback onPress={() => navigation.navigate(route)}>
<View style={styles.notificationItem}>
<Image source={image} style={styles.notificationImage} />
<View style={{flex: 1}}>
<Text style={[styles.notificationMsg, {color: theme.foreground}]}>
{msg}
</Text>
<Text style={[styles.notificationTime, {color: theme.foreground}]}>
{timeDifference}
</Text>
</View>
</View>
</TouchableNativeFeedback>
);
};
const propsAreEqual = (prevProps, nextProps) =>{
return prevProps.msg == nextProps.msg
}
const MemoizedNotificationItem = memo(notificationItem, propsAreEqual)
const Notifications = props => {
const {theme} = useContext(ThemeContext);
const [data, setData] = useState([]);
const offset = useRef(null)
const unsubscribeRef = useRef(null);
const {loading, refetch, subscribeToMore, fetchMore} = useQuery(NOTIFICATION_QUERY, {
fetchPolicy: 'cache-and-network',
onCompleted: queryData => {
setData([...queryData.notifications]);
offset.current = queryData.notifications.length
},
});
useEffect(() => {
if (subscribeToMore) {
unsubscribeRef.current = subscribeToMore({
document: NOTIFICATION_SUBSCRIPTION,
updateQuery: (prev, {subscriptionData}) => {
if (!subscriptionData.data) {
return prev;
}
setData([subscriptionData.data.userNotificationsUpdated, ...data]);
},
});
}
return () => {
if (unsubscribeRef.current) {
unsubscribeRef.current();
}
};
}, []);
return (
<Layout title="Notifications">
<View style={[styles.container, {backgroundColor: theme.background}]}>
<View style={styles.notificationHolder}>
<Text style={[styles.subtitle, {color: theme.foreground}]}>All</Text>
<FlatList
refreshControl={
<RefreshControl
refreshing={loading}
onRefresh={() => {
refetch();
}}
/>
}
data={data}
keyExtractor={data => String(data.timestamp)}
onEndReachedThreshold={0.5}
onEndReached={() => {
fetchMore({
variables: {
offset: offset.current,
},
updateQuery: (prev, {fetchMoreResult}) => {
if (!fetchMoreResult) return prev;
offset.current = offset.current + 20
return Object.assign({}, prev, {
notifications: [...prev.notifications, ...fetchMoreResult.notifications],
});
},
})
}}
renderItem={({item}) => {
return (
<MemoizedNotificationItem
image={require('../assets/bot.png')}
msg={item.message}
time={item.timestamp}
route={item.route}
navigation={props.navigation}
/>
)
}}
/>
</View>
</View>
</Layout>
);
};
const styles = StyleSheet.create({
container: {
flex: 1,
},
filterIcon: {
marginLeft: 'auto',
},
subtitle: {
fontWeight: 'bold',
fontSize: 16,
marginBottom: 5,
marginHorizontal: 10,
},
notificationHolder: {
marginVertical: 10,
flex: 1,
},
notificationItem: {
flexDirection: 'row',
alignItems: 'flex-start',
padding: 10,
},
notificationImage: {
width: 50,
height: 50,
borderRadius: 5,
},
notificationMsg: {
marginLeft: 10,
fontFamily: 'Poppins-Regular',
},
notificationTime: {
color: 'rgba(0,0,0,0.5)',
marginLeft: 10,
},
});
export default memo(Notifications);
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import StarRatings from 'react-star-ratings';
import { bindActionCreators } from 'redux';
import { connect } from 'react-redux';
import {
Dimmer, Loader, Segment, Button, Modal,
} from 'semantic-ui-react';
import {
addRating, fetchRating,
} from '../../redux/actions';
import './style.sass';
import { isLoggedIn } from '../../utils/auth';
import { isOwner } from '../../utils/permissions';
class Rating extends Component {
constructor(props) {
super(props);
this.state = {
open: false,
newRating: 0,
};
}
showModal = (size) => {
const { slug, getRating, userRating } = this.props;
this.setState({ size, open: true });
getRating({ slug });
this.setState({ newRating: userRating });
};
closeModal = () => {
const { refresh } = this.props;
refresh();
this.setState({ open: false });
};
changeRating = (newRating) => {
this.setState({ newRating });
}
sendRating = () => {
const { rate, slug } = this.props;
const { newRating } = this.state;
rate({ rating: newRating, slug });
}
render() {
const {
rating, title, username, loading,
} = this.props;
const { open, size, newRating } = this.state;
return (
<div className="rating">
<Modal size={size} open={open} onClose={this.closeModal}>
<Modal.Header>
{title}
{' '}
</Modal.Header>
<Modal.Content>
<Segment className="loading-rating">
<Dimmer className={loading ? 'active ' : null}>
<Loader size="tiny">your previous rating is....</Loader>
</Dimmer>
<StarRatings
rating={newRating}
starRatedColor="gold"
changeRating={this.changeRating}
numberOfStars={5}
name="rating"
starDimension="20px"
starSpacing="3px"
/>
</Segment>
</Modal.Content>
<Modal.Actions>
<Button className="theme-color done" onClick={() => { this.closeModal(); this.sendRating(); }}>Done</Button>
</Modal.Actions>
</Modal>
<StarRatings
rating={rating}
starDimension="20px"
starSpacing="5px"
starRatedColor="gold"
/>
{ isLoggedIn() && !isOwner(username) && <Button className="theme-color" onClick={() => this.showModal('mini')}>Rate</Button> }
</div>
);
}
}
Rating.propTypes = {
rate: PropTypes.func.isRequired,
getRating: PropTypes.func.isRequired,
userRating: PropTypes.number.isRequired,
rating: PropTypes.number.isRequired,
title: PropTypes.string.isRequired,
username: PropTypes.string.isRequired,
loading: PropTypes.bool.isRequired,
slug: PropTypes.string.isRequired,
refresh: PropTypes.func.isRequired,
};
const mapStateToProps = state => ({
avgRating: state.rating.average_rating,
userRating: state.rating.your_rating,
loading: state.rating.loading,
});
const matchDispatchToProps = dispatch => bindActionCreators({
rate: addRating,
getRating: fetchRating,
}, dispatch);
export default connect(mapStateToProps, matchDispatchToProps)(Rating);
|
//pyramid printing
for(var i=0;i<=5;i++){
var x="";
for(var j=0;j<=i;j++){
x+="*"
}
console.log(x)
}
//inverse pyramid
for(var i=5;i>=0;i--){
var x="";
for(var j=0;j<=i;j++){
x+="*"
}
console.log(x)
}
//pyramid starting from middle
var n=5;
var m = "";
for(var i=1;i<n;i++){
for(var j=1;j<n-1;j++){
m+=" "
}
for(var k=0;k<2*i-1;k++){
m+="*";
}
m+="\n";
}
console.log(m)
|
import React, { Component } from 'react';
import NavBar from './components/appbar';
import Dashboard from './components/dashboard';
import SingleGif from './components/SingleGif';
import About from './components/about';
import {Container} from '@material-ui/core';
import { BrowserRouter as Router, Switch, Route } from 'react-router-dom';
// import { PersistGate } from 'redux-persist/integration/react';
// import { persistor } from './store';
class App extends Component {
render() {
return (
// <PersistGate loading={null} persistor={persistor}>
<Router>
<NavBar />
<Container fixed>
<Switch>
<Route exact path="/">
<Dashboard />
</Route>
<Route exact path="/single-gif">
<SingleGif />
</Route>
<Route path="/about">
<About />
</Route>
</Switch>
</Container>
</Router>
// </PersistGate>
);
}
}
export default App;
|
const express = require('express');
const app = express();
const router = express.Router();
// Import the location route
router.use("/location", require("./location/check_in"));
// Import the admin activity route
router.use("/admin", require("./admin/index"));
// Require user route
router.use("/user", require("./user/index"));
// Require merchant route
router.use("/merchant", require("./merchant/index"));
module.exports = router;
|
import React, { useEffect, useState } from 'react';
export default function ChatInfoMsgs({
setElChat,
chatsDivideByDates,
searchMsgText,
setElSearchedMsgs,
elSearchedMsgs }) {
function checkIsTailed(idx, msgsInfo) {
if (idx === 0) return true;
return msgsInfo[idx - 1].isYourMessage !== msgsInfo[idx].isYourMessage
}
function getTime(timestamp) {
const time = new Date(timestamp);
return `${time.getHours()}:${time.getMinutes()}`
}
function getMsg(text) {
if (!searchMsgText || !text.includes(text)) return <span>{text}</span>
const msgParts = text.split(searchMsgText);
return <span>
{
msgParts.map((msgPart, idx) => (
<span
key={idx}
>{msgPart}{idx !== msgParts.length - 1 && <span className="marked">{searchMsgText}</span>}
</span>
))
}
</span>
}
function addElSearchMessage(el) {
if (!el) return;
if (!elSearchedMsgs[elSearchedMsgs.length-1] || elSearchedMsgs[elSearchedMsgs.length-1].offsetTop < el.offsetTop) {
setElSearchedMsgs(prevState => {
if (prevState.length === 0) return [el];
return [...prevState, el]
})
}
}
return (
<div
className='chat'
ref={(el) => setElChat(el)}
>
{!!chatsDivideByDates.length &&
chatsDivideByDates.map((date, idx) => (
<div key={idx} className="w100 flex column align-center">
<div className="date-container">
<span>{date.when}</span>
</div>
<div className="flex column align-start date-chats">
{
date.chat.map((currMsg, idx, msgsInfo) => (
<div
ref={(el) => { if (searchMsgText && currMsg.info.includes(searchMsgText)) addElSearchMessage(el) }}
key={idx}
className={`chat-pop ${currMsg.isYourMessage ? 'you' : 'him'} ${checkIsTailed(idx, msgsInfo) ? 'tailted' : ''}`}
>
{checkIsTailed(idx, msgsInfo) &&
<div className="tail"></div>
}
{
getMsg(currMsg.info)
}
<span className="time">{getTime(currMsg.sendAt)}</span>
</div>
))
}
</div>
</div>
))
}
</div>
)
}
|
/*global JSAV, document */
// Written by Yuhui Lyu and Cliff Shaffer
$(document).ready(function() {
"use strict";
var av_name = "BinomialTreeCON";
var av = new JSAV(av_name);
var xoffset = 300;
var yoffset = 15;
var circRadius = 10;
var c1 = av.g.circle(xoffset + 50, yoffset, circRadius, {"stroke-width": "2"});
var c2 = av.g.circle(xoffset + 50, yoffset + 40, circRadius, {"stroke-width": "2"});
var c3 = av.g.circle(xoffset + 100, yoffset, circRadius, {"stroke-width": "2"});
av.g.circle(xoffset + 100, yoffset + 40, circRadius, {"stroke-width": "2"});
var c5 = av.g.circle(xoffset + 150, yoffset, circRadius, {"stroke-width": "2"});
var c6 = av.g.circle(xoffset + 150, yoffset + 40, circRadius, {"stroke-width": "2"});
av.g.circle(xoffset + 200, yoffset, circRadius, {"stroke-width": "2"});
av.g.circle(xoffset + 200, yoffset + 40, circRadius, {"stroke-width": "2"});
var l1 = av.g.line(xoffset + 50, yoffset + 10, xoffset + 50, yoffset + 30, {"stroke-width": "2"});
var l2 = av.g.line(xoffset + 100, yoffset + 10, xoffset + 100, yoffset + 30, {"stroke-width": "2"});
var l3 = av.g.line(xoffset + 150, yoffset + 10, xoffset + 150, yoffset + 30, {"stroke-width": "2"});
av.g.line(xoffset + 200, yoffset + 10, xoffset + 200, yoffset + 30, {"stroke-width": "2"});
// Slide 1
av.umsg("Example of building a binomial tree. We start with 8 values, and they are paired up with the greater value for each pair on top.");
av.displayInit();
av.step();
// Slide 2
c1.hide();
c2.hide();
c5.hide();
c6.hide();
l1.hide();
l3.hide();
c1 = av.g.circle(xoffset + 50, yoffset + 40, circRadius, {"stroke-width": "2"});
c2 = av.g.circle(xoffset + 50, yoffset + 80, circRadius, {"stroke-width": "2"});
l1 = av.g.line(xoffset + 50, yoffset + 50, xoffset + 50, yoffset + 70, {"stroke-width": "2"});
var l5 = av.g.line(xoffset + 50, yoffset + 30, xoffset + 100, yoffset + 10, {"stroke-width": "2"});
c5 = av.g.circle(xoffset + 150, yoffset + 40, circRadius, {"stroke-width": "2"});
c6 = av.g.circle(xoffset + 150, yoffset + 80, circRadius, {"stroke-width": "2"});
l3 = av.g.line(xoffset + 150, yoffset + 50, xoffset + 150, yoffset + 70, {"stroke-width": "2"});
av.g.line(xoffset + 150, yoffset + 30, xoffset + 200, yoffset + 10, {"stroke-width": "2"});
av.umsg("Now we take each pair of pairs, and pick the larger of the roots to be the root of the binomial tree for those four nodes. Do this for each set of four nodes.");
av.step();
// Slide 3
c1.hide();
c2.hide();
c3.hide();
l1.hide();
l2.hide();
l5.hide();
c1 = av.g.circle(xoffset + 50, yoffset + 80, circRadius, {"stroke-width": "2"});
c2 = av.g.circle(xoffset + 50, yoffset + 120, circRadius, {"stroke-width": "2"});
c3 = av.g.circle(xoffset + 100, yoffset + 80, circRadius, {"stroke-width": "2"});
l1 = av.g.line(xoffset + 50, yoffset + 90, xoffset + 50, yoffset + 110, {"stroke-width": "2"});
l2 = av.g.line(xoffset + 100, yoffset + 50, xoffset + 100, yoffset + 70, {"stroke-width": "2"});
l5 = av.g.line(xoffset + 50, yoffset + 70, xoffset + 100, yoffset + 50, {"stroke-width": "2"});
av.g.line(xoffset + 100, yoffset + 30, xoffset + 200, yoffset + 10, {"stroke-width": "2"});
av.umsg("Now we take the pair of trees, and make the root with smaller value be the child of the root with larger value.");
av.recorded();
});
|
import React from 'react';
import './App.css';
import { Route } from 'react-router-dom'
import axios from 'axios'
import Players from './components/Players'
import Profile from './components/Profile'
import Header from './components/Header'
import Footer from './components/Footer'
import Teams from './components/Teams'
class App extends React.Component {
constructor() {
super();
this.state = {
teams: []
}
};
componentDidMount = async () => {
const response = await axios.get('https://www.thesportsdb.com/api/v1/json/1/lookup_all_teams.php?id=4387')
const teams = response.data.teams
// console.log(teams)
this.setState({
teams
})
}
render() {
return (
<div className="app" >
<Header />
<Route exact path="/" render={() => <Teams listOfTeams={this.state.teams} />} />
<Route path="/team/:idTeam" render={(props) => <Players idTeam={props.match.params.idTeam} />} />
<Route path="/profile/:idPlayer" render={(props) => <Profile idPlayer={props.match.params.idPlayer} />} />
<Footer />
</div>
);
}
}
export default App;
|
const books = [
{
id: 1, title: 'Детское море', author: 'Николай Варухин', genres: ['Наука', 'Педагогика и воспитания', 'Спорт'],
},
{
id: 2, title: 'Владычица Озера', author: 'Анджей Сапковский', genres: ['Фэнтези'],
},
{
id: 3, title: 'Ловец человеков', author: 'Надежда Попова', genres: ['Детектив', 'Научная фантастика', 'Тёмное фэнтези'],
},
{
id: 4, title: 'Болтливый мертвец', author: 'Макс Фрай', genres: ['Фэнтези'],
},
{
id: 5, title: 'Меч Предназначения', author: 'Анджей Сапковский', genres: ['Героический', 'Фэнтези'],
},
{
id: 6, title: "Герцог де Л'Омлет", author: 'Эдгар Алан По', genres: ['Классические детективы', 'Проза'],
},
{
id: 7, title: 'На байдарке', author: 'Феликс Квадригин', genres: ['Спорт'],
},
{
id: 8, title: 'Тубурская игра', author: 'Макс Фрай', genres: ['Детектив', 'Фэнтези'],
},
{
id: 9, title: 'Маяк', author: 'Эдгар Алан По', genres: ['Классические детективы', 'Проза'],
},
{
id: 10, title: 'Последнее желание', author: 'Анджей Сапковский', genres: ['Героический', 'Фэнтези'],
},
];
export default books;
|
import { connect } from 'react-redux'
import { push } from 'react-router-redux'
import ProjectsListView from './view.js'
const mapStateToProps = state => {
return {
}
}
const mapDispatchToProps = (dispatch, ownProps) => {
return {
onProjectClick: (id) => {
dispatch(push(`/project/${id}`))
}
}
}
export default connect(mapStateToProps, mapDispatchToProps)(ProjectsListView)
|
import patchString from "./string"
import patchConstructor from "./constructor"
const origSource = new WeakMap
const origFlags = new WeakMap
const applyPatches = () => {
patch(global, {RegExp})
}
export const addSyntax = fn => {
rules.push(fn)
patchString()
}
export const addFlag = fn => {
patchFlags()
}
|
import React, { useState } from 'react';
import COUNTER_CONTEXT from './COUNTER_CONTEXT';
import Parent from './PARENT'
// import logo from './logo.svg';
// import './App.css';
function GrandParent()
{
let counter = useState(0);
return (
<COUNTER_CONTEXT.Provider value={counter} >
<div>
<Parent />
</div>
</COUNTER_CONTEXT.Provider >
);
}
export default GrandParent;
|
let listaProdutos = [];
let camiseta = {
tamanho: "unico",
cor: "preta",
Modelo: "babylook",
descricao: "camiseta reprograma estilo diva function",
preco: 35,
// template string abaixo //
descrevaMe: function(){alert(`${this.descricao} - Preço R$ ${this.preco}` )},
}
console.log (camiseta.descricao)
let caneca = {
medida: "250 Ml",
cor: "roxa",
modelo: "cônica",
descricao: "Caneca maneira para minas fodas",
preco: 25,
descrevaMe: function(){alert(`${this.descricao} Preço R$ ${this.preco}`)}
}
let mochila = {
cor: "roxa",
modelo: "Pano",
descricao: "Mochila maneira para minas fodas",
preco: 50,
descrevaMe: function(){alert(`${this.descricao} Preço R$ ${this.preco}`)}
}
listaProdutos.push(camiseta,caneca,mochila)
|
import React from 'react';
import { Route, IndexRoute } from 'react-router';
import Cookies from 'universal-cookie';
import { parse } from 'query-string';
import axios from 'axios';
var jwt = require('jsonwebtoken');
import App from './components/common/App';
// import DepotsPage from './components/depot/DepotsPage';
const https = require('https')
export default (
<Route path="/" component={App} >
<IndexRoute component={App} />
<Route path="*" component={App}/>
</Route>
);
|
import { plugins } from '@citation-js/core'
// Loads plugin definitions
import output from './output'
// Define plugin name (this is how it is referenced in the code)
const ref = '@quickstatements'
// Registers the plugin
// docs: https://citation.js.org/api/tutorial-plugins.html
plugins.add(ref, { output })
|
var gulp = require('gulp'),
wiredep = require('wiredep').stream,
useref = require('gulp-useref'),
gulpif = require('gulp-if'),
uglify = require('gulp-uglify'),
minifyCss = require('gulp-minify-css'),
less = require('gulp-less'),
path = require('path'),
clean = require('gulp-clean'),
imagemin = require('gulp-imagemin'),
pngquant = require('imagemin-pngquant'),
runSequence = require('run-sequence'),
prefix = require('gulp-autoprefixer'),
browserSync = require('browser-sync').create();
// livereload
// Static server
gulp.task('browser-sync', function() {
browserSync.init({
server: {
baseDir: "source"
}
});
});
// Bower
gulp.task('bower', function () {
gulp.src('source/index.html')
.pipe(wiredep({
'directory' : 'source/bower_components/'
}))
.pipe(gulp.dest('source'));
});
// Build
gulp.task('build', function(callback) {
runSequence('clean',
'less',
'html',
'image',
'copy',
callback);
});
gulp.task('clean', function () {
return gulp.src('production',{read: false})
.pipe(clean());
});
gulp.task('html', function () {
var assets = useref.assets();
return gulp.src('source/*.html')
.pipe(assets)
.pipe(gulpif('*.js', uglify()))
.pipe(gulpif('*.css', prefix('last 3 versions', 'ie9', '>1%' )))
.pipe(gulpif('*.css', minifyCss()))
.pipe(assets.restore())
.pipe(useref())
.pipe(gulp.dest('production'));
});
gulp.task('less', function () {
return gulp.src('source/s/main.less')
.pipe(less())
.pipe(gulpif('*.css', prefix('last 3 versions', 'ie9', '>1%' )))
.pipe(gulp.dest('source/s'))
.pipe(browserSync.stream());
});
gulp.task('image', function () {
return gulp.src('source/img/*')
.pipe(imagemin({
optimizationLevel: 3,
interlaced: true
}))
.pipe(gulp.dest('production/img'));
});
gulp.task('copy', function() {
return gulp.src(['source/bower_components/components-font-awesome/fonts/*'])
.pipe(gulp.dest('production/fonts'));
});
// Watch
gulp.task('watch', function() {
gulp.watch('bower.json', ['bower']);
gulp.watch('source/s/*.less', ['less']);
gulp.watch('source/img/*', ['image']);
gulp.watch(['source/js/*.js', 'source/*.html', 'source/img/*']).on('change', browserSync.reload);
})
// default
gulp.task('default', ['watch', 'browser-sync']);
|
/*
* Copyright © 2016 Magestore. All rights reserved.
* See COPYING.txt for license details.
*
*/
define(
[
'jquery',
'ko',
'mage/translate',
'Magestore_Webpos/js/helper/alert',
'Magestore_Webpos/js/helper/price',
'Magestore_Webpos/js/helper/general',
'Magestore_Webpos/js/model/event-manager',
'Magestore_Webpos/js/view/checkout/checkout/payment_selected',
'Magestore_Webpos/js/view/checkout/checkout/payment_popup',
'Magestore_Webpos/js/view/checkout/checkout/payment',
'Magestore_Webpos/js/model/checkout/checkout',
'Magestore_Webpos/js/model/checkout/cart',
'mage/storage',
'Magestore_Webpos/js/model/checkout/cart/items',
'Magestore_Webpos/js/model/checkout/cart/totals-factory',
'Magestore_Webpos/js/action/notification/add-notification',
],
function ($, ko, __, Alert, PriceHelper, Helper, Event, SelectedPayment, PopupPayment, Payment, CheckoutModel, CartModel, storage, Items, TotalsFactory, addNotification) {
"use strict";
var VantivService = {
/**
* Payment method code
*/
PAYMENT_METHOD_CODE: 'mercuryhosted',
/**
* authorize window
*/
authorizeWindow: ko.observable(),
/**
* Paypal authorize url
*/
authorizeUrl: ko.observable(''),
/**
* Flag to check the popup has been blocked
*/
blocked: ko.observable(false),
loading: ko.observable(false),
/**
* Initialize
*/
method: "rest",
storeCode: window.webposConfig.storeCode,
version: 'V1',
serviceUrl: ':method/:storeCode/:version',
initialize: function () {
console.log('WebposVantiv');
var self = this;
self.initCallbacks();
self.initEvents();
return self;
},
/**
* Show message by process response
* @param response
*/
showMessage: function(response){
if(response && response.message){
var priority = (response.success)?'success':'danger';
var title = (response.success)?'Message':'Error';
Alert({
priority: priority,
title: __(title),
message: __(response.message)
});
}
},
/**
* Open authorize window
* @param url
*/
openAuthorizeWindow: function(url){
console.log('openAuthorizeWindow');
var self = this;
if(self.authorizeWindow()){
self.authorizeWindow().close();
}
self.authorizeUrl(url);
var authorizeWindow = window.open(url, 'authorize_window', 'status=1,width=700,height=700');
return authorizeWindow;
},
/**
* Close authorize window
*/
closeAuthorizeWindow: function(success, message){
console.log('closeAuthorizeWindow');
var self = this;
if(self.authorizeWindow()){
self.authorizeWindow().close();
self.authorizeWindow('');
}
Event.dispatch('close_vantiv_integration', '');
self.showMessage({
success:success,
message:message
});
},
/**
* Close vantiv integration popup
*/
cancel: function(){
Event.dispatch('close_vantiv_integration', '');
},
/**
* Update reference number and place order
* @param responseText
*/
success: function(responseText){
var self = this;
Event.dispatch('close_vantiv_integration', '');
},
/**
* Set init object to call from childs window
*/
initCallbacks: function(){
var self = this;
if(typeof window.vantivService == 'undefined'){
window.vantivService = {
cancel:self.cancel,
success:$.proxy(self.success, self)
};
}
},
/**
* Init some events, change event when place order
*/
initEvents: function(){
var self = this;
CheckoutModel.selectedPayments.subscribe(function(){
$('#checkout_button').unbind('click');
$('#checkout_button').click(function(){
$.proxy(self.placeOrder(), self);
});
});
Event.observer('webpos_place_order_before', function (event, data) {
self.placeOrderBefore(data);
});
Event.observer('webpos_place_order_after', function (event, data) {
self.placeOrderAfter(data);
});
},
/**
* Get paypal method from selected payment list
* @returns {*}
*/
getSelectedPaypalMethod: function(){
var self = this;
var payments = CheckoutModel.selectedPayments();
var vantiv = ko.utils.arrayFirst(payments, function(method){
return method.code == self.PAYMENT_METHOD_CODE;
});
return vantiv;
},
/**
* Rewrite place order function
* @returns {boolean}
*/
placeOrder: function(){
console.log('placeorder');
var self = this;
var vantiv = self.getSelectedPaypalMethod();
if(vantiv){
Event.dispatch('open_vantiv_integration', '');
self.start();
}else{
Event.dispatch('start_place_order', '');
}
return false;
},
createUrl: function(url, params) {
var completeUrl = this.serviceUrl + url;
return this.bindParams(completeUrl, params);
},
bindParams: function(url, params) {
params.method = this.method;
params.storeCode = this.storeCode;
params.version = this.version;
var urlParts = url.split("/");
urlParts = urlParts.filter(Boolean);
$.each(urlParts, function(key, part) {
part = part.replace(':', '');
if (params[part] != undefined) {
urlParts[key] = params[part];
}
});
return urlParts.join('/');
},
/**
* Start create payment
*/
start: function(){
var self = this;
$('#vantiv-iframe').empty();
var quoteParams = CartModel.getQuoteInitParams();
var urlLocation = window.location.href.split("webpos")[0];
// $.mage.redirect('http://127.0.0.1/vantiv/webposvantiv/index/redirect?guestemail=null"eId='+quoteParams.quote_id);
var frame = $('<iframe src="'+urlLocation+'webposvantiv/index/redirect?guestemail=null"eId='+quoteParams.quote_id+'" style="padding-bottom:30px" frameBorder="0" height="100%" width="100%"></iframe>');
self.loading(true);
$('#vantiv-iframe').append(frame);
frame.load(function(){
self.loading(false);
});
},
/**
* Add params to save data to order
* @param data
*/
placeOrderBefore: function(data){
console.log(data);
console.log('placeOrderBefore');
},
/**
* Reset invoice data
* @param data
*/
placeOrderAfter: function(data){
console.log(data);
console.log('placeOrderAfter');
},
};
return VantivService.initialize();
}
);
|
import React from 'react';
import PropTypes from 'prop-types';
import { withStyles } from '@material-ui/core/styles';
import MuiDialogTitle from '@material-ui/core/DialogTitle';
import DialogContent from '@material-ui/core/DialogContent';
import Dialog from '@material-ui/core/Dialog';
import Grid from '@material-ui/core/Grid';
import Typography from '@material-ui/core/Typography';
import IconButton from '@material-ui/core/IconButton';
import CloseIcon from '@material-ui/icons/Close';
import AppBar from '@material-ui/core/AppBar';
import Tabs from '@material-ui/core/Tabs';
import Tab from '@material-ui/core/Tab';
import Box from '@material-ui/core/Box';
import Theme from './theme';
import ResultDetailHeader from './ResultDetailHeader';
import ResultDetailContent from './ResultDetailContent';
import ResultRelatedFiles from './ResultRelatedFiles';
import ResultModelTestInfo from './ResultModelTestInfo';
const styles = theme => ({
root: {
margin: 0,
padding: theme.spacing(2),
},
closeButton: {
position: 'absolute',
right: theme.spacing(1),
top: theme.spacing(1),
color: theme.palette.grey[500],
},
});
function TabPanel(props) {
const { children, value, index, ...other } = props;
return (
<Typography
component="div"
role="tabpanel"
hidden={value !== index}
id={`simple-tabpanel-${index}`}
aria-labelledby={`simple-tab-${index}`}
{...other}
>
{value === index && <Box p={3}>{children}</Box>}
</Typography>
);
}
TabPanel.propTypes = {
children: PropTypes.node,
index: PropTypes.any.isRequired,
value: PropTypes.any.isRequired,
};
const MyDialogTitle = withStyles(styles)(props => {
const { children, classes, onClose, ...other } = props;
return (
<MuiDialogTitle disableTypography className={classes.root} {...other}>
<Typography variant="h6">{children}</Typography>
{onClose ? (
<IconButton aria-label="close" className={classes.closeButton} onClick={onClose}>
<CloseIcon />
</IconButton>
) : null}
</MuiDialogTitle>
);
});
export default class ResultDetail extends React.Component {
constructor(props) {
super(props);
this.state = { tabValue: 0 };
this.handleClose = this.handleClose.bind(this);
this.handleTabChange = this.handleTabChange.bind(this);
}
handleClose() {
this.props.onClose();
}
handleTabChange(event, newValue) {
this.setState({ tabValue: newValue })
}
render() {
const result = this.props.result;
return (
<Dialog fullScreen onClose={this.handleClose} aria-labelledby="simple-dialog-title" open={this.props.open}>
<MyDialogTitle onClose={this.handleClose} />
<DialogContent>
<Grid container spacing={3}>
<Grid item xs={12}>
<ResultDetailHeader
id={result.id}
timestamp={result.timestamp}
modelID={result.model.id}
modelName={result.model.name}
modelAlias={result.model.alias}
modelInstID={result.model_instance.id}
modelVersion={result.model_instance.version}
testID={result.test.id}
testName={result.test.name}
testAlias={result.test.alias}
testInstID={result.test_instance.id}
testVersion={result.test_instance.version}
/>
</Grid>
<Grid item xs={12}>
<AppBar position="static">
<Tabs value={this.state.tabValue} onChange={this.handleTabChange}
style={{ backgroundColor: Theme.tableRowSelectColor, color: Theme.textPrimary }}>
<Tab label="Result Info" />
<Tab label="Result Files" />
<Tab label="Model/Test Info" />
</Tabs>
</AppBar>
<TabPanel value={this.state.tabValue} index={0}>
<ResultDetailContent
score={result.score}
normalized_score={result.normalized_score}
timestamp={result.timestamp}
project_id={result.project_id}
passed={result.passed}
uri={result.uri}
/>
</TabPanel>
<TabPanel value={this.state.tabValue} index={1}>
<ResultRelatedFiles
result_files={result.results_storage}
/>
</TabPanel>
<TabPanel value={this.state.tabValue} index={2}>
<ResultModelTestInfo
model={result.model}
model_instance={result.model_instance}
test={result.test}
test_instance={result.test_instance}
/>
</TabPanel>
</Grid>
</Grid>
</DialogContent>
</Dialog>
);
}
}
ResultDetail.propTypes = {
onClose: PropTypes.func.isRequired,
open: PropTypes.bool.isRequired
};
|
const Cancion = require('../modelo/Cancion');
const fs = require('fs');
const path = require('path');
function AgregarAlbum(req,res){
var cancion = new Cancion();
var parametros = req.body;
cancion.caratula = parametros.caratula;
cancion.album = parametros.album;
cancion.artista = parametros.artista;
cancion.titulo = parametros.titulo;
cancion.canciones = [];
cancion.save((err, AlbumNuevo)=>{
if(err){
res.status(500).send({message : 'Error del servidor'});
} else{
if(!AlbumNuevo){
res.status(200).send({message : 'No fue posible crear el album'});
} else{
res.status(200).send({
message : 'Album creado',
album : AlbumNuevo
})
}
}
})
}
function LlenarAlbum(req,res){
var albumId = req.params.id;
var nomtitulo = req.body.titulo
var nombreArchivo = "no has subido una cancion";
if(req.files){
var rutaArchivo = req.files.canciones.path;
var partirArchivo = rutaArchivo.split('\\');
var nombreArchivo = partirArchivo[2];
var extencionMu = nombreArchivo.split('\.');
var extencionArchivo = extencionMu[1];
if(extencionArchivo == 'png' || extencionArchivo == 'jpg'|| extencionArchivo == 'jpeg' ){
Cancion.findByIdAndUpdate(albumId , {caratula : nombreArchivo }, (err, nuevaCaratula)=>{
if(err){
res.status(500).send({message : "Error en el servidor"});
} else {
if(!nuevaCaratula){
res.status(200).send({ message : "imagen no valida"});
} else{
res.status(200).send({
message : "Caratula nueva",
album : nuevaCaratula
})
}
}
})
} else {
if(extencionArchivo == 'mp3'){
Cancion.findByIdAndUpdate(albumId, {$push : { canciones : nombreArchivo }}, (err, canNueva)=>{
console.log(canNueva.id)
if(err){
req.status(500).send({message : "error en el servidor"});
} else{
if(!canNueva){
req.status(200).send({ message : 'no se pudo guardar la cancion'});
} else {
Cancion.findByIdAndUpdate(albumId, {$push : {titulo : nomtitulo }}, (err, cancionNueva) =>{
res.status(200).send({
message : "Cancion guardada",
album : cancionNueva
})
})
}
}
} )
} else {
res.status(200).send({message : "Formato invalido"});
}
}
}
}
function BuscarAlbum(req,res){
var parametros = req.body;
album = parametros.album;
artista = parametros.artista;
Cancion.findOne({album : album , artista : artista }, (err , Albunes )=>{
if(err){
res.status(500).send({ message : "error del servidor"});
} else {
if(!Albunes){
res.status(200).send({ message : "No se encontraron concidencias"});
} else {
res.status(200).send({
message :" Se encontraron concidencias",
busqueda : Albunes
})
}
}
})
}
function BuscarArtista(req,res){
var parametros = req.body;
artista = parametros.artista;
Cancion.find({artista : artista }, (err , Albunes )=>{
if(err){
res.status(500).send({ message : "error del servidor"});
} else {
if(!Albunes){
res.status(200).send({ message : "No se encontrar el artista"});
} else {
res.status(200).send({
message :" Se encontraron concidencias",
busqueda : Albunes
})
}
}
})
}
function ModificarAlbum(req,res){
var albumId = req.params.id;
var albumNuevo = req.body.album;
var artistaNuevo = req.body.artista;
Cancion.findByIdAndUpdate(albumId, {album : albumNuevo , artista : artistaNuevo }, (err, AlbumActualizado)=>{
if(err){
res.status(500).send({message : "Error en el servidor"});
} else {
if(!AlbumActualizado){
res.status(200).send({ message : "No se pudo actualizar el album"});
} else {
res.status(200).send({
message : "Album actualizado",
album : AlbumActualizado
})
}
}
},);
}
function EliminarAlbum(req,res){
var idCancion = req.params.id;
Cancion.findByIdAndDelete(idCancion, (err, AlbumEliminado) =>{
if(err){
res.status(500).send({ message : "Error en el serivdor"});
} else {
if(!AlbumEliminado){
res.status(200).send({message : "No se ha seleccionado un album para eliminar"});
} else {
res.status(200).send({
message : "Album Eliminado",
borrado :AlbumEliminado
})
}
}
})
}
function mostrarArchivo(req, res){
// pedir el archivo que queremos mostrar
var archivo = req.params.imageFile;
console.log(`el archivo es : ${archivo}`);
// Ubicacion del archivo
var ruta = './archivos/canciones/' + archivo;
// validar si existe o no
// fs.exists('la ruta del archivo'. (exiate)=>{})
fs.exists(ruta,(exist)=>{
if(exist){
res.sendFile(path.resolve(ruta));
} else{
res.status(200).send({message: "imagen no encontrada"});
}
})
}
function buscarCancion(req,res){
var archivo = req.params.cancion;
console.log(archivo);
// Ubicacion del archivo
var ruta = './archivos/canciones/' + archivo;
// validar si existe o no
// fs.exists('la ruta del archivo'. (exiate)=>{})
fs.exists(ruta,(exist)=>{
if(exist){
res.sendFile(path.resolve(ruta));
} else{
res.status(200).send({message: "cancion no disponible"});
}
})
}
module.exports = {
AgregarAlbum,
LlenarAlbum,
BuscarAlbum,
buscarCancion,
BuscarArtista,
ModificarAlbum,
EliminarAlbum,
mostrarArchivo
}
|
import React from 'react'
import Heading from '../Reuseable/Heading'
export default function Contact() {
return (
<section className = "py-3">
<Heading title ="Contact Us" />
<div className="col-10 col-sm-8 mx-auto">
<form action="" method ="POST">
<div className="form-grop py-3">
<input
type= "text"
name ="name"
id ="name"
placeholder = "Your Name"
className ="form-control"
/>
</div>
<div className="form-grop py-3">
<input
type= "text"
name ="email"
id ="email"
placeholder = "Your Email"
className ="form-control"
/>
</div>
<div className="form-grop py-3">
<input
type= "text"
name ="phone"
id ="phone"
placeholder = "Your Phone Number"
className ="form-control"
/>
</div>
<div className="form-grop py-3">
<textarea
type= "text"
name ="description"
id ="description"
placeholder = "Your Message"
className ="form-control"
/>
</div>
<button type="submit" className="btn btn-outline-success btn-block">
Submit
</button>
</form>
</div>
</section>
)
}
|
const { Router } = require("express");
const routes = Router();
const categories = require("./categories");
const products = require("./products");
routes.use("/categories", categories);
routes.use("/products", products);
module.exports = routes;
|
import React from 'react';
import { Layout } from 'antd';
import { Link } from 'react-router-dom';
import { renderToString } from "react-dom/server";
import decodeHtml from 'decode-html';
import PostApi from "../../services/PostApi";
import ShareButton from '../ShareButton';
import FBComment from '../FBComment';
import PopitHeader from "../PopitHeader";
import PopitMobileHeader from "../PopitMobileHeader";
import PopitMobileSider from "../PopitMobileSider";
import PopitFooter from "../PopitFooter";
import AuthorCard from '../AuthorCard';
import GoogleAd from '../GoogleAd';
import DableWidget from '../DableWidget';
import AuthorPostsWidget from '../list/AuthorPostsWidget';
import NoticeModal from './NoticeModal';
import {
PostElement, EmbeddedElement, ParagraphElement,
CaptionImageElement, SourceCodeElement, ItemsElement, BlockQuoteElement } from './PostElement';
import '../popit.css';
import {PUBLIC_PATH} from "../../routes";
const { Content, Footer } = Layout;
export default class SinglePostPage extends React.Component {
constructor(props) {
super(props);
let post;
if (process.env.BROWSER) {
if (window.__INITIAL_DATA__) {
post = window.__INITIAL_DATA__.data;
}
delete window.__INITIAL_DATA__;
} else {
post = this.props.staticContext.data.data;
}
this.state = {
post: post,
googleAds: null,
showNotice: false,
noticePostId: "",
noticeDesc: "",
};
this.page = 0;
this.getPostByPermalink = this.getPostByPermalink.bind(this);
this.getGoogleAd = this.getGoogleAd.bind(this);
this.getSitePreference = this.getSitePreference.bind(this);
}
componentDidMount () {
if (!this.state.post) {
this.getPostByPermalink(this.props.match.params.permalink);
}
this.getGoogleAd();
this.getSitePreference();
}
getGoogleAd() {
if (!this.state.googleAds) {
PostApi.getGoogleAds('post.desktop')
.then(json => {
if (json.success !== true) {
console.log("Google Ad Error:" + json.message);
return;
}
this.setState({
googleAds: json.data,
});
})
.catch(error => {
console.log("Google Ad Error:" + error);
});
}
}
getSitePreference() {
PostApi.getSitePreference('notice.post')
.then(json => {
if (json.success !== true) {
alert("Error:" + json.message);
return;
}
if (json.data) {
const postId = json.data.value.split(",")[0];
const description = json.data.value.substr(postId.length + 1).trim();
if (postId == this.state.post.id) {
return;
}
setTimeout(() => {
this.setState({
showNotice: true,
noticePostId: postId,
noticeDesc: description,
})
}, 5000);
}
})
.catch(error => {
alert("Error:" + error);
});
}
getPostByPermalink(permalink) {
PostApi.getPostByPermalink(permalink)
.then(json => {
if (json.success !== true) {
alert("Error:" + json.message);
return;
}
this.setState({
post: json.data,
});
})
.catch(error => {
alert("Error:" + error);
});
};
render() {
const { post, googleAds } = this.state;
if (!post) {
return (<div style={{textAlign: 'center', marginTop: 20}}>Loading...</div>);
}
const ads = [];
if (googleAds) {
if (googleAds["ad.post.desktop.top"]) ads.push(
(<GoogleAd googleAd={googleAds["ad.post.desktop.top"].value} key={'ad_google_top'}></GoogleAd>)
);
if (googleAds["ad.post.desktop.middle"]) ads.push(
(<GoogleAd googleAd={googleAds["ad.post.desktop.middle"].value} key={'ad_google_middle'}></GoogleAd>)
);
if (googleAds["ad.post.desktop.bottom"]) ads.push(
(<GoogleAd googleAd={googleAds["ad.post.desktop.bottom"].value} key={'ad_google_bottom'}></GoogleAd>)
);
} else {
ads.push((<div key={'ad_google_top'}></div>));
ads.push((<div key={'ad_google_middle'}></div>));
ads.push((<div key={'ad_google_bottom'}></div>));
}
const categories = post.categories.map((category, index) => {
const delimiter = index === 0 ? "" : ",";
return (<span key={"categories-" + index}>{delimiter} <Link to={`${PUBLIC_PATH}/category/${category.slug}`}>{category.name}</Link></span>)
});
const tags = post.tags.map((tag, index) => {
if (index > 2) {
return null;
}
const delimiter = index === 0 ? "" : ",";
return (<span key={"tags-" + index}>{delimiter} <Link to={`${PUBLIC_PATH}/tag/${tag.slug}`}>{tag.name}</Link></span>)
});
const tagSeparator = tags.length > 0 ? " | " : "";
const sentences = post.content.split("\n");
let postElement = null;
let postElements = [];
let verbose = false;
for (let i = 0; i < sentences.length; i++) {
let eachSentence = "";
try {
eachSentence = decodeURIComponent(sentences[i]);
} catch(e) {
eachSentence = sentences[i];
}
eachSentence = eachSentence.replace('\n', '').replace('\r', '');
if (eachSentence.toString().trim().length == 0 || eachSentence === ' ') {
continue;
}
if (postElement == null) {
postElement = PostElement.newPostElement(eachSentence);
} else {
if (postElement.needNextLine()) {
postElement.addNextLine(eachSentence);
}
}
if (postElement.isFinished()) {
postElements.push(postElement);
postElement = null;
}
}
if (postElement != null) {
postElements.push(postElement);
}
let middleAdIndex = Math.floor(postElements.length / 2);
let componentIndex = 0;
let postHtml = "";
if (this.props.isMobile) {
postElements.forEach((element, index) => {
const elementHtml = element.getHtmlString();
if (elementHtml) {
postHtml += "\n" + elementHtml;
componentIndex++;
}
if (index == 1) {
postHtml += "\n" + renderToString((<DableWidget widgetId="1XDOg2le"/>));
} else if (index == middleAdIndex) {
postHtml += "\n" + renderToString((<DableWidget widgetId="wXQ42RlA"/>));
}
});
} else {
postElements.forEach((element, index) => {
const elementHtml = element.getHtmlString();
if (elementHtml) {
postHtml += "\n" + elementHtml;
componentIndex++;
}
if (index == 2) {
postHtml += "\n" + renderToString((<DableWidget widgetId="1XDOg2le"/>));
}
});
}
const postUrl = `https://www.popit.kr/${post.postName}/`;
const fbPluginUrl = PostApi.getFacebookShareLink(post);
let shareButton = (<div></div>);
if (process.env.BROWSER && post.postName) {
shareButton = (<ShareButton url={postUrl} title={post.title} fbLikeUrl={fbPluginUrl} />)
}
if (this.props.isMobile) {
return (
<Layout className="layout" style={{background: '#ffffff'}}>
<PopitMobileSider/>
<Layout>
<PopitMobileHeader/>
<Content style={{ padding: '10px', marginTop: 94}}>
<div style={{padding: "10px", background: '#ffffff', borderRadius: 10}}>
<div className="list-post">
<div className="post-inner">
<div className="post-content" itemProp="articleBody">
<div><h1>{decodeHtml(post.title)}</h1></div>
{ ads[0] }
<div>
<div style={{display: 'none'}}>{post.id}</div>
<AuthorCard author={post.author} postDate={post.date}/>
<div className="post_tag">{categories}{tagSeparator}{tags}</div>
<div style={{marginTop: 10}}>
{ shareButton }
</div>
</div>
<div style={{marginTop:10}} className="entry-content">
<div dangerouslySetInnerHTML={{ __html: postHtml }} />
</div>
{ ads[1] }
<DableWidget widgetId='370W3Kox'/>
<div style={{marginTop:20, textAlign: 'center'}} >
<div className="fb-page"
data-href="https://www.facebook.com/popitkr"
data-width="300"
data-height="80"
small_header="true"
data-hide-cover="false"
adapt_container_width="false"
data-show-facepile="false"
/>
</div>
<div style={{marginTop:30}} >
<hr/>
<FBComment fbPluginUrl={fbPluginUrl}/>
{ ads[2] }
<div style={{marginTop:10, fontSize: 12, lineHeight: '18px', fontStyle: 'italic', color: '#C3C3C3'}}>
Popit은 페이스북 댓글만 사용하고 있습니다. 페이스북 로그인 후 글을 보시면 댓글이 나타납니다.
</div>
</div>
</div>
</div>
</div>
</div>
</Content>
<PopitFooter/>
</Layout>
</Layout>
);
}
return (
<Layout className="layout" hasSider={false} style={{background: '#ffffff'}}>
<PopitHeader/>
<Content style={{padding: '20px 10px', maxWidth: 1360, margin: '74px auto auto auto'}}>
<div style={{width: 800, float: 'left'}}>
<div className="post-content" itemProp="articleBody">
<div><h1>{decodeHtml(post.title)}</h1></div>
<div>
<div>
<div style={{display: 'none'}}>{post.id}</div>
<AuthorCard author={post.author} postDate={post.date}/>
<div className="post_tag">{categories}{tagSeparator}{tags}</div>
<div style={{marginTop: 10}}>
{ shareButton }
</div>
</div>
</div>
{ ads[0] }
<div style={{marginTop:10}} className="entry-content">
<div dangerouslySetInnerHTML={{ __html: postHtml }} />
{ ads[2] }
</div>
<DableWidget widgetId="wXQ42RlA"/>
<div style={{marginTop:30}} >
<hr/>
<FBComment fbPluginUrl={fbPluginUrl}/>
<div style={{marginTop: 10, fontSize: 12, fontStyle: 'italic', color: '#C3C3C3'}}>
Popit은 페이스북 댓글만 사용하고 있습니다. 페이스북 로그인 후 글을 보시면 댓글이 나타납니다.
</div>
</div>
</div>
</div>
<div style={{ width: 310, marginLeft: 20, float: 'left'}}>
<div style={{marginTop: 10}}>
<div className="fb-page"
data-href="https://www.facebook.com/popitkr"
data-width="300"
data-height="200"
small_header="true"
data-hide-cover="false"
adapt_container_width="false"
data-show-facepile="true"
/>
</div>
<div style={{marginTop: 20}}>
<AuthorPostsWidget author={post.author} except={post.id}/>
</div>
<div style={{width: 300, height: 300}}>
{ ads[1] }
</div>
<div style={{marginTop: 20}}>
<DableWidget widgetId="goPgAyXQ"/>
</div>
</div>
<div style={{clear: 'both'}}/>
</Content>
<PopitFooter/>
<NoticeModal visible={this.state.showNotice} noticePostId={this.state.noticePostId} noticeDesc={this.state.noticeDesc}/>
</Layout>
)
}
}
|
var class_label_face_camera_on_y_axis =
[
[ "labelGO", "class_label_face_camera_on_y_axis.html#af50f5c5422c9057e75cee8f5917d9d83", null ]
];
|
import React from "react";
import "./ExpandedImage.css";
const ExpandedImage = ({ title, image, setImage }) => {
return (
<div className={"expanded-image"}>
<div className={"black-bar expanded-image-header"}>
<span
data-testid={"expanded-image-title"}
className={"expanded-image-title"}
>
{title}
</span>
<button
data-testid={"expanded-close-btn"}
onClick={() => setImage("")}
className={"expanded-close-button"}
>
Close
</button>
</div>
<img src={`${image}_27.jpg`} alt="" />
<div className={"black-bar expanded-image-footer"}></div>
</div>
);
};
export default ExpandedImage;
|
function initDoomWadThing(context) {
/**
* Constructor
*/
var Thing = context.DoomWad.Thing = function(info, thingInfo) {
var self = this;
self._engine = info.engine();
if (self._engine == "Hexen") {
self._size = 20;
}
else {
self._size = 10;
}
self._x = thingInfo['x'];
self._y = thingInfo['y'];
self._angle = thingInfo['angle'];
self._flags = thingInfo['flags'];
self._type = thingInfo['type'];
};
Thing.prototype.size = function() {
return this._size;
};
Thing.prototype.angle = function() {
return this._angle;
};
Thing.prototype.x = function() {
return this._x;
};
Thing.prototype.y = function() {
return this._y;
};
Thing.prototype.flags = function() {
return this._flags;
};
Thing.prototype.appearsOnEasy = function() {
return (this._flags & 0x1) > 0;
};
Thing.prototype.appearsOnMedium = function() {
return (this._flags & 0x2) > 0;
};
Thing.prototype.appearsOnHard = function() {
return (this._flags & 0x4) > 0;
};
Thing.prototype.isDeafGuard = function() {
return (this._flags & 0x8) > 0;
};
Thing.prototype.appearsInMultiplayer = function() {
return (this._flags & 0x10) > 0;
};
Thing.prototype.isHexenDormant = function() {
return (this._flags & 0x10) > 0;
};
Thing.prototype.appearsForHexenFighter = function() {
return (this._flags & 0x20) > 0;
};
Thing.prototype.appearsForHexenCleric = function() {
return (this._flags & 0x40) > 0;
};
Thing.prototype.appearsForHexenMage = function() {
return (this._flags & 0x80) > 0;
};
Thing.prototype.appearsForHexenSinglePlayer = function() {
return (this._flags & 0x100) > 0;
};
Thing.prototype.appearsForHexenCoOp = function() {
return (this._flags & 0x200) > 0;
};
Thing.prototype.appearsForHexenDeathmatch = function() {
return (this._flags & 0x400) > 0;
};
Thing.prototype._thingCollection = function() {
if (this._engine === "DOOM" || this._engine === "DOOM2") {
return context.DoomWad.Things.Doom;
}
return {};
};
Thing.prototype.info = function() {
return this._thingCollection()[this._type];
};
Thing.prototype.name = function() {
var info = this.info();
if (info) {
return this.info()['name'];
}
else {
return "unknown";
}
};
Thing.prototype.toString = function() {
return "";
};
}
|
const xmlns = "http://www.w3.org/2000/svg";
const outlineSVGAttributes = {
fill: "none",
viewBox: "0 0 24 24",
stroke: "currentColor",
};
const outlinePathAttributes = {
"stroke-linecap": "round",
"stroke-linejoin": "round",
"stroke-width": "2",
};
const solidSVGAttributes = {
fill: "currentColor",
viewBox: "0 0 20 20",
};
const solidPathAttributes = {
"clip-rule": "evenodd",
"fill-rule": "evenodd",
};
const createIcon = (type, d) => {
const iconSVG = document.createElementNS(xmlns, "svg");
const iconPath = document.createElementNS(xmlns, "path");
switch (type) {
case "outline":
for (let key in outlineSVGAttributes) {
iconSVG.setAttributeNS(null, key, outlineSVGAttributes[key]);
}
for (let key in outlinePathAttributes) {
iconPath.setAttributeNS(null, key, outlinePathAttributes[key]);
}
break;
case "solid":
for (let key in solidSVGAttributes) {
iconSVG.setAttributeNS(null, key, solidSVGAttributes[key]);
}
for (let key in solidPathAttributes) {
iconPath.setAttributeNS(null, key, solidPathAttributes[key]);
}
break;
default:
break;
}
iconPath.setAttributeNS(null, "d", d);
iconSVG.append(iconPath);
return iconSVG;
};
export default createIcon;
|
ko.bindingHandlers.semanticDropdown = {
init: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
var data = valueAccessor();
if (!data) {
data = {};
}
data['clearble'] = true;
data['placeholder'] = 'Choose...';
$(element).dropdown(data);
},
update: function (element, valueAccessor, allBindings, viewModel, bindingContext) {
}
};
|
/**
* Copyright (c) 2013 Oculus Info Inc.
* http://www.oculusinfo.com/
*
* Released under the MIT License.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
define(['jquery', './util/ui_util', './util/rest'], function($, ui_util, rest) {
var getAttributeDistribution = function(baseUrl, datasetName, attributeName, callback){
rest.get(baseUrl + 'rest/data/distribution/'+datasetName+'/'+attributeName, 'Get distribution', callback)
};
var fetchDBInfo = function(baseURL, callback) {
rest.get(baseURL + "rest/data/clusterSets", 'Get initial DB info', callback);
};
var createAttributeRow = function(widget, baseUrl) {
var datasetName = widget.datasetDropdown.val();
var columns = widget.datasetToColumnNames[datasetName];
var rowObject = {};
rowObject.attributeDiv = document.createElement('div');
rowObject.chartDiv = document.createElement('div');
$(rowObject.chartDiv).css({width:600,height:100});
rowObject.chartDiv.id = ui_util.uuid();
rowObject.dropdown = ui_util.createDropdown(columns, 200, function() {
$(rowObject.chartDiv).empty();
if (rowObject.dropdown.value=='NONE') {
return;
}
var datasetName = widget.datasetDropdown.val();
getAttributeDistribution(baseUrl, datasetName, rowObject.dropdown.value, function(data) {
updateRowChart(rowObject, data);
});
});
rowObject.attributeDiv.appendChild(document.createTextNode('Attribute:'));
rowObject.attributeDiv.appendChild(rowObject.dropdown);
var removeButton = document.createElement("button");
removeButton.innerHTML = 'x';
$(removeButton).click(function() {
widget.attributeArea.removeChild(rowObject.attributeDiv);
widget.attributeRows.remove(rowObject);
}).css({position:'absolute',left:'580px'});
rowObject.attributeDiv.appendChild(removeButton);
rowObject.attributeDiv.appendChild(rowObject.chartDiv);
rowObject.textNode = document.createElement('div');
rowObject.attributeDiv.appendChild(rowObject.textNode);
widget.attributeArea.appendChild(rowObject.attributeDiv);
return rowObject;
};
var updateAttributeRows = function(widget, datasetName) {
var columns = widget.datasetToColumnNames[datasetName];
for (var i=0; i<widget.attributeRows.length; i++) {
var rowObject = widget.attributeRows[i];
ui_util.setDropdownOptions(rowObject.dropdown, columns);
}
};
var updateRowChart = function(rowObject, data) {
rowObject.chart = new aperture.chart.Chart(rowObject.chartDiv.id);
rowObject.chart.map('width').asValue(600);
rowObject.chart.map('height').asValue(100);
var rangeX = new aperture.Scalar('Cluster Size');
var rangeY = new aperture.Scalar('Number of Clusters');
var maxSize = 0;
var clusterCount = 0;
for (var i = 0; i < data.distribution.length; i++) {
var xVal = data.distribution[i].size;
var yVal = data.distribution[i].clusters;
if (xVal>maxSize) maxSize = xVal;
clusterCount += yVal;
rangeX.expand(xVal);
rangeY.expand(yVal);
}
rangeY.expand(0);
rowObject.textNode.innerHTML = 'Largest Cluster: ' + maxSize + ' Total Clusters: ' + clusterCount;
var bandedX = rangeX.banded(10);
var bandedY = rangeY.banded(4);
var xMapping = bandedX.mapKey([0,1]), yMapping = bandedY.mapKey([1,0]);
rowObject.chart.map('x').using(xMapping);
rowObject.chart.map('y').using(yMapping);
rowObject.chart.all(data);
createAxes(rowObject.chart);
var dotLayer = rowObject.chart.addLayer( aperture.RadialLayer );
dotLayer.all(data.distribution);
dotLayer.map('x').from('size');
dotLayer.map('y').from('clusters');
dotLayer.map('stroke-width').asValue(1);
dotLayer.map('stroke').asValue('#000');
dotLayer.map('fill').asValue('#F00');
dotLayer.map('radius').asValue(3);
rowObject.chart.all().redraw();
};
var createAxes = function(chart){
var xAxisLayer = chart.xAxis(0);
xAxisLayer.map('margin').asValue(40);
xAxisLayer.map('title').asValue('Cluster Size');
xAxisLayer.map('font-size').asValue(10); // Set the font size of the axes text.
var yAxisLayer = chart.yAxis(0);
yAxisLayer.map('title').asValue('Cluster Count');
yAxisLayer.map('margin').asValue(50);
yAxisLayer.map('font-size').asValue(10); // Set the font size of the axes text.
yAxisLayer.map('label-offset-x').asValue(2);
};
var createWidget = function(container, baseUrl) {
var chartWidget = {
attributeRows: [],
datasetDropdown: null,
attributeArea: null,
datasetToColumnNames: {},
init: function() {
var datasetLabel = document.createTextNode("Dataset Name:");
container.appendChild(datasetLabel);
this.datasetDropdown = $('<select/>');
this.datasetDropdown.change(function(event) {
var datasetName = $(event.currentTarget).val();
updateAttributeRows(that, datasetName);
});
container.appendChild(this.datasetDropdown.get(0));
var linkButton = document.createElement("button");
linkButton.innerHTML = 'links';
$(linkButton).click(function() {
window.location.assign(baseUrl + '#link');
window.location.reload(true);
});
container.appendChild(linkButton);
var searchButton = document.createElement("button");
searchButton.innerHTML = 'search';
$(searchButton).click(function() {
window.location.assign(baseUrl + '#subset');
window.location.reload(true);
});
container.appendChild(searchButton);
this.attributeArea = document.createElement('div');
container.appendChild(this.attributeArea);
var that = this;
var addButton = document.createElement("button");
addButton.innerHTML = '+';
$(addButton).click(function() {
that.createAttributeRow();
});
container.appendChild(addButton);
fetchDBInfo(baseUrl, function(response) {
that.datasetDropdown.empty();
for (var i=0; i < response.tableToColumns.length; i++) {
tableName = response.tableToColumns[i].string;
that.datasetToColumnNames[tableName] = response.tableToColumns[i].list;
var option = $('<option/>');
option.attr('value',tableName);
option.html(tableName);
that.datasetDropdown.append(option);
}
updateAttributeRows(that, that.datasetDropdown.val());
});
},
createAttributeRow: function() {
var rowObject = createAttributeRow(this, baseUrl);
this.attributeRows.push(rowObject);
},
resize: function(width,height) {
}
};
chartWidget.init();
return chartWidget;
};
return {
createWidget:createWidget
}
});
|
'use strict';
const math = require('mathjs');
const pkg = require('../package.json');
const request = require('request');
const whilst = require('async/whilst');
const Commerce = require('./commerce').Commerce;
const logger = require('./logging').logger;
const getTokenFromBody = (body) => {
const tokenRegex = /^TOKEN=([0-9A-Fa-f]+)/;
const errorRegex = /^ERROR=([\d\w]+)/;
let token, error;
for (let line of body.trim().split('\n')) {
if (tokenRegex.test(line)) {
token = tokenRegex.exec(line)[1];
} else if (errorRegex.test(line)) {
error = errorRegex.exec(line)[0];
}
}
if (error !== '0') throw new Error(`Payment token generation failed. ERROR=${error}`);
return token;
};
const cleanAmount = (amount) => {
math.round(parseFloat(amount), 2);
};
class Payment {
constructor(requestIp, amount, orderId, successUrl, confirmationUrl, sessionId=null, failureUrl=null, commerce=null) {
this._token = null;
this._params = null;
this._transaction_id = null;
this.commerce = commerce || Commerce.create_commerce();
this.requestIp = requestIp;
this.amount = cleanAmount(amount);
this.orderId = orderId;
this.successUrl = successUrl;
this.confirmationUrl = confirmationUrl;
this.sessionId = sessionId;
this.failureUrl = failureUrl || successUrl;
}
// @property
redirectUrl() {
return `${this.get_process_url()}?TBK_VERSION_KCC=${pkg.tbkVersionKcc}&TBK_TOKEN=${this.token}`;
}
// @property
token() {
if (!this._token) {
this._token = this.fetchToken();
logger.payment();
}
return this._token;
}
fetchToken(cb) {
let validationUrl = this.getValidationUrl();
let isRedirect = true;
const requestOptions = {
url: validationUrl,
form: {
TBK_VERSION_KCC: pkg.tbkVersionKcc,
TBK_CODIGO_COMERCIO: this.commerce.id,
TBK_KEY_ID: this.commerce.webpayKeyId,
TBK_PARAM: this.params
},
headers: {
'User-Agent': `TBK/${pkg.tbkVersionKcc} (NodeTbk/${pkg.version})`
},
followRedirect: false,
encoding: null
};
whilst(
() => isRedirect,
(callback) => {
request.post(requestOptions, (err, response, body) => {
if (err) return callback(err);
isRedirect = response.statusCode >= 300 && response.statusCode < 400;
validationUrl = response.headers.location;
callback(null, response.statusCode, body);
});
},
(err, statusCode, body) => {
if (err) return cb(err);
if (statusCode !== 200) return cb(new Error('Payment token generation failed'));
let _body;
try {
const dataDecrypted = this.commerce.webpayDecrypt(body);
_body = dataDecrypted.body;
} catch (err) {
if (getTokenFromBody(body)) cb(new Error(`Suspicious message from server: ${body.toString()}`));
}
cb(null, getTokenFromBody(_body));
}
);
}
}
module.exports = {
getTokenFromBody: getTokenFromBody,
cleanAmount: cleanAmount,
Payment: Payment
};
|
const List = require('../models/list');
//
// Create
//
module.exports.create = async (req, res) => {
const list = req.body;
const listCreated = new List({
name: list.name,
user_id: list.userId
});
listCreated.save(function (err) {
if (err) return console.log(err);
// saved!
})
return res.status(200).send(listCreated);
}
//
// List
//
module.exports.list = (req, res) => {
const page = (req.query.page && parseInt(req.query.page) > 0) ? parseInt(req.query.page) : 1
const sort = (req.query.sort) ? { [req.query.sort]: 1 } : {}
let size = 10
if (req.query.size
&& parseInt(req.query.size) > 0
&& parseInt(req.query.size) < 500) {
size = parseInt(req.query.size)
}
const skip = (size*(page-1) > 0) ? size*(page-1) : 0
let response = {
todos: [],
page: page,
size: size,
sort: req.params.sort,
total: 0
}
if (req.params.sort) response.sort = req.params.sort
List
.find()
.skip(skip)
.sort(sort)
.limit(size)
.then(function(todos) {
return res.status(200).send(todos);
});
}
//
// Find One
//
module.exports.findOne = (req, res) => {
List.findById(req.query.list_id, (err, response) => {
if (err) return reject(err)
return res.status(200).send(response);
})
}
//
// Update
//
module.exports.update = (req, res) => {
const list = req.body;
List.updateOne(list, (err, response) => {
if (err) return reject(err)
// Mongo Client automatically adds an id to an inserted object, but
// if using a work-a-like we may need to add it from the response.
if (!list._id && response._id) list._id = response._id
return res.status(200).send(list);
})
}
//
// Delete
//
module.exports.delete = (req, res) => {
const list = req.body;
// List.updateOne(list, (err, response) => {
// if (err) return reject(err)
// // Mongo Client automatically adds an id to an inserted object, but
// // if using a work-a-like we may need to add it from the response.
// if (!list._id && response._id) list._id = response._id
// return res.status(200).send(list);
// // return resolve(list)
// })
}
|
import classNames from "classnames";
import React from "react";
const Language = ({item, className }) => {
const { title, point } = item;
return (
<div className="mb-3">
<span>{title}</span>
<div className="my-1">
<div className="progress">
<div
className={classNames("progress-bar", className)}
role="progressbar"
style={{ width: `${point}%` }}
ariaValueNow={point}
ariaValueMin="0"
ariaValueMax="100"
/>
</div>
</div>
</div>
);
};
export default Language;
|
function doDeviceIdentification(event, callback) {
var identifiedDeviceEvent = {
brand: "google",
model: "chrome"
};
callback(null, identifiedDeviceEvent);
}
module.exports = doDeviceIdentification;
|
$(document).ready(function(){
$(".titleError").hide();
$(".descError").hide();
var newRows = 0;
/*
// Functionality for the "Show More/Less" button
$(".hid").hide();
$("#showToggle").click(function(){
if($(".hid").is(":hidden")) {
$(".hid").show();
$(this).html('<button type="button" class="btn btn-default"><span class="glyphicon glyphicon-chevron-up" aria-hidden="true"> Show Less</span></button>');
}
else {
$(".hid").hide();
$(this).html('<button type="button" class="btn btn-default"><span class="glyphicon glyphicon-chevron-down" aria-hidden="true"> Show More</span></button>');
}
});
*/
// Voting system - restricted to one vote per user
// Upvotes
$(".glyphicon-plus").click(function(){
var td = $(this).parent();
var thisCount = td.find('#count');
var text = thisCount.text();
if($(td).hasClass("upvoted")) {
var number = parseInt(text, 10) - 1;
thisCount.html(number);
$(this).css("background-color", "#BDBDBD");
}
else if($(td).hasClass("downvoted")) {
var number = parseInt(text, 10) + 2;
thisCount.html(number);
$(td).toggleClass("downvoted");
$(this).css("background-color", "#009647");
var downvote = td.find('.glyphicon-minus');
$(downvote).css("background-color", "#BDBDBD");
}
else {
var number = parseInt(text, 10) + 1;
thisCount.html(number);
$(this).css("background-color", "#009647");
}
$(td).effect("highlight", {}, 500);
$(td).toggleClass("upvoted");
sortIdeas()
});
// Downvotes
$(".glyphicon-minus").click(function(){
var td = $(this).parent();
var thisCount = td.find('#count');
var text = thisCount.text();
if($(td).hasClass("downvoted")) {
var number = parseInt(text, 10) + 1;
thisCount.html(number);
$(this).css("background-color", "#BDBDBD");
}
else if($(td).hasClass("upvoted")) {
var number = parseInt(text, 10) - 2;
thisCount.html(number);
$(td).toggleClass("upvoted");
$(this).css("background-color", "#f43535");
var upvote = td.find('.glyphicon-plus');
$(upvote).css("background-color", "#BDBDBD");
}
else {
var number = parseInt(text, 10) - 1;
thisCount.html(number);
$(this).css("background-color", "#f43535");
}
$(td).effect("highlight", {}, 500);
$(td).toggleClass("downvoted");
sortIdeas()
});
// Add a row to the table with a new idea
$("#addIdea").click(function(){
var title = document.getElementById('titleBox').value;
var description = document.getElementById('descriptionBox').value;
if(title === "")
$(".titleError").show();
if(description === "")
$(".descError").show();
if(title != "" && description != "") {
$(".titleError").hide();
$(".descError").hide();
$('#addIdeaModal').modal('hide');
var table = document.getElementById("ideasTable");
var row = table.insertRow();
var cell1 = row.insertCell(0);
var cell2 = row.insertCell(1);
var cell3 = row.insertCell(2);
var cell4 = row.insertCell(3);
var cell5 = row.insertCell(4);
var cell6 = row.insertCell(5);
var d = new Date();
cell1.innerHTML = '<button class="glyphicon glyphicon-minus btn-xs" aria-hidden="true"></button><span id="count"> 0 </span><button class="glyphicon glyphicon-plus btn-xs" aria-hidden="true"></button>';
$(cell1).toggleClass("vote");
cell2.innerHTML = title;
cell3.innerHTML = 'You';
cell4.innerHTML = d.toDateString();
cell5.innerHTML = '<div class=scrollable>' + description + '</div>';
var editButton = document.createElement("input");
editButton.type = "button";
editButton.className = "glyphicon glyphicon-pencil btn-sm"
var delButton = document.createElement("input");
delButton.type = "button";
delButton.className = "glyphicon glyphicon-remove btn-sm"
var click="location.href='./tab.html?event=" + title + "'";
cell6.innerHTML = '<button class="glyphicon glyphicon-pencil btn-sm" aria-hidden="true" id="newEdit' + newRows + '"></button>' +
'<button class="glyphicon glyphicon-remove btn-sm" aria-hidden="true" id="newRem' + newRows + '"></button>' +
'<button class="btn btn-success" OnClick="'+ click +'">Make It</button>';
var removeB = document.getElementById('newRem' + newRows);
removeB.addEventListener("click", function(){removeIdea(removeB);}, false);
var editB = document.getElementById('newEdit' + newRows);
editB.addEventListener("click", function(){editIdea(editB);}, false);
document.getElementById('titleBox').value = '';
document.getElementById('descriptionBox').value = '';
$(row).effect("highlight", {}, 3000);
newRows += 1;
}
});
// Delete an idea from the table
$(".glyphicon-remove").click(function() {
removeIdea(this);
});
// Edit an idea on the table
$(".glyphicon-pencil").click(function() {
editIdea(this);
});
var delRow;
function removeIdea(target) {
delRow = $(target).parent().parent();
$('#deleteIdeaModal').modal('show'); // launch confimation modal
$("#deleteIdea").click(function() {
delRow.css("background-color","#FF3700");
delRow.fadeOut(400, function(){
delRow.remove();
});
});
}
var editRow;
var c1;
var c4;
function editIdea(target) {
editRow = $(target).parent().parent();
$('#editIdeaModal').modal('show'); // launch modal
c1 = editRow[0].cells[1];
c4 = editRow[0].cells[4];
document.getElementById('editTitleBox').value = c1.innerHTML;
var cellHtml = c4.innerHTML;
document.getElementById('editDescriptionBox').value = cellHtml.replace(/<[^>]*>/g, "");
$(editRow).effect("highlight", {}, 1000);
$("#editIdea").click(function() {
var eTitle = document.getElementById('editTitleBox').value;
var eDesc = document.getElementById('editDescriptionBox').value;
if(eTitle === "")
$(".titleError").show();
if(eDesc === "")
$(".descError").show();
if(eTitle != "" && eDesc != "") {
$(".titleError").hide();
$(".descError").hide();
$('#editIdeaModal').modal('hide');
c1.innerHTML = eTitle;
c4.innerHTML = '<div class=scrollable>' + eDesc + '</div>';
}
});
}
// Hide error messages upon closing the modal
$(".closeModal").click(function() {
$(".titleError").hide();
$(".descError").hide();
});
// Searching functionality
$("#searchBox").keyup(function() {
var userInput = $(this).val().toLowerCase();
$("#ideasTable td").map(function(index, value) {
if($(value).text().toLowerCase().indexOf(userInput) >= 0)
$(value).css("background-color", "yellow");
else
$(value).css("background-color", "white");
if(userInput === "")
$(value).css("background-color", "white");
});
});
// Sort ideas by popularity
function sortIdeas() {
var tableData = document.getElementById("ideasTable").getElementsByTagName('tbody').item(0);
// Read table row nodes
var rowData = tableData.getElementsByTagName('tr');
for(var i = 0; i < rowData.length - 1; i++){
for(var j = 0; j < rowData.length - (i + 1); j++) {
var td1 = $(rowData.item(j).getElementsByTagName('td').item(0));
var td2 = $(rowData.item(j+1).getElementsByTagName('td').item(0));
if(parseInt(td1.find('#count').text()) < parseInt(td2.find('#count').text()))
tableData.insertBefore(rowData.item(j+1),rowData.item(j));
}
}
}
});
|
import React from "react";
import { Paper, LinearProgress, Avatar, Grid } from "@material-ui/core";
import design from "../../assets/Icons/dashboardIcon/design.svg";
import person from "../../assets/Icons/dashboardIcon/person.svg";
import date from "../../assets/Icons/dashboardIcon/date.svg";
import task from "../../assets/Icons/dashboardIcon/task.svg";
function ProjectCard({ title, freelancer, process, endDate, status }) {
if(title.length >= 30 ){
var cardTitle = title.substring(0, 23)+"...";
}else{
cardTitle = title
}
const dateended = endDate.substring(0, 10);
return (
<Grid container direction="row" xs={3}>
<Paper className=" card-dashboard">
<Avatar src={design} className="pink"></Avatar>
<h4>{cardTitle}</h4>
<div className="mainAvatarBox">
<img src={person} alt="person" />
<span>فریلنسر: </span>
<span>{freelancer}</span>
</div>
<div className="progresDeatails">
<span>میزان پیشرفت</span>
<span>{process}%</span>
</div>
<div className="progresBar">
<LinearProgress color="secondary" variant="buffer" value={process} />
</div>
<div className="progresDeatails">
<div className="mainAvatarBox">
<img src={date} alt="date" />
<span>تاریخ پایان</span>
</div>
<div className="mainAvatarBox">
<img src={task} alt="task" />
<span>وضعیت پروژه </span>
</div>
</div>
<div className="date-Condition">
<span className="date">{dateended}</span>
<span
className={`Condition ${
status === 2
? "inProcess"
: status === 1
? "Pending"
: status === 3
? "Finished"
: null
}`}
>
{status === 1
? "درحال بررسی"
: status === 2
? "درحال اجرا"
: status === 3
? "پایان یافته"
: null}
</span>
</div>
</Paper>
</Grid>
);
}
export default ProjectCard;
|
define('LobbyClientListener', [
'createjs',
'Lobby'
], function(createjs, Lobby) {
var Listener = function() {};
createjs.EventDispatcher.initialize(Listener.prototype);
Listener.prototype.initialize = function (callback) {
Lobby.prototype.addEventListener('lobby.enter', function(event) {
callback('lobby', event);
});
Lobby.prototype.addEventListener('lobby.create', function(event) {
callback('lobby', event);
});
Lobby.prototype.addEventListener('lobby.join', function(event) {
callback('lobby', event);
});
Lobby.prototype.addEventListener('lobby.leave', function(event) {
callback('lobby', event);
});
};
return Listener;
});
|
import React, { Fragment } from 'react';
import { Form } from 'react-bootstrap';
function MainHeader() {
return(
<Fragment>
<div className="blog_main_header">
<div className="blog_tranding_slider">
<div className="swiper-container">
<div className="swiper-wrapper">
<div className="swiper-slide">
<p><span><i></i></span> Parquet Courts on Resisting Nihilism & Why Tourism in Dubai is booming the world.</p>
</div>
<div className="swiper-slide">
<p><span><i></i></span> Parquet Courts on Resisting Nihilism & Why Tourism in Dubai.</p>
</div>
</div>
{/* <!-- Add Arrows --> */}
<div className="swiper-button-next"><svg xmlns="http://www.w3.org/2000/svg" width="10px" height="6px"><path fill-rule="evenodd" fill="#707070" d="M5.390,5.837 L9.840,1.292 C9.943,1.187 10.000,1.046 10.000,0.897 C10.000,0.747 9.943,0.607 9.840,0.502 L9.513,0.167 C9.299,-0.051 8.952,-0.051 8.739,0.167 L5.002,3.983 L1.261,0.163 C1.158,0.057 1.021,-0.000 0.874,-0.000 C0.728,-0.000 0.590,0.057 0.487,0.163 L0.160,0.497 C0.057,0.603 -0.000,0.743 -0.000,0.893 C-0.000,1.042 0.057,1.182 0.160,1.287 L4.614,5.837 C4.717,5.942 4.855,6.000 5.002,5.999 C5.149,6.000 5.287,5.942 5.390,5.837 Z"/></svg></div>
<div className="swiper-button-prev"><svg xmlns="http://www.w3.org/2000/svg" width="10px" height="7px"><path fill-rule="evenodd" fill="#707070" d="M4.610,0.163 L0.160,4.708 C0.057,4.813 -0.000,4.953 -0.000,5.103 C-0.000,5.253 0.057,5.393 0.160,5.498 L0.487,5.833 C0.701,6.050 1.048,6.050 1.261,5.833 L4.998,2.016 L8.739,5.837 C8.842,5.942 8.979,6.000 9.126,6.000 C9.272,6.000 9.410,5.942 9.513,5.837 L9.840,5.502 C9.943,5.397 10.000,5.257 10.000,5.107 C10.000,4.958 9.943,4.817 9.840,4.712 L5.386,0.163 C5.283,0.058 5.145,-0.000 4.998,0.000 C4.851,-0.000 4.713,0.058 4.610,0.163 Z"/></svg></div>
</div>
</div>
<div className="blog_main_menu">
<div className="blog_main_menu_innerdiv">
<ul>
<li className="active"><a href="#">Home</a>
<ul className="sub-menu">
<li><a href="index.html">Home Page1</a></li>
<li><a href="index2.html">Home Page2</a></li>
</ul>
</li>
<li><a href="politics.html">Politics <span>new</span></a></li>
<li><a href="world.html">World</a></li>
<li><a href="technology.html">Tech</a></li>
<li><a href="sport.html">Sports <span>new</span></a></li>
<li><a href="lifestyle.html">lifestyle</a></li>
<li><a href="travel.html">Travel</a></li>
<li><a href="fashion.html">Fashion <span>new</span></a></li>
<li><a href="#">pages</a>
<ul className="sub-menu">
<li><a href="blog_single_fullwidth.html">Blog Single FullWidth</a></li>
<li><a href="blog_single_with_sidebar.html">Blog Single With Sidebar</a></li>
<li><a href="contactus.html">contact</a></li>
<li><a href="error.html">Error</a></li>
</ul>
</li>
</ul>
</div>
</div>
<div className="blog_top_search">
<ul>
<li className="blog_search">
<a href="javascript:;"><svg xmlns="http://www.w3.org/2000/svg" width="16px" height="16px"><path fill-rule="evenodd" fill="#000000" d="M15.750,14.573 L11.807,10.612 C12.821,9.449 13.376,7.984 13.376,6.459 C13.376,2.898 10.376,-0.000 6.687,-0.000 C2.999,-0.000 -0.002,2.898 -0.002,6.459 C-0.002,10.021 2.999,12.919 6.687,12.919 C8.072,12.919 9.391,12.516 10.520,11.750 L14.493,15.741 C14.659,15.907 14.882,15.999 15.121,15.999 C15.348,15.999 15.563,15.916 15.726,15.764 C16.073,15.442 16.084,14.908 15.750,14.573 ZM6.687,1.685 C9.414,1.685 11.631,3.827 11.631,6.459 C11.631,9.092 9.414,11.234 6.687,11.234 C3.961,11.234 1.743,9.092 1.743,6.459 C1.743,3.827 3.961,1.685 6.687,1.685 Z"/></svg></a>
<div className="blog_search_popup">
<a className="search_close"></a>
<Form.Group controlId="formBasicEmail">
<Form.Label>Email address</Form.Label>
<Form.Control type="email" placeholder="Enter email" />
<Form.Text className="text-muted">
We'll never share your email with anyone else.
</Form.Text>
</Form.Group>
{/* <Form className="form-inline">
<h3>Input Your Search Keywords And Press Enter</h3>
<div className="blog_form_group">
<input type="text" className="form-control" placeholder="Search Here...">
<button type="button" className="blog_header_search">Search</button>
</div>
</Form> */}
</div>
</li>
<li className="blog_righttoggle">
<a href="javascript:;"><svg xmlns="http://www.w3.org/2000/svg" width="13px" height="14px"><path fill-rule="evenodd" fill="rgb(0, 0, 0)" d="M0.001,10.115 L0.001,7.969 L13.000,7.969 L13.000,10.115 L0.001,10.115 ZM3.649,6.028 L3.649,3.881 L12.992,3.881 L12.992,6.028 L3.649,6.028 ZM0.001,-0.002 L13.000,-0.002 L13.000,2.145 L0.001,2.145 L0.001,-0.002 ZM12.992,13.998 L3.649,13.998 L3.649,11.853 L12.992,11.853 L12.992,13.998 Z"/></svg></a>
</li>
</ul>
</div>
</div>
</Fragment>
)
}
export default MainHeader;
|
window.addEventListener('load', function(){
var isPC = false;
var classname = document.body.className;
//ユーザーエージェント振り分けてclass追加
var ua = navigator.userAgent.toLowerCase();
if(ua.indexOf('iphone') != -1 || (ua.indexOf('android') != -1 && ua.indexOf('mobile') != -1)){ //iPhone, Android SPN
document.body.className = classname + " body_spn";
}else{ //PC,tab
isPC = true;
document.body.className = classname + " body_pc";
}
document.body.style.visibility = "visible";
//viewport書き換え
if(isPC){
var metalist = document.getElementsByTagName('meta');
for(var i = 0; i < metalist.length; i++) {
var name = metalist[i].getAttribute('name');
if(name && name.toLowerCase() === 'viewport') {
metalist[i].setAttribute('content', 'width=1050');
break;
}
}
}
}, false);
// language
window.addEventListener('load', function () {
// setting variable
var languageMenuButton = document.querySelector('.js-languagemenu');
var languageMenu = document.querySelector('.languagemenu');
var closeButton = document.querySelector('.languagemenu .modalBtnClose_sp');
var closeButtonSp = document.querySelector('.languagemenu .modalBtnClose');
var className = {
active: 'is-active'
};
var open = function () {
languageMenuButton.classList.add(className.active);
languageMenu.classList.add(className.active);
};
var close = function () {
languageMenuButton.classList.remove(className.active);
languageMenu.classList.remove(className.active);
};
// addEvent
languageMenuButton.addEventListener('click', function () {
if (new RegExp(className.active).test(languageMenuButton.className)) {
close();
}
else {
open();
}
}, false);
closeButton.addEventListener('click', function () {
close();
}, false);
closeButtonSp.addEventListener('click', function () {
close();
}, false);
}, false);
|
export const DB_URL = 'mongodb://localhost/pm102-lecture-9'
|
/**
*
*/
$(document).ready(function() {menu.getMenu(9); menu.getListBody();});
var font = "用户反馈";
var valids = ["标题", "内容", "状态", "最后修改时间", "最后修改人"];
var sizes = [100, 100, 100, 100, 100];
var contents = ["标题", "内容", "状态", "最后修改时间", "最后修改人"];
var keys = ["title", "content", "status", "last_update_time", "last_update_by"];
|
'use strict';
/**
* We create the object ball
* @type {Object}
*/
var Ball = function (radius, position) {
this.radius = radius;
this.position = position;
this.speed = 0.1;
this.changeRightY = false;
this.changeLeftY = false;
//Direction defines if we need to increment or decrement the move
this.direction = [2,2];
}
/**
* Renders the ball in the canvas
*/
function ballRender(ball, ctx) {
ctx.beginPath();
ctx.fillStyle = 'white';
ctx.fill();
ctx.arc(ball.position[0], ball.position[1], ball.radius, 0,2*Math.PI);
ctx.stroke();
};
/**
* Move the ball and checks the collision with the paddles
* @param {[object]} paddleLeft Left paddle
* @param {[object]} paddleRight Right paddle
*/
function ballMove (ball, paddleLeft, paddleRight, ctx) {
let xPositionRadius = ball.position[0] + ball.radius * ball.direction[0];
let yPositionRadius = ball.position[1] + ball.radius * ball.direction[1];
//ballBoardCollision(xPositionRadius, yPositionRadius, ball, ctx);
//ballPaddleColission(paddleLeft, paddleRight, xPositionRadius, yPositionRadius, ball);
//Move the ball
let newPosition = [ball.position[0] += ball.direction[0], ball.position[1] += ball.direction[1]];
return new Ball(ball.radius, newPosition);
};
function ballBoardCollision (xPositionRadius, yPositionRadius, ball, ctx){
if (yPositionRadius <= 0){
ball.direction[1] *= -1
ball.position[1] = 0 + ball.radius;
};
if (yPositionRadius >= ctx.canvas.clientHeight){
ball.direction[1] *= -1
ball.position[1] = ctx.canvas.clientHeight - ball.radius;
};
if (xPositionRadius <= 0){
ball.direction[0] *= -1;
ball.position[0] = 0 + ball.radius;
ball.players[1].score++;
ball.players[1].strikeCounter++;
ball.players[0].strikeCounter--;
ball.players[1].scoreTime = new Date().getTime();
};
if (xPositionRadius >= ball.context.canvas.clientWidth){
ball.direction[0] *= -1
ball.position[0] = ball.context.canvas.clientWidth - ball.radius;
ball.players[0].score++;
ball.players[1].strikeCounter--;
ball.players[0].strikeCounter++;
ball.players[0].scoreTime = new Date().getTime();
}
}
/**
* [description]
* @param {[object]} paddleLeft Left paddle object
* @param {[object]} paddleRight Right paddle object
*/
function ballPaddleColission(paddleLeft, paddleRight, xPositionRadius, yPositionRadius) {
//Check the paddleLeft position for the collision
if (this.position[0]-this.radius <= paddleLeft.position[0] + paddleLeft.width &&
this.position[1] >= paddleLeft.position[1] &&
this.position[1] <= paddleLeft.position[1] + paddleLeft.height &&
this.direction[0] < 0
){
this.position[0] = paddleLeft.position[0] + paddleLeft.width + this.radius;
this.direction[0] *= (this.direction[0] > -5) ? (-1 - this.speed) : -1;
if (this.changeLeftY === true) this.direction[1] *= -1;
}
//Check the paddleRight position for the collision
if (this.position[0] + this.radius >= paddleRight.position[0] &&
this.position[1] >= paddleRight.position[1] &&
this.position[1] <= paddleRight.position[1] + paddleRight.height &&
this.direction[0] > 0
){
this.position[0] = paddleRight.position[0] - this.radius;
this.direction[0] *= (this.direction[0] < 5) ? (-1 - this.speed) : -1;
if (this.changeRightY === true) this.direction[1] *= -1;
}
}
|
// Generated by CoffeeScript 1.8.0
(function() {
var __hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
define(['views/slider'], function(SliderView) {
'use strict';
var ProjectView;
return ProjectView = (function(_super) {
__extends(ProjectView, _super);
function ProjectView() {
return ProjectView.__super__.constructor.apply(this, arguments);
}
ProjectView.prototype.el = '.main';
ProjectView.prototype.initialize = function() {
return this.render();
};
ProjectView.prototype.destroy = function() {
return console.log('destroy');
};
ProjectView.prototype.render = function() {
this.$el.html(this.template());
this.$el.find('article').addClass('is-visible');
this.$el.addClass('is-visible');
return this;
};
ProjectView.prototype.atBottom = function() {
if ($(window).scrollTop() > $('article').height() - $(window).height() - 100) {
return $('.navigation:not(.is-expanded)').addClass('is-expanded js-atBottom');
} else {
$('.navigation.js-atBottom').removeClass('is-expanded js-atBottom');
return $('.navigation').scrollTop(0);
}
};
ProjectView.prototype.initializeSlider = function(slider) {
return _.each($('.slider'), function(slider) {
return new SliderView({
el: slider
});
});
};
return ProjectView;
})(Backbone.View);
});
}).call(this);
|
../../../../../shared/ssr/lib/requests/fetchResponseExtractor.js
|
export default (row = { original: {} }, column) => {
let classes = 'row-cell ';
switch (column.Header) {
case 'Symbol':
classes += 'fixed';
break;
case 'Pattern':
classes += 'pattern';
break;
case 'WaveLength':
classes += row.original.WLColor || '';
break;
case 'BetaAlpha':
classes += row.original.BAColor || '';
break;
case 'Chg':
classes += row.original.Color || '';
break;
default:
break;
}
return classes;
};
|
(function(scope, Class, Symbol, InternalSlot, Object) {
"use strict";
var EventProperties = InternalSlot("EventProperties"),
DefineProperty = Object.defineProperty,
Create = Object.create,
Prototype = Object.prototype,
ToStringTag = Symbol.toStringTag,
HasOwnProperty = (function() {
var HasOwnProperty = Prototype.hasOwnProperty;
return function hasOwnProperty(target, propertyName) {
return HasOwnProperty.call(target, propertyName);
};
})();
var $MyEvent = Class({
/** constructs a MyEvent Object
* @constructor
* @param type {string}
* @param eventInitDict {EventInit}
*/
_constructor: function MyEvent(Internal, type, eventInitDict) {
if (this instanceof $MyEvent === false) {
throw new TypeError("Illegal invocation");
};
if (arguments.length == 0) {
throw new TypeError("Failed to construct 'MyEvent': 1 argument required, but only " + arguments.length + " present.");
};
var a,
b = Object(eventInitDict);
DefineProperty(this, EventProperties, {
value: {
bubbles: b.bubbles == false ? false : true,
cancelable: b.cancelable == false ? false : true,
currentTarget: null,
defaultPrevented: false,
eventPhase: $MyEvent.NONE,
immediatePropagationStopped: false,
isTrusted: false,
path: [],
propagationStopped: false,
target: null,
timeStamp: Date.now(),
type: type
}
});
for (a in b) {
if (a in this == false) {
this[a] = b[a];
};
};
},
NONE: 0,
CAPTURING_PHASE: 1,
AT_TARGET: 2,
BUBBLING_PHASE: 3,
static_NONE: 0,
static_CAPTURING_PHASE: 1,
static_AT_TARGET: 2,
static_BUBBLING_PHASE: 3,
/** @return {boolean} */
get_bubbles: function bubbles() {
return this[EventProperties].bubbles;
},
/** @return {boolean} */
get_cancelable: function cancelable() {
return this[EventProperties].cancelable;
},
/** @return {Object} */
get_currentTarget: function currentTarget() {
return this[EventProperties].currentTarget;
},
/** @return {number} */
get_eventPhase: function eventPhase() {
return this[EventProperties].eventPhase;
},
get_path: function path() {
return this[EventProperties].path;
},
/** @return {boolean} */
get_isTrusted: function isTrusted() {
return this[EventProperties].isTrusted;
},
/** @return {Object} */
get_target: function target() {
return this[EventProperties].target;
},
/** @return {number} */
get_timeStamp: function timeStamp() {
return this[EventProperties].timeStamp;
},
/** @return {string} */
get_type: function type() {
return this[EventProperties].type;
},
/**
* @param {string} eventTypeArg
* @param {boolean} canBubbleArg
* @param {boolean} cancelableArg
*/
initEvent: function initEvent(eventTypeArg, canBubbleArg, cancelableArg) {
this[EventProperties].type = eventTypeArg;
this[EventProperties].bubbles = canBubbleArg;
this[EventProperties].cancelable = cancelableArg;
},
/** @return {boolean} */
isDefaultPrevented: function isDefaultPrevented() {
return this[EventProperties].defaultPrevented;
},
preventDefault: function preventDefault() {
if (this[EventProperties].cancelable) {
this[EventProperties].defaultPrevented = true;
};
},
stopImmediatePropagation: function stopImmediatePropagation() {
this[EventProperties].immediatePropagationStopped = true;
this[EventProperties].propagationStopped = true;
},
stopPropagation: function stopPropagation() {
this[EventProperties].propagationStopped = true;
},
});
scope.MyEvent = $MyEvent;
var EventListeners = InternalSlot("EventListeners");
var $MyEventTarget = Class({
/**
* @constructor
* @param defaultEvents {any[]} list of default eventtypes which can be dispatched
* @param func {function} callback which first parameter is a function which creates trusted MyEvents
* @return {MyEventTarget} returns new EventTarget
*/
_constructor: function MyEventTarget(defaultEvents, func) {
if (this instanceof $MyEventTarget === false) {
throw new TypeError("Illegal invocation");
};
DefineProperty(this, EventListeners, {
value: [],
writable: true
});
},
/**
* @param type {string}
* @param {EventListener} listener
* @param {boolean} useCapture
*/
addEventListener: function addEventListener(type, listener, useCapture) {
if (HasOwnProperty(this, EventListeners) === false) {
throw new TypeError("Illegal invocation");
};
useCapture = useCapture === true ? true : false;
this.removeEventListener(type, listener, useCapture);
if (typeof listener === "function" && typeof type === "string") {
this[EventListeners].push({
type: type,
listener: listener,
useCapture: useCapture
});
};
},
/**
* @param type {string}
* @param {EventListener} listener
* @param {boolean} useCapture
*/
removeEventListener: function removeEventListener(type, listener, useCapture) {
if (HasOwnProperty(this, EventListeners) === false) {
throw new TypeError("Illegal invocation");
};
useCapture = useCapture === true ? true : false;
this[EventListeners] = this[EventListeners].filter(function(handler) {
if (handler.type == type && handler.listener == listener && handler.useCapture == useCapture) {
return true;
};
return false;
});
},
/**
* @param event {Event|Object}
* @return {boolean}
*/
dispatchEvent: function dispatchEvent(event) {
if (HasOwnProperty(this, EventListeners) === false) {
throw new TypeError("Illegal invocation");
};
if (arguments.length == 0) {
throw new TypeError("Failed to execute 'dispatchEvent' on 'MyEventTarget': 1 argument required, but only 0 present.");
};
if (event instanceof $MyEvent === false) {
throw new TypeError("Failed to execute 'dispatchEvent' on 'MyEventTarget': parameter 1 is not of type 'MyEvent'.")
};
if (this instanceof $MyEventTarget === false || this === $MyEventTarget) {
throw new TypError("this is not instanceof MyEventTarget");
};
var target = this,
path = [];
event[EventProperties].target = target;
event[EventProperties].path.push(target);
path.unshift(target);
while (target = target.parent) {
event[EventProperties].path.push(target);
path.unshift(target);
};
self.event = event;
path.map(function(target) {
if (event[EventProperties].propagationStopped === false) {
event[EventProperties].currentTarget = target;
target[EventListeners].map(function(handler) {
if (handler.type == event[EventProperties].type && handler.useCapture === true && event[EventProperties].immediatePropagationStopped === false) {
if (target === event[EventProperties].target) {
event[EventProperties].eventPhase = $MyEvent.AT_TARGET;
} else {
event[EventProperties].eventPhase = $MyEvent.CAPTURING_PHASE;
};
event[EventProperties].currentTarget = target;
try {
handler.listener.call(target, event);
} catch (error) {
console.log(error);
};
};
});
};
});
if (event[EventProperties].propagationStopped === false) {
path.reverse().map(function(target) {
if (event[EventProperties].propagationStopped === false) {
event[EventProperties].currentTarget = target;
target[EventListeners].map(function(handler) {
if (handler.type == event[EventProperties].type && handler.useCapture === false && event[EventProperties].immediatePropagationStopped === false) {
if (target === event[EventProperties].target) {
event[EventProperties].eventPhase = $MyEvent.AT_TARGET;
} else {
event[EventProperties].eventPhase = $MyEvent.BUBBLING_PHASE;
};
event[EventProperties].currentTarget = target;
try {
handler.listener.call(target, event);
} catch (error) {
console.log(error);
};
};
});
};
});
};
self.event = undefined;
event[EventProperties].currentTarget = event[EventProperties].target;
event[EventProperties].eventPhase = $MyEvent.NONE;
return event[EventProperties].defaultPrevented === false;
},
});
scope.MyEventTarget = $MyEventTarget;
})(self, self.Class, self.Symbol, self.InternalSlot || self.Symbol, self.Object);
|
import React from "react";
import RatingFilter from "./RatingFilter";
import { connect } from "react-redux";
import { setRating } from "../../../../actions/filters";
import Container from "../PriceFilter/Container";
class RatingFilterContainer extends React.Component {
state = {
value: undefined,
name: "Calificacion",
isActive: false
};
onChange = (e, data) => {
const value = !data.checked ? undefined : data.value;
this.setState(() => ({ value }));
};
handleApplyChanges = async () => {
let name = this.state.value
? ` ${this.state.value} ★ en adelante`
: "Calificacion";
let isActive = this.state.value ? true : false;
this.props.setRating(this.state.value);
this.setState({ name, isActive });
};
render() {
return (
<RatingFilter
onChange={this.onChange}
handleApplyChanges={this.handleApplyChanges}
{...this.state}
/>
);
}
}
const mapDispatchToProps = dispatch => {
return {
setRating: rating => {
dispatch(setRating(rating));
}
};
};
const mapStateToProps = ({ filters: { rating } }) => {
return {
rating
};
};
export default connect(
mapStateToProps,
mapDispatchToProps
)(RatingFilterContainer);
|
// Dom Elements
const items = document.querySelectorAll('.gooey__item');
const rectangle = document.querySelector('.gooey__rectangle');
const container = document.querySelector('.gooey');
const active = document.querySelector('.active');
const itemsArray = Array.from(items);
// Co-ords
let rectCoords = active.getBoundingClientRect();
const containerCoords = container.getBoundingClientRect();
const containerOffset = window.getComputedStyle(container,null).getPropertyValue('padding-left').replace(/\D/g,'');
// Values + Other
let transVal;
let prevPosition = getArrayPosition(active);
const transDur = 0.4;
const scaleHeight = 0.25;
const scaleWidth = 0.7;
const transitionEnd = 'transitionend webkitTransitionEnd oTransitionEnd MSTransitionEnd';
function init(e) {
const coords = {
width: rectCoords.width,
height: rectCoords.height,
top: rectCoords.top + window.scrollY,
left: (rectCoords.left + window.scrollX) - containerCoords.left - containerOffset
}
rectangle.style.width = `${coords.width}px`;
rectangle.style.height = `${coords.height}px`;
rectangle.style.left = `${coords.left}px`;
}
function getCoords(el) {
const thisCoords = el.getBoundingClientRect();
const newCoords = {
width: Math.floor(thisCoords.width),
height: Math.floor(thisCoords.height),
left: Math.floor(thisCoords.left - containerCoords.left - containerOffset)
}
return newCoords;
}
function getArrayPosition(el) {
return itemsArray.indexOf(el);
}
function gooeyHandler(e) {
const newCoords = getCoords(this);
const currentPosition = getArrayPosition(this);
transVal = transDur * Math.abs(currentPosition - prevPosition);
updateRectanglePos(newCoords);
rectangle.addEventListener('transitionend', () => afterTransition(this,newCoords),{once:true});
}
function updateRectanglePos(coords) {
rectangle.style.left = ``;
rectangle.style.width = `${coords.width}`;
rectangle.style.transitionDuration = `${transVal}s`;
rectangle.style.transform = `translateX(${coords.left}px)scale(${scaleWidth},${scaleHeight})`;
}
function afterTransition(item,coords) {
items.forEach(item => item.classList.remove('active'));
item.classList.add('active');
rectangle.style.transform = `translateX(${coords.left}px)scale(1)`;
prevPosition = getArrayPosition(item);
}
items.forEach(item => item.addEventListener('click',gooeyHandler));
init();
|
var express = require('express')
var NodeTTL = require('node-ttl')
var os = require('os')
var app = express()
var ttl = new NodeTTL()
// Initializing the arrays
var items = [];
app.get('/', function (req, res) {
res.status(200).send('ok')
});
app.get('/stack/add/:item', (req, res) => {
// Set value to the item
this.item = req.params.item
// Adding item to the array
items.push(this.item)
res.status(200).send('ok')
})
app.get('/stack/get', (req, res) => {
// Display and remove the last item from the array
res.send(items.splice(-1, 1)[0])
})
app.get('/store/add/:key-:value/:ttl?', (req, res) => {
// Set values to variables
this.key = req.params.key
this.value = req.params.value
this.ttl = req.params.ttl
// Optional route return undefined if not set
if(this.ttl === undefined)
this.ttl = 0
// Add key-value to the store
ttl.push(this.key, this.value, null, this.ttl)
res.status(200).send('ok')
})
app.get('/store/get/:key', (req, res) => {
var test = ttl.get(req.params.key)
res.status(200).send(test)
})
app.get('/store/delete/:key', (req, res) => {
ttl.del(req.params.key)
res.status(200).send('ok')
})
var server = app.listen(3000)
module.exports = server
|
const pool = require("../../config/database");
module.exports = {
create: (data, callBack) => {
pool.query(
"insert into coquan(tencq, diachi, dienthoai, fax, email) value(?,?,?,?,?)",
[data.tencq, data.diachi, data.dienthoai, data.fax, data.email],
(error, results, fields) => {
if (error) {
return callBack(error);
}
return callBack(null, results);
}
);
},
getOrganizations: (callBack) => {
pool.query(
"select maCQ, tencq, diachi, dienthoai, fax, email from coquan ",
[],
(error, results, fields) => {
if (error) {
return callBack(error);
}
return callBack(null, results);
}
);
},
getOrganizationByID: (id, callBack) => {
pool.query(
"select maCQ, tencq, diachi, dienthoai, fax, email from coquan where maCQ=? ",
[id],
(error, results, fields) => {
if (error) {
return callBack(error);
}
return callBack(null, results[0]);
}
);
},
updateOrganization: (data, callBack) => {
pool.query(
"update coquan set tencq=?, diachi=?, dienthoai=?,fax=?, email=? where maCQ=? ",
[
data.tencq,
data.diachi,
data.dienthoai,
data.fax,
data.email,
data.maCQ,
],
(error, results, fields) => {
if (error) {
return callBack(error);
}
return callBack(null, results);
}
);
},
deleteOrganization: (data, callBack) => {
pool.query(
"delete from coquan where maCQ=?",
[data.maCQ],
(error, results, fields) => {
if (error) {
return callBack(error);
}
return callBack(null, results);
}
);
},
};
|
/**
* Created by Wwei on 2016/9/9.
*/
Ext.define('Admin.view.resources.Resource', {
extend: 'Ext.container.Container',
xtype: 'resource',
requires: [
'Ext.form.Panel',
'Ext.layout.container.HBox',
'Ext.tree.Panel',
'Admin.view.resources.ResourceController'
],
controller: 'resource',
layout: 'hbox',
listeners: {
beforerender: 'resourceBeforeRender'
},
defaults: {
height: '100%'
},
items: [{
title: '菜单管理',
flex: 1,
xtype: 'treepanel',
reference: 'menuTree',
useArrows: true,
store: 'resources.Menu',
listeners: {
select: 'onMenuTreeSelected'
},
dockedItems: [{
xtype: 'toolbar',
dock: 'top',
items: [{
text: '添加',
handler: "createMenu",
iconCls: 'fa fa-plus'
}, {
text: '修改',
handler: "updateMenu",
iconCls: 'fa fa-pencil-square-o'
}, {
text: '删除',
reference: 'delMenuBtn',
disabled: true,
handler: "deleteMenu",
iconCls: 'fa fa-times'
}]
}]
}, {
flex: 1,
frame: true,
title: '权限管理',
xtype: 'grid',
reference: 'permGrid',
columns: [{
xtype: 'rownumberer'
}, {
text: '名称',
dataIndex: 'text',
width: 150
}, {
text: '表达式',
dataIndex: 'permission',
flex: 1
}, {
text: '名称',
dataIndex: 'status',
width: 150,
renderer: function (v) {
return v == 1 ? '有效' : '无效';
}
}],
store: 'resources.Permission',
dockedItems: [{
xtype: 'toolbar',
dock: 'top',
items: [{
text: '添加',
handler: "createPermission",
iconCls: 'fa fa-plus'
}, {
text: '修改',
handler: "updatePermission",
iconCls: 'fa fa-pencil-square-o'
}, {
text: '删除',
handler: "deletePermission",
iconCls: 'fa fa-times',
bind: {
disabled: '{!permGrid.selection}'
}
}]
}]
}]
});
|
import ReactDOM from 'react-dom';
import React, { Component } from 'react';
import {createStore} from 'redux';
import {Provider, connect} from 'react-redux';
const reducer = (state = 0, action) => {
if (action.type === 'SET_COUNTER') {
return action.value;
}
if (action.type === 'INCREMENT') {
return state + 1;
}
if (action.type === 'DECREMENT') {
return state - 1;
}
console.log('Reducer called.');
return state;
}
const store = createStore(reducer, 0);
const Counter = (props) => {
return <div>
<p>Count: {props.count}</p>
<p>
<button onClick={props.increment}>Increment</button>
<button onClick={props.decrement}>Decrement</button>
<button onClick={() => props.setValueTo(props.initValue)}>Reset to {props.initValue}</button>
</p>
</div>;
}
const CounterContainer = connect(
(state) => ({ count: state, initValue: 80 }),
(dispatch) => ({
increment: () => dispatch({type: 'INCREMENT'}),
decrement: () => dispatch({type: 'DECREMENT'}),
setValueTo: (value) => dispatch({type: 'SET_COUNTER', value: value})
})
)(Counter);
class App extends Component {
render() {
return (
<Provider store={store}>
<div className="App">
<CounterContainer/>
</div>
</Provider>
);
}
}
ReactDOM.render(
<App />,
document.getElementById('root')
);
|
import React, { useContext } from "react";
import { Link } from "@reach/router";
import styled from "styled-components";
import { ThemeContext } from "../contexts/ThemeContext";
const Wrapper = styled.div`
width: 100%;
background: ${({ theme }) => theme.bg};
display: flex;
align-items: center;
justify-content: center;
> a {
text-decoration: none;
flex: 1;
padding: 12px;
text-align: center;
color: #fff;
}
`;
export default function Navbar() {
const { state } = useContext(ThemeContext);
return (
<Wrapper theme={state}>
<Link to="/profile">
<i className="fa fa-2x fa-user"></i>
</Link>
<Link to="/">
<i className="fa fa-2x fa-home"></i>
</Link>
<Link to="/mobile">
<i className="fa fa-2x fa-shield-alt"></i>
</Link>
</Wrapper>
);
}
|
var searchData=
[
['node_2ejava',['Node.java',['../Node_8java.html',1,'']]]
];
|
function createNewArticle() {
let auth = document.getElementById('author').value;
let titl = document.getElementById('title').value;
let txt = document.getElementById('text').value;
const date = new Date();
let dat = '' + validDate(date.getDate()) + '.' + validDate(date.getMonth() + 1) + '.' + date.getFullYear();
let obj = JSON.stringify({ title: titl, text: txt, date: dat, author: auth, comments: [] });
console.log(obj);
$.post("/api/articles/create", obj, (data) => {
window.location.replace("./");
alert('Create successful');
});
}
function validDate(param) {
if (param < 10)
return '0' + param;
else return param;
}
|
/*
* This module will control the overall functionality of google authentication process flow
*/
const passport = require('passport');
const users = require('../users/users.entity');
const jwt = require('jsonwebtoken');
const jwtDecode = require('jwt-decode');
const superSecret = require('../../config/config.js');
// this function is to encode the data provided by google into JWT using a secret keyword
const googleCallback = function(user) {
const token = jwt.sign(user, superSecret.JWT_AUTH.secret);
return token;
};
// this function is to authenticate user actions by passing token, decoding it and matching with the database
const authenticatePage = function(token) {
try {
console.log("inside callback");
const user = jwtDecode(token);
const promise = new Promise(function(resolve, reject) {
// checking for the existence of user data in database mongodb
users.findOne({
username: user._doc.username
}, function(err, user) {
if (err) {
reject(err);
}
if (!user) {
reject({
error: 'No such user exist'
});
}
resolve(user);
});
});
return promise;
} catch (e) {
const promise = new Promise(function(resolve, reject) {
reject(e);
});
return promise;
} finally {
}
};
module.exports = {
googleCallback: googleCallback,
authenticatePage: authenticatePage
};
|
module.exports = {
siteMetadata: {
title: `Toolshed SoundLab`,
description: `Toolshed SoundLab Recording Studio - I offer music production &amp; recording services at a comfortable studio in the heart of Port Townsend, near Seattle Washington`,
keywords: `port townsend,recording studio,washington,jefferson county,olympic peninsula,sequim,port angeles,analog,digital,tape transfer,music production,music studio,guitar lesson,luthier,guitar repair,Seattle,best,acoustic,folk,blues,jazz,rock,music production,voice over`,
author: `Christopher Pappas <damassi.pappas@gmail.com>`,
},
plugins: [
`gatsby-plugin-react-helmet`,
`gatsby-transformer-sharp`,
`gatsby-plugin-sharp`,
"gatsby-plugin-catch-links",
"gatsby-plugin-styled-components",
"gatsby-plugin-typescript",
"gatsby-plugin-root-import",
{
resolve: "gatsby-plugin-netlify-cms",
options: {
modulePath: `${__dirname}/src/cms/cms.jsx`,
manualInit: true,
enableIdentityWidget: true,
},
},
{
resolve: `gatsby-source-filesystem`,
options: {
name: `images`,
path: `${__dirname}/src/images`,
},
},
{
resolve: `gatsby-source-filesystem`,
options: {
path: `${__dirname}/content/pages`,
name: `pages`,
},
},
{
resolve: `gatsby-transformer-remark`,
options: {
plugins: [`gatsby-remark-smartypants`],
},
},
{
resolve: `gatsby-plugin-manifest`,
options: {
name: `gatsby-starter-default`,
short_name: `starter`,
start_url: `/`,
background_color: `#663399`,
theme_color: `#663399`,
display: `minimal-ui`,
icon: `src/images/gatsby-icon.png`, // This path is relative to the root of the site.
},
},
],
}
|
// 计数排序
// 时间复杂度 O(n+k)
function findMax(arr) {
let max = arr[0], i = arr.length - 1
while(i > 0) {
let item = arr[i]
item > max && (max = item)
i--
}
return max
}
// 计数排序
function countSrot(arr) {
const max = findMax(arr)
const countArr = new Array(max + 1)
let i = arr.length - 1
while(i >= 0) {
let temp = arr[i--]
if(countArr[temp]) {
countArr[temp]++
} else {
countArr[temp] = 1
}
}
let sortIndex = 0
for(let [index, count] of countArr.entries()) {
while(count-- > 0) {
arr[sortIndex++] = index
}
}
return arr
}
// 生成随机数组用于测试
// random-随机数组/order-降序数组/same-元素相同的数组
function createArray(n, type = 'random') {
const arr = []
let i = n
while(i > 0) {
let random = Math.floor( Math.random() * n )
arr.push(
type === 'random' // 随机数组
? random
: type === 'order' // 倒序数组
? i
: type === 'object' // 对象数组
? {count: random}
: 1 // same
)
i--
}
return arr
}
// 返回函数执行时间
function getRuntime(fn) {
const start = performance.now()
fn()
const end = performance.now() - start
return end.toFixed(2)
}
function runNext(arr, fn) {
if(arr.length > 0) {
const runtime = getRuntime(
() => fn(arr.shift())
)
console.log(`执行时间: ${runtime}毫秒`)
return runNext(arr, fn)
}
}
// 测试
console.group('quick sort test')
runNext(
[1000000],
count => console.log(
countSrot(createArray(count))
)
)
console.groupEnd()
|
const express = require("express");
require("./config/config").config;
const app = express();
const port = process.env.PORT;
const userRoute = require("./routes/user.route");
app.use(express.json()); // for parsing application/json
app.use(express.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
app.use(express.static("public"));
app.use("/user", userRoute);
app.listen(port, () => {
console.log(`App is listening on port ${port}`);
});
|
var ajax = webix.ajax().headers({
'Content-type': 'application/json'
})
webix.ready(function () {
webix.ui({
id: "editFormAndTable",
container: "date",
view: "form",
css: "webix_primary",
align: "center",
type: "wide",
borderless: true,
rows: [
{
id: "deadline",
view: "datepicker",
timepicker: true,
name: "end",
stringResult: true,
format: "%d %M %Y at %H:%i"
}
],
});
});
function submitCreationForm() {
$('#deadlineHelp').hide();
if (validateCreationForm()) {
webix.ajax().post("http://localhost:8080/controller?command=create-technical-task",
{
"deadline": $$("deadline").getValue(),
"name": document.getElementById("name").value,
"overview": document.getElementById("overview").value
})
.then((response) => {
window.location.href = "http://localhost:8080/controller?command=to-create-requirement";
})
}
}
var technicalTaskCreationInputs;
var technicalTaskCreationPatterns;
window.addEventListener("load", function (event) {
const nameRegex = new RegExp(document.getElementById('regex-name').textContent);
const overviewRegex = new RegExp(document.getElementById('regex-overview').textContent);
technicalTaskCreationInputs = document.querySelectorAll('.form-control');
technicalTaskCreationPatterns = {
name: nameRegex,
overview: overviewRegex
};
technicalTaskCreationInputs.forEach((input) => {
input.addEventListener('keyup', (e) => {
validate(e.target, technicalTaskCreationPatterns[e.target.attributes.id.value]);
});
});
});
function validateCreationForm() {
var today = new Date();
var deadlineValue = $$("deadline").getValue();
var deadline = new Date(deadlineValue);
if (deadline < today) {
$('#deadlineHelp').show();
}
return validateInputs(technicalTaskCreationInputs, technicalTaskCreationPatterns)
&& (deadline > today);
}
|
var randomNumber1= Math.floor((Math.random()*6)+1);
var randomNumber2= Math.floor((Math.random()*6)+1);
var image1 = "images/dice" + randomNumber1+ ".png"
var image2 = "images/dice" + randomNumber2+ ".png"
document.querySelector("img.img1").setAttribute("src",image1);
document.querySelector("img.img2").setAttribute("src",image2);
if(randomNumber1===randomNumber2){
document.querySelector(".container h1").innerHTML="Draw!";
}
else if(randomNumber1>randomNumber2){
document.querySelector(".container h1").innerHTML="Player 1 Wins!";
}
else if(randomNumber1<randomNumber2){
document.querySelector(".container h1").innerHTML="Player 2 Wins!";
}
|
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.setCartFromFirebase = exports.checkOutSuccess = exports.UpdateCartInFirebase = exports.clearCart = exports.clearItemFromCart = exports.removeItem = exports.addItem = exports.toggleCartHidden = void 0;
var cart_types_1 = __importDefault(require("./cart.types"));
var toggleCartHidden = function () { return ({
type: cart_types_1.default.TOGGLE_CART_HIDDEN,
}); };
exports.toggleCartHidden = toggleCartHidden;
var addItem = function (item) { return ({
type: cart_types_1.default.ADD_ITEM,
payload: item,
}); };
exports.addItem = addItem;
var removeItem = function (item) { return ({
type: cart_types_1.default.REMOVE_ITEM,
payload: item,
}); };
exports.removeItem = removeItem;
var clearItemFromCart = function (item) { return ({
type: cart_types_1.default.CLEAR_ITEM_FROM_CART,
payload: item,
}); };
exports.clearItemFromCart = clearItemFromCart;
var clearCart = function () { return ({
type: cart_types_1.default.CLEAR_CART,
}); };
exports.clearCart = clearCart;
var UpdateCartInFirebase = function () { return ({
type: cart_types_1.default.UPDATE_CART_IN_FIREBASE,
}); };
exports.UpdateCartInFirebase = UpdateCartInFirebase;
var checkOutSuccess = function () { return ({
type: cart_types_1.default.CLEAR_CART,
}); };
exports.checkOutSuccess = checkOutSuccess;
var setCartFromFirebase = function (cartItems) { return ({
type: cart_types_1.default.SET_CART_FROM_FIREBASE,
payload: cartItems,
}); };
exports.setCartFromFirebase = setCartFromFirebase;
|
"use strict";
var ActionMethods = {};
ActionMethods.initializeStore = function(){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.initializeStore() );
};
ActionMethods.changeDomainName = function(domainName){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.changeDomainName(domainName) );
};
ActionMethods.showNewMessageDialog = function(domain, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.showNewMessageDialog(domain, dialogPositionChain) );
};
ActionMethods.hideNewMessageDialog = function(domain, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.hideNewMessageDialog(domain, dialogPositionChain) );
};
ActionMethods.submitNewMessage = function(domainName, dialogPositionChain, messageStr){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.submitNewMessage(domainName, dialogPositionChain, messageStr) );
};
ActionMethods.submitNewContradiction = function(domainName, dialogPositionChain, contradictionPositionChain, cantText, cuzText){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.submitNewContradiction(domainName, dialogPositionChain, contradictionPositionChain, cantText, cuzText) );
};
ActionMethods.selectMessage = function(domainName, dialogPositionChain, openMainTab){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.selectMessage(domainName, dialogPositionChain, openMainTab) );
};
ActionMethods.goPerpendicular = function(domainName, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.goPerpendicular(domainName, dialogPositionChain) );
};
ActionMethods.leavePerpendicular = function(domainName, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.leavePerpendicular(domainName, dialogPositionChain) );
};
ActionMethods.showContradictWindow = function(domainName, dialogPositionChain, contradictionPositionChain, cachedSuggestedContradictions){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.showContradictWindow(domainName, dialogPositionChain, contradictionPositionChain, cachedSuggestedContradictions) );
};
ActionMethods.hideContradictWindow = function(domainName, dialogPositionChain, contradictionPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.hideContradictWindow(domainName, dialogPositionChain, contradictionPositionChain) );
};
ActionMethods.newMessageSelectTab = function(domainName, dialogPositionChain, tabName){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.newMessageSelectTab(domainName, dialogPositionChain, tabName) );
};
ActionMethods.newContradictionSelectTab = function(domainName, dialogPositionChain, contradictionPositionChain, tabName){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.newContradictionSelectTab(domainName, dialogPositionChain, contradictionPositionChain, tabName) );
};
ActionMethods.createSymbolicLink = function(domainName, dialogPositionChain, linkPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.createSymbolicLink(domainName, dialogPositionChain, linkPositionChain) );
};
ActionMethods.viewDialogProperties = function(viewFlag){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.viewDialogProperties(viewFlag) );
};
ActionMethods.mainSelectTab = function(domainName, tabName){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.mainSelectTab(domainName, tabName) );
};
ActionMethods.changeUserSetting = function(settingName, settingValue){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.changeUserSetting(settingName, settingValue) );
};
ActionMethods.contributionDeleteLeaf = function(domainName, linkingArr){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.contributionDeleteLeaf(domainName, linkingArr) );
};
ActionMethods.contributionRemoveOwnership = function(domainName, linkingArr){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.contributionRemoveOwnership(domainName, linkingArr) );
};
ActionMethods.addNewDomain = function(domainName){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.addNewDomain(domainName) );
};
ActionMethods.editMessage = function(domainName, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.editMessage(domainName, dialogPositionChain) );
};
ActionMethods.hideEditMessage = function(domainName, dialogPositionChain){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.hideEditMessage(domainName, dialogPositionChain) );
};
ActionMethods.updateMessage = function(domainName, dialogPositionChain, messageStr){
HIPI.framework.AppState.dispatchAction( HIPI.state.ActionObjects.updateMessage(domainName, dialogPositionChain, messageStr) );
};
|
var detik = 0;
var menit = 0;
var jam = 0;
//timer 15 menit
var timer_detik = 00;
var timer_menit = 15;
var timer_jam = 00;
function timer() { //timer countdown => 5 4 3 2 1
if (timer_jam == 0 && timer_menit == 0 && timer_detik == 0) { // jam menit detik 00:00:00
window.alert("Waktu mengerjakan telah habis. Tekan OK untuk melanjutkan"); // alert
document.forms["form"].submit(); // action pada form
}
timer_detik = timer_detik - 1; // detik dikurangi satu
if (timer_detik < 0) { // bila detik bernilai 0
timer_detik = 59; // detik akan kembali ke nilai 59
timer_menit = timer_menit - 1; // nilai menit akan dikurangi satu
}
if (timer_menit < 0 && timer_jam != 0) { // sama seperti detik
timer_menit = 59;
timer_jam = timer_jam - 1;
}
document.getElementById('timer').value = ((timer_jam <= 9) ? "0" + timer_jam : timer_jam) + ":" + ((timer_menit <= 9) ? "0" + timer_menit : timer_menit) + ":" + ((timer_detik <= 9) ? "0" + timer_detik : timer_detik);
setTimeout("timer()", 1000); // fungsi waktu dalam js
}
function load()
{ // membuat fungsi untuk memanggil fungsi stopwatch dan timer
timer(); // memanggil fungsi timer
//fungsi load akan diletakkan pada bagian body, agar saat halaman di akses, maka fungsi load akan terpanggil dan timer serta coundown akan berjalan
}
|
/**
* Creation of an image element that can be placed on the mood board
*/
/*global define */
define(
['entities/base', 'models/dom', 'controllers/input', 'controllers/layering'],
function (BaseEntity, dom, input) {
'use strict';
var _strokePadding = 5;
var DEBUG = false;
var Text = BaseEntity.extend({
tag: 'text',
on: false,
// Canvas containing the glyph
canvas: null,
// Pre-rendered Canvas text
textCanvas: null,
coordLibrary: null,
string: null,
init: function (x, y) {
this._super(x, y);
this.coordLibrary = {};
this.textCanvas = document.createElement('canvas');
},
update: function () {
var pointTest = this.pointTest(input.mouse);
// Check for clicks based upon highest entity first
if (pointTest && !input.isClicked()) {
// Clicking object
if (input.keyDown('select')) {
// If already active check to see if the resize area is clicked otherwise active drag
this.drag = true;
input.pushClicked(this);
// Hover
} else {
}
}
// Click'n drag
if (this.selected && this.drag) {
// Detect clicking on the image
if (input.keyPress('select') && input.mouse.x && input.mouse.y && (input.mouse.x !== input.mousePrev.x || input.mouse.y !== input.mousePrev.y)) {
this.x -= input.mousePrev.x - input.mouse.x;
this.y -= input.mousePrev.y - input.mouse.y;
}
}
if (input.keyUp('select')) {
input.setClicked(false);
this.drag = false;
}
this._super();
},
draw: function () {
if (this.on) {
dom.ctx.drawImage(this.textCanvas, this.x, this.y);
if (this.selected) {
dom.ctx.strokeStyle = '#428bca';
dom.ctx.strokeRect(this.x - _strokePadding, this.y - _strokePadding, this.width + (_strokePadding * 2), this.height + (_strokePadding * 2));
}
}
},
setText: function (string) {
var ctx = this.textCanvas.getContext('2d');
if (string !== undefined) {
this.string = string;
}
var width = 0;
var xPos = 0;
var letters = this.string.split('');
var l;
// Temporarily disable text rendering since it will flicker
this.on = false;
// Determine width and height of new Canvas by counting letter lengths
for (var i = 0; i < letters.length; i++) {
// Replace all spaces with a non-breakable space
if (letters[i] === ' ') {
letters[i] = ' '
}
// Increment width
width += this.coordLibrary[letters[i]].width;
}
// Setup existing Canvas
this.width = this.textCanvas.width = width;
this.height = this.textCanvas.height = this.canvas.height - 1; // Subtract one pixel to remove red underline for character tracking
ctx.clearRect(0, 0, this.textCanvas.width, this.textCanvas.height);
// Draw each individual letter onto the Canvas
for (i = 0; i < letters.length; i++) {
l = this.coordLibrary[letters[i]];
ctx.drawImage(this.canvas, l.xStart, 0, l.width, this.canvas.height, xPos, 0, l.width, this.canvas.height);
xPos += l.width;
}
if (DEBUG) {
console.log('new canvas width', width);
$(this.textCanvas).css('display', 'block').appendTo('body');
}
this.on = true;
}
});
return Text;
});
|
import Vue from 'vue'
import Filterbar from '../../../src/components/shared/layout/Filterbar'
const updateSearch = jest.fn()
const Constructor = Vue.extend({
data() {
return {
showDefault: false,
showAdvancedFilters: false,
}
},
render(h) {
return h(Filterbar, {
on: {
'update:search': updateSearch,
},
}, [
this.showDefault ? h('div', {
class: 'default-slot-test',
}) : null,
this.showAdvancedFilters ? h('div', {
class: 'advanced-slot-test',
slot: 'advanced-filters',
}) : null,
])
},
})
const vm = new Constructor().$mount()
describe('Filerbar', () => {
it('should match the snapshot', () => {
expect(vm.$el).toMatchSnapshot()
})
it('should emit new search to parent', () => {
const newSearchTerm = 'netflix'
vm.$children[0]._search = newSearchTerm
expect(updateSearch).toBeCalledWith(newSearchTerm)
})
describe('slots', () => {
beforeEach(() => {
vm.showDefault = false
vm.showAdvancedFilters = false
})
it('should show default props', (done) => {
vm.showDefault = true
vm.$nextTick(() => {
expect(vm.$el.querySelectorAll('.default-slot-test').length).toBe(1)
done()
})
})
it('should hide advanced filters by default', (done) => {
vm.showAdvancedFilters = true
vm.$nextTick(() => {
expect(vm.$children[0].collapse).toBe(true)
expect(vm.$el.querySelector('button').textContent).toBe('Advanced')
done()
})
})
it('should show advanced filters when not collapsed', (done) => {
vm.showAdvancedFilters = true
vm.$children[0].collapse = false
vm.$nextTick(() => {
expect(vm.$el.querySelectorAll('.advanced-slot-test').length).toBe(1)
done()
})
})
})
})
|
// // ////////////////////////// BASIC JS/react EXAMPLES
// // ////////////////////////////////rest parametr//////////////////////////////
// const rest = (a, b, ...num) => {
// console.log(num, a, b);
// };
// rest(1, 2, 3, 4);
// // ////////////////////////////////array spread operator//////////////////////////////
// const arr1 = [1, 2, 3];
// const arr2 = [4, 5, 6];
// const copy = [...arr1, ...arr2, 7, 8];
// console.log(copy);
// // ////////////////////////////////array spread operator//////////////////////////////
// const def = {
// host: 'localhost',
// dbName: 'blog',
// user: 'admin',
// };
// const opts = {
// user: 'john',
// password: 'utopia',
// };
// const port1 = 8080;
// const result = {
// ...def, ...opts, port1,
// };
// console.log(result);
// // ////////////////////////////////object destructuring///////////////////////////
// const person = {
// age: 21,
// name: {
// first: 'Peter',
// last: 'Smith',
// },
// };
// const { age, name: { first: firstName, last: lastName }, role = 'user' } = person;
// console.log(firstName, lastName, age, role);
// const { permissions: { role1 = 'user1' } = {} } = person;
// console.log(role1);
// const connect = ({
// host = 'localhost',
// port = 12345,
// user = 'guest',
// } = {}) => {
// console.log('user:', user, 'port:', port, 'host:', host);
// };
// connect({ port: 1111 });
// const dict = {
// duck: 'quack',
// dog: 'wuff',
// mouse: 'squeak',
// };
// const { duck, ...otherAnimals } = dict;
// console.log(otherAnimals);
// // ////////////////////////////////array destructuring///////////////////////////
// const line = [[10, 17], [14, 7]];
// const [[p1x, p1y], [p2x, p2y]] = line;
// console.log(p1x, p1y, p2x, p2y);
// const people = ['chris', 'sandra', 'bob'];
// const [a, b, c = 'guest'] = people;
// console.log(a, b, c);
// console.log(people);
// const dict1 = {
// duck: 'quack',
// dog: 'wuff',
// mouse: 'squeak',
// hamster: 'squeak',
// };
// const res = Object.entries(dict1)
// .filter(([, value]) => value === 'squeak')
// .map(([key]) => key);
// console.log(res);
// const shape = {
// type: 'seqment',
// coordinates: {
// start: [10, 15],
// end: [17, 15],
// },
// };
// const { coordinates: { start: [startX, startY], end: [endX, endY] } } = shape;
// console.log(startX, startY, endX, endY);
|
import './aside.scss';
import template from './aside.html';
export default (appModule)=>{
appModule.config($stateProvider =>{
$stateProvider
.state('aside', {
url: '',
abstract: true,
template
});
});
};
|
import React from 'react';
import { storiesOf } from '@storybook/react';
import { action } from '@storybook/addon-actions';
import { linkTo } from '@storybook/addon-links';
import { default as TokenView } from '../ui/components/token';
storiesOf('UI Components|Token View', module)
.add('View', () => (
<TokenView token={ '7c173e04-1234-1234-1234-123412341234' } />
));
|
angular.module('Todo').controller('TodoController', function($scope){
// Constant name
$scope.appName= "Todos App";
$scope.btnSave = "Save";
$scope.btnDelete = "Delete Completed";
$scope.btnInProgress = "In Progress";
$scope.btnDone = "Done";
$scope.btnAll = "All";
//todos list
$scope.saved = localStorage.getItem('todos');
console.log($scope.saved);
$scope.todos = ($scope.saved !==null) ? JSON.parse($scope.saved) : [ {text: 'Learn AngularJS', done: false}, {text: 'Build an Angular app', done: false} ];
localStorage.setItem('todos', angular.toJson($scope.todos));
$scope.addTodo = function() {
$scope.todos.push({
text: $scope.newTodo,
done: false
});
$scope.newTodo = ''; //clear the input after adding
localStorage.setItem('todos', angular.toJson($scope.todos));
};
$scope.clearComplete = function(){
$scope.todos = $scope.todos.filter(function(item){
return !item.done
})
localStorage.setItem('todos', angular.toJson($scope.todos));
}
$scope.showTodo = function(btn){
var list = JSON.parse(localStorage.getItem('todos'));
if(btn === "notYet"){
console.log("IN PROGRESS CLICKED")
$scope.todos = list.filter(function(item){
return !item.done
})
list = {}
}else if(btn === "done"){
console.log("DONE CLICKED")
$scope.todos = list.filter(function(item){
return item.done
})
list = {}
}else if(btn === "all"){
console.log("ALL CLIKED")
$scope.todos = undefined = JSON.parse(localStorage.getItem('todos'));
console.log($scope.todos)
//$scope.todos = localStorage.getItem('todos');
}
}
$scope.updateStatus = function(todo){
$scope.todos[$scope.todos.indexOf(todo)] = todo
localStorage.setItem('todos', angular.toJson($scope.todos));
};
});
|
({
updateContacts : function(component, event, helper) {
component.set('v.contactsList', []);
component.set('v.isLoading', true);
if(!event.getParam('accountId')) return;
// Prepare the action to load account record
var action = component.get("c.getContactsByAccount");
//set parameters
action.setParams({'accountId': event.getParam('accountId')});
// Configure response handler
action.setCallback(this, function(response) {
component.set('v.isLoading', false);
if(!component.isValid()) return;
var state = response.getState();
if(state === "SUCCESS") {
component.set("v.contactsList", response.getReturnValue());
console.log(component.get("v.contactsList"));
} else {
console.log('Problem getting account, response state: ' + state);
}
});
$A.enqueueAction(action);
}
})
|
import react from 'react'
import $ from 'jquery'
const UploadFile = () => {
const varifyBeforeLoad = () => {
if(format.includes(finalName.toLowerCase())){
if(size<5242880){
var array = [];
if(queueMsgService.selectedGroup.type ==3){
var roomId = queueMsgService.selectedGroup.content ;
array.push(roomId);
queueMsgService.fileStreamUpload(array,$("#upload")[0].files[0],2);
}else if(queueMsgService.selectedGroup.type ==0){
$("#selectGroupList .groupItem").each(function (i) {
if($("#selectGroupList .groupItem").eq(i).css('display')!='none')
array.push($("#selectGroupList .groupItem").eq(i).attr('id'));
})
queueMsgService.fileStreamUpload(array,$("#upload")[0].files[0],2);
}
$("#upload").val('')
}else {
alert("文件大小超出限制!");
}
}
}
const uploadFile = () => {
var formData = new FormData();
var mid = dataModel.userInfo.main.id;
formData.append('file',value);
formData.append('RoomIDs',roomIDs);
formData.append('type',type);
formData.append('mID',mid);
// alert(JSON.stringify({'file':value,'RoomIDs':roomIDs,'type':type,'mID':mid}));
$.ajax({
url: dataModel.url.sendMsg,
type: 'POST',
cache: false,
data: formData,
processData: false,
contentType: false
}).done(function(res) {
}).fail(function(res) {
})
}
return(
<div className="toolBtn uploadBtn">
<input id="upload" type="file" multiple="multiple" />
</div>
)
}
|
console.log('Find what you\'re looking for?');
document.addEventListener('DOMContentLoaded', () => {
'use strict';
let buffer = [];
document.addEventListener('keydown', event => {
const inputs = ['arrowup', 'arrowright', 'arrowdown', 'arrowleft', 'b', 'a', 'enter']
const konami_code = ['arrowup', 'arrowup', 'arrowdown', 'arrowdown', 'arrowleft', 'arrowright', 'arrowleft', 'arrowright', 'b', 'a', 'enter']
const key = event.key.toLowerCase();
if (inputs.indexOf(key) === -1) return;
buffer.push(key);
if (buffer[buffer.length - 1] !== konami_code[buffer.length - 1]) buffer = [];
else if (buffer.length === 11 && buffer[buffer.length - 1] === 'enter') {
alert("do something cool")
}
});
});
|
import React from 'react';
import styled from 'styled-components';
import spinner from '../../static/img/spinner.svg';
const Img = styled.img`
animation: ${props => props.theme.rotate360} infinite 2s linear;
border-radius: 50%;
display: block;
height: 100px;
margin: 20px auto;
width: 100px;
`;
const LoadingIndicator = () => {
return (
<Img src={spinner} />
);
}
export default LoadingIndicator;
|
const express = require('express');
const router = express.Router();
const Products = require('../models/products.js');
//Get all products
router.get('/products', function(req, res, next){
Products.find(function(err, prods){
res.json(prods)
});
});
//Get a product by id
router.get('/products/:id', function(req,res,next){
Products.findOne({_id: req.params.id}, function(err, foundProduct){
if (err)
res.json(err);
else
res.json(foundProduct);
});
});
//Add new product
router.post('/addProduct', function(req, res, next){
let newProduct = new Products({
id: req.body.id,
name: req.body.name,
price: req.body.price,
stock: req.body.stock
});
newProduct.save(function(err, prod){
if(err){
res.json({msg: 'Failed to add product'});
}else{
res.json({msg: 'Product added successfully'})
}
});
});
//Edit existed product by id
router.put('/editProduct/:id', function(req, res, next){
let updatedProduct = new Products({
id: req.body.id,
name: req.body.name,
price: req.body.price,
stock: req.body.stock
});
Products.findOne({_id: req.params.id}, function(err, foundObject){
if(err){
res.json(err);
}else{
if(foundObject){
if(updatedProduct.name){
foundObject.name = req.body.name;
}
if(updatedProduct.price){
foundObject.price = req.body.price;
}
if(updatedProduct.stock){
foundObject.stock = req.body.stock;
}
foundObject.save(function(err, updatedObject){
if(updatedObject){
res.json({msg: 'Product editted successfully'})
}else{
res.json({msg: 'Fail to edit document'})
}
});
}
}
});
});
// Delete product by id
router.delete('/delProduct/:id', function(req, res, next){
Products.remove({_id: req.params.id}, function(err, result){
if(err){
res.json(err);
}else{
res.json(result);
}
});
});
// check low stock
router.get('/lowStocks', function(req, res, next){
Products.find({stock : {$lt:30}}, function(err, lowStock) {
res.json(lowStock)
});
});
module.exports = router;
|
'use strict';
module.exports.emptytestnodejs = (event, context, callback) => {
// just an empty function
callback(null, { "message": "Empty NodeJS test Function Completed."});
};
|
(function(cookies) {
if (cookies.hasInitialised) return;
var util = {
escapeRegExp: function(str) {
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
},
hasClass: function(element, selector) {
var s = ' ';
return element.nodeType === 1 &&
(s + element.className + s).replace(/[\n\t]/g, s).indexOf(s + selector + s) >= 0;
},
addClass: function(element, className) {
element.className += ' ' + className;
},
removeClass: function(element, className) {
var regex = new RegExp('\\b' + this.escapeRegExp(className) + '\\b');
element.className = element.className.replace(regex, '');
},
interpolateString: function(str, callback) {
var marker = /{{([a-z][a-z0-9\-_]*)}}/ig;
return str.replace(marker, function(matches) {
return callback(arguments[1]) || '';
})
},
getCookie: function(name) {
var value = '; ' + document.cookie;
var parts = value.split('; ' + name + '=');
return parts.length != 2 ?
undefined : parts.pop().split(';').shift();
},
setCookie: function(name, value, expiryDays, domain, path) {
var exdate = new Date();
exdate.setDate(exdate.getDate() + (expiryDays || 365));
var cookie = [
name + '=' + value,
'expires=' + exdate.toUTCString(),
'path=' + (path || '/')
];
if (domain) {
cookie.push('domain=' + domain);
}
document.cookie = cookie.join(';');
},
deepExtend: function(target, source) {
for (var prop in source) {
if (source.hasOwnProperty(prop)) {
if (prop in target && this.isPlainObject(target[prop]) && this.isPlainObject(source[prop])) {
this.deepExtend(target[prop], source[prop]);
} else {
target[prop] = source[prop];
}
}
}
return target;
},
throttle: function(callback, limit) {
var wait = false;
return function() {
if (!wait) {
callback.apply(this, arguments);
wait = true;
setTimeout(function() {
wait = false;
}, limit);
}
}
},
hash: function(str) {
var hash = 0,
i, chr, len;
if (str.length === 0) return hash;
for (i = 0, len = str.length; i < len; ++i) {
chr = str.charCodeAt(i);
hash = ((hash << 5) - hash) + chr;
hash |= 0;
}
return hash;
},
normaliseHex: function(hex) {
if (hex[0] == '#') {
hex = hex.substr(1);
}
if (hex.length == 3) {
hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
}
return hex;
},
getContrast: function(hex) {
hex = this.normaliseHex(hex);
var r = parseInt(hex.substr(0, 2), 16);
var g = parseInt(hex.substr(2, 2), 16);
var b = parseInt(hex.substr(4, 2), 16);
var yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
return (yiq >= 128) ? '#000' : '#fff';
},
getLuminance: function(hex) {
var num = parseInt(this.normaliseHex(hex), 16),
amt = 38,
R = (num >> 16) + amt,
B = (num >> 8 & 0x00FF) + amt,
G = (num & 0x0000FF) + amt;
var newColour = (0x1000000 + (R<255?R<1?0:R:255)*0x10000 + (B<255?B<1?0:B:255)*0x100 + (G<255?G<1?0:G:255)).toString(16).slice(1);
return '#'+newColour;
},
isMobile: function() {
return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
},
isPlainObject: function(obj) {
return typeof obj === 'object' && obj !== null && obj.constructor == Object;
},
};
cookies.status = {
deny: 'deny',
allow: 'allow',
dismiss: 'dismiss'
};
cookies.transitionEnd = (function() {
var el = document.createElement('div');
var trans = {
t: "transitionend",
OT: "oTransitionEnd",
msT: "MSTransitionEnd",
MozT: "transitionend",
WebkitT: "webkitTransitionEnd",
};
for (var prefix in trans) {
if (trans.hasOwnProperty(prefix) && typeof el.style[prefix + 'ransition'] != 'undefined') {
return trans[prefix];
}
}
return '';
}());
cookies.hasTransition = !!cookies.transitionEnd;
var __allowedStatuses = Object.keys(cookies.status).map(util.escapeRegExp);
cookies.customStyles = {};
cookies.Popup = (function() {
var defaultOptions = {
enabled: true,
container: null,
cookie: {
name: 'cookieconsent_status',
path: '/',
domain: '',
expiryDays: 365,
},
onPopupOpen: function() {},
onPopupClose: function() {},
onInitialise: function(status) {},
onStatusChange: function(status, chosenBefore) {},
onRevokeChoice: function() {},
content: {
header: 'Cookies used on the website!',
message: 'This website uses cookies to ensure you get the best experience on our website.',
dismiss: 'Got it!',
allow: 'Allow cookies',
deny: 'Decline',
link: 'Learn more',
href: 'http://cookiesandyou.com',
close: '❌',
revoke: 'Cookies',
},
elements: {
header: '<span class="cookies-header">{{header}}</span> ',
message: '<span id="cookieconsent:desc" class="cookies-message">{{message}}</span>',
messagelink: '<span id="cookieconsent:desc" class="cookies-message">{{message}} <a aria-label="learn more about cookies" role=button tabindex="0" class="cookies-link" href="{{href}}" target="_blank">{{link}}</a></span>',
dismiss: '<a aria-label="dismiss cookie message" role=button tabindex="0" class="cookies-btn cookies-dismiss">{{dismiss}}</a>',
allow: '<a aria-label="allow cookies" role=button tabindex="0" class="cookies-btn cookies-allow">{{allow}}</a>',
deny: '<a aria-label="deny cookies" role=button tabindex="0" class="cookies-btn cookies-deny">{{deny}}</a>',
link: '<a aria-label="learn more about cookies" role=button tabindex="0" class="cookies-link" href="{{href}}" target="_blank">{{link}}</a>',
close: '<span aria-label="dismiss cookie message" role=button tabindex="0" class="cookies-close">{{close}}</span>',
},
window: '<div role="dialog" aria-live="polite" aria-label="cookieconsent" aria-describedby="cookieconsent:desc" class="cookies-window {{classes}}"><!--googleoff: all-->{{children}}<!--googleon: all--></div>',
revokeBtn: '<div class="cookies-revoke {{classes}}">{{revoke}}</div>',
compliance: {
'info': '<div class="cookies-compliance">{{dismiss}}</div>',
'opt-in': '<div class="cookies-compliance cookies-highlight">{{dismiss}}{{allow}}</div>',
'opt-out': '<div class="cookies-compliance cookies-highlight">{{deny}}{{dismiss}}</div>',
},
type: 'info',
layouts: {
'basic': '{{messagelink}}{{compliance}}',
'basic-close': '{{messagelink}}{{compliance}}{{close}}',
'basic-header': '{{header}}{{message}}{{link}}{{compliance}}',
},
layout: 'basic',
position: 'bottom',
theme: 'block',
static: false,
palette: null,
revokable: false,
animateRevokable: true,
showLink: true,
dismissOnScroll: false,
dismissOnTimeout: false,
autoOpen: true,
autoAttach: true,
whitelistPage: [],
blacklistPage: [],
overrideHTML: null,
};
function CookiePopup() {
this.initialise.apply(this, arguments);
}
CookiePopup.prototype.initialise = function(options) {
if (this.options) {
this.destroy();
}
util.deepExtend(this.options = {}, defaultOptions);
if (util.isPlainObject(options)) {
util.deepExtend(this.options, options);
}
if (checkCallbackHooks.call(this)) {
this.options.enabled = false;
}
if (arrayContainsMatches(this.options.blacklistPage, location.pathname)) {
this.options.enabled = false;
}
if (arrayContainsMatches(this.options.whitelistPage, location.pathname)) {
this.options.enabled = true;
}
var cookiePopup = this.options.window
.replace('{{classes}}', getPopupClasses.call(this).join(' '))
.replace('{{children}}', getPopupInnerMarkup.call(this));
var customHTML = this.options.overrideHTML;
if (typeof customHTML == 'string' && customHTML.length) {
cookiePopup = customHTML;
}
if (this.options.static) {
var wrapper = appendMarkup.call(this, '<div class="cookies-grower">' + cookiePopup + '</div>');
wrapper.style.display = '';
this.element = wrapper.firstChild;
this.element.style.display = 'none';
util.addClass(this.element, 'cookies-invisible');
} else {
this.element = appendMarkup.call(this, cookiePopup);
}
applyAutoDismiss.call(this);
applyRevokeButton.call(this);
if (this.options.autoOpen) {
this.autoOpen();
}
};
CookiePopup.prototype.destroy = function() {
if (this.onButtonClick && this.element) {
this.element.removeEventListener('click', this.onButtonClick);
this.onButtonClick = null;
}
if (this.dismissTimeout) {
clearTimeout(this.dismissTimeout);
this.dismissTimeout = null;
}
if (this.onWindowScroll) {
window.removeEventListener('scroll', this.onWindowScroll);
this.onWindowScroll = null;
}
if (this.onMouseMove) {
window.removeEventListener('mousemove', this.onMouseMove);
this.onMouseMove = null;
}
if (this.element && this.element.parentNode) {
this.element.parentNode.removeChild(this.element);
}
this.element = null;
if (this.revokeBtn && this.revokeBtn.parentNode) {
this.revokeBtn.parentNode.removeChild(this.revokeBtn);
}
this.revokeBtn = null;
removeCustomStyle(this.options.palette);
this.options = null;
};
CookiePopup.prototype.open = function(callback) {
if (!this.element) return;
if (!this.isOpen()) {
if (cookies.hasTransition) {
this.fadeIn();
} else {
this.element.style.display = '';
}
if (this.options.revokable) {
this.toggleRevokeButton();
}
this.options.onPopupOpen.call(this);
}
return this;
};
CookiePopup.prototype.close = function(showRevoke) {
if (!this.element) return;
if (this.isOpen()) {
if (cookies.hasTransition) {
this.fadeOut();
} else {
this.element.style.display = 'none';
}
if (showRevoke && this.options.revokable) {
this.toggleRevokeButton(true);
}
this.options.onPopupClose.call(this);
}
return this;
};
CookiePopup.prototype.fadeIn = function() {
var el = this.element;
if (!cookies.hasTransition || !el)
return;
if (this.afterTransition) {
afterFadeOut.call(this, el)
}
if (util.hasClass(el, 'cookies-invisible')) {
el.style.display = '';
if (this.options.static) {
var height = this.element.clientHeight;
this.element.parentNode.style.maxHeight = height + 'px';
}
var fadeInTimeout = 20;
this.openingTimeout = setTimeout(afterFadeIn.bind(this, el), fadeInTimeout);
}
};
CookiePopup.prototype.fadeOut = function() {
var el = this.element;
if (!cookies.hasTransition || !el)
return;
if (this.openingTimeout) {
clearTimeout(this.openingTimeout);
afterFadeIn.bind(this, el);
}
if (!util.hasClass(el, 'cookies-invisible')) {
if (this.options.static) {
this.element.parentNode.style.maxHeight = '';
}
this.afterTransition = afterFadeOut.bind(this, el);
el.addEventListener(cookies.transitionEnd, this.afterTransition);
util.addClass(el, 'cookies-invisible');
}
};
CookiePopup.prototype.isOpen = function() {
return this.element && this.element.style.display == '' && (cookies.hasTransition ? !util.hasClass(this.element, 'cookies-invisible') : true);
};
CookiePopup.prototype.toggleRevokeButton = function(show) {
if (this.revokeBtn) this.revokeBtn.style.display = show ? '' : 'none';
};
CookiePopup.prototype.revokeChoice = function(preventOpen) {
this.options.enabled = true;
this.clearStatus();
this.options.onRevokeChoice.call(this);
if (!preventOpen) {
this.autoOpen();
}
};
CookiePopup.prototype.hasAnswered = function(options) {
return Object.keys(cookies.status).indexOf(this.getStatus()) >= 0;
};
CookiePopup.prototype.hasConsented = function(options) {
var val = this.getStatus();
return val == cookies.status.allow || val == cookies.status.dismiss;
};
CookiePopup.prototype.autoOpen = function(options) {
!this.hasAnswered() && this.options.enabled && this.open();
};
CookiePopup.prototype.setStatus = function(status) {
var c = this.options.cookie;
var value = util.getCookie(c.name);
var chosenBefore = Object.keys(cookies.status).indexOf(value) >= 0;
if (Object.keys(cookies.status).indexOf(status) >= 0) {
util.setCookie(c.name, status, c.expiryDays, c.domain, c.path);
this.options.onStatusChange.call(this, status, chosenBefore);
} else {
this.clearStatus();
}
};
CookiePopup.prototype.getStatus = function() {
return util.getCookie(this.options.cookie.name);
};
CookiePopup.prototype.clearStatus = function() {
var c = this.options.cookie;
util.setCookie(c.name, '', -1, c.domain, c.path);
};
function afterFadeIn(el) {
this.openingTimeout = null;
util.removeClass(el, 'cookies-invisible');
}
function afterFadeOut(el) {
el.style.display = 'none';
el.removeEventListener(cookies.transitionEnd, this.afterTransition);
this.afterTransition = null;
}
function checkCallbackHooks() {
var complete = this.options.onInitialise.bind(this);
if (!window.navigator.cookieEnabled) {
complete(cookies.status.deny);
return true;
}
if (window.CookiesOK || window.navigator.CookiesOK) {
complete(cookies.status.allow);
return true;
}
var allowed = Object.keys(cookies.status);
var answer = this.getStatus();
var match = allowed.indexOf(answer) >= 0;
if (match) {
complete(answer);
}
return match;
}
function getPositionClasses() {
var positions = this.options.position.split('-');
var classes = [];
positions.forEach(function(cur) {
classes.push('cookies-' + cur);
});
return classes;
}
function getPopupClasses() {
var opts = this.options;
var positionStyle = (opts.position == 'top' || opts.position == 'bottom') ? 'banner' : 'floating';
if (util.isMobile()) {
positionStyle = 'floating';
}
var classes = [
'cookies-' + positionStyle,
'cookies-type-' + opts.type,
'cookies-theme-' + opts.theme,
];
if (opts.static) {
classes.push('cookies-static');
}
classes.push.apply(classes, getPositionClasses.call(this));
var didAttach = attachCustomPalette.call(this, this.options.palette);
if (this.customStyleSelector) {
classes.push(this.customStyleSelector);
}
return classes;
}
function getPopupInnerMarkup() {
var interpolated = {};
var opts = this.options;
if (!opts.showLink) {
opts.elements.link = '';
opts.elements.messagelink = opts.elements.message;
}
Object.keys(opts.elements).forEach(function(prop) {
interpolated[prop] = util.interpolateString(opts.elements[prop], function(name) {
var str = opts.content[name];
return (name && typeof str == 'string' && str.length) ? str : '';
})
});
var complianceType = opts.compliance[opts.type];
if (!complianceType) {
complianceType = opts.compliance.info;
}
interpolated.compliance = util.interpolateString(complianceType, function(name) {
return interpolated[name];
});
var layout = opts.layouts[opts.layout];
if (!layout) {
layout = opts.layouts.basic;
}
return util.interpolateString(layout, function(match) {
return interpolated[match];
});
}
function appendMarkup(markup) {
var opts = this.options;
var div = document.createElement('div');
var cont = (opts.container && opts.container.nodeType === 1) ? opts.container : document.body;
div.innerHTML = markup;
var el = div.children[0];
el.style.display = 'none';
if (util.hasClass(el, 'cookies-window') && cookies.hasTransition) {
util.addClass(el, 'cookies-invisible');
}
this.onButtonClick = handleButtonClick.bind(this);
el.addEventListener('click', this.onButtonClick);
if (opts.autoAttach) {
if (!cont.firstChild) {
cont.appendChild(el);
} else {
cont.insertBefore(el, cont.firstChild)
}
}
return el;
}
function handleButtonClick(event) {
var targ = event.target;
if (util.hasClass(targ, 'cookies-btn')) {
var matches = targ.className.match(new RegExp("\\bcookies-(" + __allowedStatuses.join('|') + ")\\b"));
var match = (matches && matches[1]) || false;
if (match) {
this.setStatus(match);
this.close(true);
}
}
if (util.hasClass(targ, 'cookies-close')) {
this.setStatus(cookies.status.dismiss);
this.close(true);
}
if (util.hasClass(targ, 'cookies-revoke')) {
this.revokeChoice();
}
}
function attachCustomPalette(palette) {
var hash = util.hash(JSON.stringify(palette));
var selector = 'cookies-color-override-' + hash;
var isValid = util.isPlainObject(palette);
this.customStyleSelector = isValid ? selector : null;
if (isValid) {
addCustomStyle(hash, palette, '.' + selector);
}
return isValid;
}
function addCustomStyle(hash, palette, prefix) {
if (cookies.customStyles[hash]) {
++cookies.customStyles[hash].references;
return;
}
var colorStyles = {};
var popup = palette.popup;
var button = palette.button;
var highlight = palette.highlight;
if (popup) {
popup.text = popup.text ? popup.text : util.getContrast(popup.background);
popup.link = popup.link ? popup.link : popup.text;
colorStyles[prefix + '.cookies-window'] = [
'color: ' + popup.text,
'background-color: ' + popup.background
];
colorStyles[prefix + '.cookies-revoke'] = [
'color: ' + popup.text,
'background-color: ' + popup.background
];
colorStyles[prefix + ' .cookies-link,' + prefix + ' .cookies-link:active,' + prefix + ' .cookies-link:visited'] = [
'color: ' + popup.link
];
if (button) {
button.text = button.text ? button.text : util.getContrast(button.background);
button.border = button.border ? button.border : 'transparent';
colorStyles[prefix + ' .cookies-btn'] = [
'color: ' + button.text,
'border-color: ' + button.border,
'background-color: ' + button.background
];
if(button.background != 'transparent')
colorStyles[prefix + ' .cookies-btn:hover, ' + prefix + ' .cookies-btn:focus'] = [
'background-color: ' + getHoverColour(button.background)
];
if (highlight) {
highlight.text = highlight.text ? highlight.text : util.getContrast(highlight.background);
highlight.border = highlight.border ? highlight.border : 'transparent';
colorStyles[prefix + ' .cookies-highlight .cookies-btn:first-child'] = [
'color: ' + highlight.text,
'border-color: ' + highlight.border,
'background-color: ' + highlight.background
];
} else {
colorStyles[prefix + ' .cookies-highlight .cookies-btn:first-child'] = [
'color: ' + popup.text
];
}
}
}
var style = document.createElement('style');
document.head.appendChild(style);
cookies.customStyles[hash] = {
references: 1,
element: style.sheet
};
var ruleIndex = -1;
for (var prop in colorStyles) {
if (colorStyles.hasOwnProperty(prop)) {
style.sheet.insertRule(prop + '{' + colorStyles[prop].join(';') + '}', ++ruleIndex);
}
}
}
function getHoverColour(hex) {
hex = util.normaliseHex(hex);
if (hex == '000000') {
return '#222';
}
return util.getLuminance(hex);
}
function removeCustomStyle(palette) {
if (util.isPlainObject(palette)) {
var hash = util.hash(JSON.stringify(palette));
var customStyle = cookies.customStyles[hash];
if (customStyle && !--customStyle.references) {
var styleNode = customStyle.element.ownerNode;
if (styleNode && styleNode.parentNode) {
styleNode.parentNode.removeChild(styleNode);
}
cookies.customStyles[hash] = null;
}
}
}
function arrayContainsMatches(array, search) {
for (var i = 0, l = array.length; i < l; ++i) {
var str = array[i];
if ((str instanceof RegExp && str.test(search)) ||
(typeof str == 'string' && str.length && str === search)) {
return true;
}
}
return false;
}
function applyAutoDismiss() {
var setStatus = this.setStatus.bind(this);
var delay = this.options.dismissOnTimeout;
if (typeof delay == 'number' && delay >= 0) {
this.dismissTimeout = window.setTimeout(function() {
setStatus(cookies.status.dismiss);
}, Math.floor(delay));
}
var scrollRange = this.options.dismissOnScroll;
if (typeof scrollRange == 'number' && scrollRange >= 0) {
var onWindowScroll = function(evt) {
if (window.pageYOffset > Math.floor(scrollRange)) {
setStatus(cookies.status.dismiss);
window.removeEventListener('scroll', onWindowScroll);
this.onWindowScroll = null;
}
};
this.onWindowScroll = onWindowScroll;
window.addEventListener('scroll', onWindowScroll);
}
}
function applyRevokeButton() {
if (this.options.type != 'info') this.options.revokable = true;
if (util.isMobile()) this.options.animateRevokable = false;
if (this.options.revokable) {
var classes = getPositionClasses.call(this);
if (this.options.animateRevokable) {
classes.push('cookies-animate');
}
if (this.customStyleSelector) {
classes.push(this.customStyleSelector)
}
var revokeBtn = this.options.revokeBtn.replace('{{classes}}', classes.join(' '));
this.revokeBtn = appendMarkup.call(this, revokeBtn);
var btn = this.revokeBtn;
if (this.options.animateRevokable) {
var wait = false;
var onMouseMove = util.throttle(function(evt) {
var active = false;
var minY = 20;
var maxY = (window.innerHeight - 20);
if (util.hasClass(btn, 'cookies-top') && evt.clientY < minY) active = true;
if (util.hasClass(btn, 'cookies-bottom') && evt.clientY > maxY) active = true;
if (active) {
if (!util.hasClass(btn, 'cookies-active')) {
util.addClass(btn, 'cookies-active');
}
} else {
if (util.hasClass(btn, 'cookies-active')) {
util.removeClass(btn, 'cookies-active');
}
}
}, 200);
this.onMouseMove = onMouseMove;
window.addEventListener('mousemove', onMouseMove);
}
}
}
return CookiePopup
}());
cookies.Location = (function() {
var defaultOptions = {
timeout: 5000,
services: [
'freegeoip',
'ipinfo',
'maxmind'
],
serviceDefinitions: {
freegeoip: function() {
return {
url: '//freegeoip.net/json/?callback={callback}',
isScript: true,
callback: function(done, response) {
try{
var json = JSON.parse(response);
return json.error ? toError(json) : {
code: json.country_code
};
} catch (err) {
return toError({error: 'Invalid response ('+err+')'});
}
}
}
},
ipinfo: function() {
return {
url: '//ipinfo.io',
headers: ['Acookiesept: application/json'],
callback: function(done, response) {
try{
var json = JSON.parse(response);
return json.error ? toError(json) : {
code: json.country
};
} catch (err) {
return toError({error: 'Invalid response ('+err+')'});
}
}
}
},
ipinfodb: function(options) {
return {
url: '//api.ipinfodb.com/v3/ip-country/?key={api_key}&format=json&callback={callback}',
isScript: true,
callback: function(done, response) {
try{
var json = JSON.parse(response);
return json.statusCode == 'ERROR' ? toError({error: json.statusMessage}) : {
code: json.countryCode
};
} catch (err) {
return toError({error: 'Invalid response ('+err+')'});
}
}
}
},
maxmind: function() {
return {
url: '//js.maxmind.com/js/apis/geoip2/v2.1/geoip2.js',
isScript: true,
callback: function(done) {
if (!window.geoip2) {
done(new Error('Unexpected response format. The downloaded script should have exported `geoip2` to the global scope'));
return;
}
geoip2.country(function(location) {
try {
done({
code: location.country.iso_code
});
} catch (err) {
done(toError(err));
}
}, function(err) {
done(toError(err));
});
}
}
},
},
};
function Location(options) {
util.deepExtend(this.options = {}, defaultOptions);
if (util.isPlainObject(options)) {
util.deepExtend(this.options, options);
}
this.currentServiceIndex = -1;
}
Location.prototype.getNextService = function() {
var service;
do {
service = this.getServiceByIdx(++this.currentServiceIndex);
} while (this.currentServiceIndex < this.options.services.length && !service);
return service;
};
Location.prototype.getServiceByIdx = function(idx) {
var serviceOption = this.options.services[idx];
if (typeof serviceOption === 'function') {
var dynamicOpts = serviceOption();
if (dynamicOpts.name) {
util.deepExtend(dynamicOpts, this.options.serviceDefinitions[dynamicOpts.name](dynamicOpts));
}
return dynamicOpts;
}
if (typeof serviceOption === 'string') {
return this.options.serviceDefinitions[serviceOption]();
}
if (util.isPlainObject(serviceOption)) {
return this.options.serviceDefinitions[serviceOption.name](serviceOption);
}
return null;
};
Location.prototype.locate = function(complete, error) {
var service = this.getNextService();
if (!service) {
error(new Error('No services to run'));
return;
}
this.callbackComplete = complete;
this.callbackError = error;
this.runService(service, this.runNextServiceOnError.bind(this));
};
Location.prototype.setupUrl = function(service) {
var serviceOpts = this.getCurrentServiceOpts();
return service.url.replace(/\{(.*?)\}/g, function(_, param) {
if (param === 'callback') {
var tempName = 'callback' + Date.now();
window[tempName] = function(res) {
service.__JSONP_DATA = JSON.stringify(res);
}
return tempName;
}
if (param in serviceOpts.interpolateUrl) {
return serviceOpts.interpolateUrl[param];
}
});
};
Location.prototype.runService = function(service, complete) {
var self = this;
if (!service || !service.url || !service.callback) {
return;
}
var requestFunction = service.isScript ? getScript : makeAsyncRequest;
var url = this.setupUrl(service);
requestFunction(url, function(xhr) {
var responseText = xhr ? xhr.responseText : '';
if (service.__JSONP_DATA) {
responseText = service.__JSONP_DATA;
delete service.__JSONP_DATA;
}
self.runServiceCallback.call(self, complete, service, responseText);
}, this.options.timeout, service.data, service.headers);
};
Location.prototype.runServiceCallback = function(complete, service, responseText) {
var self = this;
var serviceResultHandler = function (asyncResult) {
if (!result) {
self.onServiceResult.call(self, complete, asyncResult)
}
};
var result = service.callback(serviceResultHandler, responseText);
if (result) {
this.onServiceResult.call(this, complete, result);
}
};
Location.prototype.onServiceResult = function(complete, result) {
if (result instanceof Error || (result && result.error)) {
complete.call(this, result, null);
} else {
complete.call(this, null, result);
}
};
Location.prototype.runNextServiceOnError = function(err, data) {
if (err) {
this.logError(err);
var nextService = this.getNextService();
if (nextService) {
this.runService(nextService, this.runNextServiceOnError.bind(this));
} else {
this.completeService.call(this, this.callbackError, new Error('All services failed'));
}
} else {
this.completeService.call(this, this.callbackComplete, data);
}
};
Location.prototype.getCurrentServiceOpts = function() {
var val = this.options.services[this.currentServiceIndex];
if (typeof val == 'string') {
return {name: val};
}
if (typeof val == 'function') {
return val();
}
if (util.isPlainObject(val)) {
return val;
}
return {};
};
Location.prototype.completeService = function(fn, data) {
this.currentServiceIndex = -1;
fn && fn(data);
};
Location.prototype.logError = function (err) {
var idx = this.currentServiceIndex;
var service = this.getServiceByIdx(idx);
console.error('The service[' + idx + '] (' + service.url + ') responded with the following error', err);
};
function getScript(url, callback, timeout) {
var timeoutIdx, s = document.createElement('script');
s.type = 'text/' + (url.type || 'javascript');
s.src = url.src || url;
s.async = false;
s.onreadystatechange = s.onload = function() {
var state = s.readyState;
clearTimeout(timeoutIdx);
if (!callback.done && (!state || /loaded|complete/.test(state))) {
callback.done = true;
callback();
s.onreadystatechange = s.onload = null;
}
};
document.body.appendChild(s);
timeoutIdx = setTimeout(function () {
callback.done = true;
callback();
s.onreadystatechange = s.onload = null;
}, timeout);
}
function makeAsyncRequest(url, onComplete, timeout, postData, requestHeaders) {
var xhr = new(window.XMLHttpRequest || window.ActiveXObject)('MSXML2.XMLHTTP.3.0');
xhr.open(postData ? 'POST' : 'GET', url, 1);
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
if (Array.isArray(requestHeaders)) {
for (var i = 0, l = requestHeaders.length; i < l; ++i) {
var split = requestHeaders[i].split(':', 2)
xhr.setRequestHeader(split[0].replace(/^\s+|\s+$/g, ''), split[1].replace(/^\s+|\s+$/g, ''));
}
}
if (typeof onComplete == 'function') {
xhr.onreadystatechange = function() {
if (xhr.readyState > 3) {
onComplete(xhr);
}
};
}
xhr.send(postData);
}
function toError(obj) {
return new Error('Error [' + (obj.code || 'UNKNOWN') + ']: ' + obj.error);
}
return Location;
}());
cookies.Law = (function() {
var defaultOptions = {
regionalLaw: true,
hasLaw: ['AT', 'BE', 'BG', 'HR', 'CZ', 'CY', 'DK', 'EE', 'FI', 'FR', 'DE', 'EL', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL', 'PL', 'PT', 'SK', 'SI', 'ES', 'SE', 'GB', 'UK'],
revokable: ['HR', 'CY', 'DK', 'EE', 'FR', 'DE', 'LV', 'LT', 'NL', 'PT', 'ES'],
explicitAction: ['HR', 'IT', 'ES'],
};
function Law(options) {
this.initialise.apply(this, arguments);
}
Law.prototype.initialise = function(options) {
util.deepExtend(this.options = {}, defaultOptions);
if (util.isPlainObject(options)) {
util.deepExtend(this.options, options);
}
};
Law.prototype.get = function(countryCode) {
var opts = this.options;
return {
hasLaw: opts.hasLaw.indexOf(countryCode) >= 0,
revokable: opts.revokable.indexOf(countryCode) >= 0,
explicitAction: opts.explicitAction.indexOf(countryCode) >= 0,
};
};
Law.prototype.applyLaw = function(options, countryCode) {
var country = this.get(countryCode);
if (!country.hasLaw) {
options.enabled = false;
}
if (this.options.regionalLaw) {
if (country.revokable) {
options.revokable = true;
}
if (country.explicitAction) {
options.dismissOnScroll = false;
options.dismissOnTimeout = false;
}
}
return options;
};
return Law;
}());
cookies.initialise = function(options, complete, error) {
var law = new cookies.Law(options.law);
if (!complete) complete = function() {};
if (!error) error = function() {};
cookies.getCountryCode(options, function(result) {
delete options.law;
delete options.location;
if (result.code) {
options = law.applyLaw(options, result.code);
}
complete(new cookies.Popup(options));
}, function(err) {
delete options.law;
delete options.location;
error(err, new cookies.Popup(options));
});
};
cookies.getCountryCode = function(options, complete, error) {
if (options.law && options.law.countryCode) {
complete({
code: options.law.countryCode
});
return;
}
if (options.location) {
var locator = new cookies.Location(options.location);
locator.locate(function(serviceResult) {
complete(serviceResult || {});
}, error);
return;
}
complete({});
};
cookies.utils = util;
cookies.hasInitialised = true;
window.cookieconsent = cookies;
}(window.cookieconsent || {}));
|
function Question(questionData) {
this.question = questionData.question;
this.answer = questionData.answer;
this.choices = questionData.choices;
this.id = questionData.id;
this.attempts = questionData.attempts;
this.timesCorrect = questionData.timesCorrect;
}
|
/*
* Copyright 2011-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var vertx = vertx || {};
if (!vertx.createSockJSServer) {
vertx.createSockJSServer = function(httpServer) {
if (typeof httpServer._to_java_server != 'function') {
throw "Please construct a vertx.SockJSServer with an instance of vert.HttpServer"
}
var vertx = org.vertx.java.platform.impl.RhinoVerticleFactory.vertx;
var jserver = vertx.createSockJSServer(httpServer._to_java_server());
function convertPermitted(permitted) {
var json_arr = new org.vertx.java.core.json.JsonArray();
for (var i = 0; i < permitted.length; i++) {
var match = permitted[i];
var json_str = JSON.stringify(match);
var jJson = new org.vertx.java.core.json.JsonObject(json_str);
json_arr.add(jJson);
}
return json_arr;
}
var server = {
installApp: function(config, handler) {
jserver.installApp(new org.vertx.java.core.json.JsonObject(JSON.stringify(config)), handler);
},
setEventBusBridgeListener: function(bridgeListener) {
jserver.setEventBusBridgeListener(new org.vertx.java.core.sockjs.EventBusBridgeListener(bridgeListener));
return server;
},
bridge: function(config, inboundPermitted, outboundPermitted, authTimeout, authAddress) {
if (typeof authTimeout === 'undefined') {
authTimeout = 5 * 50 * 1000;
}
if (typeof authAddress === 'undefined') {
authAddress = null;
}
var jInboundPermitted = convertPermitted(inboundPermitted);
var jOutboundPermitted = convertPermitted(outboundPermitted);
jserver.bridge(new org.vertx.java.core.json.JsonObject(JSON.stringify(config)),
jInboundPermitted, jOutboundPermitted, authTimeout, authAddress);
}
}
return server;
}
}
|
const fs=require('fs');
const bencode=require('bencode');
const bignum=require('bignum');
//torrent-parser.open
module.exports.open=filepath=>{
return bencode.decode(fs.readFileSync(filepath));
}
//torrent-parser.size
module.exports.size=torrent=>{
const size=torrent.info.files ? torrent.info.files.map(file=>file.length).reduce((a,b)=>a+b) : torrent.info.length;
return bignum.toBuffer(size,{size:8});
}
//torrent-parse.infoHash
module.exports.infoHash=torrent=>{
const info=bencode.decode(torrent.info);
return crypto.createHash('sha1').update(info).digest();
}
|
import bodyParser from 'body-parser';
import express from 'express';
import cors from 'cors';
import mongoose from 'mongoose';
import config from 'config';
import fakeData from './config/fakeData';
require('mongoose-schema-jsonschema')(mongoose);
const app = express();
app.use(cors());
app.use(bodyParser.json({limit: '25mb'}));
app.use(bodyParser.urlencoded({
extended: true
}));
mongoose.Promise = global.Promise;
mongoose.connect(config.get('mongodb.uri'), {
useNewUrlParser: true,
connectTimeoutMS: 2147483647,
useUnifiedTopology: true
});
mongoose.connection.on('error', (err) => {
throw err;
});
mongoose.connection.on('connected', async () => {
console.log('MongoDB database connected! Environment:', config.get('entorno'));
try {
await fakeData.buildProducts();
await fakeData.buildDeliveries();
} catch (e) {
console.log('MongoDB ensuring indexes FAIL', e);
}
});
// Routes
import router from './components/router/routes';
router.mountRoutes(app);
// Handle uncaughtException
process.on('uncaughtException', (err) => {
console.log(err);
// console.log('Caught exception: %j', err);
});
export default app;
|
import React, { Component } from 'react'
import {Link} from 'react-router-dom';
import {
Collapse,
Navbar,
NavbarToggler,
NavbarBrand,
Nav,
NavItem,
NavLink,
UncontrolledDropdown,
DropdownToggle,
DropdownMenu,
DropdownItem,
NavbarText
} from 'reactstrap';
class AppNavbar extends Component {
state={
isOpen:false,
}
toggle = () =>
this.setState({
isOpen:!this.state.isOpen
});
render() {
return (
<div>
<Navbar color="warning" light expand="md">
<NavbarBrand ><Link style={{color:'black'}} to="/">COVID19-Tracker</Link></NavbarBrand>
<NavbarToggler onClick={this.toggle} />
<Collapse isOpen={this.state.isOpen} navbar>
<Nav className="mr-auto" navbar>
<NavItem>
<NavLink><Link style={{color:'black'}} to="/about">About</Link></NavLink>
</NavItem>
<UncontrolledDropdown nav inNavbar>
<DropdownToggle nav caret>
Countries
</DropdownToggle>
<DropdownMenu right>
<DropdownItem onClick={()=>{this.props.setCountry('India')}}>
India
</DropdownItem>
<DropdownItem onClick={()=>{this.props.setCountry('Italy')}}>
Italy
</DropdownItem>
<DropdownItem onClick={()=>{this.props.setCountry('China')}}>
China
</DropdownItem>
<DropdownItem onClick={()=>{this.props.setCountry('United States of America')}}>
United States
</DropdownItem>
<DropdownItem divider />
<DropdownItem onClick={()=>{this.props.setGlobal()}}>
Global
</DropdownItem>
</DropdownMenu>
</UncontrolledDropdown>
</Nav>
<NavbarText>{this.props.simpleText}</NavbarText>
</Collapse>
</Navbar>
</div>
);
}
}
export default AppNavbar
|
const express = require('express');
const router = express.Router();
const catchAsync = require('../utils/catchAsync');
const ExpressError = require('../utils/ExpressError');
const Campground = require('../models/campground');
const campgrounds = require('../controllers/campgrounds');
const multer = require('multer')
const { storage } = require('../cloudinary');
const upload = multer({ storage });
const {isLoggedIn,isAuthor, validateCampground } = require('../middleware');
router.route('/')
.get(catchAsync(campgrounds.index))
.post(isLoggedIn, upload.array('image'),validateCampground,catchAsync(campgrounds.createCampground));
router.get('/new',isLoggedIn, campgrounds.renderNewForm); // this has to be in front of /:id otherwise the node treat it as id
router.route('/:id')
.get(catchAsync(campgrounds.showCampground))
.put(isLoggedIn,isAuthor,upload.array('image'),validateCampground , catchAsync(campgrounds.updateCampground))
.delete(isLoggedIn,isAuthor,catchAsync(campgrounds.deleteCampground));
router.get('/:id/edit',isLoggedIn,isAuthor, catchAsync(campgrounds.renderEdit));
module.exports = router;
|
import React from 'react';
import {Platform, Alert, StyleSheet, AsyncStorage, View, ScrollView, FlatList, Text, TextInput, TouchableOpacity, StatusBar} from 'react-native';
import Icon from 'react-native-vector-icons/Feather';
import _ from 'lodash';
import MemoryListItem from '../components/memory-list-item';
import MemoryStore from '../store/memory.store';
import HashtagStore from '../store/hashtag.store';
import { Colors } from '../scripts/styles';
export default class Memories extends React.Component {
constructor(props){
super(props);
this.state = {
initialMemoryArray: [],
memoryArray: [],
tags: {},
searchTerm: '',
}
}
componentDidMount() {
const { navigation } = this.props;
navigation.addListener('willFocus', () => {
MemoryStore.get().then(memories => {
HashtagStore.get().then((tags) => {
this.setState({'memoryArray': memories, initialMemoryArray: memories, tags});
});
});
});
this.props.navigation.navigate('EditMemory');
}
toggleFlag = (id) => this.toggle(id,'flag');
toggleDone = (id) => this.toggle(id,'done');
toggle = (id, key) => {
let memoryArray = _.clone(this.state.memoryArray);
let memory = _.find(memoryArray, {id});
memory[key] = !memory[key];
MemoryStore.update(id, memory).then(() => {
this.setState({memoryArray});
});
}
editMemory = (id) => {
this.props.navigation.navigate('EditMemory', {id});
}
deleteMemory = (id, memoryText) => {
const memoryRemoval = (id) => {
let memoryArray = (Object.assign([], this.state.memoryArray));
memoryArray.splice(id, 1);
MemoryStore.delete(id);
this.setState({'memoryArray': this.state.memoryArray});
};
Alert.alert(
'Delete this memory?',
memoryText,
[
{text: 'Cancel', style: 'cancel'},
{text: 'Delete', onPress: () => memoryRemoval(id), style: 'destructive'},
],
{ cancelable: false }
);
}
search = _.throttle((searchTerm) => {
MemoryStore.search(searchTerm).then(memoryArray => {
this.setState({memoryArray});
});
}, 600);
renderMemory = ({item, index}) => (
<MemoryListItem
id={item.id}
memory={item}
onDonePress={this.toggleDone}
onFlagPress={this.toggleFlag}
onEditPress={this.editMemory}
onDeletePress={this.deleteMemory}
/>
);
keyExtractor = (item, index) => String(item.id);
render() {
return (
<View style={styles.container}>
<StatusBar backgroundColor={Colors.primary} barStyle="dark-content"/>
<View style={styles.memoryInput}>
<TextInput style={styles.textInput} placeholder="Search Memories" placeholderTextColor="#CCC" multiline={true} underlineColorAndroid="transparent"
onChangeText={this.search} />
</View>
<View>
</View>
<FlatList
style={styles.body}
data={this.state.memoryArray}
extraData={this.state}
keyExtractor={this.keyExtractor}
renderItem={this.renderMemory}
/>
<TouchableOpacity style={styles.newButton} onPress={() => this.props.navigation.navigate('EditMemory')} >
<Icon name="plus" size={18} color='#FFF'/>
</TouchableOpacity>
</View>
);
}
}
const styles = StyleSheet.create({
container: {
flex: 1,
},
memoryInput: {
backgroundColor: Colors.primary,
borderBottomWidth: 1,
borderBottomColor: '#EEE',
padding: 12,
},
textInput: {
alignSelf: 'stretch',
textAlignVertical: 'top',
fontSize: 18,
color: Colors.text.onDark,
padding: 6,
paddingLeft: 10,
backgroundColor: Colors.overlay.light,
borderRadius: 3,
},
scrollContainer: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#FFF',
marginBottom: 64,
//padding: 5
},
newButton: {
position: 'absolute',
bottom: 20,
right: 20,
height: 56,
width: 56,
borderRadius: 28,
elevation: 6,
alignItems: 'center',
justifyContent: 'center',
backgroundColor: Colors.primary.light,
},
newButtonText: {
fontSize: 22,
color: '#FFF'
}
});
|
import axios from 'axios';
import { GET_EVENTS, ADD_EVENT, DELETE_EVENT, SET_VISIBLE_FALSE } from './types';
import moment from "moment-timezone";
export const getEvents = (token) => {
try {
return async dispatch => {
const response = await axios.get('https://exchangestudentsapp-fardel.herokuapp.com/eventsByDate', { headers: { 'Authorization': `Bearer ${token}` } });
if (response.data) {
response.data.sort((a, b) => {
a.data.sort((c, d) => {
if (moment(c.time, 'LT') > moment(d.time, 'LT'))
return 1;
else return -1;
});
if (a.date > b.date)
return 1;
else return -1;
})
dispatch({
type: GET_EVENTS,
payload: response.data
});
} else {
console.log('Unable to fetch data from the API BASE URL!');
}
};
} catch (error) {
console.log(error);
}
};
export const deleteEvent = (index, token) => {
let url = 'https://exchangestudentsapp-fardel.herokuapp.com/event/' + index;
try {
return async dispatch => {
await axios.delete(url, { headers: { 'Authorization': `Bearer ${token}` } })
.then(response => {
dispatch({
type: DELETE_EVENT,
payload: index
});
});
};
} catch (error) {
console.log(error);
}
};
export const addEvent = (event, token) => {
try {
return async dispatch => {
await axios.post('https://exchangestudentsapp-fardel.herokuapp.com/addevent', event, { headers: { 'Authorization': `Bearer ${token}` } })
.then(response => {
dispatch({
type: ADD_EVENT,
payload: event
});
});
};
} catch (error) {
console.log(error);
}
};
export const setVisibleFalse = () => dispatch => {
dispatch({
type: SET_VISIBLE_FALSE
})
};
|
import React from 'react'
const Junemasterclass = () => {
return (
<div>
<div className="news-updates">
<div className="container">
<div className="row">
<div className="col-lg-12">
<div className="section-heading">
<h3 className="discover_about">June Master Class</h3>
</div>
</div>
</div>
</div>
</div>
</div>
)
}
export default Junemasterclass
|
var config = require("config")
const fetch = require("node-fetch");
const Discord = require('discord.js');
import Helpers from '../../helpers/helpers'
module.exports = class ban {
constructor() {
this.name = 'ban',
this.alias = ['bankiller'],
this.usage = `${process.env.DISCORD_COMMAND_PREFIX || config.commandPrefix}${this.name}`
this.messagesToDelete = [];
}
async run(bot, message, args) {
if (!(message.member.roles.cache.has(process.env.DISCORD_RCON_ROLEID || config.rconRoleId))) {
message.reply("You don't have permission to use this command.")
return
}
await message.delete()
let server = await Helpers.selectServer(message)
if (!server) {
message.reply("Unknown error");
message.delete({ timeout: 5000 });
clearMessages();
return;
}
let parameters = await this.getParameters(message, server)
.then(parameters => {
this.clearMessages();
return parameters;
})
.catch(err => {
console.log(err);
this.clearMessages();
return null;
})
if (!parameters) {
return
}
return fetch(`${server}/admin/ban`, {
method: "post",
headers: {
"Content-type": "application/json",
"Accept": "application/json",
"Accept-Charset": "utf-8"
},
body: JSON.stringify(parameters)
})
.then(response => response.json())
.then(json => {
return message.channel.send({ embed: this.buildEmbed(message, parameters, json) })
})
.catch(error => {
console.log(error)
return false
})
}
clearMessages() {
for (const message of this.messagesToDelete) {
message.delete();
}
}
getParameters(message) {
return new Promise(async (resolve, reject) => {
let banType;
let banId;
let timeout;
let banReason;
askbanType: while (true) {
banType = await Helpers.askbanType(message);
if (!banType) {
if (await Helpers.askTryAgain(message)) {
continue askbanType;
}
return reject(Error("Couldn't get the ban Type"))
}
break;
}
askPlayerName: while (true) {
banId = await Helpers.askPlayerName(message);
if (!banId) {
if (await Helpers.askTryAgain(message)) {
continue askPlayerName;
}
return reject(Error("Couldn't get the banId"))
}
break;
}
const embed = new Discord.MessageEmbed()
.setTimestamp()
.setColor("00FF00")
.setAuthor('Given Properties', message.author.avatarURL());
embed.addField('Given playername', `**${banId}**`, false);
const msg = await message.channel.send(embed);
asktimeout: while (true) {
timeout = await Helpers.asktimeout(message);
if (!timeout) {
if (await Helpers.askTryAgain(message)) {
continue asktimeout;
}
return reject(Error("Couldn't get the ban type"))
}
break;
}
msg.delete();
// valid arg -> perm OR rounds -> there space needs to be added for valid call
switch (timeout) {
case "perm":
break;
case "seconds":
asktimeout: while (true) {
timeout += " " + await Helpers.asktimeout(message);
if (!timeout) {
if (await Helpers.askTryAgain(message)) {
continue asktimeout;
}
return reject(Error("Couldn't get ban duration in seconds"))
}
break;
}
break;
case "rounds":
asktimeout: while (true) {
timeout += " " + await Helpers.asktimeout(message);
if (!timeout) {
if (await Helpers.askTryAgain(message)) {
continue asktimeout;
}
return reject(Error("Couldn't get ban duration in rounds"))
}
break;
}
break;
}
askReason: while (true) {
banReason = await Helpers.askReason(message);
if (!banReason) {
if (await Helpers.askTryAgain(message)) {
continue askReason;
}
return reject(Error("Couldn't get the reason"))
}
break;
}
msg.delete();
const confirmEmbed = new Discord.MessageEmbed()
.setTimestamp()
.setColor("00FF00")
.setAuthor('Are you sure you want to ban the player?', message.author.avatarURL());
confirmEmbed.addField('Given banType', `**${banType}**`, false);
confirmEmbed.addField('Given playername', `**${banId}**`, false);
confirmEmbed.addField('Given timeout', `**${timeout}**`, false);
confirmEmbed.addField('Given reason', `**${banReason}**`, false);
if (await Helpers.confirm(message, confirmEmbed)) {
return resolve({
banType: banType,
banId: banId,
timeout: timeout,
banReason: banReason,
});
}
else {
return reject(Error("Ban interrupted!"))
}
})
}
buildEmbed(message, parameters, response) {
const embed = new Discord.MessageEmbed()
.setTimestamp()
.setColor(response.status === "OK" ? "00FF00" : "FF0000")
.setThumbnail('https://img.pngio.com/ban-banhammer-censor-censorship-hammer-ip-block-moderator-icon-banhammer-png-512_512.png')
.setFooter('Author: Bartis', 'https://img.pngio.com/ban-banhammer-censor-censorship-hammer-ip-block-moderator-icon-banhammer-png-512_512.png')
.setAuthor('Ban', message.author.avatarURL())
.addField('Issuer', message.author.username, true)
.addField('Target', `**${response?.data?.banId}**`, true)
.addField('Type', response?.data?.banType, true)
switch (response?.data?.banTimeoutType) {
case "perm":
embed.addField('Duration', '**Permanent**', true)
break
case "rounds":
embed.addField('Duration', `**${response?.data?.banTimeout}** rounds`, true)
break
case "seconds":
embed.addField('Duration', `**${response?.data?.banTimeout}** seconds`, true)
break
default:
embed.addField('Duration', `unknown`, true)
break
}
embed.addField('Reason', response?.data?.banReason, true)
embed.addField('Server', response?.server, false)
return embed
}
}
|
import { useQuery, useLazyQuery, useMutation } from '@apollo/react-hooks';
import {
GET_PORTFOLIOS,
GET_PORTFOLIO,
GET_USER_PORTFOLIOS,
CREATE_PORTFOLIO,
UPDATE_PORTFOLIO,
DELETE_PORTFOLIO,
SIGN_IN,
SIGN_OUT,
GET_USER,
} from '@/apollo/queries';
export const useGetPortfolios = () => useQuery(GET_PORTFOLIOS);
export const useGetPortfolio = (options) => useQuery(GET_PORTFOLIO, options);
export const useGetUserPortfolios = () => useQuery(GET_USER_PORTFOLIOS);
export const useUpdatePortfolio = () => useMutation(UPDATE_PORTFOLIO);
export const useCreatePortfolio = () => useMutation(CREATE_PORTFOLIO, {
update(cache, { data: { createPortfolio } }) {
const { portfolios } = cache.readQuery({ query: GET_PORTFOLIOS });
const newPortfolios = [...portfolios, createPortfolio];
cache.writeQuery({
query: GET_PORTFOLIOS,
data: { portfolios: newPortfolios }
});
}
});
export const useDeletePortfolio = () => useMutation(DELETE_PORTFOLIO, {
update(cache, { data: { deletePortfolio: deletedId } }) {
const { userPortfolios } = cache.readQuery({ query: GET_USER_PORTFOLIOS });
const index = userPortfolios.findIndex(p => p._id === deletedId);
const newPortfolios = [...userPortfolios];
newPortfolios.splice(index, 1);
cache.writeQuery({
query: GET_USER_PORTFOLIOS,
data: { userPortfolios: newPortfolios }
});
}
});
export const useSignIn = () => useMutation(SIGN_IN, {
update(cache, { data: { signIn: signedInUser }}) {
cache.writeQuery({
query: GET_USER,
data: { user: signedInUser }
})
}
})
export const useLazyGetUser = () => useLazyQuery(GET_USER);
export const useGetUser = () => useQuery(GET_USER);
export const useSignOut = () => useMutation(SIGN_OUT);
|
import React from 'react';
import { shallow } from 'enzyme';
import renderer from 'react-test-renderer';
import ReposPage from './ReposPage';
describe('ReposPage suite', () => {
it('renders RepoPage', () => {
const comp = <ReposPage isLoading username="gabrielseco" />;
const component = shallow(comp);
const tree = renderer.create(comp).toJSON();
expect(component).toBeDefined();
expect(tree).toMatchSnapshot();
});
});
|
/**
* Created by iyobo on 2016-04-24.
*
* For Common Nunjuck filters
* @param nunjucksEnv
*/
module.exports = function(nunjucksEnv){
//Renders a textfield
nunjucksEnv.addFilter('textfield', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="field '+(kwargs.class || "field ")+'"> <label for="fid_'+field.name+'" class="'+(kwargs.labelClass )+'">'+field.label+' '+(required?"*":"")+'</label> ';
output += '<input type="'+(kwargs.type || "text")+'" id="fid_'+field.name+'" name="'+field.name+'" class="skelinput '+(kwargs.inputClass || "u-full-width")+'" value="'+field.value+'" placeholder="'+field.placeholder+'" '+(required?"required":"")+' '+(kwargs.countrySelect?"country-select":"")+'> ';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span>'
output +='</div>'
return output;
});
nunjucksEnv.addFilter('hidden', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="field '+(kwargs.class || "field ")+'">';
output += '<input type="hidden" id="fid_'+field.name+'" name="'+field.name+'" class="'+(kwargs.inputClass || "u-full-width")+'" value="'+field.value+'" placeholder="'+field.placeholder+'" '+(required?"required":"")+' '+(kwargs.countrySelect?"country-select":"")+'> ';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span>'
output +='</div>'
return output;
});
nunjucksEnv.addFilter('countryfield', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="field '+(kwargs.class || "field ")+'"> <label for="fid_'+field.name+'" class="'+(kwargs.labelClass )+'">'+field.label+' '+(required?"*":"")+'</label> ';
// output += '<select id="fid_'+field.name+'" name="'+field.name+'" class="'+(kwargs.inputClass || "u-full-width form-control bfh-countries")+'" data-country="'+(field.value||"US")+'" placeholder="'+field.placeholder+'" '+(required?"required":"")+' ></select> ';
output += `
<select id="fid_${field.name}" name="${field.name}" class="${(kwargs.inputClass || "u-full-width form-control")}" data-country="${(field.value||"USA")}">
<option value="AFG">Afghanistan</option>
<option value="ALA">Åland Islands</option>
<option value="ALB">Albania</option>
<option value="DZA">Algeria</option>
<option value="ASM">American Samoa</option>
<option value="AND">Andorra</option>
<option value="AGO">Angola</option>
<option value="AIA">Anguilla</option>
<option value="ATA">Antarctica</option>
<option value="ATG">Antigua and Barbuda</option>
<option value="ARG">Argentina</option>
<option value="ARM">Armenia</option>
<option value="ABW">Aruba</option>
<option value="AUS">Australia</option>
<option value="AUT">Austria</option>
<option value="AZE">Azerbaijan</option>
<option value="BHS">Bahamas</option>
<option value="BHR">Bahrain</option>
<option value="BGD">Bangladesh</option>
<option value="BRB">Barbados</option>
<option value="BLR">Belarus</option>
<option value="BEL">Belgium</option>
<option value="BLZ">Belize</option>
<option value="BEN">Benin</option>
<option value="BMU">Bermuda</option>
<option value="BTN">Bhutan</option>
<option value="BOL">Bolivia, Plurinational State of</option>
<option value="BES">Bonaire, Sint Eustatius and Saba</option>
<option value="BIH">Bosnia and Herzegovina</option>
<option value="BWA">Botswana</option>
<option value="BVT">Bouvet Island</option>
<option value="BRA">Brazil</option>
<option value="IOT">British Indian Ocean Territory</option>
<option value="BRN">Brunei Darussalam</option>
<option value="BGR">Bulgaria</option>
<option value="BFA">Burkina Faso</option>
<option value="BDI">Burundi</option>
<option value="KHM">Cambodia</option>
<option value="CMR">Cameroon</option>
<option value="CAN">Canada</option>
<option value="CPV">Cape Verde</option>
<option value="CYM">Cayman Islands</option>
<option value="CAF">Central African Republic</option>
<option value="TCD">Chad</option>
<option value="CHL">Chile</option>
<option value="CHN">China</option>
<option value="CXR">Christmas Island</option>
<option value="CCK">Cocos (Keeling) Islands</option>
<option value="COL">Colombia</option>
<option value="COM">Comoros</option>
<option value="COG">Congo</option>
<option value="COD">Congo, the Democratic Republic of the</option>
<option value="COK">Cook Islands</option>
<option value="CRI">Costa Rica</option>
<option value="CIV">Côte d'Ivoire</option>
<option value="HRV">Croatia</option>
<option value="CUB">Cuba</option>
<option value="CUW">Curaçao</option>
<option value="CYP">Cyprus</option>
<option value="CZE">Czech Republic</option>
<option value="DNK">Denmark</option>
<option value="DJI">Djibouti</option>
<option value="DMA">Dominica</option>
<option value="DOM">Dominican Republic</option>
<option value="ECU">Ecuador</option>
<option value="EGY">Egypt</option>
<option value="SLV">El Salvador</option>
<option value="GNQ">Equatorial Guinea</option>
<option value="ERI">Eritrea</option>
<option value="EST">Estonia</option>
<option value="ETH">Ethiopia</option>
<option value="FLK">Falkland Islands (Malvinas)</option>
<option value="FRO">Faroe Islands</option>
<option value="FJI">Fiji</option>
<option value="FIN">Finland</option>
<option value="FRA">France</option>
<option value="GUF">French Guiana</option>
<option value="PYF">French Polynesia</option>
<option value="ATF">French Southern Territories</option>
<option value="GAB">Gabon</option>
<option value="GMB">Gambia</option>
<option value="GEO">Georgia</option>
<option value="DEU">Germany</option>
<option value="GHA">Ghana</option>
<option value="GIB">Gibraltar</option>
<option value="GRC">Greece</option>
<option value="GRL">Greenland</option>
<option value="GRD">Grenada</option>
<option value="GLP">Guadeloupe</option>
<option value="GUM">Guam</option>
<option value="GTM">Guatemala</option>
<option value="GGY">Guernsey</option>
<option value="GIN">Guinea</option>
<option value="GNB">Guinea-Bissau</option>
<option value="GUY">Guyana</option>
<option value="HTI">Haiti</option>
<option value="HMD">Heard Island and McDonald Islands</option>
<option value="VAT">Holy See (Vatican City State)</option>
<option value="HND">Honduras</option>
<option value="HKG">Hong Kong</option>
<option value="HUN">Hungary</option>
<option value="ISL">Iceland</option>
<option value="IND">India</option>
<option value="IDN">Indonesia</option>
<option value="IRN">Iran, Islamic Republic of</option>
<option value="IRQ">Iraq</option>
<option value="IRL">Ireland</option>
<option value="IMN">Isle of Man</option>
<option value="ISR">Israel</option>
<option value="ITA">Italy</option>
<option value="JAM">Jamaica</option>
<option value="JPN">Japan</option>
<option value="JEY">Jersey</option>
<option value="JOR">Jordan</option>
<option value="KAZ">Kazakhstan</option>
<option value="KEN">Kenya</option>
<option value="KIR">Kiribati</option>
<option value="PRK">Korea, Democratic People's Republic of</option>
<option value="KOR">Korea, Republic of</option>
<option value="KWT">Kuwait</option>
<option value="KGZ">Kyrgyzstan</option>
<option value="LAO">Lao People's Democratic Republic</option>
<option value="LVA">Latvia</option>
<option value="LBN">Lebanon</option>
<option value="LSO">Lesotho</option>
<option value="LBR">Liberia</option>
<option value="LBY">Libya</option>
<option value="LIE">Liechtenstein</option>
<option value="LTU">Lithuania</option>
<option value="LUX">Luxembourg</option>
<option value="MAC">Macao</option>
<option value="MKD">Macedonia, the former Yugoslav Republic of</option>
<option value="MDG">Madagascar</option>
<option value="MWI">Malawi</option>
<option value="MYS">Malaysia</option>
<option value="MDV">Maldives</option>
<option value="MLI">Mali</option>
<option value="MLT">Malta</option>
<option value="MHL">Marshall Islands</option>
<option value="MTQ">Martinique</option>
<option value="MRT">Mauritania</option>
<option value="MUS">Mauritius</option>
<option value="MYT">Mayotte</option>
<option value="MEX">Mexico</option>
<option value="FSM">Micronesia, Federated States of</option>
<option value="MDA">Moldova, Republic of</option>
<option value="MCO">Monaco</option>
<option value="MNG">Mongolia</option>
<option value="MNE">Montenegro</option>
<option value="MSR">Montserrat</option>
<option value="MAR">Morocco</option>
<option value="MOZ">Mozambique</option>
<option value="MMR">Myanmar</option>
<option value="NAM">Namibia</option>
<option value="NRU">Nauru</option>
<option value="NPL">Nepal</option>
<option value="NLD">Netherlands</option>
<option value="NCL">New Caledonia</option>
<option value="NZL">New Zealand</option>
<option value="NIC">Nicaragua</option>
<option value="NER">Niger</option>
<option value="NGA">Nigeria</option>
<option value="NIU">Niue</option>
<option value="NFK">Norfolk Island</option>
<option value="MNP">Northern Mariana Islands</option>
<option value="NOR">Norway</option>
<option value="OMN">Oman</option>
<option value="PAK">Pakistan</option>
<option value="PLW">Palau</option>
<option value="PSE">Palestinian Territory, Occupied</option>
<option value="PAN">Panama</option>
<option value="PNG">Papua New Guinea</option>
<option value="PRY">Paraguay</option>
<option value="PER">Peru</option>
<option value="PHL">Philippines</option>
<option value="PCN">Pitcairn</option>
<option value="POL">Poland</option>
<option value="PRT">Portugal</option>
<option value="PRI">Puerto Rico</option>
<option value="QAT">Qatar</option>
<option value="REU">Réunion</option>
<option value="ROU">Romania</option>
<option value="RUS">Russian Federation</option>
<option value="RWA">Rwanda</option>
<option value="BLM">Saint Barthélemy</option>
<option value="SHN">Saint Helena, Ascension and Tristan da Cunha</option>
<option value="KNA">Saint Kitts and Nevis</option>
<option value="LCA">Saint Lucia</option>
<option value="MAF">Saint Martin (French part)</option>
<option value="SPM">Saint Pierre and Miquelon</option>
<option value="VCT">Saint Vincent and the Grenadines</option>
<option value="WSM">Samoa</option>
<option value="SMR">San Marino</option>
<option value="STP">Sao Tome and Principe</option>
<option value="SAU">Saudi Arabia</option>
<option value="SEN">Senegal</option>
<option value="SRB">Serbia</option>
<option value="SYC">Seychelles</option>
<option value="SLE">Sierra Leone</option>
<option value="SGP">Singapore</option>
<option value="SXM">Sint Maarten (Dutch part)</option>
<option value="SVK">Slovakia</option>
<option value="SVN">Slovenia</option>
<option value="SLB">Solomon Islands</option>
<option value="SOM">Somalia</option>
<option value="ZAF">South Africa</option>
<option value="SGS">South Georgia and the South Sandwich Islands</option>
<option value="SSD">South Sudan</option>
<option value="ESP">Spain</option>
<option value="LKA">Sri Lanka</option>
<option value="SDN">Sudan</option>
<option value="SUR">Suriname</option>
<option value="SJM">Svalbard and Jan Mayen</option>
<option value="SWZ">Swaziland</option>
<option value="SWE">Sweden</option>
<option value="CHE">Switzerland</option>
<option value="SYR">Syrian Arab Republic</option>
<option value="TWN">Taiwan, Province of China</option>
<option value="TJK">Tajikistan</option>
<option value="TZA">Tanzania, United Republic of</option>
<option value="THA">Thailand</option>
<option value="TLS">Timor-Leste</option>
<option value="TGO">Togo</option>
<option value="TKL">Tokelau</option>
<option value="TON">Tonga</option>
<option value="TTO">Trinidad and Tobago</option>
<option value="TUN">Tunisia</option>
<option value="TUR">Turkey</option>
<option value="TKM">Turkmenistan</option>
<option value="TCA">Turks and Caicos Islands</option>
<option value="TUV">Tuvalu</option>
<option value="UGA">Uganda</option>
<option value="UKR">Ukraine</option>
<option value="ARE">United Arab Emirates</option>
<option value="GBR">United Kingdom</option>
<option value="USA">United States</option>
<option value="UMI">United States Minor Outlying Islands</option>
<option value="URY">Uruguay</option>
<option value="UZB">Uzbekistan</option>
<option value="VUT">Vanuatu</option>
<option value="VEN">Venezuela, Bolivarian Republic of</option>
<option value="VNM">Viet Nam</option>
<option value="VGB">Virgin Islands, British</option>
<option value="VIR">Virgin Islands, U.S.</option>
<option value="WLF">Wallis and Futuna</option>
<option value="ESH">Western Sahara</option>
<option value="YEM">Yemen</option>
<option value="ZMB">Zambia</option>
<option value="ZWE">Zimbabwe</option>
</select>
`
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span>'
output +='</div>'
return output;
});
//Renders a textarea
nunjucksEnv.addFilter('textarea', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="field '+(kwargs.class || "field")+'"> ';
output +='<label for="fid_'+field.name+'" class="'+(kwargs.labelClass)+'">'+field.label+' '+(required?"*":"")+'</label> ' +
'<textarea id="fid_'+field.name+'" name="'+field.name+'" class="skelinput '+(kwargs.inputClass || "u-full-width")+'" placeholder="'+field.placeholder+'" '+(required?"required":"")+'>'+field.value+'</textarea>';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span>'
output +='</div>'
return output;
});
//Renders a checkbox
nunjucksEnv.addFilter('checkbox', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var checked = field.value? "checked" : ""
var output='<div class="field '+(kwargs.class || "field ")+'"> ';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span> ';
output +='<label for="fid_'+field.name+'" class="'+(kwargs.labelClass || "mdl-checkbox mdl-js-checkbox mdl-js-ripple-effect")+'">' +
'<input type="checkbox" id="fid_'+field.name+'" name="'+field.name+'" class="'+(kwargs.inputClass || "input mdl-checkbox__input")+'" '+checked+' '+(required?"required":"")+'> ' +
'<span class="mdl-checkbox__label">'+field.label+' '+(required?"*":"")+'</span>' +
'</label></div><br/>'
return output;
});
//Renders a radio group for a multifield
nunjucksEnv.addFilter('radio', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="field '+(kwargs.class || "field")+'" id="fid_'+field.name+'" > '+
'<label for="fid_'+field.name+'" class="'+(kwargs.labelClass || "")+'">'+field.label+' '+(required?"*":"")+'</label> ';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span> ';
for (var i=0; i<field.options.length; i++){
var option = field.options[i]
var checked = field.value == option.value? "checked" : ""
output +='<input type="radio" id="fid_'+field.name+'_'+option.value+'" name="'+field.name+'" class="'
+(kwargs.inputClass || "input")+'" value="'+option.value+'" '+checked+
' '+required.input+'> <label for="fid_'+field.name+'_'+option.value+'" '+(required?"required":"")+'>'+option.text+'</label>'
}
output += '</div>'
return output;
});
//Renders a geo-autocomplete
nunjucksEnv.addFilter('geosuggest', function(field, kwargs) {
kwargs = kwargs || {}
if(!field) return ""
var required = field.isRequired();
var output='<div class="textfield '+(kwargs.class || "field ")+'"> ';
output +='<label for="fid_'+field.name+'" class="skelinput '+(kwargs.labelClass||"")+'">'+field.label+' '+(required?"*":"")+'</label> ' +
'<input type="text" id="fid_'+field.name+'" name="'+field.name+'" class="'+(kwargs.inputClass || "u-full-width")+'" value="'+field.value+'" placeholder="'+field.placeholder+'" '+(required?"required":"")+' geo-suggest> ';
if(field.error)
output+='<span class="'+(kwargs.errorClass || "error")+'">'+field.error+'</span>';
output +='</div>';
return output;
});
}
|
'use strict';
const API = 'http://' + window.location.host + '/api/v1';
let versos;
const poem = document.getElementById('content_poem');
const getPoem = function (){
$.ajax({
method: 'GET',
url: `${API}/poems/page`
}).done(function(res){
if(res.success){
versos = res.books.slice(-5,);
displayPoem(versos);
}else{
alert('Hubo un problema en la recuperación de datos');
}
});
}
const displayPoem = function(versos, status){
versos.forEach(v => {
let verso = document.createElement('p');
verso.textContent = v.verso;
if (status){
verso.classList.add('push')
}
if (v.new){
verso.classList.add('userVerso')
}
poem.appendChild(verso);
})
}
const updatePoem = function(verso){
while (poem.firstChild) {
poem.removeChild(poem.firstChild);
}
versos.push({'verso': verso, 'new': 'user'});
versos = versos.slice(-5,);
displayPoem(versos, 'push');
}
const uploadPoem = function(verso){
$.ajax({
method: 'POST',
url: `${API}/poems/upload/${verso}`
}).done(function(res){
if(res.success){
updatePoem(verso);
}else{
alert('Hubo un problema');
}
});
}
const nuevoVerso = function() {
document.getElementById('newVerso')
.addEventListener('submit', function(e) {
let verso = document.getElementById('verse');
uploadPoem(verso.value.slice(0,140));
verso.value = '';
e.preventDefault();
}, false);
}
getPoem();
nuevoVerso();
|
'use strict';
App.
controller('DeclarationDetailCtrl',
['$scope','$http','$location','$routeParams',
function($scope, $http,$location,$routeParams) {
var declarationRecus = 'http://localhost:8080/message/declarationRecus/';
var loadDec = 'http://localhost:8080/message/declaration/';
var self =this;
self.declarationsrecus = [];
self.declaration={};
//loding Deeclaration
$scope.idd = $routeParams.id;
self.getMessage=function(id){
//var id =parseInt($routeParams.id) ;
$http.get(loadDec+id).then(
function(response) {
self.declaration = response.data;
$scope.idd = declaration.idDeclaration;
}, function(errResponse) {
console.log('fail to load Declaration',self.declaration);
});
};
self.getMessage($scope.idd);
// les declarations recus
self.loadDeclarationsReceived = function() {
$http.get(declarationRecus).then(
function(response) {
self.declarationsrecus = response.data;
}, function(errResponse) {
console.log('fail to load Sdeclarations');
});
};
self.loadDeclarationsReceived();
}]);
|
import React from "react";
import Button from 'react-bootstrap/Button';
function FilterButton(props) {
return (
<Button
className="toggle-btn"
variant="info"
aria-pressed={props.isPressed}
onClick={() => props.setFilter(props.name)}
>
<span>{props.name}</span>
</Button>
);
}
export default FilterButton;
|
/**
*
*/
goog.provide('SB.PhysicsSystem');
/**
* Interface for a PhysicsSystem.
*
* Allows multiple different backends for physics.
* @interface
*/
SB.PhysicsSystem = function() {};
//---------------------------------------------------------------------
// Initialization/Termination
//---------------------------------------------------------------------
/**
* Initializes the physics world.
*/
SB.PhysicsSystem.prototype.initialize = function() {};
/**
* Terminates the physics world.
*/
SB.PhysicsSystem.prototype.terminate = function() {};
//---------------------------------------------------------------------
// Properties
//---------------------------------------------------------------------
/**
* Sets the gravity of the simulation.
* @param {number} x Gravity in the x direction.
* @param {number} y Gravity in the y direction.
* @param {number} z Gravity in the z direction.
*/
SB.PhysicsSystem.prototype.setGravity = function(x, y, z) {};
/**
* Sets the bounds of the simulation.
* @param {number} minX The minimum x value.
* @param {number} maxX The maximum x value.
* @param {number} minY The minimum y value.
* @param {number} maxY The maximum y value.
* @param {number] minZ The minimum z value.
* @param {number} maxZ The maximum z value.
*/
SB.PhysicsSystem.prototype.setBounds = function(minX, maxX, minY, maxY, minZ, maxZ) {};
//---------------------------------------------------------------------
// Methods
//---------------------------------------------------------------------
/**
* Adds a PhysicsBody to the simulation.
* @param {SB.PhysicsBody} body The body to add to the simulation.
*/
SB.PhysicsSystem.prototype.addBody = function(body) {};
/**
* Removes a PhysicsBody from the simulation.
* @param {SB.PhysicsBody} body The body to remove from the simulation.
*/
SB.PhysicsSystem.prototype.removeBody = function(body) {};
/**
* Updates the PhysicsSystem.
*/
SB.PhysicsSystem.prototype.update = function() {};
|
var express = require('express');
var router = express.Router();
const yelp = require('yelp-fusion');
router.get('/', function (req, res) {
var YELP_ID = "CMtBgncyN7TNiZowQ-Lun5bL7_SpWyI7uwtFz_jz7WfKlTNS_hhp-L91vkKhk7uN8kcSzXiB9RG57PZHqYLW2Xgy7jeowqoc-hlJsnl-BfkYO2fNmozYwxlZ8DmwWnYx";
const client = yelp.client(YELP_ID);
var name = req.query.matchName;
var address1 = req.query.matchAddress1;
var address2 = req.query.matchAddress2;
var city = req.query.matchCity;
var state = req.query.matchState;
var country = req.query.matchCountry;
var zipCode = req.query.matchZipCode;
var output = {};
if(name &&address1 &&address2&&city&&state&&country){
client.businessMatch('lookup', {
name: name,
address1: address1,
address2: address2,
city: city,
state: state,
country: country
}).then( function(response){
var result = response.jsonBody.businesses[0];
if(result.location.zip_code == zipCode){
var bestId = result.id;
output.bestId = bestId;
output.error = 0;
res.send(JSON.stringify(output));
} else{
output.error = 1;
output["error message"] = "No Records has been found";
res.send(JSON.stringify(output));
}
}).catch(function(e){
output.error = 1;
output["error message"] = e;
res.send(JSON.stringify(output));
});
} else {
output.error = 1;
output["error message"] = "No Records has been found";
res.send(JSON.stringify(output));
}
});
module.exports = router;
|
Template.AddToMenu.events({
'submit #new-day-form': function(event, template) {
event.preventDefault();
Meteor.call('addDayToMenu', Session.get('choosenRecipes'));
Session.set('choosenRecipes', []);
},
'keyup [name="recipeAmount"]': function(event, template) {
var holdingName = template.data.handling;
if(holdingName == undefined)
holdingName = "choosenRecipes";
let newAmount = event.target.value.trim();
var recipes = Session.get(holdingName);
var id = this._id;
var position = this.position;
recipes.find(recipe => recipe.id == id && recipe.position == position).amount = newAmount;
Session.set(holdingName, recipes);
},
'click .remove-recipe-toAdd' : function(event, template) {
event.preventDefault();
var holdingName = template.data.handling;
if(holdingName == undefined)
holdingName = "choosenRecipes";
var recipes = Session.get(holdingName);
var oldRecipePosition = this.position;
Session.set(holdingName, moveOtherRecipes(recipes.filter(recp => recp.position != oldRecipePosition), oldRecipePosition));
},
'click .move-recipe-down': function(event, template) {
event.preventDefault();
moveChoosenRecipe(template, this, 1);
},
'click .move-recipe-up': function(event, template) {
event.preventDefault();
moveChoosenRecipe(template, this, -1);
}
});
Template.AddToMenu.helpers({
choosenRecipes: function(handling) {
var holdingName = handling;
if(holdingName == undefined)
holdingName = "choosenRecipes";
var currentRecipes = Session.get(holdingName);
console.log(currentRecipes);
if(currentRecipes !== undefined) {
var converted = currentRecipes.map((recipe) => convertRecipeByAmount(recipe)).sort((a,b) => a.position > b.position);
console.log(converted);
return converted;
}
else
return [];
},
firstPosition: function(position) {
return position == 0;
},
lastPosition: function(recipes, position) {
var maxPosition = Math.max(...recipes.map(recipe => recipe.position));
return maxPosition == position;
},
sumRecipes: function(recipes) {
var nutrients = recipes.map(recipe => { return {
calorie: recipe.calorie,
carb: recipe.carb,
fat: recipe.fat,
protein: recipe.protein
}});
return {
calorie: nutrients.map(nut => nut.calorie).reduce((a,b) => a + b, 0),
protein: nutrients.map(nut => nut.protein).reduce((a,b) => a + b, 0),
fat: nutrients.map(nut => nut.fat).reduce((a,b) => a + b, 0),
carb: nutrients.map(nut => nut.carb).reduce((a,b) => a + b, 0)
}
}
});
convertRecipeByAmount = function (recipe) {
var foundRecipe;
if(recipe.itProduct) {
foundRecipe = Products.findOne(recipe.id);
foundRecipe.calorie = foundRecipe.nutritionals.calorie * 0.01 * recipe.amount;
foundRecipe.protein = foundRecipe.nutritionals.protein * 0.01 * recipe.amount;
foundRecipe.fat = foundRecipe.nutritionals.fat * 0.01 * recipe.amount;
foundRecipe.carb = foundRecipe.nutritionals.carb * 0.01 * recipe.amount;
foundRecipe.amount = recipe.amount;
foundRecipe.position = recipe.position;
} else {
foundRecipe = Recipes.findOne(recipe.id);
foundRecipe.calorie = foundRecipe.calorie * recipe.amount;
foundRecipe.protein = foundRecipe.protein * recipe.amount;
foundRecipe.fat = foundRecipe.fat * recipe.amount;
foundRecipe.carb = foundRecipe.carb * recipe.amount;
foundRecipe.amount = recipe.amount;
foundRecipe.position = recipe.position;
}
return foundRecipe;
}
moveChoosenRecipe = function(template, recipe, where) {
var holdingName = template.data.handling;
if(holdingName == undefined)
holdingName = "choosenRecipes";
var currentRecipes = Session.get(holdingName);
var recipeWithNewPositions = moveRecipePositionFrom(currentRecipes, recipe, where);
Session.set(holdingName, recipeWithNewPositions);
}
moveRecipePositionFrom = function(recipes, recipe, where) {
var oldRecipePosition = recipe.position;
return recipes.map(recp => {
if(oldRecipePosition + where > -1 && oldRecipePosition + where < recipes.length) {
if(recp.position == oldRecipePosition) {
recp.position += where;
}
else if (recp.position == oldRecipePosition + where) {
recp.position -= where;
}
}
return recp;
});
}
moveOtherRecipes = function(recipes, oldRecipePosition) {
var i;
for(i = 0; i < recipes.length; i++) {
if(recipes[i].position > oldRecipePosition){
recipes[i].position -= 1;
}
}
return recipes;
}
|
module.exports = {
siteMetadata: {
title: `Khaled Maher | Software Engineer`,
description: `The Realm you want to know more about...`,
author: `@maxios`,
},
plugins: [
"gatsby-plugin-react-helmet",
"gatsby-transformer-sharp",
"gatsby-plugin-sharp",
"gatsby-plugin-manifest",
"gatsby-plugin-offline",
"gatsby-plugin-sass",
{
resolve: `gatsby-plugin-alias-imports`,
options: {
alias: {
"@src": "src",
"@components": "src/components",
"@atoms": "src/components/atoms",
"@molecules": "src/components/molecules",
"@organisms": "src/components/organisms",
"@constants": "src/constants",
"@layouts": "src/layouts",
"@pages": "src/pages",
"@images": "src/images",
"@styles": "src/styles"
},
extensions: [
"js",
],
}
},
{
resolve: `gatsby-plugin-manifest`,
options: {
name: `gatsby-starter-default`,
short_name: `starter`,
start_url: `/`,
background_color: `#663399`,
theme_color: `#663399`,
display: `minimal-ui`
},
},
// this (optional) plugin enables Progressive Web App + Offline functionality
// To learn more, visit: https://gatsby.dev/offline
// `gatsby-plugin-offline`,
],
}
|
Content.makeFrontInterface(568, 320);
//sampler
const var sampleList = Sampler.getSampleMapList();
const var sampler1 = Synth.getSampler("Sampler1");
sampler1.loadSampleMap("tongali");function onNoteOn()
{
}
function onNoteOff()
{
}
function onController()
{
}
function onTimer()
{
}
function onControl(number, value)
{
}
|
/*弹出层tab页切换*/
$('#settingTabs a').click(function (e) {
e.preventDefault()
$(this).tab('show')
});
/*拖拽*/
var $win = $(window);
var lyt = {
init:function(ele1,ele2,direction){
this.$ele1 = ele1;
this.$ele2 = ele2;
this.$direction = direction;
//初始化事件
this.initEvts();
},
initEvts:function(){
//窗体发生变化时重新计算高度或者宽度
var me = this;
$win.on('resize.lyt',function(e){
if(me.$direction === 'horizontal'){
me.$ele1Width = me.$ele1.outerWidth(true);
me.$ele2Width = me.$ele2.outerWidth(true);
}else if(me.$direction === 'vertical'){
me.$ele1Height = me.$ele1.outerHeight(true);
}
});
},
//调整高度或者宽度
adjust:function(px){
if(this.$direction === 'horizontal'){
this.$ele1.addClass('no-flex');
this.$ele1.css('width',this.$ele1Width+px);
this.$ele2.addClass('no-flex');
this.$ele2.css('width',this.$ele2Width-px);
}else if(this.$direction === 'vertical'){
this.$ele1.addClass('no-flex');
this.$ele1.css('height',this.$ele1Height+px);
}
}
};
lyt.init($('#lytCell1'),$('#lytCell2'),'horizontal');
lyt.init($('#lytCell2'),$('#lytCell3'),'horizontal');
lyt.init($('#lytRow1'),$('#lytRow2'),'vertical');
var splitter = {
init:function(ele){
var me = this,
eleSplitter = ele;
this.$vl = eleSplitter.draggable({
containment: 'parent',
scroll: false,
axis: me.$direction === 'horizontal'?'x' : (me.$direction === 'vertical'?'y':''),
drag: function(evt,ui){
//计算本次拖动后的位置与上一次位置的差值
ui.pos = me.$direction === 'horizontal'?ui.position.left : (me.$direction === 'vertical'?ui.position.top:'');
var dis = ui.pos - me.pos0;
me.onDrag(dis);
}
});
if(this.$direction === 'horizontal') {
this.width = this.$vl.width();
}else if(this.$direction === 'vertical') {
this.height = this.$vl.height();
};
this.initPos();
this.initEvts();
},
initEvts: function(){
var me = this;
$win.on('resize.splitter',function(){
me.initPos();
});
},
initPos:function(){
if(this.$direction === 'horizontal'){
this.pos0 = lyt.$ele1Width - this.width/2;
this.$vl.css('left',this.pos0);
}else if(this.$direction === 'vertical'){
this.pos0 = lyt.$ele1Height - this.height/2;
this.$vl.css('top',this.pos0);
}
},
onDrag: function(dis){
lyt.adjust(dis);
}
};
splitter.init($('#splitterV1'));
splitter.init($('#splitterV2'));
splitter.init($('#splitterH'));
/*添加额外文件的删除功能*/
function close(id,ele){
id.on('click',ele,function(){
var $row = $(this).closest('ul');
var len = $row.find('li').length;
if(len>2){
$(this).closest('li').remove();
}
})
};
close($('#sortableCss'),'.btn-close-item');
close($('#sortableJs'),'.btn-close-item');
/*添加额外文件的增加功能*/
function addList(id,pid,ele){
id.on('click',function(){
$(this).closest('form').siblings('ul').append('<li class="list-item-file">' +
'<div class="input-group lyt-margin">' + '<span class="input-group-addon mouse-pointer">' +
'<span class="glyphicon glyphicon-menu-hamburger" aria-hidden="true"></span> </span>' +
'<input type="text" class="form-control"/><span class="input-group-addon mouse-pointer btn-close-item">' +
'<span class="glyphicon glyphicon-remove" aria-hidden="true"></span></span></div>');
close(pid,ele);
});
};
addList($('#addStyle'),$('#sortableCss'),'.btn-close-item');
addList($('#addScript'),$('#sortableJs'),'.btn-close-item');
//初始化js选择组件
new extraAssets('Javascript');
//初始化css选择组件
new extraAssets('CSS');
/*弹出层文件引用*/
function addFlie(id,uid){
var $selection = id.on('change',function(){
var $val = $selection.val();
var $list = id.closest('form').siblings(uid).find('input');
var $len = $list.length;
for(var i=0;i<$len;i++){
var $value = $list[i].value;
var $input = $list[i];
if($value == ''){
$input.attr('value',$val);
return false;
}
}
/*$list.each(function(){
var $valInput = $(this).val();
console.log($valInput);
if($valInput == ''){
$valInput.innerText = $val;
}
else{
var $newItem = '<li class="list-item-file">' +
'<div class="input-group lyt-margin">' + '<span class="input-group-addon mouse-pointer">' +
'<span class="glyphicon glyphicon-menu-hamburger" aria-hidden="true"></span> </span>' +
'<input type="text" class="form-control"/><span class="input-group-addon mouse-pointer btn-close-item">' +
'<span class="glyphicon glyphicon-remove" aria-hidden="true"></span></span></div>'
var $newInput = $newItem.find('input');
$newInput.attr('value',$val);
}
});*/
});
};
//addFlie($('#anotherStyle'),'#sortableCss');
//addFlie($('#anotherScript'),'#sortableJs');
|
/*
所有在Promotions中使用到的Model以及Store
添加順序為Model-Store 一一對應
添加的時候注意命名規範，還有所有store都必須設置成autoload:false
*/
//會員群組Model
Ext.define("gigade.VipGroup", {
extend: 'Ext.data.Model',
fields: [
{ name: "group_id", type: "string" },
{ name: "group_name", type: "string" }]
});
//會員群組store
var VipGroupStore = Ext.create('Ext.data.Store', {
model: 'gigade.VipGroup',
// autoLoad: true,
proxy: {
type: 'ajax',
url: "/PromotionsDiscount/GetVipGroup",
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
//site
Ext.define("gigade.Site", {
extend: 'Ext.data.Model',
fields: [
{ name: "Site_Id", type: "string" },
{ name: "Site_Name", type: "string" }]
});
var SiteStore = Ext.create('Ext.data.Store', {
model: 'gigade.Site',
proxy: {
type: 'ajax',
url: "/PromotionsDiscount/GetSite",
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
function Tomorrow() {
var d;
d = new Date(); // 创建 Date 对象。
d.setDate(d.getDate() + 1);
d.setHours(0, 0, 0);
return d;
}
function BounTypeShow(val) {
switch (val) {
case "1":
return BONUS_ONE;
break;
case "2":
return BONUS_TWO;
break;
case "3":
return BONUS_THREE;
break;
case "4":
return BONUS_FOUR;
break;
case "0":
return DEVICE_1;
break;
}
}
function ZhiFuType(val) {
switch (val) {
case "":
return DEVICE_1;
break;
default:
return val;
break;
}
}
//館別Model
Ext.define("gigade.ShopClass", {
extend: 'Ext.data.Model',
fields: [
{ name: "class_id", type: "string" },
{ name: "class_name", type: "string" }]
});
//館別Store
var ShopClassStore = Ext.create('Ext.data.Store', {
model: 'gigade.ShopClass',
// autoLoad: true,
proxy: {
type: 'ajax',
url: "/PromotionsMaintain/GetShopClass",
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
var ShopClassStoreYuan = Ext.create('Ext.data.Store', {
model: 'gigade.ShopClass',
// autoDestroy: true,
// autoLoad: true,
proxy: {
type: 'ajax',
url: "/PromotionsMaintain/GetShopClass",
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
/*********參數表model***********/
Ext.define("gigade.paraModel", {
extend: 'Ext.data.Model',
fields: [
{ name: 'parameterCode', type: 'string' },
{ name: 'parameterName', type: 'string' }
]
});
//裝置
var deviceStore = Ext.create("Ext.data.Store", {
model: 'gigade.paraModel',
// autoLoad: true,
proxy: {
type: 'ajax',
url: '/Parameter/QueryPara?paraType=device',
noCache: false,
getMethod: function () { return 'get'; },
actionMethods: 'post',
reader: {
type: 'json',
root: 'items'
}
}
});
//付款方式
var paymentStore = Ext.create("Ext.data.Store", {
model: 'gigade.paraModel',
proxy: {
type: 'ajax',
url: '/Parameter/QueryPara?paraType=payment',
noCache: false,
getMethod: function () { return 'get'; },
actionMethods: 'post',
reader: {
type: 'json',
root: 'items'
}
}
});
//運送類別Store
var YunsongStore = Ext.create('Ext.data.Store', {
fields: ['type_id', 'type_name'],
data: [
{ type_id: '0', type_name: DEVICE_1 },
{ type_id: '1', type_name: DEVICE_4 },
{ type_id: '2', type_name: DEVICE_5 }
]
});
//物流方式Store
var DeliverStore = Ext.create('Ext.data.Store', {
// model: 'gigade.DeliverModel',
fields: ['deliver_id', 'deliver_name'],
data: [
{ deliver_id: "1", deliver_name: DELIVERDEFAULT }
]
});
//供應商Model
Ext.define("gigade.Vendor", {
extend: 'Ext.data.Model',
fields: [
{ name: "vendor_id", type: "string" },
{ name: "vendor_name_simple", type: "string" }]
});
//供應商Store
var VendorStore = Ext.create('Ext.data.Store', {
model: 'gigade.Vendor',
// autoLoad: true,
proxy: {
type: 'ajax',
url: "/Vendor/GetVendor",
actionMethods: 'post',
reader: {
type: 'json',
root: 'data'
}
}
});
//過期未過期的store
var ExpireZheStore = Ext.create('Ext.data.Store', {
fields: ['txt', 'value'],
data: [
{ "txt": NOTPASTDUE, "value": "0" },
{ "txt": TEXPIRED, "value": "1" }
]
})
var UrlZheStore = Ext.create('Ext.data.Store', {
fields: ['txt', 'value'],
data: [
{ "txt": "否", "value": "0" },
{ "txt": "是", "value": "1" }
]
})
setNextMonth = function (source, n) {
var s = new Date(source);
s.setMonth(s.getMonth() + n);
if (n < 0) {
s.setHours(0, 0, 0);
}
else if (n > 0) {
s.setHours(23, 59, 59);
}
return s;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.