text
stringlengths 7
3.69M
|
|---|
import React from "react";
import clsx from "clsx";
import { makeStyles, useTheme } from "@material-ui/core/styles";
import Drawer from "@material-ui/core/Drawer";
import AppBar from "@material-ui/core/AppBar";
import Toolbar from "@material-ui/core/Toolbar";
import CssBaseline from "@material-ui/core/CssBaseline";
import List from "@material-ui/core/List";
import Divider from "@material-ui/core/Divider";
import IconButton from "@material-ui/core/IconButton";
import MenuIcon from "@material-ui/icons/Menu";
import ChevronLeftIcon from "@material-ui/icons/ChevronLeft";
import ChevronRightIcon from "@material-ui/icons/ChevronRight";
import ListItem from "@material-ui/core/ListItem";
import ListItemIcon from "@material-ui/core/ListItemIcon";
import ListItemText from "@material-ui/core/ListItemText";
import logos from "./../../assets/Icons/dashboardIcon/logos.svg";
import premium2 from "../../assets/Icons/home/premium2.svg";
import {
ExpandLess,
ExpandMore,
HomeOutlined,
PeopleOutline,
FilterTiltShift,
DescriptionOutlined,
MeetingRoomOutlined,
InfoOutlined,
} from "@material-ui/icons";
import { Button, Collapse } from "@material-ui/core";
import { Link } from "react-router-dom";
const drawerWidth = 240;
const useStyles = makeStyles((theme) => ({
root: {
display: "flex",
},
appBar: {
transition: theme.transitions.create(["margin", "width"], {
easing: theme.transitions.easing.sharp,
duration: theme.transitions.duration.leavingScreen,
}),
},
appBarShift: {
width: `calc(100% - ${drawerWidth}px)`,
transition: theme.transitions.create(["margin", "width"], {
easing: theme.transitions.easing.easeOut,
duration: theme.transitions.duration.enteringScreen,
}),
marginRight: drawerWidth,
},
title: {
flexGrow: 1,
},
hide: {
display: "none",
},
drawer: {
width: drawerWidth,
flexShrink: 0,
},
drawerPaper: {
width: drawerWidth,
},
drawerHeader: {
display: "flex",
alignItems: "center",
padding: theme.spacing(0, 1),
// necessary for content to be below app bar
...theme.mixins.toolbar,
justifyContent: "space-between",
backgroundColor: "#002e6e",
},
content: {
flexGrow: 1,
padding: theme.spacing(3),
transition: theme.transitions.create("margin", {
easing: theme.transitions.easing.sharp,
duration: theme.transitions.duration.leavingScreen,
}),
marginRight: -drawerWidth,
},
contentShift: {
transition: theme.transitions.create("margin", {
easing: theme.transitions.easing.easeOut,
duration: theme.transitions.duration.enteringScreen,
}),
marginRight: 0,
},
}));
export default function PersistentDrawerRight() {
const classes = useStyles();
const theme = useTheme();
const [open, setOpen] = React.useState(false);
const [opens, setOpens] = React.useState(true);
const handleDrawerOpen = () => {
setOpen(true);
};
const handleDrawerClose = () => {
setOpen(false);
};
const handleClick = () => {
setOpens(!opens);
};
return (
<div className={classes.root}>
<CssBaseline />
<AppBar
position="fixed"
className={clsx(classes.appBar, {
[classes.appBarShift]: open,
})}
style={{ direction: "ltr" }}
>
<Toolbar
style={{
display: "flex",
justifyContent: "space-between",
}}
>
<IconButton>
<Link to="/login">
<MeetingRoomOutlined style={{ color: "#fff" }} />
</Link>
</IconButton>
<div>
<img style={{ width: "5rem" }} src={logos} alt="parkJab-logo" />
</div>
<IconButton
color="inherit"
aria-label="open drawer"
edge="end"
onClick={handleDrawerOpen}
className={clsx(open && classes.hide)}
>
<MenuIcon />
</IconButton>
</Toolbar>
</AppBar>
<Drawer
className={classes.drawer}
variant="persistent"
anchor="left"
open={open}
classes={{
paper: classes.drawerPaper,
}}
>
<div className={classes.drawerHeader}>
<IconButton onClick={handleDrawerClose}>
{theme.direction === "ltr" ? (
<ChevronLeftIcon style={{ color: "#fff" }} />
) : (
<ChevronRightIcon style={{ color: "#fff" }} />
)}
</IconButton>
<div>
<img style={{ width: "5rem" }} src={logos} alt="parkJab-logo" />
</div>
</div>
<Divider />
<List>
<ListItem button>
<ListItemIcon>
<HomeOutlined />
</ListItemIcon>
<Link style={{ textDecoration: "none", color: "black" }} to="/">
<ListItemText primary="صفحه اصلی" />
</Link>
</ListItem>
<Divider />
<ListItem button>
<ListItemIcon>
<PeopleOutline />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/Freelancers"
>
<ListItemText primary="فریلنسرها" />
</Link>
</ListItem>
</List>
<Divider />
<List>
<ListItem button onClick={handleClick}>
<ListItemIcon>
<DescriptionOutlined />
</ListItemIcon>
<ListItemText primary="پروژه ها" />
{open ? <ExpandLess /> : <ExpandMore />}
</ListItem>
<Collapse in={!opens} timeout="auto" unmountOnExit>
<List component="div" disablePadding>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="طراحی گرافیک" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="تولید محتوا" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="ترجمه و تایپ" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="دیجیتال مارکتینگ سئو" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="عکس ,انیمیشن و ویدئو" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="طراحی سایت" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="برنامه نویسی , نرم افزار" />
</Link>{" "}
</ListItem>
<ListItem button className={classes.nested}>
<ListItemIcon>
<FilterTiltShift />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/ProjectsList"
>
<ListItemText primary="سایر کسب و کارها" />
</Link>{" "}
</ListItem>
</List>
</Collapse>
</List>
<Divider />
<List>
<ListItem button>
<ListItemIcon className={classes.iconlogin}>
<img src={premium2} alt="gem" />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/PricingTableCommonPage"
>
<ListItemText primary="طرح های عضویت" />
</Link>{" "}
</ListItem>
<Divider />
<ListItem button>
<ListItemIcon>
<InfoOutlined />
</ListItemIcon>
<Link
style={{ textDecoration: "none", color: "black" }}
to="/HomeAboutUs"
>
<ListItemText primary="درباره ما" />
</Link>{" "}
</ListItem>
</List>
</Drawer>
</div>
);
}
|
import React, { useState, useEffect } from "react";
import { Navbar, Nav, Button } from "react-bootstrap";
import { useHistory, useLocation } from "react-router-dom";
const Header = () => {
const history = useHistory();
const location = useLocation();
const [showButton, setShowButton] = useState(false);
useEffect(() => {
setShowButton(location.pathname === "/home");
}, [location.pathname]);
const goTo = path => e => {
e.preventDefault();
history.push(path);
};
return (
<div>
<Navbar expand="lg" variant="light" bg="light">
<Navbar.Brand>
<img
src="/via-logo-black.png"
alt="Via.work logo"
width="80"
height="27"
className="d-inline-block align-top"
/>
{` `}
<span>Invoices</span>
</Navbar.Brand>
<Navbar.Toggle aria-controls="responsive-navbar-nav" />
<Navbar.Collapse>
<Nav className="mr-auto">
<Nav.Link href="/home" onClick={goTo("/home")}>
Home
</Nav.Link>
</Nav>
{showButton && (
<Button variant="outline-primary" onClick={goTo("/new-invoice")}>
New Invoice
</Button>
)}
</Navbar.Collapse>
</Navbar>
</div>
);
};
export default Header;
|
import React, { Component } from 'react';
import {connect} from 'react-redux';
class Act extends Component {
render() {
return (
<div className='App'>
<div className='Age-label'>
<span>using redux</span><br/>
yourage:<span>{this.props.age}</span>
</div>
<button onClick={this.props.onAgeUp}>Age Up</button>
<button onClick={this.props.onAgeDown}>Age Down</button>
</div>
);
}
}
const mapStateToProps=(state)=>{
return{
age:state.age
};
};
const mapDispatchToProps=(dispatch)=>{
return{
onAgeUp:()=>dispatch({type:'AGE_UP',value:1}),
onAgeDown:()=>dispatch({type:'AGE_DOWN',value:1})
};
};
export default connect(
mapStateToProps,
mapDispatchToProps
)(Act);
|
(function(){
var menu = document.getElementsByClassName('main-menu')[0];
var hamburger = document.getElementById('hamburger');
console.log(hamburger);
console.log(menu);
function clickHandler(e) {
menu.classList.toggle('main-menu_opened');
}
function resizeHandler(e) {
var width = window.innerWidth
|| document.documentElement.clientWidth
|| document.body.clientWidth;
if (width > 996)
menu.classList.remove('main-menu_opened');
}
hamburger.addEventListener('click', clickHandler);
menu.addEventListener('resize', resizeHandler);
})();
|
'use strict';
angular.module('d3', [])
.factory('d3Service', [function() {
var d3;
return d3;
}]);
angular.module('app', ['d3']);
angular.module('resistor', [
'ui.router',
'resistor.controllers',
'resistor.filters',
'resistor.services',
'resistor.directives',
]).
config(function ($stateProvider, $urlRouterProvider) {
$urlRouterProvider.otherwise('/');
$stateProvider.state('home', {
templateUrl: '/',
controller: 'HomeCtrl'
}).
// This is an example state. Please replace with one that makes sense for your application
state('example-state', {
url: '/example/:name',
templateUrl: '/example',
controller: 'ExampleCtrl'
});
});
|
import React from 'react'
import style from './recipe.module.css'
const Recipe = ({title,image,healthLabels,calories}) => {
return (
<div className={style.recipe}>
<h1>{title}</h1>
<div className={style.fields}>
<h3>Heath Labels :</h3>
<ul>
{healthLabels.map((item,index) => (
<li key={index}>{item}</li>
))}
</ul>
<h3>Calories : {calories}</h3>
</div>
<img className={style.image} src={image} alt="Food" />
</div>
)
}
export default Recipe
|
import React from "react";
import { skills, projects_data } from "./Data";
import EachProject from "./EachProject";
import MySkills from "./MySkills";
function Project() {
return (
<div className="container p-container section-padding" id="projects">
<div className="row text-right">
<div className="col-md-9 projects">
<h3 className="pj-section-title">پروژهای من</h3>
{projects_data.map(p => {
return (
<React.Fragment key={p.name}>
<EachProject project_data={p} />
{p !== projects_data[projects_data.length - 1] && (
<div className="card-hr"></div>
)}
</React.Fragment>
);
})}
</div>
<div className="col-md-3 skills">
<h3>مهارت‌های من</h3>
{skills.map(skill => (
<MySkills skill_data={skill} />
))}
</div>
</div>
</div>
);
}
export default Project;
|
import React, { Component } from "react";
import Card from "../components/Card";
const moment = require("moment");
export default class Weekly extends Component {
state = {
movies: [],
};
formatDateToday(dateString) {
// console.log("test 1 :",moment(dateString).format("DD/MM/YYYY"));
const today = moment(dateString).format("YYYY-MM-DD");
return today;
}
formatDateLastWeek(dateString) {
// console.log("test 2:",moment(dateString).subtract(7, 'days').format("DD/MM/YYYY"));
const lastWeek = moment(dateString)
.subtract(7, "days")
.format("YYYY-MM-DD");
return lastWeek;
}
componentDidMount() {
// const url = "http://api.themoviedb.org/3/discover/movie?primary_release_date.gte=" +
// this.formatDateLastWeek() +
// "&primary_release_date.lte=" +
// this.formatDateToday() +
// "&api_key=e441f8a3a151d588a4932d2c5d310769";
const url = "http://localhost:8000/movies/weekly";
fetch(url)
.then((response) => response.json())
.then((data) => {
console.log("weekly data movies ", data.dataMoviesWeekly.results);
this.setState({
movies: data.dataMoviesWeekly.results,
// movies: data.results,
});
});
}
render() {
// console.log("render today:",this.formatDateToday());
// console.log("render last week:",this.formatDateLastWeek());
return (
<div>
<h1 className="text-center mt-4 font-weight-light ">Weekly Movies</h1>
<div className=" m-5">
{this.state.movies.map((elem, index) => {
return <Card key={index} {...elem} />;
})}
</div>
</div>
);
}
}
|
/**
* Created by Administrator on 2018-02-26.
*/
module.exports = (sequelize, DataTypes) => {
var ClientMenu = sequelize.define('client_menu', {
id: {
type: DataTypes.INTEGER,
allowNull: false,
primaryKey: true,
autoIncrement: true
},
name: DataTypes.STRING(50),
type: DataTypes.STRING(10),
parentId: {
type: DataTypes.INTEGER,
references: {
model: 'client_menu',
key: 'id',
}
},
permission: DataTypes.STRING(50),
}, {
classMethods: {
associate: function(models) {
// associations can be defined here
}
}
}, {
timestamps: false
});
return ClientMenu;
};
|
import * as types from './actionTypes'
export const loadExportCategories = (artPieces) => {
//TODO: Change to Thunk and call service.loadTemplates
return { type: types.EXPORT_CATEGORIES_LOAD_CATEGORIES, payload: artPieces }
}
export const resetExportCategories = () => {
return { type: types.EXPORT_CATEGORIES_RESET }
}
|
/*
* @lc app=leetcode.cn id=76 lang=javascript
*
* [76] 最小覆盖子串
*/
// @lc code=start
/**
* @param {string} s
* @param {string} t
* @return {string}
*/
var minWindow = function(s, t) {
let need = new Map();
for (let i = 0; i < t.length; i++) {
need.set(t[i], need.get(t[i]) + 1 || 1);
}
let left = 0, right = 0, len = Infinity, valid = 0, start = 0;
let window = new Map();
while (right < s.length) {
let r = s[right];
if (need.has(r)) {
window.set(r, window.get(r) + 1 || 1);
if (window.get(r) === need.get(r)) {
valid++;
}
}
right++;
while (need.size === valid) {
if (right - left < len) {
start = left;
len = right - left;
}
let d = s[left];
if (need.has(d)) {
if (need.get(d) === window.get(d)) valid--;
window.set(d, window.get(d) - 1 || -1);
}
left++;
}
}
return len == Infinity ? '' : s.substr(start, len);
};
// @lc code=end
|
import axios from 'axios';
/* import urlAPI from "../constants/urlAPI";
import apiKey from "../constants/apiKey";
import localLanguage from "../constants/localLanguage"; */
// Tous les films par durée (ici : 1min au temps choisi par l'utilisateur), par ordre alphabetique
const articlesByDuration = (urlAPI, apiKey) => (sorted, minMinute, maxMinute, callBack) => {
if (!sorted) {
const request = axios.get(`${urlAPI}/discover/movie?api_key=${apiKey}&language=en-EN&sort_by=original_title.asc&include_adult=false&include_video=false&page=1&with_runtime.gte=${minMinute}&with_runtime.lte=${maxMinute}`);
request.then(({ data }) => callBack(data));
} else {
const request = axios.get(`${urlAPI}/discover/movie?api_key=${apiKey}&language=en-EN&sort_by=original_title.${sorted}&include_adult=false&include_video=false&page=1&with_runtime.gte=${minMinute}&with_runtime.lte=${maxMinute}`);
request.then(({ data }) => callBack(data));
}
};
/* // Tous les films par durée (ici : 1min au temps choisi par l'utilisateur), par ordre alphabetique
const articlesByDuration = (urlAPI, apiKey) => (maxMinute, callBack) => {
const request = axios.get(${urlAPI}/discover/movie?api_key=${apiKey}&language=${localLanguage}&sort_by=original_title.asc&include_adult=false&include_video=false&page=1&with_runtime.lte=${maxMinute}`);
request.then(({data}) => callBack(data));
}; */
export default articlesByDuration;
|
const mongoose = require('mongoose')
const Posts = require('../models/posts')
const User = require('../models/user')
const getAllPosts = async(username) => {
try {
let user = await User.findOne({ username })
if (!user) {
return { status: false, message: 'User not found!' }
} else {
let posts = await Posts.find({ author: user._id }).populate('author', 'username')
return { status: true, message: posts }
}
} catch (error) {
return { status: false, message: error.message }
}
}
const createPost = async(username, post) => {
try {
let user = await User.findOne({ username })
if (!user) {
return { status: false, message: 'User not found!' }
} else {
let newPost = new Posts({ post: post, author: user._id })
let createdPost = await newPost.save()
createdPost._doc.author = { username }
return { status: true, message: createdPost }
}
} catch (error) {
return { status: false, message: error.message }
}
}
const deletePost = async(username, post_id) => {
try {
let user = await User.findOne({ username })
if (!user) {
return { status: false, message: 'User not found!' }
} else {
let post = await Posts.findOne({ _id: post_id })
if (!post) {
return { status: false, message: `Post doesn't exist!` }
} else {
if (post.author === user._id) {
await post.remove()
return { status: true, message: `Post deleted successfully!` }
} else {
return { status: false, message: 'Only authors can delete posts!' }
}
}
}
} catch (error) {
return { status: false, message: error.message }
}
}
const getFollowedUserPosts = async(username) => {
try {
let currentUser = await User.findOne({ username })
if (!currentUser) {
return { status: false, message: 'User not found!' }
} else {
let following = currentUser.following.map(user => user._id)
following.push(currentUser._id)
let posts = await Posts.find({ author: { "$in": following } }, { post: 1, author: 1, createdAt: 1, likes: 1 }).populate('author', 'username photoURL name')
posts.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
let postsToSend = []
if (posts.length > 20) {
postsToSend = posts.slice(0, 20)
} else {
postsToSend = [...posts]
}
let likesMap = postsToSend.map(post => post.likes.includes(currentUser._id) ? true : false)
console.log(postsToSend)
return { status: true, message: { posts: postsToSend, likesMap: likesMap } }
}
} catch (error) {
console.log('in error')
return { status: false, message: error.message }
}
}
const likePost = async(username, postId) => {
try {
let currentUser = await User.findOne({ username })
if (!currentUser) {
return { status: false, message: 'User not found!' }
} else {
let post = await Posts.findOne({ _id: postId })
if (!post) {
return { status: false, message: `Post doesn't exist!` }
} else {
post.likes.push(currentUser._id)
await post.save()
return { status: true, message: 'Successfully liked the post!' }
}
}
} catch (error) {
return { status: false, message: error.message }
}
}
const unlikePost = async(username, postId) => {
try {
let currentUser = await User.findOne({ username })
if (!currentUser) {
return { status: false, message: 'User not found!' }
} else {
let post = await Posts.findOne({ _id: postId })
if (!post) {
return { status: false, message: `Post doesn't exist!` }
} else {
post.likes.pull(currentUser._id)
await post.save()
return { status: true, message: 'Successfully unliked the post!' }
}
}
} catch (error) {
return { status: false, message: error.message }
}
}
module.exports = {
getAllPosts,
createPost,
deletePost,
getFollowedUserPosts,
likePost,
unlikePost
}
|
import React, {Component} from 'react';
import PropTypes from 'prop-types';
import {Column, Table, AutoSizer} from 'react-virtualized';
import {P, H2, ListGrid} from '@gstarrltd/fragmented';
import Immutable from 'immutable';
import styles from './SearchResults.scss';
const columnNames = [
{
name: '',
key: 'thumbnail',
width: 120
},
{
name: 'Title',
key: 'title',
width: 400
},
{
name: 'Episodes',
key: 'episodes',
width: 100
},
{
name: 'Added',
key: 'added',
width: 200
},
{
name: 'Author',
key: 'author',
width: 200
}
];
const list = [];
export default class SearchResults extends Component {
constructor(props) {
super(props);
const query = new URLSearchParams(props.location.search);
const searchText = query.get('search');
this.state = {
list,
searchText
};
}
static getDerivedStateFromProps(nextProps) {
const query = new URLSearchParams(nextProps.location.search);
const searchText = query.get('search');
return {
searchText
};
}
render() {
return (
<div className={styles.container}>
<H2 className={styles.heading}>Search Results for {this.state.searchText}</H2>
<ListGrid
data={this.state.list}
listMetaData={columnNames} />
</div>
);
}
}
|
(function ($) {
"use strict";
var menuToggler = $('.menu_toggler'),
offsetMenu = $('.offset_menu'),
menuQuit = $('.cross');
menuToggler.on('click', function (e) {
e.preventDefault();
offsetMenu.addClass('visible');
});
menuQuit.on('click', function () {
offsetMenu.removeClass('visible');
});
// Mix js
var containerEl = document.querySelector('#project_mix');
// var mixer = mixitup(containerEl);
var mixer = mixitup(containerEl, {
selectors: {
target: '.mix'
},
animation: {
effects: 'fade',
duration: 700
}
});
//message js
var pauseBtn = $(".sound_toggle_btn"),
playing = false;
pauseBtn.on('click', function () {
$(this).children('span').toggleClass('fa fa-times fa fa-clone');
});
//Service slick js
$('.service_slic').slick({
infinite: true,
slidesToShow: 3,
slidesToScroll: 1,
autoplay: true,
arrows: true,
prevArrow: '<i class="fa fa-chevron-left slidprev4"></i>',
nextArrow: '<i class="fa fa-chevron-right slidNext4"></i>',
autoplaySpeed: 1300,
responsive: [
{
breakpoint: 1024,
settings: {
slidesToShow: 3,
slidesToScroll: 1,
infinite: true,
}
},
{
breakpoint: 800,
settings: {
slidesToShow: 2,
slidesToScroll: 2
}
},
{
breakpoint: 480,
settings: {
slidesToShow: 1,
slidesToScroll: 1
}
}
]
});
//testimonial slick js
$('.testimonial_slick').slick({
centerPadding: '0px',
centerMode: true,
focusOnSelect: true,
infinite: true,
slidesToShow: 2,
slidesToScroll: 1,
autoplay: true,
arrows: true,
prevArrow: '<i class="fa fa-long-arrow-right slidPrev3"></i>',
nextArrow: '<i class="fa fa-long-arrow-left slidNext3"></i>',
autoplaySpeed: 3000,
responsive: [
{
breakpoint: 1024,
settings: {
slidesToShow: 2,
slidesToScroll: 1,
infinite: true
}
},
{
breakpoint: 600,
settings: {
slidesToShow: 2,
slidesToScroll: 2
}
},
{
breakpoint: 480,
settings: {
slidesToShow: 1,
slidesToScroll: 1
}
}
]
});
$(document).ready(function () {
// Add scrollspy to <body>
$('body').scrollspy({
target: ".nav_area",
offset: 50
});
$("#navbar-example a").on('click', function (event) {
if (this.hash !== "") {
event.preventDefault();
var hash = this.hash;
$('html, body').animate({
scrollTop: $(hash).offset().top
}, 1000, function () {
window.location.hash = hash;
});
}
});
});
// newsletter
$(window).load(function () {
setTimeout(function () {
$('#enquirypopup').modal('show');
}, 100);
});
//Preloader
$(window).load(function () {
$('#preloader').fadeOut(1000);
});
// bottom to top
$(window).scroll(function () {
if ($(this).scrollTop() >= 100) { // If page is scrolled more than 50px
$('#top_to').fadeIn(500); // Fade in the arrow
} else {
$('#top_to').fadeOut(300); // Else fade out the arrow
}
});
$('#top_to').click(function () { // When arrow is clicked
$('body,html').animate({
scrollTop: 0 // Scroll to top of body
}, 1200);
});
// feature design hover js ends
})(jQuery);
|
import React from 'react'
const url = require('../../assets/error_message.jpg')
const PageNotFound = () => (
<section style={{
'width': '600px',
'margin': 'auto',
'margin-top': '20px'
}}>
<div style={{
'margin-top': '80px',
'font-size': '60px',
'padding-bottom': '225px',
'background': `url(${url}) bottom center no-repeat`,
'width': '100%',
'text-align': 'center'
}}>Error 404</div>
</section>
)
export default PageNotFound
|
import { Template } from 'meteor/templating';
import './home.html';
import '../common/recipecard.js';
Template.home.helpers({
recent_activity: () => [
{owner:"You", details:"wrote a new Baked Chicken recipe", time:"5min"},
{owner:"Prodeo", details:"made Steamed Asparagus", time:"3hr"},
{owner:"Abraham", details:"wrote a Delicious Waffles recipe", time:"2d"},
{owner:"Sam", details:"made Green Waffles", time:"1wk"},
],
});
|
import React, { Component } from 'react';
import styles from './loader.scss';
class LoaderComponent extends Component {
constructor(props) {
super(props);
}
render() {
return (
<div className={styles.loaderWrap}>
<div className={styles.outerImage}>
<div className={styles.loader} id="loader-6">
<span></span>
<span></span>
<span></span>
<span></span>
</div>
<div className={styles.loaderText}>Loading...</div>
</div>
</div>
);
}
}
export default LoaderComponent;
|
/******************************************************************************
*
* PROJECT: Flynax Classifieds Software
* VERSION: 4.1.0
* LISENSE: FL43K5653W2I - http://www.flynax.com/license-agreement.html
* PRODUCT: Real Estate Classifieds
* DOMAIN: avisos.com.bo
* FILE: LIB.JS
*
* This script is a commercial software and any kind of using it must be
* coordinate with Flynax Owners Team and be agree to Flynax License Agreement
*
* This block may not be removed from this file or any other files with out
* permission of Flynax respective owners.
*
* Copyrights Flynax Classifieds Software | 2013
* http://www.flynax.com/
*
******************************************************************************/
$(document).ready(function(){
$("#jCodeOut").focus(function() {
$(this).select();
$(this).mouseup(function() {
$(this).unbind("mouseup");
return false;
});
});
$('#Account').change(function(){
setTimeout(function(){
adurl['account_id'] = $('#ac_hidden').val();
buildBox( adurl );
},1);
});
$('#field_names_switch input[type=radio]').change(function(){
adurl['field_names'] = $(this).val();
if( $(this).val() == 1 )
{
$('#field_names_color_cont').fadeIn();
}else
{
$('#field_names_color_cont').fadeOut();
}
buildBox( adurl );
});
$('.colorSelector').ColorPicker({
color: '#'+bg_color,
onShow: function (colpkr) {
$(colpkr).fadeIn(500);
return false;
},
onHide: function (colpkr) {
$(colpkr).fadeOut(500);
refreshBox();
return false;
},
onChange: function (hsb, hex, rgb) {
var cur_id = $(this).attr('id')
$('div.colorSelector').each(function(){
if( $(this).data('colorpickerId') == cur_id )
{
$(this).children('div').css('backgroundColor', '#' + hex);
$(this).prev().val(hex);
}
});
}
});
$('select[name=listing_type]').change(function(){
xajax_loadCategories( $(this).val(), 0, -1 );
if( $(this).val() )
{
adurl['listing_type'] = $(this).val();
}
buildBox( adurl );
});
$('input[name=per_page]').change(function(){
if( $(this).val() )
{
adurl['per_page'] = $(this).val();
}
buildBox( adurl );
});
$('input[name=limit]').change(function(){
if( $(this).val() )
{
adurl['limit'] = $(this).val();
}
buildBox( adurl );
});
$('.multicat').change(function(){
var level = $(this).attr('id').split('category_level')[1];
var category_id = '';
if( $(this).val() && $(this).val() != 0 )
{
category_id = $(this).val();
}else if( $('#category_level' + (level - 1) ).val() )
{
category_id = $('#category_level' + (level - 1) ).val();
}
if( !$(this).hasClass('last') )
{
xajax_loadCategories( $('select[name=listing_type]').val(), category_id, level );
}
adurl['category_id'] = category_id;
buildBox( adurl );
});
$('table#jParams input[type=text]').change(function(){
refreshBox();
});
$('table#jParams select').change(function(){
refreshBox();
});
});
var buildBox = function( adurl )
{
if( !adurl['listing_type'] && $('select[name=listing_type]').val() )
{
adurl['listing_type'] = $('select[name=listing_type]').val();
}
aurl = '';
for( var x in adurl )
{
if( adurl[x] && typeof(adurl[x]) != 'function' )
{
aurl += '&' + x + "=" + adurl[x];
}
}
$.getScript(url + aurl, function(data, textStatus, jqxhr) {
refreshBox();
});
}
var refreshBox = function()
{
var params = new Array();
var jconf = new Array();
var value = false;
var colorPkrFields = new Array('conf_advert_bg', 'conf_field_first_color', 'conf_field_color', 'conf_field_names_color');
var sizeFields = new Array('conf_img_width', 'conf_img_height');
$('#jParams input').each(function(){
if( ($(this).attr('type') == 'text' || $(this).attr('type') == 'hidden') && $(this).val() && $(this).attr('abbr').typeOf != "undefined")
{
if( $.inArray( $(this).attr('name'), colorPkrFields ) >= 0 )
{
value = '#' + $(this).val();
}else if( $.inArray( $(this).attr('name'), sizeFields ) >= 0 )
{
value = $(this).val() + $(this).next('select').val();
}
else
{
value = $(this).val();
}
params = $(this).attr('abbr').split("|");
setStyleByClass(params[0], params[1], params[2], value);
jconf[$(this).attr('name')] = value;
}
});
refreshCode( jconf );
}
var refreshCode = function( jconf )
{
var jconf_out = '';
var out = '';
if( jconf )
{
for( var x in jconf )
{
if( typeof(jconf[x]) != 'function' )
{
jconf_out += "\t" + x + " = '" + jconf[x] + "';\r\n";
}
}
}
if( jconf_out )
{
out = '<script type="text/javascript">\r\n';
out += jconf_out;
out += "<\/script>\r\n";
}
var jParams = '';
out += '';
out += iout.replace('[aurl]', acurl + aurl);
$('#jCodeOut').val( out );
}
|
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// Define the collection and schema for Employees
let Employees = new Schema({
employee_id: {
type: Number
},
first_name: {
type: String
},
last_name: {
type: String
},
email_address: {
type: String
},
phone_number: {
type: Number
},
employee_salary: {
type: Number
}
},{
collection: 'employees'
});
module.exports = mongoose.model('Employees', Employees);
|
define([
], function() {
return {
storeName: "notes"
};
});
|
/*
* Module code goes here. Use 'module.exports' to export things:
* module.exports.thing = 'a thing';
*
* You can import it from another modules like this:
* var mod = require('role.war.wallBreaker');
* mod.thing == 'a thing'; // true
*/
wallBreaker = {
pickup: function(creep) {
if(creep.memory.fighting && creep.hits < 3000) {
creep.memory.fighting = false;
}
if(!creep.memory.fighting && creep.hitsMax == creep.hits) {
creep.memory.fighting = true;
}
// creep.moveTo(Game.flags.cs);
//See if we got to the waypoint
// if(!creep.memory.waypoint && creep.pos.roomName == Game.flags.waypoint.pos.roomName){
// creep.memory.waypoint = true;
// } else if(!creep.memory.waypoint) {
// creep.moveTo(Game.flags.waypoint);
// }
// if (creep.memory.waypoint && !creep.memory.waypoint2 && creep.pos.roomName == Game.flags.waypoint2.pos.roomName){
// creep.memory.waypoint2 = true;
// } else if (!creep.memory.waypoint2 && creep.memory.waypoint) {
// creep.moveTo(Game.flags.waypoint2);
// }
// if (creep.memory.waypoint2 && !creep.memory.waypoint4 && creep.pos.roomName == Game.flags.waypoint4.pos.roomName){
// creep.memory.waypoint4 = true;
// } else if (!creep.memory.waypoint4 && creep.memory.waypoint2) {
// creep.moveTo(Game.flags.waypoint4);
// }
if(true) {
console.log(creep.pos.roomName + Game.flags.trenches.pos.roomName);
if(creep.memory.fighting && creep.pos.roomName == Game.flags.trenches.pos.roomName) {
//Break the first wall
var breakThis = creep.room.lookForAt(LOOK_STRUCTURES, Game.flags.trenches);
//Break the second wall
if(breakThis.length == 0) {
breakThis = creep.room.lookForAt(LOOK_STRUCTURES, Game.flags.entrypoint2);
}
//Break their spawn
if(breakThis.length == 0) {
breakThis = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: (structure) => structure.structureType == 'tower'});
}
if(breakThis.length == 0) {
breakThis = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: (structure) => structure.structureType == 'spawn'});
}
if(breakThis.length == 0) {
breakThis = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: (structure) => structure.structureType == 'extension'});
}
if(breakThis.length == 0) {
// breakThis = creep.room.find(FIND_STRUCTURES, {filter: (structure) => structure.structureType == 'road'});
}
if(breakThis.length != 0) {
breakThis = breakThis[0];
if(creep.dismantle(breakThis) == ERR_NOT_IN_RANGE){
creep.moveTo(breakThis);
} else {
console.log("attacking " + breakThis);
}
}
} else if (creep.memory.fighting) {
creep.moveTo(Game.flags.trenches);
} else {
creep.moveTo(Game.flags.trenches);
}
}
}
}
module.exports = wallBreaker;
|
import React from 'react';
import PropTypes from 'prop-types';
import { Modal as BSModal } from 'react-bootstrap';
const Modal = props => (
<BSModal className="customModal" {...props}>
{props.children}
</BSModal>
);
Modal.propTypes = {
children: PropTypes.node.isRequired,
};
export default Modal;
|
var express = require ("express");
var app = express ();
var library = require ("./library.js")
var path = require("path");
var bodyParser = require('body-parser');
app.use(bodyParser.json()); // to support JSON-encoded bodies
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(__dirname + '/static'));
// var mysql = require('mysql');
// var dbconn = mysql.createConnection({
// host : 'localhost',
// user : 'root',
// password : '',
// database : 'test'
// });
app.get('/', function (req, res) {
res.sendFile(path.join(__dirname +'/index.html'));
})
/* local DB
app.post ('/library/addBook', function (req,res){
var data = req.body;
library.addBook(data);
res.send('book was added succefully');
})
app.post ('/library/searchBook', function (req,res){
var name = req.body;
res.send({result: library.searchBook(name)});
})*/
//DB
dbconn.query('CREATE DATABASE IF NOT EXISTS db_test', function (err) {
if (err) throw err;
dbconn.query('USE db_test', function (err) {
if (err) throw err;
dbconn.query('CREATE TABLE IF NOT EXISTS library('
+ 'name VARCHAR(30),'
+ 'PRIMARY KEY(name),'
+ 'title VARCHAR(30),'
+ 'num INT(30)'
+ ')', function (err) {
if (err) throw err;
});
console.log ("DB tables created succefully");
});
});
app.post('/library/addBook',function(req,res){
var book = req.body; // { name , title, num }
var query = library.addBook();
console.log(query.sql); // INSERT INTO library SET `id` = 1, `title` = 'Hello MySQL'
res.send('book was added to DB succefully');
});
app.post ('/library/searchBook',function(req,res){
var name = req.body.name;
var query = dbconn.query ("SELECT * FROM library WHERE name = ?",name, function(err,result){
console.log(query.sql);
console.log (result);
res.send({result : result});
});
});
var a;
a.kuku = "rotem";
console.log(a.kuku);
console.log(a['kuku']);
app.listen(3000)
|
//app.js用来启动express服务
//1引入express模块
const express = require('express');
const fri = require('./router/fri');
const mongoose = require("mongoose");
const bodyParser = require("body-parser");
const cookieParser = require('cookie-parser');
//连接上数据库
var db = mongoose.connect('mongodb://localhost:27017/myDbs');//这里的myDbs是数据库的名字
//2.创建app对象
const app = express()
//定义路由
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use('/api',fri)
//定义服务启动端口
app.listen(3000,() => {
console.log('app listening on port 3000.')
})
|
/**
* Created with JetBrains WebStorm.
* User: SNSukhanov
* Date: 04.12.13
* Time: 12:17
* To change this template use File | Settings | File Templates.
*/
RD.TabsController = function(m){
var view = {},
config = {
},
_handlers = function(){
var holder = $('.static-tabs').children('ul').find('li');
holder.bind('click', function(event){
_activeTabs(event, holder);
})
},
_activeTabs = function(e, list){
var id = $(e.currentTarget).attr('id-tab');
list.removeClass('active');
$(e.currentTarget).addClass('active');
$('#'+id).css('display', 'block');
$('#'+id).siblings('div').css('display', 'none');
};
view.init = function(){
_handlers();
};
return view;
}(RD);
RD.TabsController.init();
|
var searchData=
[
['hostname_5ftype_5ft',['hostname_type_t',['../connection__edge_8h.html#ac6ca65932a6302ac960ebd72fdf741e2',1,'connection_edge.h']]],
['hs_5fstats_5ft',['hs_stats_t',['../rephist_8c.html#a21e417cc521b1a837412142c77013f6c',1,'rephist.c']]]
];
|
import Vector from './vector';
export default class Derivative {
constructor (velocity, acceleration) {
this.velocity = velocity || new Vector(0, 0);
this.acceleration = acceleration || new Vector(0, 0);
}
add(derivative) {
return new Derivative(
this.velocity.add(derivative.velocity),
this.acceleration.add(derivative.acceleration)
);
}
scale(scalar) {
return new Derivative(
this.velocity.scale(scalar),
this.acceleration.scale(scalar)
);
}
}
|
function validateInputLength (creditCard) {
return creditCard.length >= 16;
}
function validateInputDigits (creditCard) {
let arrayCreditCard = creditCard.split('');
return arrayCreditCard.every((element) => element === arrayCreditCard[0]);
}
function removeSpecialCharacters (creditCard) {
return creditCard.replace(/[\W ]+/g, '');
}
function normalizeInput (creditCard) {
let normalized = removeSpecialCharacters(creditCard.toString());
if (validateInputLength(normalized) && !validateInputDigits(normalized)) {
return normalized.split('').map(digit => parseInt(digit));
}
}
function validateCalculation (creditCard) {
const isValid = normalizeInput(creditCard);
if (isValid) {
return isValid.reduce((acc, currentValue, index) => {
if (index % 2 === 0) {
let double = currentValue * 2;
double > 9 ? acc += double - 9 : acc += double;
} else {
acc += currentValue;
}
return acc;
}, 0);
}
}
function cardValidator (creditCard) {
return validateCalculation(creditCard) % 10 === 0;
}
module.exports.cardValidator = cardValidator;
|
import Const from '../Constants';
// Action Creators
const ReceiveSubgroups = subgroups => {
return { type: Const.RECEIVE_SUBGROUPS, subgroups };
};
const DeleteSubgroup = subgroup => {
return { type: Const.DELETE_SUBGROUP, subgroup };
};
const LoadingUsers = () => {
return { type: Const.LOADING_USERS };
};
const LoadingSubgroups = () => {
return { type: Const.LOADING_SUBGROUPS };
};
const ReceiveUsers = users => {
return { type: Const.RECEIVE_USERS, users };
};
export const ClearUsers = () => {
return { type: Const.CLEAR_USERS, users: [] };
};
const UpdateUsers = user => {
return { type: Const.UPDATE_USERS, user };
};
const RemoveUser = user => {
return { type: Const.REMOVE_USER, user };
};
const Authenticated = (authenticated, iaaAuth, iaacheck) => {
return { type: Const.USER_AUTHENTICATION, authenticated, iaaAuth, iaacheck };
};
const AddDummyUser = displayId => {
return { type: Const.ADD_DUMMY_USER, displayId };
};
const MarkUserForDeletion = identifier => {
return { type: Const.MARK_USER_FOR_DELETION, identifier };
};
const DummyUserFail = displayId => {
return { type: Const.FAILED_DUMMY_USER, displayId };
};
export const ResetState = () => {
return { type: Const.RESET_STATE };
};
const AddNotification = (messageId, title, message) => {
return { type: Const.ADD_NOTIFICATION, notification: { messageId, title, message } };
};
const RemoveNotification = messageId => {
return { type: Const.REMOVE_NOTIFICATION, messageId };
};
const PrivateGroup = confidential => {
return { type: Const.PRIVATE_GROUP, confidential };
};
const StoreRegistrationToken = token => {
return { type: Const.STORE_REGISTRATION_TOKEN, token };
};
export const UpdateGroupName = groupName => {
return { type: Const.RECEIVE_GROUP_NAME, groupName };
};
export const UpdatePrivateGroupVis = enabled => {
return { type: Const.STORE_PRIVATE_GROUP_VISIBILITY, enabled };
};
export const UpdatePrivateGroupVisTimeout = timeout => {
return { type: Const.STORE_PRIVATE_GROUP_VISIBILITY_TIMEOUT, timeout };
};
export const UpdateNetidAllowed = netidAllowed => {
return { type: Const.STORE_NETID_ALLOWED, netidAllowed };
};
export const UpdateTokenTTL = tokenTTL => {
return { type: Const.STORE_TOKEN_TTL, tokenTTL };
};
// -----------------------
// Thunks - Async Actions
const APIRequestWithAuth = async (url, opts) => {
let body = Object.assign({ method: 'GET', credentials: 'same-origin' }, opts);
return await fetch(url, body);
};
export const CreateGroup = (group, confidential = true, description, email) => {
return async dispatch => {
let body = {
confidential,
description,
email
};
let res = await APIRequestWithAuth(`/api/subgroups/${group}`, {
method: 'POST',
body: JSON.stringify(body),
headers: {
'Content-Type': 'application/json'
}
});
return res.status === 200;
};
};
export const LoadSubgroups = () => {
return async (dispatch, getState) => {
let state = getState();
if (!state.loading.subgroups) {
dispatch(LoadingSubgroups());
let subgroups = await (await APIRequestWithAuth(`/api/subgroups`)).json();
return await dispatch(ReceiveSubgroups(subgroups));
}
};
};
export const DestroySubgroup = group => {
return async dispatch => {
await APIRequestWithAuth(`/api/subgroups/${group}`, { method: 'DELETE' });
dispatch(UpdateGroupName(''));
return await dispatch(DeleteSubgroup(group));
};
};
export const LoadUsers = () => {
return async (dispatch, getState) => {
let state = getState();
let group = state.groupName;
if (group) {
dispatch(ClearUsers());
dispatch(LoadingUsers());
let groupInfo = await (await APIRequestWithAuth(`/api/members/${group}`)).json();
dispatch(PrivateGroup(groupInfo.confidential));
state = getState();
// only receive the users for the selected group
// if a user switches groups a bunch, we can't cancel the API calls
// so we throw away the results
if (group === state.groupName) {
return await dispatch(ReceiveUsers(groupInfo.members));
}
}
};
};
export const AddUser = (group, identifier) => {
return async (dispatch, getState) => {
let state = getState();
let displayId = Math.floor(Math.random() * 1000000).toString(16);
dispatch(AddDummyUser(displayId));
let body = {
displayId,
identifier
};
try {
let res = await APIRequestWithAuth(`/api/members/${group}`, {
method: 'PUT',
body: JSON.stringify(body),
headers: {
'Content-Type': 'application/json'
}
});
if (res.status === 404) {
dispatch(FlashNotification('User not found', 'Could not find the specified user.'));
return dispatch(DummyUserFail(displayId));
}
if (res.status === 401) {
if (state.registrationToken) {
dispatch(FlashNotification('Session Ended', 'Your registration session has ended, please start a new session.'));
return dispatch(DummyUserFail(displayId));
} else {
dispatch(FlashNotification('Not Authorized', 'You are not authorized to register users or your registration session has ended.'));
}
}
let user = await res.json();
// GWS considers adding the same user to a group an update and returns a 200, so we have to handle the dupes..
let dupe = state.users.find(u => {
return u.UWRegID === user.UWRegID;
});
if (dupe) {
dispatch(FlashNotification('Duplicate User', `${user.UWNetID || 'This user'} has already been added to this group.`));
dispatch(DummyUserFail(displayId));
} else {
// Return early if a private group w/o visibility
if (state.confidential && !state.privGrpVis) {
await dispatch(DummyUserFail(displayId));
return;
}
// Show the user
await dispatch(UpdateUsers(user));
// Fade out the user if the group is confidential w/visibility
if (state.confidential && state.privGrpVis) {
const fadeOutDelay = 5000; // This should match scss `.fadeOutRemoval` transition
const visibleDelay = state.privGrpVisTimeout * 1000;
window.setTimeout(async () => {
await dispatch(MarkUserForDeletion(identifier));
window.setTimeout(async () => {
await dispatch(RemoveUser(user.UWNetID));
}, fadeOutDelay);
}, visibleDelay);
}
}
} catch (ex) {
dispatch(DummyUserFail(displayId));
}
};
};
export const DeleteUser = (group, identifier) => {
return async dispatch => {
dispatch(MarkUserForDeletion(identifier));
await APIRequestWithAuth(`/api/members/${group}/member/${identifier}`, { method: 'DELETE' });
return dispatch(RemoveUser(identifier));
};
};
export const CheckAuthentication = () => {
return async dispatch => {
try {
let json = await (await APIRequestWithAuth('/api/checkAuth')).json();
dispatch(Authenticated(json.Authenticated, json.IAAAAuth, json.IAARedirect));
} catch (ex) {
dispatch(Authenticated(false, false));
}
};
};
export const Logout = (loggedOut = false) => {
return async dispatch => {
await APIRequestWithAuth('/api/logout' + (loggedOut ? `?loggedOut=${loggedOut}` : ''));
dispatch(Authenticated(false, false));
};
};
export const StartRegistrationSession = (groupName, netidAllowed = false, tokenTTL = 180, privGrpVis = true) => {
return async dispatch => {
await APIRequestWithAuth(`/api/getToken?groupName=${groupName}&netidAllowed=${netidAllowed}&tokenTTL=${tokenTTL}&privGrpVis=${privGrpVis}`);
dispatch(StoreRegistrationToken(true));
dispatch(ClearUsers());
await dispatch(Logout(true));
};
};
export const StopRegistrationSession = () => {
return async dispatch => {
dispatch(Logout());
dispatch(ResetState());
};
};
// spec compliant uuid v4: https://gist.github.com/jed/982883#file-index-js
const uuid = function b(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,b)};
export const FlashNotification = (title = '', message = '') => {
return async dispatch => {
let messageId = uuid();
dispatch(AddNotification(messageId, title, message));
dispatch(RemoveNotification(messageId));
};
};
|
const Promise = require('bluebird') // override ES6 Promise to be able to use '.using'
const dbConn = require('./connection')
function getQuestionById(qid, id) {
return new Promise((fulfill, reject) => {
const quest = Promise.using(dbConn.get(), (conn) => {
const query = `
SELECT * FROM questions
WHERE qid = ?
`
return conn.query(query, [qid]);
})
const answer = Promise.using(dbConn.get(), (conn) => {
const query = `
SELECT * FROM answers
WHERE qid = ?
`
return conn.query(query, [qid]);
})
const vote = Promise.using(dbConn.get(), (conn) => {
const query = `
SELECT * FROM surveyvotes
WHERE (uid = ? AND qid = ?)
`
return conn.query(query, [id, qid]);
})
const surveyvotes = Promise.using(dbConn.get(), (conn) => {
const query = `
SELECT * FROM surveyvotes
WHERE qid = ?
ORDER BY aid
`
return conn.query(query, [qid]);
})
Promise.all([quest, answer, vote, surveyvotes]).then((results) => {
let question = results[0];
question = question[0];
const choices = results[1];
let values = []
let vote = results[2];
vote = vote[0];
let temp = [];
for (choice of choices) {
values.push({id: choice.id, description: choice.description});
if (vote && vote.aid == choice.id) {
temp.push(vote.aid);
}
}
let votes = results[3];
let surveyvotes = [];
//what is this?
for (votee in votes) {
}
fulfill({question: {id: question.qid, question: question.question, description: question.description, type: question.type, choices: values}, vote: temp});
})
.catch((err) => {
reject(err);
})
})
}
function createQuestion({question, type, description, choices, qid}, uid) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
INSERT INTO questions SET ?
`
return conn.query(query, {qid: qid, question: question, type: type, description: description, uid: uid});
})
.then((result) => {
const temp = Promise.using(dbConn.get(), (conn) => {
const query = `
INSERT INTO answers (description, qid) VALUES ?
`
let values = []
for (choice of choices) {
let temp = []
temp.push(choice);
temp.push(result.insertId);
values.push(temp);
}
return conn.query(query, [values]);
})
.then((result2) => {
fulfill(result);
})
.catch((err) => {
reject(err);
})
})
.catch((err) => {
reject(err);
})
})
}
//question is a an object with one or more fields
function updateQuestion(qid, question) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
UPDATE questions SET ?
WHERE qid = ?
`
return conn.query(query, [question, qid]);
})
.then((result) => {
if (!result) {
reject("could not find question");
}
fulfill(result);
})
.catch((err) => {
reject("Update Error");
})
})
}
function removeQuestion(qid) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
DELETE FROM surveyvotes
WHERE qid = ?
`
return conn.query(query, [qid]);
})
.then((result) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
DELETE FROM answers
WHERE qid = ?
`
return conn.query(query, [qid]);
})
.then((result) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
DELETE FROM questions
WHERE qid = ?
`
return conn.query(query, [qid]);
})
.then((result2) => {
fulfill(result2);
})
.catch((err) => {
reject(err);
})
})
.catch((err) => {
reject("delete error");
})
})
.catch((err) => {
reject(err);
})
})
}
function listQuestions(page, pgSize = 10) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
return conn.query('SELECT * FROM questions ')
})
.then((questions1) => {
if (!questions1) {
reject("Could not find questions");
}
results = [];
for (let i = 0; i < 10; i++) {
if (questions1[page * pgSize + i] != undefined) {
const questionn = questions1[page * pgSize + i];
const apiResult = {qid: questionn.qid, question: questionn.question, type: questionn.type, description: questionn.description, uid: questionn.uid}
results.push(apiResult);
}
}
let hasMore = false;
if (page * pgSize + 10 <= questions1.length) {
hasMore = true;
}
fulfill({has_more: hasMore, questions: results});
})
.catch((err) => {
reject("Database Error");
})
})
}
function removeVote(id, qid) {
let ids;
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
DELETE FROM surveyvotes
WHERE (qid = ? and uid = ?)
`
return conn.query(query, [qid, id]);
})
.then((result) => {
fulfill(result);
})
.catch((err) => {
reject(err);
})
})
}
function castVote(uid, aid, qid) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `
INSERT INTO surveyvotes SET ?
`
return conn.query(query, {uid: uid, aid: aid, qid: qid});
})
.then((result) => {
fulfill(qid);
})
.catch((err) => {
reject(err);
})
})
}
function totalVotes(qid) {
return new Promise((fulfill, reject) => {
Promise.using(dbConn.get(), (conn) => {
const query = `SELECT DISTINCT answers.description, COUNT(surveyvotes.aid) AS count
FROM answers, surveyvotes
WHERE surveyvotes.qid = ? AND surveyvotes.aid = answers.id
GROUP BY answers.description`
return conn.query(query, qid);
})
.then((result) => {
fulfill(result);
})
.catch((err) => {
reject(err);
})
})
}
module.exports = {
getQuestionById,
createQuestion,
updateQuestion,
removeQuestion,
listQuestions,
removeVote,
castVote,
totalVotes
}
|
// Version 0.1, lets get it working first
(function() {
var prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)');
var interactiveMode;
var currentTime = 0;
var active = false;
var currentActiveTime = null;
var interactiveCheckbox = document.querySelector("#interactive");
var audioElement = document.querySelector("audio");
var tutorialContentParent = document.querySelector(".tutorial-content");
var tutorialContent = document.querySelector(".tutorial-content-wrapper");
// Checkbox can be turned off
interactiveCheckbox.addEventListener("click", e => {
interactiveMode = e.target.checked;
});
// Audio element reports its own updates
audioElement.addEventListener("timeupdate", e => {
currentTime = audioElement.currentTime;
if (interactiveMode) checkUpdate();
});
prefersReducedMotion.addEventListener('change', () => {
setInteractiveMode();
});
const nodeData = [];
function setInteractiveMode() {
// turns off interactive mode if user has preferences for prefers-reduced-motion
interactiveMode = !prefersReducedMotion.matches;
interactiveCheckbox.checked = interactiveMode;
}
function getAndPrepTimes() {
const nodes = document.querySelectorAll("[data-time]");
nodes.forEach(node => {
const times = node.getAttribute("data-time").split(":");
const totalSeconds = parseInt(times[0]) * 60 + parseInt(times[1]);
nodeData.push({
time: totalSeconds,
domNode: node
});
});
}
function checkUpdate() {
const passedTimes = nodeData.filter(item => {
return item.time < currentTime;
});
const currentItem = passedTimes[passedTimes.length - 1];
if (
currentItem &&
currentActiveTime !== currentItem.time &&
interactiveMode
) {
currentActiveTime = currentItem.time;
currentItem.domNode.scrollIntoView({ behavior: "smooth" });
}
}
setInteractiveMode();
getAndPrepTimes();
})();
|
var config = require('./webpack.base.js'),
path = require('path'),
webpack = require('webpack'),
port = 3000,
HappyPack = require('happypack');
config.devtool = 'cheap-module-eval-source-map';
config.entry.main = [
'webpack-hot-middleware/client?path=http://localhost:' + port + '/__webpack_hmr',
'./assets/index',
];
config.output.publicPath = 'http://localhost:' + port + '/dist/';
config.plugins.unshift(new webpack.HotModuleReplacementPlugin());
config.plugins.unshift(new HappyPack({
id: 'js',
loaders: [{
path: 'babel-loader',
options: {
plugins: [
['transform-object-rest-spread'],
['syntax-object-rest-spread'],
['syntax-dynamic-import'],
['dynamic-import-webpack'],
['react-transform', {
transforms: [{
transform: 'react-transform-hmr',
imports: ['react'],
locals: ['module'],
}, {
'transform': 'react-transform-catch-errors',
'imports': ['react', 'redbox-react'],
}],
}],
],
},
}],
verbose: false,
threads: 4,
}));
config.module = {
noParse: /node_modules\/quill\/dist\/quill\.js/,
rules: [{
test: /\.js$/,
use: 'happypack/loader?id=js',
include: path.join(__dirname, 'assets'),
}, {
test: /\.css$/, loader: 'style-loader!css-loader',
}],
};
module.exports = config;
|
import React from "react"
import styled from "styled-components"
import Layout from "../components/layout"
import Landing from "../components/landing"
const Container = styled.section`
position: relative;
height: 100vh;
background: linear-gradient(rgba(0, 0, 0, 0.4), rgba(0, 0, 0, 0.4)),
url(/images/hero4.jpg) center left/cover no-repeat;
@media only screen and (max-width: 56.25em) {
background-position: center;
}
`
const Skyline = styled.img`
position: absolute;
bottom: 0;
left: 50%;
transform: translate(-50%);
width: 30rem;
@media only screen and (max-width: 41em) {
width: 15rem;
}
`
const IndexPage = () => {
return (
<Layout title="KnoGeo">
<Container>
<Landing />
</Container>
<Skyline src="/images/skyline.png" />
</Layout>
)
}
export default IndexPage
|
/*
Road systems can be imagined as a graph of intersections connected by lines. The advantage of this is it makes it easier to find the shortest path between any two intersections.
Task
Write a function that takes as arguments:
A graph of the road system
The starting intersection (node)
The ending intersection (node)
And returns an object containing information about the shortest path.
Format of the road graph
The road graph follows the JSON graph specification linked in the Resources tab. As an example, this is what one road graph could look like (in JSON):
{
"graph": {
"directed": false,
"nodes": [
{ "id": 0 },
{ "id": 1 },
{ "id": 2 },
{ "id": 3 }
],
"edges": [
{
"source": 0,
"target": 1,
"metadata": {
"distance": 5
}
},
{
"source": 1,
"target": 3,
"metadata": {
"distance": 9
}
},
{
"source": 3,
"target": 2,
"metadata": {
"distance": 6
}
},
{
"source": 2,
"target": 4,
"metadata": {
"distance": 3
}
},
{
"source": 4,
"target": 3,
"metadata": {
"distance": 8
},
},
{
"source": 4,
"target": 0,
"metadata": {
"distance": 2
}
}
]
}
}
Additionally, all edges are two way roads (undirected), so you don't need to worry about that. Which node is in source and which is in target does not matter. Edges may contain the property label, which is just a street name and not necessary for you to use.
And remember, the goal is to minimize the sum of all the metadata.distance properties of edges used.
Format of return value
The return value should be an object with properties distance and path.
distance should be the number that is the total sum of the distance metadata on each edge used.
path should be an array of numbers, where each number is the id of a node used along the path from the start to the end.
For example, if the shortest path from node 1 to node id 2 was going from node 1 to node 3 to node 2, then the result should be [1, 3, 2]. You must include the starting and ending nodes in the path.
If two paths have the same distance, it does not matter which one you return (which won't happen in the tests).
Example
In the example road graph, if I asked you to find the path from node id 2 to node id 0, the function call would be
navigate(roads, 2, 0) // Where roads is the example graph structure
And you should return
{
"distance": 5,
"path": [ 2, 4, 0 ]
}
Notes
If two paths have the same distance, it doesn't matter which one you return (which won't happen in the tests).
Make sure to include the starting and ending nodes in the path.
The order of the path array does matter.
Distance between 2 nodes is located in the metadata.distance property of the edge connecting them.
*/
function navigate(roads, startingNode, endingNode) {
const paths = [];
const takeTurns = (path) => {
const turns = path.getTurns(roads);
if (path.success(endingNode)) {
paths.push(path.summary());
} else if (turns.length > 0) {
turns.forEach( turn => {
const cp = new Path(path.visited, path.turns);
cp.takeTurn(turn);
takeTurns(cp);
});
}
};
takeTurns(new Path([startingNode]));
return paths.reduce( (accum, path) => {
if (path.distance < accum.distance) return path;
return accum;
}, paths[0]);
}
class Path {
constructor(visited = [], turns = []) {
this.visited = visited.slice();
this.turns = turns.slice();
}
success(endingNode) {
return this.getCurrentNode() == endingNode;
}
takeTurn(turn) {
this.turns.push(turn);
this.visited.push(turn.source == this.getCurrentNode() ? turn.target : turn.source);
}
getCurrentNode() {
return this.visited[this.visited.length - 1];
}
getTurns(roads) {
const lastNode = this.getCurrentNode();
return roads.graph.edges.filter( edge =>
(edge.source == lastNode &&
this.visited.indexOf(edge.target) < 0) ||
(edge.target == lastNode && this.visited.indexOf(edge.source) < 0));
}
cp() {
return new Path(this.visited, this.turns);
}
summary() {
const dist = this.turns.reduce( (accum, turn) => accum + parseInt(turn.metadata.distance), 0 );
return {
distance: dist,
path: this.visited
}
}
}
|
import React, {useHistory} from 'react'
// import Home from '../components/home/Home'
const CustomersPage = (props) => {
return (
<div>
<h1> this is customers page </h1>
</div>
)
}
export default CustomersPage;
|
angular.module('music4BizWebsite')
.controller('songsCtrl', function ($scope, $location, $rootScope, songsService) {
//$scope.songs = [];
$scope.genres = [{ id: 1, text: "שקט ורומנטי" }, { id: 2, text: "ג'אז" }, { id: 3, text: "צ'יל / לאונג'" },
{ id: 4, text: "להיטים" }, { id: 5, text: "קלאב פאשן" }, { id: 6, text: "קלאסי" }, { id: 7, text: "דאנס" }];
$scope.currentGenre = {};
$scope.currentSongIndex = 0;
$scope.currentSongPlayingObject = undefined;
$scope.showPause = false;
$scope.getSongsFromBucket = function () {
showLoader();
songsService.getSongsFromBucket().then(function (response) {
$scope.songs = response.songs;
hideLoader();
});
}
$scope.handleFileCompleted = function () {
$scope.removeSong();
$scope.currentSongIndex++;
// $scope.currentSongPlayingObject = undefined;
$scope.playGenre($scope.currentGenre.id - 1);
}
$scope.openPricesTable = function () {
$("#pricesTable").modal('show');
}
//---------------------------------- Player ------------------------------------------------------------
$scope.playGenre = function (index, pause) {
if (pause === true) {
$scope.pauseGenre(index);
return;
}
var songsFolder = $scope.songs[index];
if ($scope.currentSongPlayingObject != undefined) $scope.currentSongPlayingObject.pause(true);
$scope.showPause = true;
if ($scope.currentGenre === $scope.genres[index]) {
if ($scope.currentSongPlayingObject != undefined) {
$scope.currentSongPlayingObject.play();
} else if ($scope.songs[index][$scope.currentSongIndex] != undefined) {
$scope.currentSongPlayingObject = new Audio(songsFolder[$scope.currentSongIndex].SongUrl);
$scope.currentSongPlayingObject.onended = $scope.handleFileCompleted;
$scope.currentSongPlayingObject.play();
} else {
$scope.currentGenre = {}
$scope.currentSongIndex = 0;
$scope.$apply();
}
} else {
$scope.currentGenre = $scope.genres[index];
$scope.currentSongIndex = 0;
$scope.currentSongPlayingObject = new Audio(songsFolder[$scope.currentSongIndex].SongUrl);
$scope.currentSongPlayingObject.onended = $scope.handleFileCompleted;
$scope.currentSongPlayingObject.play();
}
}
$scope.pauseGenre = function () {
if ($scope.currentSongPlayingObject != undefined) {
$scope.currentSongPlayingObject.pause(true);
$scope.showPause = false;
}
}
$scope.removeSong = function() {
$scope.currentSongPlayingObject.pause();
delete $scope.currentSongPlayingObject;
$($scope.currentSongPlayingObject).remove();
$scope.currentSongPlayingObject = undefined;
}
//-----------------------------------Buttons------------------------------------------------------------------
$scope.changeBg = function (path) {
$("body").removeClass("home-bg");
$("body").removeClass("lib-bg");
$("body").removeClass("portfolio-bg");
$("body").removeClass("businessMusic-bg");
var className = "";
if (path === "/") className = "home-bg";
if (path === "/libraries") className = "lib-bg";
if (path === "/portfolio") className = "portfolio-bg";
if (path === "/businessMusic") className = "businessMusic-bg";
$("body").addClass(className);
//if ($("#ng-view .businessMusic")[0] != undefined) $("#ng-view .businessMusic")[0].style.marginTop = "9%";
}
$scope.pricesTable = [];
$scope.getPriceList = function () {
songsService.getPriceList().success(function (response) {
$scope.pricesTable = response;
});
}
$scope.goToSignUp = function (itemId) {
$("#pricesTable").modal('hide');
if (!$scope.logedIn) window.location.href = "#signup/" + itemId;
else window.location.href = "#account";
}
createjs.Sound.on("fileload", $scope.handleFileLoad);
$scope.changeBg($location.path());
// $scope.getSongsFromBucket();
// $scope.getPriceList();
})
|
require('dotenv').config();
const express = require('express');
const {mongoose} = require('./db/mongoose.js');
const cookieParser = require('cookie-parser');
const site = require('./routes/api/site');
const user = require('./routes/api/users');
const product = require('./routes/api/product');
const appRoutes = require('./utils/appRoutes')
const app = express();
app.use(express.urlencoded({
extended: false
}));
app.use(express.json());
app.use(cookieParser());
app.use(express.static('client/build'));
app.use(appRoutes.product, product)
app.use(appRoutes.users, user);
app.use(appRoutes.site, site);
// DEFAULT
if( process.env.NODE_ENV === 'production' ){
const path = require('path');
app.get('/*', (req, res)=> {
res.sendfile(path.resolve(__dirname, '../client', 'build', 'index.html'))
})
}
const port = process.env.PORT || 3002;
app.listen(port, () => {
console.log(`Server running on ${port}`);
});
|
+function (window, angular, undefined) {
'use strict';
angular.module('ngQuantum.carousel', ['ngQuantum.services.helpers'])
.run(['$templateCache', function ($templateCache) {
'use strict';
$templateCache.put('carousel/carousel.tpl.html',
'<div class="carousel" ng-style="{width:$outerWidth}">'
+ '<div class="carousel-inner" ng-transclude ng-style="{height:$innerHeight}" ng-swipe-left="$next()" ng-swipe-right="$prev()"></div>'
+ '<div class="carousel-control left" ng-click="$prev()" ng-style="{height:$conrolHeight}">'
+ '<span class="icon-prev"></span>'
+ '</div>'
+ '<div class="carousel-control right" ng-click="$next()" ng-style="{height:$conrolHeight}">'
+ '<span class="icon-next"></span>'
+ '</div>'
+ '<ol class="carousel-indicators" ng-if="!$hideIndicator">'
+ '<li ng-repeat="item in items" indicator-transclude="item" ng-class="{active: item.active}" ng-click="item.select($index)">'
+ '<span class="indicator-no">{{$index + 1}}</span>'
+ '</li>'
+ '</ol>'
+ '<div class="carousel-page-control page-left" ng-click="$prevPage()" ng-if="!$hideIndicator">'
+ '<span class="icon-page-prev fic fu-angle-l"></span>'
+ '</div>'
+ '<div class="carousel-page-control page-all" ng-click="$showAllThumbs()" ng-if="!$hideIndicator">'
+ '<span class="page-all-total" ng-bind="totalValidItems"></span>'
+ '<span class="icon-page-all fic fu-angle-d"></span>'
+ '</div>'
+ '<div class="carousel-page-control page-right" ng-click="$nextPage()" ng-if="!$hideIndicator">'
+ '<span class="icon-page-next fic fu-angle-r"></span>'
+ '</div>'
+ '</div>'
);
}])
.provider('$carousel', function () {
var defaults = this.defaults = {
effect: 'slide-right-left',
prevEffect: 'slide-left-right',
type: 'carousel',
speed: 'fastest',
prefixEvent: 'carousel',
directive: 'nqCarousel',
instanceName: 'carousel',
keyboard: true,
hoverStop: true,
showIndicator: true,
showPrevNext: true,
showPause: true,
showPlay: true,
autoPlay: true,
outerWidth: '650px',
innerHeight: '405px',
interval: 5000,
maxHeightRate: false,
hideIndicator: false,
pageSize: 10,
showPageButtons: false,
allThumbsButton:false
};
this.$get = ['$timeout', '$interval', '$filter', '$compile', '$sce', '$animate',
function ($timeout, $interval, $filter, $compile, $sce, $animate) {
function CarouselFactory($element, $scope, config) {
var $carousel = {},
options = $carousel.$options = angular.extend({}, defaults, config),
items = $carousel.items = $scope.items = [];
$scope.totalAdded = 0;
$scope.totalRemoved = 0;
var lastIndex = $carousel.$lastIndex = 0;
var prevIndex = 0;
var pageIndex = $scope.$pageIndex = 0;
var totalPageIndex = $scope.$totalPageIndex = 0;
var stopFunc;
if (options.maxHeightRate)
options.maxHeightRate = parseFloat(options.maxHeightRate)
angular.forEach(['next', 'prev', 'play', 'pause', 'nextPage', 'prevPage', 'showAllThumbs'], function (value) {
$scope['$' + value] = function (evt) {
$carousel[value](evt);
}
})
angular.forEach(['outerWidth', 'innerHeight', 'hideIndicator'], function (value) {
$scope['$' + value] = options[value];
})
if ($element.hasClass('thumb-navigation') || $element.hasClass('number-navigation')) {
$carousel.$watchIndicator = true;
}
if (options.showPageButtons)
$element.addClass('show-page-butons')
if (options.allThumbsButton)
$element.addClass('all-thumbs-button')
$carousel.init = function () {
if (options.autoPlay) {
$carousel.play()
hoverStop();
}
$timeout(function () {
$scope.$conrolHeight = '';
var eWidth = $element.width();
if (eWidth > 0 && (options.maxHeightRate || parseInt($scope.$outerWidth) > $element.width())) {
var eHeight = ((parseInt($scope.$innerHeight) / parseInt($scope.$outerWidth)) * $element.width());
if (options.maxHeightRate && parseFloat(eHeight / eWidth) > options.maxHeightRate)
eHeight = options.maxHeightRate * eWidth;
$scope.$innerHeight = eHeight + 'px';
if (eWidth > 767) {
$scope.$conrolHeight = $scope.$innerHeight;
}
}
}, 800)
};
$carousel.select = function (index, isPrev) {
if (!items.length) {
$carousel.pause();
return;
}
if ($scope.totalItems > 0 && index >= items.length - 2 && $scope.currentLimit < $scope.totalItems) {
var newLimit = $scope.currentLimit + $scope.pageSize;
if (newLimit > $scope.totalItems)
newLimit = $scope.totalItems;
$scope.currentLimit = newLimit;
}
if ($carousel.$watchIndicator)
$scope.totalValidItems = ($scope.totalItems ? $scope.totalItems - $scope.totalRemoved : items.length);
$carousel.isPrev = isPrev;
var selectedItem = items[index];
angular.forEach(items, function (item) {
if (item.active && item !== selectedItem) {
item.active = false;
item.activeClasses = '';
}
});
if (!selectedItem && items.length) {
prevIndex = lastIndex;
selectedItem = items[0];
lastIndex = $carousel.$lastIndex = 0;
}
if (selectedItem) {
prevIndex = lastIndex;
selectedItem.active = true;
lastIndex = $carousel.$lastIndex = index;
pageIndex = $scope.$pageIndex = parseInt(lastIndex / $scope.pageSize);
}
};
$carousel.pause = function () {
$interval.cancel(stopFunc)
};
$carousel.play = function () {
if (!$carousel)
return;
stopFunc = $interval($carousel.next, options.interval)
};
$carousel.next = function (evt) {
if (!$carousel)
return;
var i = lastIndex < items.length - 1 ? lastIndex + 1 : 0;
if (!angular.isNumber(i) || i < 0)
i = 0;
$carousel && $carousel.select(i);
};
$carousel.prev = function () {
if (!$carousel)
return;
var i = lastIndex > 0 ? lastIndex - 1 : items.length - 1;
if (!angular.isNumber(i) || i < 0)
i = items.length - 1;
$carousel && $carousel.select(i, true);
};
$carousel.prevPage = function () {
if (!$carousel || ($carousel && $scope.$pageIndex == 0))
return;
$carousel.goPage($scope.$pageIndex - 1);
};
$carousel.nextPage = function (evt) {
if (!$carousel || ($carousel && $scope.$totalPageIndex > 0 && $scope.$pageIndex >= $scope.$totalPageIndex))
return;
$carousel.goPage($scope.$pageIndex + 1);
};
$carousel.showAllThumbs = function (evt) {
if (!$carousel)
return;
$scope.currentLimit = $scope.totalItems;
$carousel.visibleThumb = $scope.totalItems;
$carousel.$watchIndicator = false;
$element.addClass('shown-all-thumbs');
};
$carousel.goPage = function (_pageIndex) {
if (!$carousel)
return;
var totalIndex = ($scope.totalItems ? $scope.totalItems - $scope.totalRemoved : items.length) - 1;
var pageSize = $scope.pageSize;
var _totalPageIndex = $scope.$totalPageIndex = totalPageIndex = parseInt(totalIndex / pageSize);
_pageIndex = _pageIndex < 0 ? 0 : _pageIndex > _totalPageIndex ? _totalPageIndex : _pageIndex;
var pageStartIndex = (_pageIndex * pageSize) - 1;
if (pageStartIndex > totalIndex)
pageStartIndex = totalIndex;
var i = pageStartIndex + (lastIndex % pageSize);
if (i > totalIndex)
i = pageStartIndex;
if (!angular.isNumber(i) || i < 0) {
i = 0;
_pageIndex = 0;
}
$carousel && $carousel.select(i);
};
$carousel.addItem = function (item) {
items.push(item);
if (items.length === 1 || item.$index == lastIndex) {
item.active = true;
} else if (item.active) {
$carousel.select(items.indexOf(item));
}
$scope.totalAdded = $scope.totalAdded + 1;
};
$carousel.removeItem = function (item) {
if (!$carousel)
return;
var index = items.indexOf(item);
if (item.active && items.length > 1) {
var newActiveIndex = index == items.length - 1 ? index - 1 : index + 1;
$carousel && $carousel.select(newActiveIndex);
}
items.splice(index, 1);
$carousel.totalRemoved = $scope.totalRemoved = $scope.totalRemoved + 1;
};
$carousel.setIndicatorVisibility = function (_elm, _index) {
if ($carousel.visibleThumb > 0) {
var totalIndex = ($scope.totalItems ? $scope.totalItems - $scope.totalRemoved : items.length) - 1;
var visThumbs = $carousel.visibleThumb;
var minIndex = parseInt(lastIndex / (visThumbs - 1)) * (visThumbs - 1);
var maxIndex = minIndex + visThumbs;
if (maxIndex > totalIndex) {
maxIndex = totalIndex + 1;
minIndex = maxIndex - visThumbs;
}
if (minIndex == lastIndex && prevIndex > lastIndex && minIndex >= (visThumbs -1)) {
minIndex = minIndex - 1;
maxIndex = maxIndex + visThumbs;
}
if (minIndex <= _index && _index < maxIndex) {
_elm.css('display', '');
}
else {
_elm.css('display', 'none');
}
}
};
$carousel.init();
function hoverStop() {
if (options.hoverStop) {
$element.on('mouseenter', function () {
$carousel.pause();
})
$element.on('mouseleave', function () {
$carousel.play();
})
}
}
$scope.$on('$destroy', function () {
$carousel && ($carousel = null);
});
return $carousel;
}
return CarouselFactory;
}
];
})
.directive('nqCarousel', ['$carousel', '$helpers', function ($carousel, $helpers) {
return {
restrict: 'EA',
transclude: true,
replace: true,
scope: {
pageSize: '=?',
totalItems: '=?',
thumbSize: '=?'
},
templateUrl: 'carousel/carousel.tpl.html',
controller: ['$scope', '$element', '$attrs', function ($scope, $element, $attrs) {
var carWidth = $element.width() ? $element.width() : window.innerWidth;
var pageSize = 10;
$scope.thumbSize = $scope.thumbSize || -1;
if ($scope.thumbSize < 1)
pageSize = $scope.pageSize = $scope.pageSize || 10;
else
pageSize = $scope.pageSize = parseInt($scope.pageSize ? $scope.pageSize : (carWidth / ($scope.thumbSize > 0 ? $scope.thumbSize : 70)));
$scope.totalItems = $scope.totalItems || 0;
$scope.totalValidItems = $scope.totalItems;
$scope.currentLimit = pageSize;
var options = {};
angular.forEach(['effect', 'prevEffect', 'speed', 'interval', 'keyboard', 'hoverStop', 'autoPlay', 'outerWidth', 'innerHeight', 'maxHeightRate', 'hideIndicator', 'showPageButtons', 'allThumbsButton'],
function (key) {
angular.isDefined($attrs[key]) && (options[key] = $helpers.parseConstant($attrs[key]))
})
var ctrl = new $carousel($element, $scope, options);
ctrl.thumbSize = $scope.thumbSize;
ctrl.pageSize = pageSize;
if ($scope.thumbSize < 1)
ctrl.thumbOuterWidth = carWidth / pageSize;
$scope.carCtrl = ctrl;
$scope.$on('$destroy', function () {
ctrl && (ctrl = null);
});
return ctrl;
}]
};
}])
.directive('carouselItem', ['$parse', function ($parse) {
return {
require: '^nqCarousel',
restrict: 'EA',
replace: true,
template: '<div class="item" carousel-item-transclude="" ng-swipe-left="$parent.$next()" ng-swipe-right="$parent.$prev()"></div>',
transclude: true,
scope: {
active: '=?',
heading: '@',
},
controller: function () {
},
compile: function (elm, attrs, transclude) {
return function postLink(scope, elm, attrs, controller) {
scope.effect = controller.$options.effect;
scope.prevEffect = controller.$options.prevEffect;
scope.speed = controller.$options.speed;
angular.isDefined(attrs.effect) && (scope.effect = attrs.effect)
angular.isDefined(attrs.speed) && (scope.effect = attrs.speed)
scope.$order = angular.isDefined(attrs.order) ? parseFloat(attrs.order) : scope.$index;
scope.select = function (index) {
index = index || scope.$index || 0;
controller.select(index);
};
controller.addItem(scope);
scope.$on('$destroy', function () {
controller && controller.removeItem(scope);
});
scope.$parent.$remove = function (index) {
controller && controller.removeItem(scope);
};
scope.$transcludeFn = transclude;
};
}
};
}])
.directive('indicatorTransclude', ['$compile', function ($compile) {
return {
restrict: 'A',
require: '^nqCarousel',
link: function (scope, elm, attrs, controller) {
var item = scope.$eval(attrs.indicatorTransclude);
if (controller.$watchIndicator && scope.$first) {
if (controller.thumbSize < 1) {
var indicator = elm.closest('.carousel-indicators');
var width = parseInt(indicator.width() / controller.pageSize);
controller.thumbWidth = width;
controller.visibleThumb = controller.pageSize;
} else {
controller.thumbWidth = elm.width();
controller.visibleThumb = parseInt((elm.closest('.carousel-indicators').innerWidth()) / controller.thumbWidth)
}
controller.thumbHeight = elm.height();
}
elm.css('width', controller.thumbWidth);
scope.$watch(function () { return item.thumbImage }, function (image) {
if (image) {
var thumbImg = angular.isElement(image) ? image : angular.element(image);
if (!thumbImg.hasClass('thumb-image')) {
thumbImg.on('load', function () {
var c = document.createElement("canvas"),
w = controller.thumbWidth,
h = controller.thumbHeight,
ow = controller.$options.outherWidth;
c.width = w; c.height = h;
c.getContext("2d").drawImage(this, 0, 0, w, h);
elm.html(c)
});
} else {
elm.html(image)
}
}
});
if (controller.$watchIndicator) {
var listener = scope.$watch(function () { return controller.$lastIndex }, function (index) {
controller.setIndicatorVisibility(elm, scope.$index);
if (!controller.$watchIndicator) {
elm.css('display', '');
listener();
}
});
var listener2 = scope.$watch(function () { return controller.totalRemoved }, function (val) {
if (val)
controller.setIndicatorVisibility(elm, scope.$index);
if (!controller.$watchIndicator) {
elm.css('display', '');
listener2();
}
});
}
}
};
}])
.directive('carouselItemTransclude', ['$animate', '$timeout', function ($animate, $timeout) {
return {
restrict: 'A',
require: ['^carouselItem', '^nqCarousel'],
link: function (scope, elm, attrs, controller) {
scope.$watch('$transcludeFn', function (value) {
scope.$transcludeFn(scope.$parent, function (contents) {
angular.forEach(contents, function (node) {
elm.append(node);
var nodeEl = angular.element(node)
if (nodeEl.hasClass('thumb-image')) {
scope.noCanvas = true;
scope.thumbImage = nodeEl;
}
else
elm.append(node);
});
if (!scope.thumbImage) {
var thImg = elm.find('.generate-thumb');
scope.thumbImage = thImg;
}
});
});
scope.$watch('active', function (value) {
var ctrl = controller[1];
value ? show(ctrl.isPrev) : hide(ctrl.isPrev);
});
function show(isPrev) {
isPrev && elm.removeClass(scope.effect);
elm.show();
if (scope.effect) {
elm.addClass(scope.speed)
$animate.addClass(elm, isPrev ? scope.prevEffect : scope.effect).then(function () {
});
}
}
function hide(isPrev) {
if (scope.effect) {
if (isPrev) {
elm.removeClass(scope.effect);
elm.addClass(scope.prevEffect);
}
$animate.removeClass(elm, isPrev ? scope.prevEffect : scope.effect).then(function () {
elm.hide();
});
elm.animationEnd(function (evt) {
!scope.active && elm.hide();
});
}
else
elm.hide();
}
}
};
}]);
}(window, window.angular);
|
'use strict';
let routes = require('./routes');
let mockdata = require('./mockdata');
module.exports = {
routes,
mockdata
};
|
import { GameLogic} from './gamelogic.js';
function mainScript(){
let gamelogic = new GameLogic();
gamelogic.start();
}
document.getElementById('start').onclick=mainScript;
|
(function () {
angular
.module('myApp')
.controller('GroupsetsController', GroupsetsController)
GroupsetsController.$inject = ['$state', '$scope', '$rootScope', '$filter'];
function GroupsetsController($state, $scope, $rootScope, $filter) {
// ************** router: groupRoot *****************
$rootScope.setData('showMenubar', true);
$rootScope.setData('backUrl', "groupRoot");
$scope.groupsets = {};
$scope.criteria_types = ['Age', 'Gender', 'Language', 'Nationality', 'Institution']
$scope.criteria_options = ['Same', 'Different']
$scope.genders = ["Male", "Female"]
$rootScope.safeApply();
$scope.$on('$destroy', function () {
$('#createGroupModal').modal('hide');
$('#createGroupModal1').modal('hide');
if ($scope.subGroupRef) $scope.subGroupRef.off('value')
if ($scope.qsetRef) $scope.qsetRef.off('value')
if ($scope.qstRef) $scope.qstRef.off('value')
if ($scope.userRef) $scope.userRef.off('value')
if ($scope.userGroupRef) $scope.userGroupRef.off()
})
$scope.init = function () {
$rootScope.setData('loadingfinished', false);
$scope.getAllQuestionSets();
$scope.getAllQuestions();
$scope.getGroupsets();
$scope.getUserList();
$scope.getUserGroups();
}
$scope.getAllQuestionSets = function () {
$scope.qsetRef = firebase.database().ref('QuestionSets');
$scope.qsetRef.once('value', function (snapshot) {
$scope.allSets = snapshot.val() || {}
$scope.ref_1 = true
$scope.finalCalc()
});
}
$scope.getAllQuestions = function () {
$scope.qstRef = firebase.database().ref('Questions');
$scope.qstRef.once('value', function (snapshot) {
$scope.allQuestions = {}
var allQuestions = snapshot.val();
for (key in allQuestions) {
var question = allQuestions[key]
if (question.questionType == 'Answer Type') continue;
var setKey = question.Set
$scope.allQuestions[setKey] = $scope.allQuestions[setKey] || {}
$scope.allQuestions[setKey][key] = question
}
$scope.ref_2 = true
$scope.finalCalc()
});
}
$scope.getGroupsets = function () {
$scope.subGroupRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets');
$scope.subGroupRef.on('value', function (snapshot) {
$scope.originGroupSets = snapshot.val();
$scope.ref_3 = true;
$scope.finalCalc()
});
}
$scope.getUserList = function () {
$scope.userRef = firebase.database().ref('Users').orderByChild('Usertype').equalTo('Student');
$scope.userRef.on('value', function (snapshot) {
$scope.allUsers = snapshot.val() || {}
$scope.ref_4 = true;
$scope.finalCalc()
})
}
$scope.getUserGroups = function () {
$scope.userGroupRef = firebase.database().ref('StudentGroups');
$scope.userGroupRef.on('value', function (snapshot) {
let userGroups = snapshot.val() || {}
$scope.groupUsers = {}
for (userKey in userGroups) {
if (Object.values(userGroups[userKey]).indexOf($rootScope.settings.groupKey) > -1) {
$scope.groupUsers[userKey] = {}
}
}
$scope.ref_5 = true;
$scope.finalCalc()
})
}
$scope.finalCalc = function () {
if (!$scope.ref_1 || !$scope.ref_2 || !$scope.ref_3 || !$scope.ref_4 || !$scope.ref_5) return
for (userKey in $scope.groupUsers) {
$scope.groupUsers[userKey] = angular.copy($scope.allUsers[userKey])
}
var groupSets = angular.copy($scope.originGroupSets)
for (key in groupSets) {
var groupset = groupSets[key];
if (!groupset.addRule) groupset.addRule = { type: 'manually' };
// get questionset
var sets = groupset.QuestionSets;
groupset.questions = {};
if (sets) {
sets.forEach(qSet => {
qSet.setname = $scope.allSets[qSet.key].setname
groupset.questions[qSet.key] = [];
var qsts = $scope.allQuestions[qSet.key];
for (var qstKey in qsts) {
qsts[qstKey].key = qstKey;
groupset.questions[qSet.key].push(qsts[qstKey]);
}
groupset.questions[qSet.key] = $filter('orderBy')(groupset.questions[qSet.key], 'order');
});
}
for (var subKey in groupset.subgroupsets) {
var subset = groupset.subgroupsets[subKey];
if (!subset.addRule) subset.addRule = { type: 'manually' };
var sets = subset.QuestionSets;
subset.questions = {};
if (sets) {
sets.forEach(qSet => {
qSet.setname = $scope.allSets[qSet.key].setname
subset.questions[qSet.key] = [];
var qsts = $scope.allQuestions[qSet.key];
for (var qstKey in qsts) {
qsts[qstKey].key = qstKey;
subset.questions[qSet.key].push(qsts[qstKey]);
}
subset.questions[qSet.key] = $filter('orderBy')(subset.questions[qSet.key], 'order');
});
}
}
}
$scope.groupsets = groupSets;
$rootScope.setData('loadingfinished', true);
}
$scope.changeGroupsetName = function (groupSet) {
var nameRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets/' + groupSet.key + '/name');
nameRef.set(groupSet.name);
}
$scope.changeTeamSetName = function (groupSetKey, subgroupSetKey, name) {
var nameRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets/' + groupSetKey + '/subgroupsets/' + subgroupSetKey + '/name');
nameRef.set(name);
}
$scope.changeGroupName = function (groupSet, index) {
var nameRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets/' + groupSet.key + '/data/groups/' + index + '/name');
nameRef.set(groupSet.data.groups[index].name);
}
$scope.changeTeamName = function (groupSet, subgroupSetKey, index, name) {
var updates = {}
for (var i = 0; i < groupSet.data.groups.length; i++) {
updates['Groups/' + $rootScope.settings.groupKey + '/groupsets/' + groupSet.key + '/data/groups/' + i + '/subgroupsets/' +
subgroupSetKey + '/groups/' + index + '/name'] = name;
}
firebase.database().ref().update(updates).then(function () {
$rootScope.safeApply();
});
}
$scope.changeLock = function (selectedKey) {
var lockRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets/' + selectedKey + '/locked');
lockRef.set($scope.groupsets[selectedKey].locked);
}
$scope.changeLock1 = function (setKey, subSetKey) {
var lockRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets/' + setKey + '/subgroupsets/' + subSetKey + '/locked');
lockRef.set($scope.groupsets[setKey].subgroupsets[subSetKey].locked);
}
//================================ create group set functions=============================
$scope.showCreateModal = function () {
$scope.groupset = {};
$scope.groupset.name = '';
$scope.groupset.count = 4;
$scope.groupset.max_member = 5;
$scope.groupset.exclusive = false;
$scope.groupset.addRule = { type: 'manually' }
$scope.groupset.criteria = { type: 'Age', option: 'Same' }
$rootScope.safeApply();
$('#createGroupModal').modal({ backdrop: 'static', keyboard: false });
}
$scope.showCreateModal1 = function (groupSetKey) {
$scope.subset = {};
$scope.subset.name = '';
$scope.subset.count = 4;
$scope.subset.max_member = 5;
$scope.subset.exclusive = false;
$scope.subset.addRule = { type: 'manually' }
$scope.subset.criteria = { type: 'Age', option: 'Same' }
$scope.selectedKey = groupSetKey;
$rootScope.safeApply();
$('#createGroupModal1').modal({ backdrop: 'static', keyboard: false });
}
$scope.createGroupSet = function () {
let userKeys = Object.keys($scope.groupUsers)
if ($scope.groupset.name == '') {
$rootScope.warning("You need to input Groupset name!");
return;
}
$rootScope.setData('loadingfinished', false);
var subSets = $scope.groupsets;
for (key in subSets) {
if (subSets[key].name == $scope.groupset.name) {
$rootScope.setData('loadingfinished', true);
$rootScope.warning('duplicated name!');
return;
}
}
if ($scope.groupset.addRule.type != 'manually' && userKeys.length == 0) {
$rootScope.error("There isn't any user in this group. Please create groups by manually.")
$rootScope.setData('loadingfinished', true);
return;
}
$scope.groupset.data = { member_count: 0, groups: [] };
switch ($scope.groupset.addRule.type) {
case 'manually':
$scope.groupset.data.groups = Array($scope.groupset.count).fill().map(() => { return { member_count: 0 } })
break;
case 'randomly':
$scope.groupset.data.member_count = userKeys.length;
$scope.groupset.data.members = angular.copy(userKeys);
$scope.groupset.count = 0;
while (userKeys.length) {
let group = {
members: [],
member_count: 0
}
while (userKeys.length && group.member_count < $scope.groupset.max_member) {
let userIndex = Math.floor(Math.random() * userKeys.length);
group.members.push(userKeys[userIndex]);
group.member_count++;
userKeys.splice(userIndex, 1);
}
$scope.groupset.data.groups.push(group)
$scope.groupset.count++;
}
break;
case 'criteria':
userKeys = sortUserKeys(userKeys, $scope.groupset.criteria.type)
$scope.groupset.count = Math.ceil(userKeys.length / $scope.groupset.max_member);
$scope.groupset.data.member_count = userKeys.length;
$scope.groupset.data.members = angular.copy(userKeys);
$scope.groupset.data.groups = []
for (i = 0; i < $scope.groupset.count; i++) {
$scope.groupset.data.groups[i] = { member_count: 0, members: [] }
}
if ($scope.groupset.criteria.option == "Same") {
let groupIndex = 0;
userKeys.forEach(userKey => {
$scope.groupset.data.groups[groupIndex].member_count++;
$scope.groupset.data.groups[groupIndex].members.push(userKey)
if ($scope.groupset.data.groups[groupIndex].member_count == $scope.groupset.max_member) groupIndex++;
});
} else {
userKeys.forEach((userKey, index) => {
let groupIndex = index % $scope.groupset.max_member;
$scope.groupset.data.groups[groupIndex].member_count++;
$scope.groupset.data.groups[groupIndex].members.push(userKey)
});
}
break;
}
$rootScope.setData('loadingfinished', true);
if (confirm("Are you sure want to create this groupset?")) {
$rootScope.setData('loadingfinished', false);
var subGroupRef = firebase.database().ref('Groups/' + $rootScope.settings.groupKey + '/groupsets').push();
$scope.groupset.key = subGroupRef.key;
subGroupRef.set($scope.groupset).then(function () {
$rootScope.setData('loadingfinished', true);
$rootScope.success('New group set is created successfully!');
$('#createGroupModal').modal('hide');
});
}
}
$scope.createGroupSet1 = function () {
var groupKey = $rootScope.settings.groupKey;
var setKey = $scope.selectedKey;
if ($scope.subset.name == '') {
$rootScope.warning("You need to input sub groupset name!");
return;
}
$rootScope.setData('loadingfinished', false);
var subSets = $scope.groupsets[setKey].subgroupsets;
for (key in subSets) {
if (subSets[key].name == $scope.subset.name) {
$rootScope.setData('loadingfinished', true);
$rootScope.warning('duplicated name!');
return;
}
}
$scope.subset.key = firebase.database().ref('Groups/' + groupKey + '/groupsets/' + setKey + '/subgroupsets').push().key;
var updates = {};
switch ($scope.subset.addRule.type) {
case 'manually':
for (var i = 0; i < $scope.groupsets[setKey].count; i++) {
let subsetData = {
member_count: 0,
groups: Array($scope.subset.count).fill().map(() => { return { member_count: 0 } })
};
updates['Groups/' + groupKey + '/groupsets/' + setKey + '/data/groups/' + i + '/subgroupsets/' + $scope.subset.key] = subsetData;
}
break;
case 'randomly':
$scope.subset.count = Math.ceil($scope.groupsets[setKey].max_member / $scope.subset.max_member);
for (var i = 0; i < $scope.groupsets[setKey].count; i++) {
let userKeys = angular.copy($scope.groupsets[setKey].data.groups[i].members || [])
let subsetData = {
member_count: userKeys.length,
members: angular.copy(userKeys),
};
for (j = 0; j < $scope.subset.count; j++) {
if (!userKeys.length) break
let group = {
members: [],
member_count: 0
}
while (userKeys.length && group.member_count < $scope.subset.max_member) {
let userIndex = Math.floor(Math.random() * userKeys.length);
group.members.push(userKeys[userIndex]);
group.member_count++;
userKeys.splice(userIndex, 1);
}
subsetData.groups[j] = group
}
updates['Groups/' + groupKey + '/groupsets/' + setKey + '/data/groups/' + i + '/subgroupsets/' + $scope.subset.key] = subsetData;
}
break;
case 'criteria':
$scope.subset.count = Math.ceil($scope.groupsets[setKey].max_member / $scope.subset.max_member);
for (var i = 0; i < $scope.groupsets[setKey].count; i++) {
let userKeys = angular.copy($scope.groupsets[setKey].data.groups[i].members || [])
userKeys = sortUserKeys(userKeys, $scope.subset.criteria.type)
let subsetData = {
member_count: userKeys.length,
members: angular.copy(userKeys),
groups: []
};
for (j = 0; j < $scope.subset.count; j++) {
subsetData.groups[j] = { member_count: 0, members: [] }
}
if ($scope.subset.criteria.option == "Same") {
let groupIndex = 0;
userKeys.forEach(userKey => {
subsetData.groups[groupIndex].member_count++;
subsetData.groups[groupIndex].members.push(userKey)
if (subsetData.groups[groupIndex].member_count == $scope.subset.max_member) {
groupIndex++;
}
});
} else {
userKeys.forEach((userKey, index) => {
let groupIndex = index % $scope.subset.max_member;
subsetData.groups[groupIndex].member_count++;
subsetData.groups[groupIndex].members.push(userKey)
});
}
updates['Groups/' + groupKey + '/groupsets/' + setKey + '/data/groups/' + i + '/subgroupsets/' + $scope.subset.key] = subsetData;
}
break;
}
updates['Groups/' + groupKey + '/groupsets/' + setKey + '/subgroupsets/' + $scope.subset.key] = $scope.subset;
$rootScope.setData('loadingfinished', true);
if (confirm("Are you sure want to create this subgroupset?")) {
$rootScope.setData('loadingfinished', false);
firebase.database().ref().update(updates).then(function () {
$rootScope.setData('loadingfinished', true);
$rootScope.success('New sub groupset is created successfully!');
$('#createGroupModal1').modal('hide');
});
}
}
sortUserKeys = function (userKeys, type) {
let tempUsers = []
let sortField = '';
switch (type) {
case 'Age':
userKeys.forEach(userKey => {
let user = angular.copy($scope.allUsers[userKey])
user.age = user.age || Math.floor(Math.random() * 10 + 18);
tempUsers.push(user);
});
sortField = 'age';
break;
case 'Gender':
userKeys.forEach(userKey => {
let user = angular.copy($scope.allUsers[userKey])
user.gender = user.gender || $scope.genders[Math.floor(Math.random() * $scope.genders.length)];
tempUsers.push(user);
});
sortField = 'gender';
break;
case 'Language':
userKeys.forEach(userKey => {
let user = angular.copy($scope.allUsers[userKey])
user.countrylanguage = user.countrylanguage || $scope.countrylanguages[Math.floor(Math.random() * $scope.countrylanguages.length)];
tempUsers.push(user);
});
sortField = 'countrylanguage';
break;
case 'Nationality':
userKeys.forEach(userKey => {
let user = angular.copy($scope.allUsers[userKey])
user.country = user.country || $scope.countries[Math.floor(Math.random() * $scope.countries.length)];
tempUsers.push(user);
});
sortField = 'country';
break;
case 'Institution':
userKeys.forEach(userKey => {
let user = angular.copy($scope.allUsers[userKey])
tempUsers.push(user);
});
sortField = 'institution';
break;
}
tempUsers.sort((a, b) => {
if (a[sortField] < b[sortField])
return -1;
if (a[sortField] > b[sortField])
return 1;
return 0;
})
let sortedKeys = []
tempUsers.forEach(user => {
sortedKeys.push(user.Userkey)
});
return sortedKeys;
}
//================================ edit Question set functions=============================
$scope.editQuestionSets = function (selectedKey) {
$rootScope.setData('groupSetKey', selectedKey);
$rootScope.setData('GroupSetName', $scope.groupsets[selectedKey].name);
$rootScope.setData('groupSetType', 'firstGroupSet');
$state.go('editQuestionsetsInGroupSet');
}
$scope.editQuestionSets1 = function (groupSetKey, subSetKey) {
$rootScope.setData('groupSetKey', groupSetKey);
$rootScope.setData('GroupSetName', $scope.groupsets[groupSetKey].name);
$rootScope.setData('subSetKey', subSetKey);
$rootScope.setData('subGroupSetName', $scope.groupsets[groupSetKey].subgroupsets[subSetKey].name);
$rootScope.setData('groupSetType', 'secondGroupSet');
$state.go('editQuestionsetsInGroupSet');
}
// $scope.likertResponse = function (set, groupSetKey, subSetKey = undefined) {
// $rootScope.setData('groupSetKey', groupSetKey);
// $rootScope.setData('subSetKey', subSetKey);
// $rootScope.setData('groupsets', $scope.groupsets[groupSetKey]);
// $rootScope.setData('setData', set);
// var groupType = 'sub';
// if (subSetKey) {
// groupType = 'second';
// }
// $rootScope.setData('groupType', groupType);
// $state.go('groupResponseOfLikertAnswer');
// }
// $scope.exportQuestionDatas = function (question, groupSetKey, subSetKey = undefined) {
// // localStorage.setItem("exportQuestion", JSON.stringify(question));
// var groupType = 'sub';
// if (subSetKey) {
// groupType = 'second';
// }
// $rootScope.setData('exportQuestion', question);
// $rootScope.setData('groupSetKey', groupSetKey);
// $rootScope.setData('subSetKey', subSetKey);
// $rootScope.setData('groupsets', $scope.groupsets[groupSetKey]);
// $rootScope.setData('groupType', groupType);
// setTimeout(() => {
// if (question.questionType == "Dropdown Type") {
// $state.go('groupResponseOfDropdownAnswer');
// } else if (question.questionType == "Multiple Type") {
// $state.go('groupResponseOfMultipleAnswer');
// } else if (question.questionType == "Contingent Type") {
// $state.go('groupResponseOfContingentAnswer');
// } else if (question.questionType == "Feedback Type") {
// $state.go('groupResponseOfFeedbackAnswer');
// } else if (question.questionType == "Rating Type") {
// $state.go('groupResponseOfRatingAnswer');
// } else {
// $state.go('groupResponseOfAnswer');
// }
// }, 0);
// }
$scope.deleteGroupset = function (groupSetKey) {
if ($scope.groupsets[groupSetKey].subgroupsets) {
$rootScope.warning("Please delete all contained sub groupsets at first!");
return;
}
if (confirm("You will be lost all of data if group set is deleted.\n Please export data before deleting the group set.")) {
var subset = $scope.groupsets[groupSetKey];
$rootScope.setData('groupType', 'sub');
$rootScope.setData('exportGroupName', $rootScope.settings.groupName + ' / ' + $scope.groupsets[groupSetKey].name);
$rootScope.setData('childGroupName', subset.name);
$rootScope.setData('groupSetKey', groupSetKey);
$rootScope.setData('questions', subset.questions);
$state.go('deleteGroupset');
}
}
$scope.deleteSubGroupset = function (groupSetKey, subGroupSetKey) {
if (confirm("You will be lost all of data if subgroupset is deleted.\n Please export data before deleting the subgroupset.")) {
var subset = $scope.groupsets[groupSetKey].subgroupsets[subGroupSetKey];
$rootScope.setData('groupType', 'second');
$rootScope.setData('exportGroupName', $rootScope.settings.groupName + ' / ' + $scope.groupsets[groupSetKey].name + ' / ' + subset.name);
$rootScope.setData('childGroupName', subset.name);
$rootScope.setData('groupSetKey', groupSetKey);
$rootScope.setData('subSetKey', subGroupSetKey);
$rootScope.setData('questions', subset.questions);
$rootScope.setData('groupsetMemberData', $scope.groupsets[groupSetKey].data.groups);
$state.go('deleteGroupset');
}
}
$scope.addNewGroup = function (groupSet) {
if (!confirm("Are you sure want to add new group?")) return
var groupKey = $rootScope.settings.groupKey;
var setKey = groupSet.key;
var newGroup = angular.copy(groupSet.data.groups[0]);
newGroup.member_count = 0
newGroup.members = {}
newGroup.name = {}
var subgroupsets = newGroup.subgroupsets;
for (var subSetKey in subgroupsets) {
var subset = subgroupsets[subSetKey]
subset.member_count = 0
subset.members = {}
var subGroups = subset.groups;
for (var i = 0; i < subGroups.length; i++) {
subGroups[i].member_count = 0
subGroups[i].members = {}
}
}
var updates = {};
updates['/count'] = groupSet.count + 1;
updates['/data/groups/' + groupSet.count] = newGroup;
firebase.database().ref('Groups/' + groupKey + '/groupsets/' + setKey).update(updates).then(function () {
$rootScope.success('New group added successfully!');
});
}
$scope.addNewSubGroup = function (groupSet, subSet) {
if (!confirm("Are you sure want to add new group?")) return
var groupKey = $rootScope.settings.groupKey;
var setKey = groupSet.key;
var updates = {};
updates['/subgroupsets/' + subSet.key + '/count'] = subSet.count + 1;
for (var i = 0; i < groupSet.count; i++) {
updates['/data/groups/' + i + '/subgroupsets/' + subSet.key +
'/groups/' + subSet.count + '/member_count'] = 0;
}
firebase.database().ref('Groups/' + groupKey + '/groupsets/' + setKey).update(updates).then(function () {
$rootScope.success('New group added successfully!');
});
}
$scope.addUsers = function (groupSetKey, subSetKey = undefined) {
$rootScope.setData('groupSetKey', groupSetKey)
if (subSetKey) {
$rootScope.setData('subSetKey', subSetKey);
$rootScope.setData('groupCount', $scope.groupsets[groupSetKey].count);
$state.go('subSetUsers')
} else {
$state.go('groupsetUsers')
}
}
$scope.exportUsers = function (groupSetKey, subSetKey = undefined) {
$rootScope.setData('groupSetKey', groupSetKey)
if (subSetKey) {
// $rootScope.setData('subSetKey', subSetKey);
// $rootScope.setData('groupCount', $scope.groupsets[groupSetKey].count);
// $state.go('subSetUsers')
} else {
$state.go('exportGroupsetUsers')
}
}
$scope.countries = [
{ name: 'Afghanistan', code: 'AF' },
{ name: 'Åland Islands', code: 'AX' },
{ name: 'Albania', code: 'AL' },
{ name: 'Algeria', code: 'DZ' },
{ name: 'American Samoa', code: 'AS' },
{ name: 'Andorra', code: 'AD' },
{ name: 'Angola', code: 'AO' },
{ name: 'Anguilla', code: 'AI' },
{ name: 'Antarctica', code: 'AQ' },
{ name: 'Antigua and Barbuda', code: 'AG' },
{ name: 'Argentina', code: 'AR' },
{ name: 'Armenia', code: 'AM' },
{ name: 'Aruba', code: 'AW' },
{ name: 'Australia', code: 'AU' },
{ name: 'Austria', code: 'AT' },
{ name: 'Azerbaijan', code: 'AZ' },
{ name: 'Bahamas', code: 'BS' },
{ name: 'Bahrain', code: 'BH' },
{ name: 'Bangladesh', code: 'BD' },
{ name: 'Barbados', code: 'BB' },
{ name: 'Belarus', code: 'BY' },
{ name: 'Belgium', code: 'BE' },
{ name: 'Belize', code: 'BZ' },
{ name: 'Benin', code: 'BJ' },
{ name: 'Bermuda', code: 'BM' },
{ name: 'Bhutan', code: 'BT' },
{ name: 'Bolivia', code: 'BO' },
{ name: 'Bosnia and Herzegovina', code: 'BA' },
{ name: 'Botswana', code: 'BW' },
{ name: 'Bouvet Island', code: 'BV' },
{ name: 'Brazil', code: 'BR' },
{ name: 'British Indian Ocean Territory', code: 'IO' },
{ name: 'Brunei Darussalam', code: 'BN' },
{ name: 'Bulgaria', code: 'BG' },
{ name: 'Burkina Faso', code: 'BF' },
{ name: 'Burundi', code: 'BI' },
{ name: 'Cambodia', code: 'KH' },
{ name: 'Cameroon', code: 'CM' },
{ name: 'Canada', code: 'CA' },
{ name: 'Cape Verde', code: 'CV' },
{ name: 'Cayman Islands', code: 'KY' },
{ name: 'Central African Republic', code: 'CF' },
{ name: 'Chad', code: 'TD' },
{ name: 'Chile', code: 'CL' },
{ name: 'China', code: 'CN' },
{ name: 'Christmas Island', code: 'CX' },
{ name: 'Cocos (Keeling) Islands', code: 'CC' },
{ name: 'Colombia', code: 'CO' },
{ name: 'Comoros', code: 'KM' },
{ name: 'Congo', code: 'CG' },
{ name: 'Congo, The Democratic Republic of the', code: 'CD' },
{ name: 'Cook Islands', code: 'CK' },
{ name: 'Costa Rica', code: 'CR' },
{ name: 'Cote D\'Ivoire', code: 'CI' },
{ name: 'Croatia', code: 'HR' },
{ name: 'Cuba', code: 'CU' },
{ name: 'Cyprus', code: 'CY' },
{ name: 'Czech Republic', code: 'CZ' },
{ name: 'Denmark', code: 'DK' },
{ name: 'Djibouti', code: 'DJ' },
{ name: 'Dominica', code: 'DM' },
{ name: 'Dominican Republic', code: 'DO' },
{ name: 'Ecuador', code: 'EC' },
{ name: 'Egypt', code: 'EG' },
{ name: 'El Salvador', code: 'SV' },
{ name: 'Equatorial Guinea', code: 'GQ' },
{ name: 'Eritrea', code: 'ER' },
{ name: 'Estonia', code: 'EE' },
{ name: 'Ethiopia', code: 'ET' },
{ name: 'Falkland Islands (Malvinas)', code: 'FK' },
{ name: 'Faroe Islands', code: 'FO' },
{ name: 'Fiji', code: 'FJ' },
{ name: 'Finland', code: 'FI' },
{ name: 'France', code: 'FR' },
{ name: 'French Guiana', code: 'GF' },
{ name: 'French Polynesia', code: 'PF' },
{ name: 'French Southern Territories', code: 'TF' },
{ name: 'Gabon', code: 'GA' },
{ name: 'Gambia', code: 'GM' },
{ name: 'Georgia', code: 'GE' },
{ name: 'Germany', code: 'DE' },
{ name: 'Ghana', code: 'GH' },
{ name: 'Gibraltar', code: 'GI' },
{ name: 'Greece', code: 'GR' },
{ name: 'Greenland', code: 'GL' },
{ name: 'Grenada', code: 'GD' },
{ name: 'Guadeloupe', code: 'GP' },
{ name: 'Guam', code: 'GU' },
{ name: 'Guatemala', code: 'GT' },
{ name: 'Guernsey', code: 'GG' },
{ name: 'Guinea', code: 'GN' },
{ name: 'Guinea-Bissau', code: 'GW' },
{ name: 'Guyana', code: 'GY' },
{ name: 'Haiti', code: 'HT' },
{ name: 'Heard Island and Mcdonald Islands', code: 'HM' },
{ name: 'Holy See (Vatican City State)', code: 'VA' },
{ name: 'Honduras', code: 'HN' },
{ name: 'Hong Kong', code: 'HK' },
{ name: 'Hungary', code: 'HU' },
{ name: 'Iceland', code: 'IS' },
{ name: 'India', code: 'IN' },
{ name: 'Indonesia', code: 'ID' },
{ name: 'Iran, Islamic Republic Of', code: 'IR' },
{ name: 'Iraq', code: 'IQ' },
{ name: 'Ireland', code: 'IE' },
{ name: 'Isle of Man', code: 'IM' },
{ name: 'Israel', code: 'IL' },
{ name: 'Italy', code: 'IT' },
{ name: 'Jamaica', code: 'JM' },
{ name: 'Japan', code: 'JP' },
{ name: 'Jersey', code: 'JE' },
{ name: 'Jordan', code: 'JO' },
{ name: 'Kazakhstan', code: 'KZ' },
{ name: 'Kenya', code: 'KE' },
{ name: 'Kiribati', code: 'KI' },
{ name: 'Korea, Democratic People\'s Republic of', code: 'KP' },
{ name: 'Korea, Republic of', code: 'KR' },
{ name: 'Kuwait', code: 'KW' },
{ name: 'Kyrgyzstan', code: 'KG' },
{ name: 'Lao People\'s Democratic Republic', code: 'LA' },
{ name: 'Latvia', code: 'LV' },
{ name: 'Lebanon', code: 'LB' },
{ name: 'Lesotho', code: 'LS' },
{ name: 'Liberia', code: 'LR' },
{ name: 'Libyan Arab Jamahiriya', code: 'LY' },
{ name: 'Liechtenstein', code: 'LI' },
{ name: 'Lithuania', code: 'LT' },
{ name: 'Luxembourg', code: 'LU' },
{ name: 'Macao', code: 'MO' },
{ name: 'Macedonia, The Former Yugoslav Republic of', code: 'MK' },
{ name: 'Madagascar', code: 'MG' },
{ name: 'Malawi', code: 'MW' },
{ name: 'Malaysia', code: 'MY' },
{ name: 'Maldives', code: 'MV' },
{ name: 'Mali', code: 'ML' },
{ name: 'Malta', code: 'MT' },
{ name: 'Marshall Islands', code: 'MH' },
{ name: 'Martinique', code: 'MQ' },
{ name: 'Mauritania', code: 'MR' },
{ name: 'Mauritius', code: 'MU' },
{ name: 'Mayotte', code: 'YT' },
{ name: 'Mexico', code: 'MX' },
{ name: 'Micronesia, Federated States of', code: 'FM' },
{ name: 'Moldova, Republic of', code: 'MD' },
{ name: 'Monaco', code: 'MC' },
{ name: 'Mongolia', code: 'MN' },
{ name: 'Montserrat', code: 'MS' },
{ name: 'Morocco', code: 'MA' },
{ name: 'Mozambique', code: 'MZ' },
{ name: 'Myanmar', code: 'MM' },
{ name: 'Namibia', code: 'NA' },
{ name: 'Nauru', code: 'NR' },
{ name: 'Nepal', code: 'NP' },
{ name: 'Netherlands', code: 'NL' },
{ name: 'Netherlands Antilles', code: 'AN' },
{ name: 'New Caledonia', code: 'NC' },
{ name: 'New Zealand', code: 'NZ' },
{ name: 'Nicaragua', code: 'NI' },
{ name: 'Niger', code: 'NE' },
{ name: 'Nigeria', code: 'NG' },
{ name: 'Niue', code: 'NU' },
{ name: 'Norfolk Island', code: 'NF' },
{ name: 'Northern Mariana Islands', code: 'MP' },
{ name: 'Norway', code: 'NO' },
{ name: 'Oman', code: 'OM' },
{ name: 'Pakistan', code: 'PK' },
{ name: 'Palau', code: 'PW' },
{ name: 'Palestinian Territory, Occupied', code: 'PS' },
{ name: 'Panama', code: 'PA' },
{ name: 'Papua New Guinea', code: 'PG' },
{ name: 'Paraguay', code: 'PY' },
{ name: 'Peru', code: 'PE' },
{ name: 'Philippines', code: 'PH' },
{ name: 'Pitcairn', code: 'PN' },
{ name: 'Poland', code: 'PL' },
{ name: 'Portugal', code: 'PT' },
{ name: 'Puerto Rico', code: 'PR' },
{ name: 'Qatar', code: 'QA' },
{ name: 'Reunion', code: 'RE' },
{ name: 'Romania', code: 'RO' },
{ name: 'Russian Federation', code: 'RU' },
{ name: 'Rwanda', code: 'RW' },
{ name: 'Saint Helena', code: 'SH' },
{ name: 'Saint Kitts and Nevis', code: 'KN' },
{ name: 'Saint Lucia', code: 'LC' },
{ name: 'Saint Pierre and Miquelon', code: 'PM' },
{ name: 'Saint Vincent and the Grenadines', code: 'VC' },
{ name: 'Samoa', code: 'WS' },
{ name: 'San Marino', code: 'SM' },
{ name: 'Sao Tome and Principe', code: 'ST' },
{ name: 'Saudi Arabia', code: 'SA' },
{ name: 'Senegal', code: 'SN' },
{ name: 'Serbia and Montenegro', code: 'CS' },
{ name: 'Seychelles', code: 'SC' },
{ name: 'Sierra Leone', code: 'SL' },
{ name: 'Singapore', code: 'SG' },
{ name: 'Slovakia', code: 'SK' },
{ name: 'Slovenia', code: 'SI' },
{ name: 'Solomon Islands', code: 'SB' },
{ name: 'Somalia', code: 'SO' },
{ name: 'South Africa', code: 'ZA' },
{ name: 'South Georgia and the South Sandwich Islands', code: 'GS' },
{ name: 'Spain', code: 'ES' },
{ name: 'Sri Lanka', code: 'LK' },
{ name: 'Sudan', code: 'SD' },
{ name: 'Suriname', code: 'SR' },
{ name: 'Svalbard and Jan Mayen', code: 'SJ' },
{ name: 'Swaziland', code: 'SZ' },
{ name: 'Sweden', code: 'SE' },
{ name: 'Switzerland', code: 'CH' },
{ name: 'Syrian Arab Republic', code: 'SY' },
{ name: 'Taiwan, Province of China', code: 'TW' },
{ name: 'Tajikistan', code: 'TJ' },
{ name: 'Tanzania, United Republic of', code: 'TZ' },
{ name: 'Thailand', code: 'TH' },
{ name: 'Timor-Leste', code: 'TL' },
{ name: 'Togo', code: 'TG' },
{ name: 'Tokelau', code: 'TK' },
{ name: 'Tonga', code: 'TO' },
{ name: 'Trinidad and Tobago', code: 'TT' },
{ name: 'Tunisia', code: 'TN' },
{ name: 'Turkey', code: 'TR' },
{ name: 'Turkmenistan', code: 'TM' },
{ name: 'Turks and Caicos Islands', code: 'TC' },
{ name: 'Tuvalu', code: 'TV' },
{ name: 'Uganda', code: 'UG' },
{ name: 'Ukraine', code: 'UA' },
{ name: 'United Arab Emirates', code: 'AE' },
{ name: 'United Kingdom', code: 'GB' },
{ name: 'United States', code: 'US' },
{ name: 'United States Minor Outlying Islands', code: 'UM' },
{ name: 'Uruguay', code: 'UY' },
{ name: 'Uzbekistan', code: 'UZ' },
{ name: 'Vanuatu', code: 'VU' },
{ name: 'Venezuela', code: 'VE' },
{ name: 'Vietnam', code: 'VN' },
{ name: 'Virgin Islands, British', code: 'VG' },
{ name: 'Virgin Islands, U.S.', code: 'VI' },
{ name: 'Wallis and Futuna', code: 'WF' },
{ name: 'Western Sahara', code: 'EH' },
{ name: 'Yemen', code: 'YE' },
{ name: 'Zambia', code: 'ZM' },
{ name: 'Zimbabwe', code: 'ZW' }
];
$scope.countrylanguages = [
"Afrikanns",
"Albanian",
"Arabic",
"Armenian",
"Basque",
"Bengali",
"Bulgarian",
"Catalan",
"Cambodian",
"Chinese",
"Croation",
"Czech",
"Danish",
"Dutch",
"English",
"Estonian",
"Fiji",
"Finnish",
"French",
"Georgian",
"German",
"Greek",
"Gujarati",
"Hebrew",
"Hindi",
"Hungarian",
"Icelandic",
"Indonesian",
"Irish",
"Italian",
"Japanese",
"Javanese",
"Korean",
"Latin",
"Latvian",
"Lithuanian",
"Macedonian",
"Malay",
"Malayalam",
"Maltese",
"Maori",
"Marathi",
"Mongolian",
"Nepali",
"Norwegian",
"Persian",
"Polish",
"Portuguese",
"Punjabi",
"Quechua",
"Romanian",
"Russian",
"Samoan",
"Serbian",
"Slovak",
"Spanish",
"Swahili",
"Swedish",
"Tamil",
"Tatar",
"Telugu",
"Thai",
"Tibetan",
"Tonga",
"Turkish",
"Ukranian",
"Urdu",
"Uzbek",
"Vietnamese",
"Welsh",
"Xhosa"
]
}
})();
|
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const GameSchema = new Schema({
userId: { type: Schema.Types.ObjectId, ref: 'users', required: true },
seasonId: { type: Schema.Types.ObjectId, ref: 'seasons', required: true },
location: {type: Object, required: true},
matchOutcome: {type: Number, required: true},
heroesPlayed: [{type: Object, required: true}],
srBefore: { type: Number, required: true },
srAfter: { type: Number, required: true },
});
const Game = mongoose.model('games', GameSchema);
module.exports = Game;
|
import React from "react";
import MathJax from 'react-mathjax';
const formulas = {
f1: `x_i`,
f2: `y_i`,
f3: `f(x_i;W,b)=Wx_i+b`,
f4: `s[0] = x[0] * W[0,0] + x[1] * W[0,1] + b[0]`,
f5: `L_i`
};
export default () => (
<MathJax.Provider>
<article>
<p>
Each row is loss due to one data point. The first three columns are the 2D
data <MathJax.Node inline formula={formulas.f1}/> and the
label <MathJax.Node inline formula={formulas.f2}/>.
</p>
<p>
The next three columns are the three class scores from each
classifier <MathJax.Node inline formula={formulas.f3}/><br/> (e.g., <MathJax.Node inline formula={formulas.f4}/>).
</p>
<p>
The last column is the data loss for a single example, <MathJax.Node inline formula={formulas.f5}/>.
</p>
</article>
</MathJax.Provider>
)
|
// const Promise = require("bluebird")
// const DatabaseServices = require("../../database/services")
// const client = require("../../database/drivers/redis/redis-connecion")
// const Config = require('./config')
// const requestData = (config, token) => {
// if (token) axios.defaults.headers.common["Authorization"] = token
// return axios(config)
// .then((res) => {
// return res.data
// })
// .catch((e) => {
// console.log(e)
// })
// }
// const getToken = () => {
// return new Promise((resolve, reject) => {
// return client
// .get("token")
// .then((data) => {
// data = JSON.parse(data)
// return resolve(data)
// })
// .catch((err) => {
// const data = {
// username: process.env.BAHARTEL_USERNAME,
// password: process.env.BAHARTEL_PASSWORD,
// uid: process.env.BAHARTEL_UID,
// }
// const axiosConfig = {
// method : "post",
// url : Config.Urls.Login,
// data
// }
// return requestData(axiosConfig)
// .then((result) => {
// client.set("token", result)
// resolve(result)
// })
// .catch((err) => reject(err))
// })
// })
// }
// const login = (params) => {
// }
// const firstStageInsuranceOrder = (params) => {
// return new Promise((resolve, reject) => {
// getToken().then((token) => {
// const axiosConfig = {
// method : "post",
// url : Config.Urls.Order,
// data: params
// }
// return requestData(axiosConfig, token)
// .then((result) => {
// if (result.code === 0) {
// let data = {
// ...params,
// providerId: result.providerId,
// insuredName: result.insuredName,
// }
// return DatabaseServices.baharTel.Add.createNewDocument(data)
// .then((result) => {
// return resolve(result)
// })
// .catch((err) => {
// return reject(err)
// })
// } else return reject(result)
// })
// .catch((err) => reject(err))
// })
// })
// }
// const secondStageInsuranceOrder = (params) => {
// return new Promise((resolve, reject) => {
// getToken().then((token) => {
// const axiosConfig = {
// method : "post",
// url : Config.Urls.Submit,
// data: params
// }
// return requestData(axiosConfig, token)
// .then((result) => {
// let data = {
// providerId: params.providerId,
// ...result.toObject(),
// }
// delete data.code
// if (result.code === 0) {
// return DatabaseServices.baharTel.FindAndModify.findAndUpdateSecondStage(
// data
// )
// .then((result) => {
// return resolve(result)
// })
// .catch((err) => {
// return reject(err)
// })
// } else return reject(result)
// })
// .catch((err) => reject(err))
// })
// })
// }
// const getReportOfInsurancePackages = (params) => {
// return new Promise((resolve, reject) => {
// getToken().then((token) => {
// const axiosConfig = {
// method : "post",
// url : Config.Urls.Report,
// data: params
// }
// return requestData(axiosConfig, token)
// .then((result) => {
// return resolve(result)
// // return DatabaseServices.baharTel.FindAndModify.findAndUpdateSecondStage(
// // result
// // )
// // .then((result) => {
// // return resolve(result)
// // })
// // .catch((err) => {
// // return reject(err)
// // })
// })
// .catch((err) => reject(err))
// })
// })
// }
// const getResultOfInsuranceByPdf = (params) => {
// return new Promise((resolve, reject) => {
// getToken()
// .then((token) => {
// const axiosConfig = {
// method : "post",
// url : Config.Urls.GetPdf,
// data: params
// }
// return requestData(axiosConfig, token)
// .then((result) => resolve(result))
// .catch((err) => reject(err))
// })
// .catch((err) => {
// return reject(err)
// })
// })
// }
// module.exports = {
// login,
// firstStageInsuranceOrder,
// secondStageInsuranceOrder,
// getResultOfInsuranceByPdf,
// getReportOfInsurancePackages,
// }
|
import React, { Component } from 'react';
import API from '../../services/api';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
import { faBackspace } from '@fortawesome/free-solid-svg-icons';
import { Link } from "react-router-dom";
export default class IncluirCliente extends Component {
state = {
cliente: {},
clientes: [],
produtos: [],
nome: '',
cpf: '',
dataDeNascimento: '',
}
componentDidMount() {
this.loadClientes();
this.loadProdutos();
}
handleChangeSku = event => {
this.setState({ sku: event.target.value });
}
handleChangeNome = event => {
this.setState({ nome: event.target.value });
}
handleChangeDescricao = event => {
this.setState({ descricao: event.target.value });
}
handleChangePreco = event => {
this.setState({ preco: event.target.value });
}
handleChangeQuantidade = event => {
this.setState({ quantidade: event.target.value });
}
cadastraProduto = async event => {
event.preventDefault();
const editaCliete = {
nome: this.state.nome,
cpf: this.state.cpf,
dataDeNascimento: this.state.dataDeNascimento,
}
const response = await API.post('cliente/cadastrar', editaCliete);
this.setState({ editarCliente: response.data });
};
loadClientes = async () => {
const response = await API.get('cliente/listar');
this.setState({ clientes: response.data })
};
loadProdutos = async () => {
const response = await API.get('produto/listar');
this.setState({ produtos: response.data })
};
deletaCliente = async (id) => {
const response = await API.delete(`cliente/deletar/${id}`);
this.setState({ clientes: response.data })
};
render() {
const { clientes, produtos } = this.state;
return(
<div className="container">
<br /><br />
<div className="row">
<div className="col-md-12">
<h4 className="center">INCLUIR</h4>
</div>
</div>
<br /><br />
<div className="row">
<div className="col-md-8 offset-md-2">
<form onSubmit={this.cadastraProduto} >
<div class="form-group">
<label for="inputNome">Data da Compra:</label>
<input type="text" class="form-control" id="inputNome" onChange={this.handleChangeSku} placeholder="11/11/9999" />
</div>
<div class="form-group">
<label for="exampleFormControlSelect1">Cliente: </label>
<select class="form-control" id="exampleFormControlSelect1">
<option>Selecione um cliente...</option>
{clientes.map(cliente => (
<option key={cliente.id} value={cliente.id}>{cliente.nome}</option>
))}
</select>
</div>
<br />
<div class="form-check">
<div className="row">
{produtos.map(produto => (
<div className="col-md-3">
<input class="form-check-input" type="checkbox" value={produto.id} id="defaultCheck1" />
<label class="form-check-label" for="defaultCheck1">
{produto.nome}
</label>
</div>
))}
</div>
</div>
<br />
<div class="form-group">
<label for="inputCpf">Preço:</label>
<input type="text" readOnly class="form-control" id="inputCpf" value="" onChange={this.handleChangePreco} />
</div>
<br />
<button type="submit" class="btn btn-primary">Cadastrar</button>
<Link to="/pedido" className="btn btn-outline-dark btn-xs"><FontAwesomeIcon icon={faBackspace} /> Voltar</Link>
</form>
<br />
</div>
</div>
</div>
);
}
}
|
const Discord = require('discord.js');
const botconfig = require("../../botconfig.json");
module.exports.run = async (bot, message, args) => {
let botembed = new Discord.MessageEmbed()
.setColor(botconfig["bot_setup"].main_embed_color)
.setAuthor(`Support Page`)
.addField('Discord Server' , 'https://discord.gg/7NJ9Zb')
.addField('Website' , 'https://www.twistedxmods.com/')
.addField('Github','https://github.com/TwistedExecutor')
.addField('Youtube channel','https://www.youtube.com/channel/UC1cISzeYvNfdYBLV0lJkhvQ')
.addField('Twitch channel','https://www.twitch.tv/twisted_x_420')
.addField('Donate','https://www.paypal.me/TwistedXModz?locale.x=en_US')
//.setTimestamp()
.setFooter(botconfig["bot_setup"].copyright);
message.author.send(botembed);
}
module.exports.help = {
name: "support",
cooldown: 5,
}
|
"use strict";
var archetype = require("../../archetype");
var mergeWebpackConfig = archetype.devRequire("webpack-partial").default;
module.exports = function (babel) {
return function (config) {
return mergeWebpackConfig(config, {
module: {
loaders: [{
name: "babel",
test: /\.jsx?$/,
exclude: /(node_modules|\bclient\/vendor\b)/,
// NOTE: webpack.config.hot.js inserts "react-hot" into loaders array
loader: archetype.devRequire.resolve("babel-loader"),
query: babel
}]
}
});
};
};
|
import State from './script.js';
console.log('------------------------------------------begin----------------------------------------');
let myState = State.create({
range: {
start: 1,
end: 5 },
visible: true
});
console.log('------------------------------------------1----------------------------------------');
console.log("--->1",myState.getState());
myState.create('range.type', {
absolute: true
});
myState.create({ focus: null });
console.log("--->2",myState.prop('range.type'));
myState.prop('visible', true);
console.log('------------------------------------------2----------------------------------------');
myState.on('range.start', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', 9);
console.log('------------------------------------------3----------------------------------------');
myState.on('range', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', 10);
myState.prop('range.type.absolute', false);
console.log('------------------------------------------4----------------------------------------');
myState.next('range', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', 11);
myState.prop('range.end', 12);
console.log('------------------------------------------5----------------------------------------');
myState.on('range', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', 12);
myState.prop('range.end', 13);
console.log('------------------------------------------6----------------------------------------');
myState.on('range', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.lock();
myState.prop('range.start', 13)
myState.prop('range.end', 14)
myState.unlock();
console.log('------------------------------------------7----------------------------------------');
myState.on('range.start.man', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', { 'man': 'monologue' });
console.log('------------------------------------------8----------------------------------------');
myState.on('range', (oldVal, newVal) => {
console.log('Value before prop change', oldVal);
console.log('Value after prop change', newVal);
});
myState.prop('range.start', { 'man': 'monologue' });
console.log('------------------------------------------end----------------------------------------');
|
import React from 'react';
import { styled } from '../stitches.config';
const Wrapper = styled('div', {
borderBottom: '1px solid #C8C7C2',
padding: '30px',
'& .image-wrap': {
position: 'relative',
width: '60%',
margin: '0 auto',
'@sp': {
width: '100%',
},
},
'& .image-wrap img': {
width: '100%',
},
'& .featured-lead-wrap': {
width: '70%',
position: 'absolute',
top: '50%',
left: '-25%',
transform: 'translate(0, -25%)',
'@sp': {
left: '-15px',
transform: 'translate(0, 0)',
top: '0',
},
},
'& .image-credit': {
fontSize: '10px',
textAlign: 'right',
},
});
const FeaturedLead = styled('h2', {
zIndex: '2',
display: 'inline',
fontSize: '2.4vw',
maxWidth: '60%',
background: '#fff',
'@sp': {
fontSize: '4vw',
},
variants: {
color: {
yellow: {
boxShadow: 'inset 0 -2.4px #fff, inset 0 -11.2px #ffff00, 5px 5px 0 5px #fff, -5px 5px 0 5px #fff',
},
red: {
boxShadow: 'inset 0 -2.4px #fff, inset 0 -11.2px #ff0000, 5px 5px 0 5px #fff, -5px 5px 0 5px #fff',
},
blue: {
boxShadow: 'inset 0 -2.4px #fff, inset 0 -11.2px #0000ff, 5px 5px 0 5px #fff, -5px 5px 0 5px #fff',
},
},
},
});
export default function FeaturedContent({ color }) {
return (
<Wrapper>
<div className='image-wrap'>
<img src='https://www.syfy.com/sites/syfy/files/styles/1140x640_hero/public/screen-shot-2021-09-09-at-9.07.24-am.png' />
<p className='image-credit'>
Credit: The Matrix Resurrections – Official Trailer 1 / Warner Bros. Pictures YouTube
</p>
<div className='featured-lead-wrap'>
<FeaturedLead className='featured-lead' color={color}>
'THE MATRIX RESURRECTIONS'
<br /> TRAILER SENDS TWITTER DOWN A RABBIT HOLE OF FAN THEORIES
</FeaturedLead>
</div>
</div>
</Wrapper>
);
}
|
sap.ui.jsview("com.jbl.lc.view.ProcessDetail", {
getControllerName: function () {
return "com.jbl.lc.view.ProcessDetail";
},
createContent: function (oController) {
var page = new sap.m.Page({showHeader: true,
showNavButton: true,
showFooter: true,
alignItems:"center",
navButtonPress:oController.handleNavBack
});
page.setCustomHeader(new sap.m.Bar("pageHdr2",{contentLeft: [new sap.m.Button({icon:"sap-icon://nav-back",press:oController.handleNavBack}),new sap.m.Image({src:"img/LC-logo.png"}).addStyleClass("nyLogo")],contentRight:[new sap.m.Text("uId2",{text:i18nModel.getResourceBundle().getText("Welcome")+" "+oCore.getModel("userModel").getData().user}).addStyleClass("welHdr"),new sap.m.Button({icon:"sap-icon://log",press:oController.handleLogoff}) ]}));
//set the footer
page.setFooter(new sap.m.Bar({
contentLeft:[new sap.m.Label({text:i18nModel.getResourceBundle().getText("ProcessOrder")}).addStyleClass("footerPO footerStyle"),new sap.m.Text("footerPO1")],
contentMiddle:[new sap.m.Text({text:i18nModel.getResourceBundle().getText("Customer")}).addStyleClass("footerStyle"),new sap.m.Text("CustomerName")],contentRight:[new sap.m.Text({text:i18nModel.getResourceBundle().getText("Material")}).addStyleClass("footerStyle"),new sap.m.Text("material1").addStyleClass("footerMat")]
}));
//display jbl logo
page.addContent(new sap.m.Bar({contentLeft:new sap.m.Image({src:"img/jabil-logo.jpg",height:"20px"}).addStyleClass("jblLogo")}).addStyleClass("subHdrBar"));
//1. initialize panel to hold main page content
var poDetailPanel = new sap.m.Panel("poDetailPanel",{width:"95%"});
poDetailPanel.addContent(new sap.m.Text({text:i18nModel.getResourceBundle().getText("ProcessDetails"),width:"100%"}).addStyleClass("eDataLabel"));
poDetailPanel.addContent(new sap.m.Text({text:i18nModel.getResourceBundle().getText("2")}).addStyleClass("seqNo seqNo2"));
//display lctypes drop down
var lctypeList= new sap.ui.commons.DropdownBox("lcListDD",{change:oController.handleLCTypeSelection}).addStyleClass("lcTypeListBox");
var oTemplate= new sap.ui.core.ListItem();
oTemplate.bindProperty("text","ProcessOrder");
// oTemplate.bindProperty("key","ProcessOrder");
lctypeList.bindItems("/",oTemplate);
lctypeList.setModel(oCore.getModel("lcListModel"));
poDetailPanel.addContent(lctypeList);
poDetailPanel.addContent(sap.ui.xmlfragment("com.jbl.lc.view.fragment.PODetails",oController));
var brdata = sap.ui.getCore().getModel("barmod");
/*var toolPD = new sap.m.Toolbar("procDetTB",{content:[new sap.m.Label({text:i18nModel.getResourceBundle().getText("ProcessOrder")}), new sap.m.Text("tool_PO"), new sap.m.ToolbarSpacer(), new sap.m.Label({text:i18nModel.getResourceBundle().getText("Plant")}),new sap.m.Text("tool_plant"),new sap.m.ToolbarSpacer(), new sap.m.Label({text:i18nModel.getResourceBundle().getText("LCStatus")}),new sap.m.Text("tool_status")] }).addStyleClass("processDetBar");
var toolPD = new sap.m.Toolbar("procDetTB",{content:[new sap.m.Label({text:i18nModel.getResourceBundle().getText("ProcessOrder")}), new sap.m.Text("tool_PO")] }).addStyleClass("processDetBar");
poDetailPanel.addContent(toolPD);*/
//display sequence
poDetailPanel.addContent(new sap.m.Text({text:i18nModel.getResourceBundle().getText("3")}).addStyleClass("seqNo seqNo3"));
//display process questionair section
var quesBar=new sap.ui.core.HTML({content:"<div class='quesContainer'><div class='quesText'>Process Questionnaires</div><img class='quesArrow' src='img/process-q-arrow.png'/></div>"});
poDetailPanel.addContent(new sap.m.CustomTile({content:quesBar,press:oController.handleQsNav}).addStyleClass("lcmaintile"));
//display cancel button
poDetailPanel.addContent(new sap.m.Button({text:"Cancel",press:oController.handleNavBack}).addStyleClass("canbtn"));
page.addContent(poDetailPanel);
return page;
}
});
|
import React, { Component } from "react";
import { BrowserRouter as Router, Route, Link } from "react-router-dom";
import {
Container,
Menu,
} from 'semantic-ui-react';
import Home from './Home';
import PreparationOrganizer from './PreparationOrganizer';
import RegistrationOrganizer from './RegistrationOrganizer';
import VotePreparationOrganizer from './VotePreparationOrganizer';
import VoteTallyingOrganizer from './VoteTallyingOrganizer';
import RegistrationVoter from './RegistrationVoter';
import VotePreparationVoter from './VotePreparationVoter';
import VoteCastingVoter from './VoteCastingVoter';
import RSAGenerator from './RSAGenerator';
import Test from './Test';
class App extends Component {
constructor(props) {
super(props);
this.state = {
isOrganizer: false,
initializePageTypeCheck: false,
loading: true,
drizzleState: null,
dataKeyOrganizers: null,
dataKeyOrganizerAddresses: null,
dataKeyOrganizerCount: null
}
}
componentDidMount() {
const {drizzle} = this.props;
// Subscribe to changes in the store
this.unsubscribe = drizzle.store.subscribe(() => {
// Every time the store updates, grab the state from drizzle
const drizzleState = drizzle.store.getState();
// Check to see if it's ready, if so, update local component state
if (drizzleState.drizzleStatus.initialized) {
this.setState({
loading: false,
drizzleState
});
}
})
}
componentWillUnmount() {
this.unsubscribe();
}
componentDidUpdate(prevProps, prevState) {
if (this.state.loading) {
return;
}
const {drizzle} = this.props;
const {drizzleState} = this.state.drizzleState;
const contract = drizzle.contracts.VotingContract;
const {VotingContract} = this.state.drizzleState.contracts;
if (this.state.dataKeyOrganizerCount === null) {
const dataKeyOrganizerCount = contract.methods.organizerCount.cacheCall();
this.setState({
dataKeyOrganizerCount
});
}
const organizerCount = VotingContract.organizerCount[this.state.dataKeyOrganizerCount];
let dataKeyOrganizerAddresses = [];
if (this.state.dataKeyOrganizerAddresses && parseInt(organizerCount.value) !== this.state.dataKeyOrganizerAddresses.length) {
// There is a change in organizerCount, reset dataKeys
this.setState({
dataKeyOrganizers: null,
dataKeyOrganizerAddresses: null,
organizers: null
})
}
else if (organizerCount && this.state.dataKeyOrganizerAddresses == null) {
for (let i = 0; i < organizerCount.value; i++) {
dataKeyOrganizerAddresses.push(contract.methods.organizerAddresses.cacheCall(i));
}
this.setState({ dataKeyOrganizerAddresses: dataKeyOrganizerAddresses });
}
else if (this.state.dataKeyOrganizerAddresses && this.state.dataKeyOrganizers == null) {
for (const dataKeyOrganizerAddress of this.state.dataKeyOrganizerAddresses) {
const organizerAddress = VotingContract.organizerAddresses[dataKeyOrganizerAddress];
if (!organizerAddress) {
return;
}
}
// Only do this if all dataKeyOrganizerAddresses are already loaded
let dataKeyOrganizers = [];
for (const dataKeyOrganizerAddress of this.state.dataKeyOrganizerAddresses) {
const organizerAddress = VotingContract.organizerAddresses[dataKeyOrganizerAddress];
dataKeyOrganizers.push(contract.methods.organizers.cacheCall(organizerAddress.value));
}
this.setState({ dataKeyOrganizers: dataKeyOrganizers });
}
else if (this.state.dataKeyOrganizers && (prevState.drizzleState.accounts[0] !== this.state.drizzleState.accounts[0] || !this.state.initializePageTypeCheck)) {
for (let i = 0; i < this.state.dataKeyOrganizers.length; i++) {
const dataKeyOrganizer = this.state.dataKeyOrganizers[i];
const organizer = VotingContract.organizers[dataKeyOrganizer];
if (!organizer) {
return;
}
}
// Only do this if all dataKeyOrganizers are already loaded
let isOrganizer = false;
for (let i = 0; i < this.state.dataKeyOrganizers.length; i++) {
const dataKeyOrganizer = this.state.dataKeyOrganizers[i];
const organizer = VotingContract.organizers[dataKeyOrganizer];
if (organizer.args[0] === this.state.drizzleState.accounts[0]) {
isOrganizer = true;
break;
}
}
this.setState({
isOrganizer: isOrganizer,
initializePageTypeCheck: true
});
}
}
render() {
if (this.state.loading) {
return "Loading drizzle...";
}
if (this.state.isOrganizer) {
return (
<Router>
<div>
<Menu fixed='top' inverted>
<Container>
<Menu.Item as={Link} to='/'>Home</Menu.Item>
<Menu.Item as={Link} to='/organizer/preparation/'>Preparation</Menu.Item>
<Menu.Item as={Link} to='/organizer/registration/'>Registration</Menu.Item>
<Menu.Item as={Link} to='/organizer/vote_preparation/'>Vote Preparation</Menu.Item>
<Menu.Item as={Link} to='/organizer/vote_tallying/'>Vote Tallying</Menu.Item>
<Menu.Menu position='right'>
<Menu.Item as={Link} to='/rsa_generator/'>RSA Generator</Menu.Item>
<Menu.Item>Organizer</Menu.Item>
</Menu.Menu>
</Container>
</Menu>
<Container style={{ marginTop: '5em' }}>
<Route path="/" exact
render={(routeProps) => (
<Home
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/organizer/preparation/" exact
render={(routeProps) => (
<PreparationOrganizer
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/organizer/registration/" exact
render={(routeProps) => (
<RegistrationOrganizer
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/organizer/vote_preparation/" exact
render={(routeProps) => (
<VotePreparationOrganizer
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/organizer/vote_tallying/" exact
render={(routeProps) => (
<VoteTallyingOrganizer
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/rsa_generator" exact component={RSAGenerator} />
<Route path="/test" exact component={Test} />
</Container>
</div>
</Router>
);
}
else {
return (
<Router>
<div>
<Menu fixed='top' inverted>
<Container>
<Menu.Item as={Link} to='/'>Home</Menu.Item>
<Menu.Item as={Link} to='/voter/registration/'>Registration</Menu.Item>
<Menu.Item as={Link} to='/voter/vote_preparation/'>Vote Preparation</Menu.Item>
<Menu.Item as={Link} to='/voter/vote_casting/'>Vote Casting</Menu.Item>
<Menu.Menu position='right'>
<Menu.Item as={Link} to='/rsa_generator/'>RSA Generator</Menu.Item>
<Menu.Item>Voter</Menu.Item>
</Menu.Menu>
</Container>
</Menu>
<Container style={{ marginTop: '5em' }}>
<Route path="/" exact
render={(routeProps) => (
<Home
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/voter/registration/" exact
render={(routeProps) => (
<RegistrationVoter
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/voter/vote_preparation/" exact
render={(routeProps) => (
<VotePreparationVoter
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/voter/vote_casting/" exact
render={(routeProps) => (
<VoteCastingVoter
{...routeProps}
drizzle={this.props.drizzle}
drizzleState={this.state.drizzleState}
/>
)}
/>
<Route path="/rsa_generator" exact component={RSAGenerator} />
<Route path="/test" exact component={Test} />
</Container>
</div>
</Router>
);
}
}
}
export default App;
|
import React from 'react';
import "./Footer.css";
function Footer(props){
return(
<footer className="footerDiv">
<ul className="footerList">
<li className="footerItem">© Tracker App - Website Create by John V. Wilson </li>
</ul>
</footer>
);
};
export default Footer;
|
// Round class
function Round(){
var self = this;
self.animalsCreated = [];
// FIXME separate into new constructor
//self.stats = new Stats();
self.stats = {
pineapple : "pineapple soup",
score : 0,
moves : 0,
duplicates : 0,
originals : 0,
combos : 0,
longestCombo : 0,
solids : 0
}; // Round.stats
self.start = function(){
var move = {},
timer = {};
//animation
animate.panel( ui.panels.game, "start" );
animate.popup( ui.popups.at.roundStart );
// WIP
//modal animation (temp placement)
// $( ui.modals.container ).show();
// $( ui.modals.roundStart ).addClass( 'animated zoomInUp' );
// //$( ui.modals.roundStart ).addClass( 'zoomOut' );
// //$( ui.modals.container ).hide();
// window.setTimeout( closeModal, seconds(2) )
// function closeModal(){
// //$( ui.modals.roundStart ).addClass( 'zoomOutDown' );
// $( ui.modals.container ).hide();
// };
// keep images from dragging
// FIXME doesn't work to reference $ui.part, not sure why
$( ui.grid ).on("dragstart", ui.part, function(e) {
e.preventDefault();
});
$( ui.grid ).on( "mousedown", ui.tile, { round: self }, tileMgr.success);
$( ui.grid ).on( "mouseenter", ui.tile, { round: self }, tileMgr.validate);
//console.log(tileMgr.validate.done);
// start timer
timer = new Timer( variables.roundTime );
timer.start( self );
// start move when user clicks any tile
$( ui.grid ).on("mousedown", ui.tile, function(){
move = new Move(self);
move.started();
});
// attach pause button handler
menuMgr.pauseGame( timer );
// end move when player stops dragging anywhere on screen
$( window ).on("mouseup", function(){
if( ANIMIX.activeMove === true ){
move.ended();
} else {
//logger.status("no move currently active");
}
});
}; // Round.start();
self.end = function(){
animate.popup( ui.popups.at.roundEnd );
console.log( "This round is over!!" );
console.log( JSON.stringify(self.stats) );
var finalStats = JSON.stringify( self.stats );
//need to figure out how to secure/obscure all of this..
//turn off ability to move
//hide game grid
//move to stats grid
//FIXME this should actually do more, it's just hiding the container..
// $( ui.panels.game )
// .addClass( 'animated bounceOutUp' );
//animation
animate.panel( ui.panels.game, "end", getRoundEndStats );
function getRoundEndStats(){
$.ajax({
url: "/roundEndStats",
type: "POST",
data: { "finalStats": finalStats },
error: function(xhr, textStatus, errMsg) {
if ( xhr.status !== 0) {
console.log("ERROR: Failed!" + errMsg);
}
},
success: function(data, textStatus, xhr) {
$( ui.panels.roundEndStats ).html( data );
animate.panel( ui.panels.roundEndStats, "start" );
}
}); //ajax
} //getRoundEndStats
}; // Round.end();
}; // Round()
|
const mongoose = require('mongoose');
const { Schema } = mongoose;
const usersSchema = new Schema({
name: { type: String, required: true},
lastname: { type: String, required: true},
code: { type: String, required: true},
program: { type: String, required: true},
user: { type: String, required: true},
password: { type: String, required: true},
isadmin: { type: Boolean }
});
module.exports = mongoose.model('Users', usersSchema);
|
import React from 'react';
import './Autocomplete.css';
import Loader from '../Loader/Loader';
import axios from '../../connection/axios';
import cloneDeep from 'lodash/cloneDeep';
class Autocomplete extends React.Component {
constructor(props) {
super(props);
this.state = {
search: '',
results: [],
value: null,
inProgress: false
}
this.handleSearch = this.handleSearch.bind(this);
this.searchTimeout = null;
}
getResults(search = '') {
if (!search.length) {
this.setState({
search: search,
results: [],
value: null
});
return;
}
const state = cloneDeep(this.state);
state.inProgress = true;
this.setState(state);
axios.get(
this.props.resultBase + search
)
.then(response => {
const state = cloneDeep(this.state);
state.results = response.data;
state.inProgress = false;
this.setState(state);
})
.catch(error => {
console.log(error);
const state = cloneDeep(this.state);
state.inProgress = false;
this.setState(state);
});
}
handleSearch(event) {
window.clearTimeout(this.searchTimeout);
const state = cloneDeep(this.state);
state.search = event.target.value;
state.value = null;
this.setState(state);
this.props.onSelect(null);
this.searchTimeout = window.setTimeout(() => {
this.getResults(this.state.search);
}, 350);
}
handleSelect(label, value) {
const state = cloneDeep(this.state);
state.value = value;
state.search = label;
state.results = [];
this.setState(state);
this.props.onSelect(value);
}
render() {
return (
<div className="autocomplete-container">
<input type="text"
placeholder="Search..."
onChange={this.handleSearch}
value={this.state.search} />
<Loader loading={this.state.inProgress} />
<div className={
[
'autocomplete-results',
this.state.results.length ? 'active' : ''
].join(' ')
}>
<ul>
{this.state.results.map(item =>
<li key={item[this.props.resultValueField]}
onClick={() =>
this.handleSelect(
item[this.props.resultLabelField],
item[this.props.resultValueField]
)
}>
{item[this.props.resultLabelField]}
</li>
)}
</ul>
</div>
</div>
);
}
}
export default Autocomplete;
|
// Set Time Out
setTimeout(
function () {
funcaoConectar();
}, 2000);
function funcaoConectar() {
alert("Próxima rodada!!!");
}
module.exports = setTimeout;
|
import React from 'react';
import {render} from 'react-dom';
import './img/favicon.ico';
//import Sass
import './_main.scss';
//import components
// import MainNav from './modules/main-nav/main-nav.jsx';
import Header from './modules/header/header.jsx';
// import About from './modules/about/about.jsx';
import Skills from './modules/skills/skills.jsx';
import SelectedWork from './modules/selected-work/selected-work.jsx';
import Reactions from './modules/reactions/reactions.jsx';
import Contact from './modules/contact/contact.jsx';
import Footer from './modules/footer/footer.jsx';
class App extends React.Component {
render() {
return(
<div className='main'>
{/* <MainNav/> */}
<Header/>
<SelectedWork/>
<Reactions/>
<Skills/>
<Contact/>
<Footer/>
</div>
);
}
}
render(<App/>, document.getElementById('app'));
|
import React, { Component } from 'react'
export class RenderPropsClick extends Component {
// constructor(props) {
// super(props)
// this.state = {
// coutr: 0
// }
// }
// countF =()=>{
// this.setState({
// coutr: this.state.coutr + 1
// })
// }
render() {
const {coutr, countF} = this.props
return (
<button onClick={countF}>Clicked {coutr} times </button>
)
}
}
export default RenderPropsClick
/***
* the JSX sample that will be in App.js
<RenderPropsClick />
* **/
|
function Mostrar()
{
var numeroRandom; //no necesita inicializacion
var iteraciones=0;
var cont1=0;
var cont2=0;
var cont3=0;
var cont4=0;
var cont5=0;
var cont6=0;
var cont7=0;
var cont8=0;
var cont9=0;
var cont10=0;
var total;
var cantpares=0;
var cantimpares=0;
while(iteraciones<1000)
//for(iteraciones=0;iteraciones<10;iteraciones++)
{
iteraciones++;
numeroRandom=Math.floor((Math.random()*10)+1);
/*if(numeroRandom&2==0)
{
cantpares++
}
else
{
cantimpares++;
}*/
//alert(numeroRandom);
//console.log("numero :"+numeroRandom);
switch(numeroRandom)
{
case 1:
cont1++;
break;
case 2:
cont2++;
break;
case 3:
cont3++;
break;
case 4:
cont4++;
break;
case 5:
total=cont1+cont2+cont3+cont4+cont5+cont6+cont7+cont8+cont9+cont10;
if((cont5/total*100)<7)
{
cont5++;
}
else
{
iteraciones--;
continue;
}
break;
case 6:
cont6++;
break;
case 7:
cont7++;
break;
case 8:
cont8++;
break;
case 9:
cont9++;
break;
case 10:
cont10++;
break;
}//fin del switch
if(numeroRandom%2==0)
{
cantpares++;
}
else
{
cantimpares++;
}
}//fin del while hasta ??
total=cont1+cont2+cont3+cont4+cont5+cont6+cont7+cont8+cont9+cont10;
console.log("el total es :" + total);
console.log("la cantidad de pares es: "+cantpares);
console.log("la cantidad de impares es:"+cantimpares);
console.log("% de pares : "+(cantpares/total*100));
console.log("% de impares : "+(cantimpares/total*100));
console.log("el numero 1 salio: " +cont1+" veces "+ (cont1/total*100)+"%");
console.log("el numero 2 salio: " +cont2+" veces "+(cont2/total*100)+"%");
console.log("el numero 3 salio: " +cont3+" veces "+(cont3/total*100)+"%");
console.log("el numero 4 salio: " +cont4+" veces "+(cont4/total*100)+"%");
console.log("el numero 5 salio: " +cont5+" veces "+(cont5/total*100)+"%");
console.log("el numero 6 salio: " +cont6+" veces "+(cont6/total*100)+"%");
console.log("el numero 7 salio: " +cont7+" veces "+(cont7/total*100)+"%");
console.log("el numero 8 salio: " +cont8+" veces "+(cont8/total*100)+"%");
console.log("el numero 9 salio: " +cont9+" veces "+(cont9/total*100)+"%");
console.log("el numero 10 salio: " +cont10+" veces "+(cont10/total*100)+"%");
}//FIN DE LA FUNCIÓN
|
import React, { useEffect, useState, useContext, useRef } from "react";
import './style.scss';
import { gsap } from "gsap";
import { ScrollToPlugin } from "gsap/ScrollToPlugin";
//components
import Paper from "../../../components/Paper";
import James from "../../../components/James";
import context from "../../../store/context";
import Chapter1Page2 from "../part2";
//assets
import portrait from "../../../assets/portrait.png";
import bg from "../../../assets/bgChapter1.jpg";
import GlobalState from "../../../store/GlobalState";
//plugins
gsap.registerPlugin(ScrollToPlugin);
const Chapter1 = () => {
const [partData, setPartData] = useState([]);
const { data } = useContext(context);
let ref = useRef([]);
const currentRef = ref.current;
useEffect(() => {
if (data !== undefined) setPartData(data?.parts);
}, [data]);
useEffect(() => {
window.scrollTo(0, 0);
document.querySelector("body").style.overflow = "hidden";
currentRef["container"].addEventListener("wheel", (e) => {
const delta = Math.sign(e.deltaY);
if (delta === 1) portraitAnim();
});
});
const portraitAnim = () => {
gsap.to(".portrait", {
filter: "grayscale(0)",
rotate: 20,
duration: 0.5,
ease: "bounce",
});
gsap.to(window, {
delay: 0.8,
duration: 1,
scrollTo: ".page2__container",
ease: "none",
});
gsap.to(".portrait", { duration: 1, delay: 1, yPercent: 130, ease: "exp" });
gsap.to(".portrait", { rotate: 360, opacity: 0, duration: 1, delay: 2 });
};
// const title = "Industrialisation";
return (
<GlobalState>
<div>
<div className="container" ref={(element) => {
currentRef["container"] = element;
}}>
<img className="bg" src={bg} alt="" />
<img className="portrait" src={portrait} alt="" />
<Paper partData={partData} />
<James partData={partData} />
</div>
<Chapter1Page2 partData={partData} />
</div>
</GlobalState>
);
};
export default Chapter1;
|
import {
Button,
Grid,
Paper,
Step,
StepLabel,
Stepper,
Typography,
} from "@material-ui/core";
import { useFormik } from "formik";
import React, { useEffect } from "react";
import classes from "./bills.module.css";
import { Link } from "react-router-dom";
import { Check } from "@material-ui/icons";
import Category from "./Category";
import ProjectInfo from "./ProjectInfo";
import UploadFiles from "./UploadFiles";
import Budget from "./Budget";
import PaymentPlan from "./PaymentPlan";
import CompletionPayment from "./CompletionPayment";
import { scrollHandler } from "../../../helper/general";
const Bills = () => {
const [activeStep, setActiveStep] = React.useState(0);
useEffect(() => {
scrollHandler(0, 0);
}, []);
const steps = [
{ type: "انتخاب دسته بندی" },
{ type: "تکمیل اطلاعات پروژه" },
{ type: "بارگذاری تصاویر ضمیمه" },
{ type: "تعیین بودجه پروژه" },
{ type: "انتخاب پلن پرداخت" },
{ type: "کد تخفیف و پرداخت" },
];
const next = "ادامه";
const accept = "ثبت درخواست";
const handleNext = () => {
if (formik.isValid) {
setActiveStep((prevActiveStep) => prevActiveStep + 1);
}
};
const handleBack = () => {
setActiveStep((prevActiveStep) => prevActiveStep - 1);
};
const initialValues = {
skills: "",
projectType: "",
projectTitle: "",
description: "",
fileUpdate: "",
poonishaProposal: "",
minBudget: "",
maxBudget: "",
offCode: "",
};
const onSubmit = (values) => {
console.log(values);
};
const formik = useFormik({
initialValues,
onSubmit,
});
function getStepContent(stepIndex) {
switch (stepIndex) {
case 0:
return <Category formik={formik} />;
case 1:
return <ProjectInfo formik={formik} />;
case 2:
return <UploadFiles formik={formik} />;
case 3:
return <Budget formik={formik} />;
case 4:
return <PaymentPlan formik={formik} />;
case 5:
return <CompletionPayment formik={formik} />;
default:
return "Unknown ";
}
}
return (
<Grid container>
<h3 style={{ paddingBottom: "2rem", margin: "0" }}>ایجاد پروژه</h3>
<Paper className={classes.paper}>
<Stepper
id={classes.stepper}
activeStep={activeStep}
alternativeLabel
className={classes.stepper}
color="secondary"
>
{steps.map((label, index) => (
<Step key={index * 1123} className={classes.step}>
<StepLabel id={classes.StepLabel} className={classes.stepLabel}>
{label.type}
</StepLabel>
</Step>
))}
</Stepper>
<form onSubmit={formik.handleSubmit} className={classes.main}>
{activeStep !== steps.length ? (
<>
<div className={classes.container}>
{getStepContent(activeStep)}
<div className={classes.stepBtnBox}>
<Button
disabled={activeStep === 0}
variant="outlined"
onClick={handleBack}
className={classes.backBtn}
>
بازگشت
</Button>
{activeStep === steps.length - 1 ? (
<Button
className={classes.forwardBtn}
variant="contained"
color="secondary"
type="submit"
>
<div>{accept}</div>
</Button>
) : (
<Button
className={classes.forwardBtn}
variant="contained"
color="secondary"
onClick={handleNext}
>
<div>{next}</div>
</Button>
)}
</div>
</div>
</>
) : (
<div className={classes.main}>
<div className={classes.container}>
<div className={classes.successfulContainer}>
<Check fontSize="large" className={classes.successfulIcon} />
<Typography variant="h6" className={classes.successfulTitle}>
درخواست شما با موفقیت ثبت شد و در لیست در خواست ها نمایش
داده می شود
</Typography>
<Link to="/dashboard" className={classes.link}>
<Button
className={classes.successfulBtn}
variant="contained"
color="primary"
onClick={handleNext}
>
مشاهده لیست درخواست های شما
</Button>
</Link>
</div>
</div>
</div>
)}
</form>
</Paper>
</Grid>
);
};
export default Bills;
|
import React from 'react'
import { Field, reduxForm } from 'redux-form'
import TextField from 'material-ui/TextField';
import Button from 'material-ui/Button';
import { FormGroup, FormControlLabel } from 'material-ui/Form';
import Divider from 'material-ui/Divider';
import { withStyles, createStyleSheet } from 'material-ui/styles';
import Grid from 'material-ui/Grid';
import Paper from 'material-ui/Paper';
import Typography from 'material-ui/Typography';
const styleSheet = createStyleSheet(theme => ({
button: {
margin: theme.spacing.unit,
},
textField: {
marginLeft: theme.spacing.unit,
marginRight: theme.spacing.unit,
},
FormGroup: {
margin: theme.spacing.unit,
},
input: {
margin: theme.spacing.unit,
},
formTitle: {
margin: theme.spacing.unit,
paddingTop: theme.spacing.unit * 2,
paddingBottom: theme.spacing.unit * 2,
maxWidth: 400,
},
title: {
flex: 1,
marginLeft: theme.spacing.unit,
marginRight: theme.spacing.unit,
},
root: theme.mixins.gutters({
paddingTop: 16,
paddingBottom: 16
}),
}));
const renderTextField = ({ input, label, meta: { touched, error }, ...custom }) => (
<TextField
label={label}
helperText={touched && error}
{...input}
{...custom}
/>
)
let EditIssueForm = props => {
const { handleSubmit, issue, initialValues } = props;
const classes = props.classes;
return (
<div>
<form onSubmit={handleSubmit}>
<div className={classes.formTitle}>
<Typography type="title" color="secondary" className={classes.title} gutterBottom={true}>
ID: {issue._id}
</Typography>
<Typography type="title" color="secondary" className={classes.title} gutterBottom={true}>
Created At: {issue.created ? issue.created.toDateString() : ''}
</Typography>
</div>
<FormGroup className={classes.FormGroup} row={true}>
<Field name="title" label="Title" component={renderTextField} className={classes.textField} fullWidth={true} />
</FormGroup>
<FormGroup className={classes.FormGroup} row={true}>
<Field name="owner" label="Owner" component={renderTextField} className={classes.textField} fullWidth={true} />
</FormGroup>
<Grid container>
<Grid item xs={4}>
<FormGroup className={classes.FormGroup} row={true}>
<Field type="number" name="effort" label="Effort" component={renderTextField} className={classes.textField} fullWidth={true} />
</FormGroup>
</Grid>
<Grid item xs={4}>
<FormGroup className={classes.FormGroup} row={true}>
<Field type="date" name="completionDate" label="Completion Date" component={renderTextField} className={classes.textField} fullWidth={true} InputLabelProps={{
shrink: true,
}} />
</FormGroup>
</Grid>
<Grid item xs={4}>
<FormGroup className={classes.FormGroup} row={true}>
<label className={classes.textField}>Status</label>
<div className={classes.textField}>
<Field name="status" component="select">
<option value="New">New</option>
<option value="Open">Open</option>
<option value="Assigned">Assigned</option>
<option value="Fixed">Fixed</option>
<option value="Verified">Verified</option>
<option value="Closed">Closed</option>
</Field>
</div>
</FormGroup>
</Grid>
</Grid>
<FormGroup className={classes.FormGroup} row={true}>
<Field name="comment" label="Comment"
component={renderTextField}
className={classes.textField}
fullWidth={true}
multiline
rows="4" />
</FormGroup>
</form>
</div>
)
}
const componentWithStyles = withStyles(styleSheet)(EditIssueForm);
EditIssueForm = reduxForm({
// a unique name for the form
form: 'EditIssueForm',
enableReinitialize: true
})(componentWithStyles)
export default EditIssueForm;
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const isNil = (val) => val === undefined || val === null;
exports.default = isNil;
|
var o = { a: "A", b: "B" };
console.dir(o);
console.time("timer1");
console.log("This is a log message");
console.error("This is an error message");
console.info("This is an info message");
console.warn("This is a warning message");
console.timeEnd("timer1");
(function func1() {
return function func2() {
console.trace();
};
})()();
console.trace();
console.assert(2 * 4 === 7, { message: "2 * 4 != 7", level: "dangerouse" }, {
message: "wrong calculation",
leve: "too dangerous"
});
console.assert(2 * 3 === 5, "2 * 3 != 5");
console.assert(2 * 1 === 3, "%d * %d != %d", 2, 1, 3);
console.assert(2 * 2 === 4, "wrong calculation");
|
import React from "react";
import { ethers } from "ethers";
import "./App.css";
import abi from "./utils/WavePortal.json";
import Confetti from "react-confetti";
import useWindowSize from "react-use/lib/useWindowSize";
import { CSSTransition } from "react-transition-group";
import nyan_cat from "./assets/nyan-cat.gif";
import award from "./assets/award.gif";
export default function App() {
const [currAccount, setCurrAccount] = React.useState("");
const [currWaves, setCurrWaves] = React.useState(0);
const [currStatus, setCurrStatus] = React.useState(0);
const [message, setMessage] = React.useState("");
const [enableMessage, setEnableMessage] = React.useState(false);
const [winner, setWinner] = React.useState(false);
const [waves, setWaves] = React.useState([]);
const contractAddress = "0xc50db631baa6eCAb3A210ae524f85bCedCe486D7";
const contractABI = abi.abi;
const checkIfWalletConnected = () => {
const { ethereum } = window;
if (!ethereum) {
console.log("Make sure metamask is installed");
return;
}
ethereum.request({ method: "eth_accounts" }).then((accounts) => {
if (accounts.length !== 0) {
const account = accounts[0];
setCurrAccount(account);
} else {
console.log("No account authorized found");
}
});
};
const connectWallet = () => {
const { ethereum } = window;
if (!ethereum) {
console.log("get metamask");
}
ethereum
.request({ method: "eth_requestAccounts" })
.then((accounts) => {
console.log("Connected", accounts[0]);
setCurrAccount(accounts[0]);
})
.catch((err) => console.log(err));
};
const wave = async () => {
if (currStatus !== 0) return;
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
const wavePortalContract = new ethers.Contract(
contractAddress,
contractABI,
signer
);
let content = "Hello 👋";
if (message.length) content = message;
let waveTxn = await wavePortalContract.wave(content, { gasLimit: 300000 });
setCurrStatus(1);
await waveTxn.wait();
setCurrStatus(2);
setTimeout(() => {
setCurrStatus(0);
}, 5000);
setMessage("");
if (enableMessage) setEnableMessage(false);
};
const totalWaves = async () => {
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
const wavePortalContract = new ethers.Contract(
contractAddress,
contractABI,
signer
);
let count = await wavePortalContract.getTotalWaves();
setCurrWaves(count.toNumber());
};
const getAllWaves = async () => {
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
const wavePortalContract = new ethers.Contract(
contractAddress,
contractABI,
signer
);
let wavesData = await wavePortalContract.getAllWaves();
let wavesList = [];
wavesData.forEach((wave) => {
wavesList.unshift({
address: wave.waver,
timestamp: new Date(wave.timestamp * 1000),
message: wave.message,
});
});
setWaves(wavesList);
wavePortalContract.on(
"NewWave",
async (from, timestamp, message, event) => {
setWaves((arr) => [
{
address: from,
timestamp: new Date(timestamp * 1000),
message: message,
},
...arr,
]);
let count = await wavePortalContract.getTotalWaves();
setCurrWaves(count.toNumber());
}
);
const address = await signer.getAddress();
wavePortalContract.on("Winner", (waver) => {
if (waver === address) {
setWinner(true);
setTimeout(() => {
setWinner(false);
}, 15000);
}
});
};
const handleChange = (e) => {
setMessage(e.target.value);
};
let dateToFormat = (date) => {
var d = new Date(date),
month = "" + (d.getMonth() + 1),
day = "" + d.getDate(),
year = d.getFullYear(),
hours = d.getHours() >= 10 ? d.getHours() : `0${d.getHours()}`,
minutes = d.getMinutes() >= 10 ? d.getMinutes() : `0${d.getMinutes()}`;
if (month.length < 2) month = "0" + month;
if (day.length < 2) day = "0" + day;
const str = `${year}-${month}-${day} ${hours}:${minutes}`;
return str;
};
React.useEffect(() => {
checkIfWalletConnected();
if (!waves.length) {
getAllWaves();
totalWaves();
}
}, []);
const connectStatus = currAccount ? (
<div className="bg-green-500 bg-opacity-30 px-5 py-2 rounded-md text-sm text-green-500">
Connected
</div>
) : (
""
);
const totalWavesRender = (
<div className="text-xl text-white">👋 {currWaves}</div>
);
const connectWalletButton = !currAccount ? (
<button
className="px-10 py-3 text-xl rounded-md bg-white font-semibold cursor-pointer"
onClick={connectWallet}
>
Connect Metamask Wallet
</button>
) : (
""
);
const waveButton = currAccount ? (
<div className="flex flex-col justify-center space-y-5 w-full ">
<div className="flex space-x-5 justify-center">
<CSSTransition
in={!enableMessage && currStatus === 0}
timeout={300}
classNames="fade"
unmountOnExit
>
<button
className="px-10 py-3 text-xl rounded-md bg-white font-semibold cursor-pointer shadow-xl transition-all hover:shadow-none"
disabled={currStatus !== 0}
onClick={wave}
>
👋 Wave at me
</button>
</CSSTransition>
<CSSTransition
in={currStatus === 0}
timeout={300}
classNames="fade"
unmountOnExit
>
<button
className="px-10 py-3 text-xl rounded-md bg-white font-semibold cursor-pointer shadow-xl transition-all hover:shadow-none"
onClick={
enableMessage ? () => wave() : () => setEnableMessage(true)
}
>
{enableMessage ? "Submit" : "Send a Message"}
</button>
</CSSTransition>
</div>
<CSSTransition
in={enableMessage && currStatus === 0}
timeout={300}
classNames="open"
unmountOnExit
>
<textarea
className="rounded-md focus:outline-none p-3 w-2/4 mx-auto"
rows="3"
onChange={handleChange}
placeholder="Enter your message here"
></textarea>
</CSSTransition>
</div>
) : (
""
);
const mining = (
<div className="flex flex-col space-y-5">
<CSSTransition
in={currStatus !== 0}
timeout={300}
classNames="fade"
unmountOnExit
>
<button className="px-10 py-3 text-xl rounded-md bg-white font-semibold cursor-pointer shadow-xl transition-all hover:shadow-none">
{currStatus === 1 ? "Mining" : <span>{!winner ? "Mined" : "You won"} ✅</span>}
</button>
</CSSTransition>
<CSSTransition
in={currStatus !== 0}
timeout={300}
classNames="open"
unmountOnExit
>
{winner ? <img className="w-40" src={award} alt="" /> : <img className="w-40" src={nyan_cat} alt="" />}
</CSSTransition>
</div>
);
const wavers = (
<div className="flex flex-col items-center space-y-4 w-3/4 mx-auto relative">
{waves.map((wave, index) => {
return (
<div
className="flex text-white text-lg border-l-4 border-white px-3 w-full space-x-5"
key={index}
>
<a
href={"https://rinkeby.etherscan.io/address/" + wave.address}
target="_blank"
rel="noreferrer"
className="my-auto truncate"
>
{wave.address}
</a>
<div className="flex-1">{wave.message}</div>
<div className="my-auto">{dateToFormat(wave.timestamp)}</div>
</div>
);
})}
</div>
);
const { width, height } = useWindowSize();
return (
<div className="w-full h-full min-h-screen bg-gray-600 pb-32">
<Confetti
width={width}
height={height}
tweenDuration={1000}
recycle={false}
run={winner}
numberOfPieces={400}
/>
<div className="container mx-auto flex items-center flex-col space-y-10">
<div className="space-y-3 flex flex-col items-center w-">
<h1 className="text-center text-white text-5xl font-bold mt-16">
Wave Portal
</h1>
<p className="text-white text-lg">Made by Zerky </p>
<p className="text-white mt-0">
feel free to follow me on{" "}
<a
href="https://github.com/zlayine"
target="_blank"
rel="noreferrer"
className="underline"
>
@github/zlayine
</a>
</p>
{connectStatus}
</div>
<div className="flex flex-col items-center space-y-5 w-2/4 relative">
{totalWavesRender}
{connectWalletButton}
{waveButton}
{mining}
</div>
{wavers}
</div>
</div>
);
}
|
/*
* Quadtree.js Quadtree implementation for spatial optimization
*/
'use strict';
C.Utils.QuadTree = C.Utils.Inherit(function (base, options) {
base();
options = options || {};
var bl_x = options.bl_x || 0;
var bl_y = options.bl_y || 0;
var tr_x = options.tr_x || 0;
var tr_y = options.tr_y || 0;
this._crs = options.crs;
this._maxObj = options.maxObj || 10;
this._maxDepth = options.maxDepth || 18;
this._root = new QuadNode(bl_x, bl_y, tr_x, tr_y, this._maxObj, 0, this._maxDepth, this._crs);
}, EventEmitter, 'C.Utils.QuadTree');
C.Utils.QuadTree.prototype.insert = function () {
this._root.insert.apply(this._root, arguments);
};
C.Utils.QuadTree.prototype.remove = function () {
this._root.remove.apply(this._root, arguments);
};
C.Utils.QuadTree.prototype.clear = function () {
var bl_x = this._root._bl_x;
var bl_y = this._root._bl_y;
var tr_x = this._root._tr_x;
var tr_y = this._root._tr_y;
delete this._root;
this._root = new QuadNode(bl_x, bl_y, tr_x, tr_y, this._maxObj, 0, this._maxDepth, this._crs);
};
C.Utils.QuadTree.prototype.select = function (bounds) {
if (bounds._crs != this._crs) {
bounds = bounds.transformTo(this._crs);
}
return this._root._select(bounds);
};
C.Utils.QuadTree.prototype.selectObject = function (bounds) {
if (bounds._crs != this._crs) {
bounds = bounds.transformTo(this._crs);
}
return this._root._selectObject(bounds);
};
var QuadNode = function (bl_x, bl_y, tr_x, tr_y, maxObj, depth, maxDepth, crs, parent) {
this._bl_x = bl_x;
this._bl_y = bl_y;
this._tr_x = tr_x;
this._tr_y = tr_y;
this._maxObj = maxObj;
this._depth = depth;
this._maxDepth = maxDepth;
this._crs = crs;
this._container = new PIXI.Container();
this._objects = [];
this._children = [];
this._parent = parent;
};
var QuadPosition = {
TOP_LEFT: 0,
TOP_RIGHT: 1,
BOTTOM_RIGHT: 2,
BOTTOM_LEFT: 3
};
QuadNode.prototype._select = function (bounds) {
var output = [this._container];
if (this._children.length > 0) {
for (var i = 0; i < 4; ++i) {
if (this._children[i]._intersect(bounds)) {
output = output.concat(this._children[i]._select(bounds));
}
}
}
return output;
};
QuadNode.prototype._selectObject = function (bounds) {
var output = [{
container: this._container,
objects: this._objects.slice(0)
}];
if (this._children.length > 0) {
for (var i = 0; i < 4; ++i) {
if (this._children[i]._intersect(bounds)) {
output = output.concat(this._children[i]._selectObject(bounds));
}
}
}
return output;
};
QuadNode.prototype._intersect = function (bounds) {
return !(bounds._bottomLeft.X > this._tr_x ||
bounds._topRight.X < this._bl_x ||
bounds._topRight.Y < this._bl_y ||
bounds._bottomLeft.Y > this._tr_y);
};
QuadNode.prototype._checkItFits = function (bounds) {
if (bounds._bottomLeft.X < this._bl_x) { return false; }
if (bounds._bottomLeft.Y < this._bl_y) { return false; }
if (bounds._topRight.X > this._tr_x) { return false; }
if (bounds._topRight.Y > this._tr_y) { return false; }
return true;
};
QuadNode.prototype.getCoveragePosition = function (bounds) {
var bl_x_h = this._bl_x + ((this._tr_x - this._bl_x) / 2.0);
var bl_y_h = this._bl_y + ((this._tr_y - this._bl_y) / 2.0);
if (bounds._bottomLeft.Y >= bl_y_h &&
bounds._topRight.Y <= this._tr_y) {
if (bounds._bottomLeft.X >= this._bl_x &&
bounds._topRight.X <= bl_x_h) { return QuadPosition.TOP_LEFT; }
if (bounds._bottomLeft.X >= bl_x_h &&
bounds._topRight.X <= this._tr_x) { return QuadPosition.TOP_RIGHT; }
}
if (bounds._bottomLeft.Y >= this._bl_y &&
bounds._topRight.Y <= bl_y_h) {
if (bounds._bottomLeft.X >= this._bl_x &&
bounds._topRight.X <= bl_x_h) { return QuadPosition.BOTTOM_LEFT; }
if (bounds._bottomLeft.X >= bl_x_h &&
bounds._topRight.X <= this._tr_x) { return QuadPosition.BOTTOM_RIGHT; }
}
return -1;
};
QuadNode.prototype._insertSelf = function (object, throwEvent) {
//Insert to this node
this._objects.push(object);
this._container.addChild(object.__graphics);
object.__quadnode = this;
if (!throwEvent) {
// console.log('toto');
// this.emit('update', this);
}
};
QuadNode.prototype._insert = function (bounds, object, throwEvent) {
// Can be directly inserted
if (this._objects.length < this._maxObj || this._depth == this._maxDepth) {
return this._insertSelf(object, throwEvent);
}
if (this._children.length < 1) {
this.divide();
}
var coverage = this.getCoveragePosition(bounds);
if (coverage !== -1) {
return this._children[coverage]._insert(bounds, object, throwEvent);
}
return this._insertSelf(object, throwEvent);
};
QuadNode.prototype.insert = function (object, throwEvent) {
if (object.__quadnode) { return; }
var bounds = object.getBounds();
if (bounds._crs != this._crs) {
bounds = bounds.transformTo(this._crs);
}
this._insert(bounds, object, throwEvent);
};
QuadNode.prototype.remove = function (object, throwEvent) {
var idx = this._objects.indexOf(object);
this._objects.splice(idx, 1);
this._container.removeChild(object.__graphics);
};
QuadNode.prototype.divide = function () {
var hWidth = (this._tr_x - this._bl_x) / 2.0;
var hHeight = (this._tr_y - this._bl_y) / 2.0;
this._children.push(
new QuadNode(this._bl_x, this._bl_y + hHeight, this._bl_x + hWidth, this._tr_y,
this._maxObj, this._depth + 1, this._maxDepth, this._crs, this),
new QuadNode(this._bl_x + hWidth, this._bl_y + hHeight, this._tr_x, this._tr_y,
this._maxObj, this._depth + 1, this._maxDepth, this._crs, this),
new QuadNode(this._bl_x + hWidth, this._bl_y, this._tr_x, this._bl_y + hHeight,
this._maxObj, this._depth + 1, this._maxDepth, this._crs, this),
new QuadNode(this._bl_x, this._bl_y, this._bl_x + hWidth, this._bl_y + hHeight,
this._maxObj, this._depth + 1, this._maxDepth, this._crs, this)
);
};
|
var form = document.querySelector(".search-hotel-form");
var formButton = document.querySelector(".open-search-form");
console.log(form);
console.log(formButton);
formButton.addEventListener("click", function (evt) {
evt.preventDefault();
console.log("fuck");
form.classList.toggle("hidden");
});
window.addEventListener("keydown", function (evt) {
if (evt.keyCode === 27) {
evt.preventDefault();
if (!form.classList.contains("hidden")) {
form.classList.add("hidden");
}
}
});
|
/* 🤖 this file was generated by svg-to-ts*/
export const EOSIconsOfflinePin = {
name: 'offline_pin',
data: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"/></svg>`
};
|
import React from 'react';
import { Typography, Grid } from '@material-ui/core';
import ReviewCard from '../ui/ReviewCard';
import { useStyles } from '../../assets/styles/Restaurant';
const Restaurant = ({ reviews, restaurant }) => {
const classes = useStyles();
const renderContent = () => {
return reviews.map((review) => {
return (
<Grid item xs key={review.review_id}>
<ReviewCard
review={review.review}
rating={review.stars}
userId={review.user_id}
/>
</Grid>
);
});
};
return (
<main>
{restaurant && (
<Typography
variant="h2"
component="h2"
className={classes.restaurantHeader}>
{restaurant}
</Typography>
)}
<div className={classes.gridContainer}>
<Grid container spacing={3}>
{renderContent()}
</Grid>
</div>
</main>
);
};
export default Restaurant;
|
//"TaskId": "T_FCTRCGJYDGHBJ_942"
|
import React, { useEffect, useState } from 'react';
import PropTypes from 'prop-types';
import axios from 'axios';
import router from 'next/router';
import moment from 'moment-timezone';
import { Formik, Field, Form } from 'formik';
import { getLoggedInUser, getMyCats } from '../services';
import Header from '../components/Header/Header';
import { CatsMainStyles } from '../components/CatsMain/CatsMainStyles';
import { PageWrap } from '../styles/PageWrap';
import CatsList from '../components/CatsList/CatsList';
import AddCat from '../components/AddCat/AddCat';
const Pets = () => {
const [cats, setCats] = useState([]);
const [user, setUser] = useState(false);
const addCat = async values => {
await axios({
method: 'POST',
url: `/catsapi/v1/cats`,
data: values,
});
const myCats = await getMyCats();
setCats(myCats.data);
};
const feed = async id => {
await axios({
method: 'PUT',
url: `/catsapi/v1/cats/${id}`,
data: {
feedingTime: new Date(),
},
});
const myCats = await getMyCats();
setCats(myCats.data);
};
const deleteCat = async cat => {
await axios({
method: 'DELETE',
url: `/catsapi/v1/cats/${cat._id}`,
});
const myCats = await getMyCats();
setCats(myCats.data);
};
useEffect(() => {
(async () => {
const usr = await getLoggedInUser();
setUser(usr.data);
if (!usr) router.push('/login');
const myCats = await getMyCats();
setCats(myCats.data);
})();
const interval = setInterval(async () => {
const myCats = await getMyCats();
setCats(myCats.data);
}, 60000);
return () => clearInterval(interval);
}, []);
return (
<>
{user && (
<>
<PageWrap>
<Header user={user} />
<CatsMainStyles>
<div className="container">
{cats?.length > 0 ? (
<h1 className="title">{user.name}’s Cats</h1>
) : (
<>
<h1 className="title">Track Your First Cat 🐱</h1>
<img
className="first-cat"
src="/illustrations/human-and-cat-chilling.svg"
alt="Human and a Cat Chilling"
/>
</>
)}
<CatsList cats={cats} deleteCat={deleteCat} feed={feed} />
<AddCat addCat={addCat} />
</div>
</CatsMainStyles>
</PageWrap>
</>
)}
</>
);
};
Pets.propTypes = {};
export default Pets;
|
var mongoose = require('mongoose');
// var User = mongoose.Schema('User');
var users = require('../controllers/users.js');
module.exports = function(app){
//index
app.get('/users', users.index);
//show
app.get('/users/:id', users.show);
//create
app.post('/users', users.create);
//update
app.put('/users/:id', users.update);
//delete
app.delete('/users/:id', users.delete);
//login and registration routes!!!!
app.post('/login', users.login);
app.post('/register', users.register);
};
|
import { documentToReactComponents } from '@contentful/rich-text-react-renderer';
import { BLOCKS } from '@contentful/rich-text-types';
import Head from 'next/head';
import { useEffect } from 'react';
import { Error } from '../../components/404';
import { Navbar } from '../../components/Navbar';
import {
ProjectBottomContainer,
ProjectBottomDiv,
ProjectContainer,
ProjectImage,
ProjectImageBGRight,
ProjectImageBGLeft,
ProjectMainImage,
ProjectMainText,
ProjectText,
ProjectTitle,
} from '../../components/ProjectS';
const client = require('contentful').createClient({
space: process.env.NEXT_CONTENTFUL_SPACE_ID,
accessToken: process.env.NEXT_CONTENTFUL_ACCESS_TOKEN,
});
export default function Post({ posts, post }) {
if (!post) return <Error />;
const data = post.fields;
return (
<>
<Head>
<title>Paragon Design Studio | {data.title}</title>
</Head>
<Navbar props={posts} />
<ProjectContainer>
<ProjectTitle>{data.title}</ProjectTitle>
<ProjectMainImage
src={'https:' + data.mainImage.fields.file.url}
alt="MainImage"
/>
<ProjectMainText>
{data.mainText
.replace(/\\n/g, ' ')
.split('\n')
.map((t, i) =>
i > 0 ? (
<span key={i}>
<br />
{t}
</span>
) : (
t
)
)}
</ProjectMainText>
<ProjectBottomContainer>
{data.textOne && (
<>
<ProjectBottomDiv>
<ProjectText>
{data.textOne
.replace(/\\n/g, ' ')
.split('\n')
.map((t, i) =>
i > 0 ? (
<span key={i}>
<br />
{t}
</span>
) : (
t
)
)}
</ProjectText>
<ProjectImage
src={'https:' + data.imageOne.fields.file.url}
alt="ImageOne"
/>
<ProjectImageBGRight />
</ProjectBottomDiv>{' '}
</>
)}
{data.textTwo && (
<>
<ProjectBottomDiv>
<ProjectImage
src={'https:' + data.imageTwo.fields.file.url}
alt="ImageTwo"
/>
<ProjectText>
{data.textTwo
.replace(/\\n/g, ' ')
.split('\n')
.map((t, i) =>
i > 0 ? (
<span key={i}>
<br />
{t}
</span>
) : (
t
)
)}
</ProjectText>
<ProjectImageBGLeft />
</ProjectBottomDiv>{' '}
</>
)}
{data.textThree && (
<>
<ProjectBottomDiv>
<ProjectText>
{data.textThree
.replace(/\\n/g, ' ')
.split('\n')
.map((t, i) =>
i > 0 ? (
<span key={i}>
<br />
{t}
</span>
) : (
t
)
)}
</ProjectText>
<ProjectImage
src={'https:' + data.imageThree.fields.file.url}
alt="ImageThree"
/>
<ProjectImageBGRight />
</ProjectBottomDiv>{' '}
</>
)}
</ProjectBottomContainer>
</ProjectContainer>
</>
);
}
export async function getStaticPaths() {
let data = await client.getEntries({
content_type: 'title',
});
return {
paths: data.items.map((item) => ({
params: { slug: item.fields.slug },
})),
fallback: true,
};
}
export async function getStaticProps({ params }) {
let data = await client.getEntries({
content_type: 'title',
'fields.slug': params.slug,
});
let alldata = await client.getEntries({
content_type: 'title',
});
return {
props: {
post: data.items[0],
posts: alldata.items,
},
// revalidate: 10,
};
}
|
//https://github.com/google/material-design-lite/blob/master/src/mdlComponentHandler.js#L333
const mdlBehaviourMixin = {
/**
* Called when component is mounted.
*/
componentDidMount() {
if (React.findDOMNode(this)) {
componentHandler.upgradeElement(React.findDOMNode(this));
}
},
/**
* Called before component is unmounted.
*/
componentWillUnmount() {
if (React.findDOMNode(this)) {
componentHandler.downgradeElements(React.findDOMNode(this));
}
}
};
module.exports = mdlBehaviourMixin;
|
"use strict";
const _ = require('underscore');
const needle = require('needle');
const util = require('util');
const pjson = require(__dirname + '/../package.json');
const SUCCESSFUL_REQUEST_STATUS = 0;
const VIBER_AUTH_TOKEN_HEADER = "X-Viber-Auth-Token";
const MAX_GET_ONLINE_IDS = 100;
const API_ENDPOINTS = {
"setWebhook": "/set_webhook",
"getAccountInfo": "/get_account_info",
"getUserDetails": "/get_user_details",
"getOnlineStatus": "/get_online",
"sendMessage": "/send_message",
"post": "/post"
};
function ViberClient(logger, bot, apiUrl, subscribedEvents) {
this._logger = logger;
this._bot = bot;
this._url = apiUrl;
this._subscribedEvents = subscribedEvents;
this._userAgent = util.format("ViberBot-Node/%s", pjson.version);
}
ViberClient.prototype.setWebhook = function(url, isInline) {
this._logger.info("Sending 'setWebhook' request for url: %s, isInline: %s", url, isInline);
return this._sendRequest("setWebhook", {
"url": url,
"is_inline": isInline,
"event_types": this._subscribedEvents
});
};
ViberClient.prototype.sendMessage = function(optionalReceiver, messageType, messageData, optionalTrackingData, optionalKeyboard, optionalChatId, optionalMinApiVersion) {
if (!optionalReceiver && !optionalChatId) {
throw new Error(`Invalid arguments passed to sendMessage. 'optionalReceiver' and 'chatId' are Missing.`);
}
if (messageType && !messageData) {
throw new Error(`Invalid arguments passed to sendMessage. 'MessageData' is Missing.`);
}
if (!messageType && !messageData && !optionalKeyboard) {
throw new Error(`Invalid arguments passed to sendMessage. 'MessageData','messageType' are Missing and there's no keyboard.`);
}
const request = {
"sender": {
"name": this._bot.name,
"avatar": this._bot.avatar
},
"tracking_data": this._serializeTrackingData(optionalTrackingData),
"keyboard": optionalKeyboard,
"chat_id": optionalChatId,
"min_api_version": optionalMinApiVersion
};
if (optionalReceiver) {
request["receiver"] = optionalReceiver;
}
this._logger.debug("Sending %s message to viber user '%s' with data", messageType, optionalReceiver, messageData);
return this._sendRequest("sendMessage", Object.assign(request, messageData));
};
ViberClient.prototype.getAccountInfo = function() {
return this._sendRequest("getAccountInfo", {});
};
ViberClient.prototype.getUserDetails = function(viberUserId) {
if (!viberUserId) throw new Error(`Missing user id`);
return this._sendRequest("getUserDetails", { "id": viberUserId });
};
ViberClient.prototype.getOnlineStatus = function(viberUserIds) {
viberUserIds = _.isArray(viberUserIds) ? viberUserIds : [viberUserIds];
if (_.isEmpty(viberUserIds)) throw new Error(`Empty or no user ids passed to getOnlineStatus`);
if (_.size(viberUserIds) > MAX_GET_ONLINE_IDS) {
throw new Error(`Can only check up to ${MAX_GET_ONLINE_IDS} ids per request`);
}
return this._sendRequest("getOnlineStatus", { "ids": viberUserIds });
};
ViberClient.prototype.postToPublicChat = function(senderProfile, messageType, messageData, optionalMinApiVersion) {
if (!senderProfile) {
throw new Error(`Invalid arguments passed to postToPublicChat. 'senderProfile' is Missing.`);
}
if (!messageType || !messageData) {
throw new Error(`Invalid arguments passed to postToPublicChat. 'MessageData' or 'messageType' are Missing.`);
}
const request = {
"from": senderProfile.id,
"sender": {
"name": senderProfile.name,
"avatar": senderProfile.avatar
},
"min_api_version": optionalMinApiVersion
};
this._logger.debug("Sending %s message to public chat as viber user '%s' with data", messageType, senderProfile.id, messageData);
return this._sendRequest("post", Object.assign(request, messageData))
};
ViberClient.prototype._sendRequest = function(endpoint, data) {
if (!_.has(API_ENDPOINTS, endpoint)) {
throw new Error(`could not find endpoint ${endpoint}`);
}
const self = this;
const url = util.format("%s%s", this._url, API_ENDPOINTS[endpoint]);
const dataWithAuthToken = Object.assign({ "auth_token": this._bot.authToken }, data);
const options = {
json: true, rejectUnauthorized: true, parse: true,
user_agent: this._userAgent, // eslint-disable-line
headers: {
[VIBER_AUTH_TOKEN_HEADER]: this._bot.authToken
}
};
this._logger.debug("Opening request to url: '%s' with data", url, data);
return new Promise((resolve, reject) => {
try {
needle.post(url, dataWithAuthToken, options)
.on("data", data => self._readData(data, resolve, reject))
.on("end", err => self._requestEnded(err, reject))
.on("err", err => reject(err));
}
catch (err) {
reject(err);
}
});
};
ViberClient.prototype._readData = function(data, resolve, reject) {
if (data.status != SUCCESSFUL_REQUEST_STATUS) {
this._logger.error("Response error", data);
return reject(data);
}
this._logger.debug("Response data", data);
return resolve(data);
};
ViberClient.prototype._requestEnded = function(err, reject) {
if (err) {
this._logger.error("Request ended with an error", err);
return reject(err);
}
this._logger.debug("Request ended successfully");
};
ViberClient.prototype._serializeTrackingData = function(optionalTrackingData) {
if (optionalTrackingData == null || _.isEmpty(optionalTrackingData)) {
// because of bug in production, we cannot send null, but we can send an empty string
optionalTrackingData = "";
}
return JSON.stringify(optionalTrackingData);
};
module.exports = ViberClient;
|
var Q, run, spawn,
__slice = [].slice;
Q = require('q');
spawn = require('child_process').spawn;
run = function(app, action) {
var args, cmd, deferred, err, osascript, out, _ref;
deferred = Q.defer();
out = [];
err = [];
_ref = ["osascript", "-e", "tell app \"" + app + "\" to " + action], cmd = _ref[0], args = 2 <= _ref.length ? __slice.call(_ref, 1) : [];
osascript = spawn(cmd, args);
osascript.stdout.on('data', function(data) {
return out.push(data);
});
osascript.stderr.on('data', function(data) {
return err.push(data);
});
osascript.on('close', function(code) {
if (code === 0) {
return deferred.resolve(out.join(' ').trim());
} else {
return deferred.reject(err.join(' ').trim());
}
});
return deferred.promise;
};
module.exports = run;
|
import { module } from 'qunit';
import {
test} from 'qunit'; import {setupTest
} from 'ember-qunit';
import EmberObject from '@ember/object';
import moment from 'moment';
module('Unit | Component | slots-picker/pickadate', function (hooks) {
setupTest(hooks);
test('jsDays computed property', function (assert) {
const component = this.owner.factoryFor('component:slots-picker/pickadate').create({
baseProps: {
days: ['20180101', '20180102']
}
});
assert.equal(
component.get('jsDays').length,
component.get('days').length,
'jsDays returns array with length equal to days length'
);
assert.equal(
_getDateAsStringFromJavaScriptDateObject(0),
'1/1/2018',
'jsDays returns first day as native javascript date.'
);
assert.equal(
_getDateAsStringFromJavaScriptDateObject(1),
'2/1/2018',
'jsDays returns last day as native javascript date.'
);
function _getDateAsStringFromJavaScriptDateObject(i) {
const dateObj = component.get('jsDays')[i];
return dateObj.getDate() + '/' + (dateObj.getMonth() + 1) + '/' + dateObj.getFullYear();
}
});
test('min computed property', function (assert) {
const component = this.owner.factoryFor('component:slots-picker/pickadate').create({
baseProps: {
days: ['20180213', '20180214', '20180215']
}
});
assert.equal(
component.get('min')[0],
2018,
'min returns year of firstObject as first item in the array'
);
assert.equal(
component.get('min')[1],
1,
'min returns month of firstObject as second item in the array'
);
assert.equal(
component.get('min')[2],
13,
'min returns date of firstObject as first item in the array'
);
});
test('max computed property', function (assert) {
const component = this.owner.factoryFor('component:slots-picker/pickadate').create({
baseProps: {
days: ['20180213', '20180214', '20180215']
}
});
assert.equal(
component.get('max')[0],
2018,
'max returns year of lastObject as first item in the array'
);
assert.equal(
component.get('max')[1],
1,
'max returns month of lastObject as second item in the array'
);
assert.equal(
component.get('max')[2],
15,
'max returns date of lastObject as first item in the array'
);
});
test('currentDay', function (assert) {
const component = this.owner.factoryFor('component:slots-picker/pickadate').create({
selected: null
});
assert.equal(component.get('currentDay'), null, 'should return null for no selection');
component.set('selected', EmberObject.create({slotPickerDay: '20190602'}));
assert.equal(component.get('currentDay'), moment('20190602').valueOf(), 'should retrieve correct day from slot');
});
test('onSelectDate action', function (assert) {
const component = this.owner.factoryFor('component:slots-picker/pickadate').create({
set: sinon.stub(),
onSelectSlot: sinon.stub(),
_scrollToSlotsOnlyIfNotOnInit: sinon.stub()
});
const onDateChangeStub = sinon.stub(component.actions, 'onDateChange');
const today = (new Date()).valueOf();
component.send('onSelectDate', today);
assert.ok(component.get('set').calledWith('currentDay', today), 'should set currentDay');
assert.ok(component.get('onSelectSlot').calledWith(null), 'should clear selected slot');
assert.ok(onDateChangeStub.calledWith(today), 'should call onDateChange with date');
onDateChangeStub.resetHistory();
component.setProperties({currentDay: today});
component.send('onSelectDate', today);
assert.notOk(onDateChangeStub.called, 'should not call change callback');
});
});
|
import { React, useState } from "react";
import {Card, Button} from "react-bootstrap";
import Logo from "../assets//img/default-movie.png";
import MovieModal from "./MovieModal"
import './moviecard.scss'
const MovieCard = ({ movie }) => {
const [show, setShow] = useState(false);
const showModal = () => {
setShow(true);
}
return (
<Card id="cardShow">
<Card.Img id="cardImg" variant="top" src={movie.Poster === "N/A" ? Logo : movie.Poster} style={{ height:"20rem", objectFit:"cover" }} />
<Card.Body id="cardBody">
<Card.Title id="cardTitle">{movie.Title}</Card.Title>
<Card.Text id="cardYear">{movie.Year}</Card.Text>
<Button id="cardButton" onClick={showModal}>MORE INFO
</Button>
<MovieModal show={show} setShow={setShow} movie={movie}/>
</Card.Body>
</Card>
);
};
export default MovieCard;
|
import React from 'react';
import { TouchableOpacity, StyleSheet, View, Alert } from 'react-native';
import { Actions } from 'react-native-router-flux';
import Ionicons from 'react-native-vector-icons/Ionicons';
const BackButton = () => (
<TouchableOpacity activeOpacity={0.9} onPress={Actions.pop} style={styles.container}>
<View>
<Ionicons name="ios-arrow-back" size={40} color='rgba(240,240,240,0.8)' />
</View>
</TouchableOpacity>
);
const styles = StyleSheet.create({
container: {
position: 'absolute',
top: 10,
left: 10,
paddingLeft: 10,
zIndex: 1000,
width: 40
}
});
export default BackButton;
|
// Repl.it Link: https://repl.it/@durgaMacrometa/HowTo-UsingGDNasEdgeCache-js
Fabric = require('jsc8')
var XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;
var xmlHttp = new XMLHttpRequest();
// Define URLs
const fed_url = "https://gdn1.macrometa.io"
const fed_url_west = "https://gdn1-sfo2.prod.macrometa.io"
const fed_url_eastcoast = "https://gdn1-nyc1.prod.macrometa.io"
const fed_url_europe = "https://gdn1-fra1.prod.macrometa.io"
const fed_url_asia = "https://gdn1-blr1.prod.macrometa.io"
// Variables
const guest_password = "guest1"
const geo_fabric = "guest1"
const guest_email = "guest1@macrometa.io"
const keys = ["dogs", "cats", "birds", "books", "business", "trees", "forests", "lakes"]
//---------------------------------------------------------------
// Cache class to utilize GDN for serving data from edge
//--------------------------------------------------------------
class Cache {
// Create a collection in GDN (if not exists) to act as Cache
constructor(fabric) {
this.fabric = fabric;
(async () => {
this.cache = fabric.collection('cache');
const result = await this.cache.exists();
if (!result) {
await fabric.collection('cache');
}
})();
}
// Read from cache.
async get(key) {
try {
const handle = await this.cache.document(key);
return handle
}
catch{
return null
}
}
// Write to cache. The writes are automatically geo replicated.
async set(key, doc, ttl = 0) {
let res = await this.cache.documentExists(key)
if (res) {
//const docHandle = this.cache.document(key)
await this.cache.replace(key, doc)
}
else {
await this.cache.save(doc)
}
return true;
}
// Purge the cache. The purge is automatically geo replicated.
async purge(keys) {
try {
for (let key of keys) {
await this.cache.remove(key)
}
}catch{
return false;
}
return true;
}
}
//---------------------------------------------------------
// Code to Read & Write from Origin (i.e., from Cloud)
//----------------------------------------------------------
// Read from Origin
function get_from_origin_db(key) {
let document = {}
const url = "https://openlibrary.org/subjects/" + key + ".json?limit=0"
xmlHttp.open("GET", url, false); // false for synchronous request
xmlHttp.send()
r = xmlHttp.responseText;
document = JSON.parse(r)
document["_key"] = key
return document
}
// Write to Origin
function write_to_origin_db(document) {
// Write to Origin DB
console.log("writing to origin database..")
return true;
}
//------------------------------------------
// Utilize GDN as edge cache for serving reads & writes. Following is the behavior of the main() method:
// 1. For First time reads,
// Gets data from OriginDB. Populates GDN transparently.
// 2. For subsequent reads from same region,
// Serves data from the GDN directly.
// 3. For subsequent reads from other regions,
// Serves data from the GDN directly.
// 4. For writes,
// Invalidates the Cache globally in realtime
// Writes to Origin
// Updates the Cache globally in realtime.
// 5. For subsequent reads from other regions,
// Serves data from the GDN directly.
//------------------------------------------
async function main() {
// Login to GDN and Create cache (if not exists)
fabric = new Fabric(fed_url)
await fabric.login(guest_email, guest_password)
await fabric.useFabric(geo_fabric)
const cache = new Cache(fabric)
//Clean Cache from previous runs
await cache.purge(keys);
// Use Macrometa GDN as Cache for Remote Origin Database
console.log("----------------------\n1. First time access:\n----------------------")
var before = Date.now();
for (let key of keys) {
doc = await cache.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = await get_from_origin_db(key)
cache.set(key, doc)
}
else {
console.log("CACHE_HIT: get from closest region cache...")
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from Origin) -------\n")
// 2nd time access served from GDN edge cache.
console.log("----------------------\n2. Second time access:\n----------------------")
before = Date.now();
for (key of keys) {
doc = await cache.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache.set(key, doc)
}
else {
console.log("CACHE_HIT: get from closest region cache...")
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from Closest Cache)-------\n")
// GDN Cache Geo replication in action... US West Coast
console.log("------------------------------\n3a. Access from US_WEST_COAST:\n------------------------------")
fabric = new Fabric(fed_url_west)
await fabric.login(guest_email, guest_password)
await fabric.useFabric(geo_fabric)
cache3a = new Cache(fabric)
var before = Date.now();
for (key of keys) {
doc = await cache3a.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache3a.set(key, doc)
}
else {
console.log("CACHE_HIT: doc_id:" + doc._id)
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from US_WEST_COAST Cache) -------\n")
// GDN Cache Geo replication in action... US East Coast
console.log("------------------------------\n3b. Access from US_EAST_COAST:\n------------------------------")
fabric = new Fabric(fed_url_eastcoast)
await fabric.login(guest_email, guest_password)
await fabric.useFabric(geo_fabric)
cache3b = new Cache(fabric)
var before = Date.now();
for (key of keys) {
doc = await cache3b.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache3b.set(key, doc)
}
else {
console.log("CACHE_HIT: doc_id:" + doc._id)
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from US_EAST_COAST Cache) -------\n")
// GDN Cache Geo replication in action... Europe
console.log("------------------------------\n3c. Access from EUROPE:\n------------------------------")
fabric = new Fabric(fed_url_europe)
await fabric.login(guest_email, guest_password)
await fabric.useFabric(geo_fabric)
cache3c = new Cache(fabric)
var before = Date.now();
for (key of keys) {
doc = await cache3c.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache3c.set(key, doc)
}
else {
console.log("CACHE_HIT: doc_id:" + doc._id)
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from EUROPE Cache)-------\n")
// GDN Cache Geo replication in action... Asia
console.log("------------------------------\n3c. Access from ASIA:\n------------------------------")
fabric = new Fabric(fed_url_asia)
await fabric.login(guest_email, guest_password)
await fabric.useFabric(geo_fabric)
cache3d = new Cache(fabric)
var before = Date.now();
for (key of keys) {
doc = await cache3d.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache3d.set(key, doc)
}
else {
console.log("CACHE_HIT: doc_id:" + doc._id)
}
}
console.log("\n------- Execution Time: " + (Date.now()-before) + "ms (from ASIA Cache)-------\n")
// Invalidate & update cache globally on writes.
console.log("------------------------------\n4. Writes from Edge to origin and global cache update: \n------------------------------")
for (key of keys) {
doc = await cache.get(key)
doc["company"] = "macrometa"
write_to_origin_db(doc)
cache.set(key, doc)
}
console.log("------------------------------\n5. After writes... Access from EUROPE:\n------------------------------")
for (key of keys) {
doc = await cache3b.get(key)
if (doc == null) {
console.log("CACHE_MISS: get from remote origin database...")
doc = get_from_origin_db(key)
cache3b.set(key, doc)
}
else {
console.log("CACHE_HIT: \ndoc:" + JSON.stringify(doc))
}
}
}
// Call main method. Starting point for the program.
main()
|
exports.onCreateWebpackConfig = require('./src/gatsby/onCreateWebpackConfig')
exports.onPreBootstrap = require('./src/gatsby/onPreBootstrap')
exports.createSchemaCustomization = require('./src/gatsby/createSchemaCustomization')
exports.onCreateNode = require('./src/gatsby/onCreateNode')
exports.createPages = require('./src/gatsby/createPages')
exports.onCreatePage = require('./src/gatsby/onCreatePage')
|
'use strict';
// vendor
import Vue from 'vue/dist/vue'
import 'bootstrap/dist/css/bootstrap.css'
import 'jquery-input-mask-phone-number/dist/jquery-input-mask-phone-number.min'
import 'slick-carousel/slick/slick.css'
import 'slick-carousel/slick/slick.min'
import AOS from 'aos/dist/aos.js'
import 'aos/dist/aos.css'
AOS.init({
disable: function () {
return window.innerWidth < 576;
}
});
// common
import './common/styles/global-variables.scss'
import './common/styles/style.scss'
import './common/styles/mixins.scss'
import './common/styles/fonts.scss'
// bem components
import './bem-components/section/section.scss'
import './bem-components/section/section'
import './bem-components/first-screen/first-screen.scss'
import './bem-components/first-screen/first-screen'
import './bem-components/section-reasons/section-reasons.scss'
import './bem-components/section-rosaburgh/section-rosaburgh.scss'
import './bem-components/section-rosaburgh/section-rosaburgh'
import './bem-components/section-gerryville/section-gerryville.scss'
import './bem-components/section-gerryville/section-gerryville'
import './bem-components/section-indicators/section-indicators.scss'
import './bem-components/section-questions/section-questions.scss'
import './bem-components/section-questions/section-questions'
import './bem-components/section-two-parts/section-two-parts.scss'
import './bem-components/section-two-parts/section-two-parts'
import './bem-components/section-rebeccamouth/section-rebeccamouth.scss'
import './bem-components/site-header/site-header.scss'
import './bem-components/site-footer/site-footer.scss'
import './bem-components/languages-switch/languages-switch.scss'
import './bem-components/main-menu/main-menu.scss'
import './bem-components/logo/logo.scss'
import './bem-components/search-btn/search-btn.scss'
import './bem-components/button/button.scss'
import './bem-components/site-select/site-select.scss'
import './bem-components/site-select/site-select'
import './bem-components/social-network-link/social-network-link.scss'
import './bem-components/decor-line-list/decor-line-list.scss'
// vue components
new Vue({
el: '#app',
components: {
}
});
|
import Service from '@ember/service';
import { queryManager } from "ember-apollo-client";
import allBlogQuery from "abulasar-profile/gql/queries/blogs.graphql";
import query from "abulasar-profile/gql/queries/blog-detail.graphql";
export default class BlogPostService extends Service {
@queryManager apollo;
async fetchPosts(variables) {
const result = await this.apollo.watchQuery({ query: allBlogQuery, variables }, "user");
return result.publication.posts;
}
async getPost(variables) {
const content = await this.apollo.watchQuery({ query, variables }, "post");
return content;
}
}
|
import React from 'react';
import { render, fireEvent } from '@testing-library/react';
import { useSelector, useDispatch } from 'react-redux';
import RestaurantCategoriesContainer from './RestaurantCategoriesContainer';
import { categories } from '../fixtures/restaurants';
import {
setCategory,
} from './actions';
jest.mock('react-redux');
describe('RestaurantCategoriesContainer', () => {
const dispatch = jest.fn();
beforeEach(() => {
useDispatch.mockImplementation(() => dispatch);
useSelector.mockImplementation((selector) => selector({
categories,
}));
});
it('show restaurant categories', () => {
const { getByText } = render((
<RestaurantCategoriesContainer />
));
categories.forEach(({ name }) => {
expect(getByText(name)).toBeInTheDocument();
});
});
it('분류 중 하나를 클릭 시 dispatch가 호출된다.', () => {
const { getByText } = render((
<RestaurantCategoriesContainer />
));
fireEvent.click(getByText('한식'));
expect(dispatch).toBeCalledWith(setCategory({
id: 1,
name: '한식',
}));
});
});
|
;(function(deps, ice){
// if running in electron, we wanna keep this around to use elektron's modules
if (window.require) window.nativeRequire = window.require;
var %REQUIRE%;
var glagol = require('glagol')
, app = window.Glagol = glagol(ice, { formats: %FORMATS% });
glagol.require.install(deps, require);
window.Glagol.noConflict = function noConflict () {
delete window.Glagol;
return app;
}
app().main();
var socket = new WebSocket("ws://" + window.location.host);
socket.onopen = function () { socket.send('glagol'); }
socket.onmessage = function (msg) {
var data = JSON.parse(msg.data);
switch (data.event) {
case "glagol.added":
glagol.defaultLoader.add(data.path, data.value);
break;
case "glagol.changed":
glagol.defaultLoader.update(data.path, data.value);
break;
case "glagol.removed":
glagol.defaultLoader.remove(data.path);
break;
}
}
})(
%DEPS%,
%ICE%
)
|
import { SET_YEARS, SET_ERROR } from "../actions/years";
const yearsReducer = (state = { years: {}, status: 0 }, action = {}) => {
switch (action.type) {
case SET_YEARS :
return {
...state,
years: action.years
};
case SET_ERROR :
return {
...state,
error: action.error
};
default : return state;
}
}
export default yearsReducer;
|
import React, { Component } from 'react';
import { Link } from 'react-router-dom'
import styled from 'styled-components'
import {
Container,
Divider,
Dropdown,
Grid,
Header,
Image,
List,
Menu,
Segment,
} from 'semantic-ui-react'
const Back = styled.div`
background-image:url("https://media.giphy.com/media/97ZkiqMSW8kW4/giphy.gif")
`
class NavBar extends Component {
render() {
return (
<Back>
<Segment clearing>
<Header as='h2' floated='right' color='red'>
<Link to="/events">Events</Link>
</Header>
<Header as='h2' floated='left'>
<Link to="/">Code.Universe</Link>
</Header>
</Segment>
</Back>
);
}
}
export default NavBar;
|
import vModal from './modal.vue'
import confirm from './confirm'
import assign from 'object-assign'
vModal.info = function (props) {
const config = assign({
type: 'info',
iconType: 'info-circle',
okCancel: false,
}, props)
return confirm(config)
}
vModal.success = function (props) {
const config = assign({
type: 'success',
iconType: 'check-circle',
okCancel: false,
}, props)
return confirm(config)
}
vModal.error = function (props) {
const config = assign({
type: 'error',
iconType: 'exclamation-circle',
okCancel: false,
}, props)
return confirm(config)
}
vModal.confirm = function (props) {
const config = assign({
type: 'confirm',
okCancel: true,
}, props)
return confirm(config)
}
export default vModal
|
//const msgpack = require("msgpack-lite");
// trying to reproduce an Enum
const CMD_CODES = {
ASSIGN_WEIGHTS : 0,
TRAIN_INFO : 1,
MODEL_INFO : 2,
COMPILE_MODEL : 3,
AVG_WEIGHTS : 4,
}
Object.freeze(CMD_CODES)
/**
* NOTE: peer.js seems to convert all array types to ArrayBuffer, making the original
* type unrecoverable (Float32Array, Uint8Array, ...). The solution is to encode any payload
* with msgpack.encode, then decode at the destination.
*/
class PeerJS {
constructor(local_peer, handle_data, ...handle_data_args) {
this.local_peer = local_peer
this.data = null
this.handle_data = handle_data
this.handle_data_args = handle_data_args
console.log("peer", local_peer)
this.local_peer.on("connection", (conn) => {
console.log("new connection")
conn.on("data", async (data) => {
this.data = data
this.new_data = true
await this.handle_data(data, ...this.handle_data_args)
})
})
}
async send(receiver, data) {
const conn = this.local_peer.connect(receiver)
conn.on('open', () => {
conn.send(data)
})
}
get_data() {
this.new_data = false
return this.data
}
}
// TODO: this doesn't need to be a class...
class ModelStorage {
static get BASEDIR() {
return "tensorflowjs_models"
}
static get FILENAMES() {
return [
"info",
"model_metadata",
"model_topology",
"weight_data",
"weight_specs"
]
}
static async store(model, name) {
await model.save("localstorage://" + name)
}
static inject(model_data, name) {
for(var i = 0; i < this.FILENAMES; i++) {
var key = this.FILENAMES[i]
var fpath = this.BASEDIR + '/' + name + '/' + key
var content = model_data[key]
localStorage.setItem(fpath, content)
}
}
static get_serialized_model(name) {
var serialized = {}
for(var i = 0; i < this.FILENAMES.length; i++) {
var key = this.FILENAMES[i]
var fpath = this.BASEDIR + '/' + name + '/' + key
var model_data = localStorage.getItem(fpath) // this is a JSON string
serialized[key] = model_data
}
serialized.name = name
return serialized
}
}
async function send_model(model, peerjs, receiver, name) {
await ModelStorage.store(model, name)
var serialized = ModelStorage.get_serialized_model(name)
const send_data = {
cmd_code : CMD_CODES.MODEL_INFO,
payload : msgpack.encode(serialized)
}
console.log("Sending model data")
console.log(send_data)
peerjs.send(receiver, send_data)
}
function send_data(data, code, peerjs, receiver) {
const send_data = {
cmd_code : code,
payload : msgpack.encode(data)
}
console.log("Sending data")
console.log(send_data)
peerjs.send(receiver, send_data)
}
async function load_model(model_data) {
var name = model_data.name
ModelStorage.inject(model_data, name)
const model = await tf.loadLayersModel("localstorage://" + name)
return model
}
async function handle_data(data, buffer) {
console.log("Received new data: ", data)
// convert the peerjs ArrayBuffer back into Uint8Array
payload = msgpack.decode(new Uint8Array(data.payload))
switch(data.cmd_code) {
case CMD_CODES.MODEL_INFO:
buffer.model = payload
break
case CMD_CODES.ASSIGN_WEIGHTS:
buffer.assign_weights = payload
break
case CMD_CODES.COMPILE_MODEL:
buffer.compile_data = payload
break
case CMD_CODES.AVG_WEIGHTS:
buffer.avg_weights = payload
break
case CMD_CODES.TRAIN_INFO:
buffer.train_info = payload
break
}
}
|
//init
const Router = require('koa-router')
const offical = require('./offical')
const client = require('./client')
const business = require('./business')
const rootRouter = new Router()
rootRouter.use('/client',client.routes(),client.allowedMethods())
rootRouter.use('/offical',offical.routes(),offical.allowedMethods())
rootRouter.use('/business',business.routes(),business.allowedMethods())
module.exports = rootRouter
|
import Vue from 'vue'
import App from './App.vue'
import router from './router'
import 'swiper/dist/css/swiper.min.css'
import axios from 'axios'
import VueAxios from 'vue-axios'
import VueLazyload from 'vue-lazyload'
import VueRouter from 'vue-router'
import xq from '/xq.vue'
import Home from '/Home.vue'
Vue.use(VueLazyload)
Vue.use(VueAxios,axios)
Vue.use(VueRouter)
Vue.config.productionTip = false
export default new VueRouter({
routes:[
{
path:'/xq',
component:xq,
name:'xq',
},
{
path:'/',
component:Home,
name:'Home',
},
]
})
new Vue({
router,
render: h => h(App)
}).$mount('#app')
|
$(document).ready(function(){
initChart();
var parentObj = 'base';
$('.dtm-tab0 li').on('click', function(event) {
parentObj = $(this).data('cpt-tab0');
$('.dtm-tab0 li').removeClass('dtm-tab0-hi-curr');
$(this).addClass('dtm-tab0-hi-curr');
$('div[data-cpt-con0]').hide();
$('[data-cpt-con0="'+parentObj+'"]').show();
});
$('div[data-cpt-tab1]').on('click', function(event) {
var childObj = $(this).data('cpt-tab1');
$('[data-cpt-con0="'+parentObj+'"] div[data-cpt-tab1]').removeClass('dtm-tab1-hi-curr');
$(this).addClass('dtm-tab1-hi-curr');
$('[data-cpt-con0="'+parentObj+'"] div[data-cpt-con1]').hide();
$('[data-cpt-con0="'+parentObj+'"] [data-cpt-con1="'+childObj+'"]').show();
});
$('.cpt-chkbtn-i').on('click', function(event) {
if($(this).parent().hasClass('cpt-disabled')) return;
var opt = $(this).data('opt');
$(this).siblings('div').removeClass('cpt-chkbtn-i-active');
$(this).addClass('cpt-chkbtn-i-active');
console.info(opt);
eval('chartOpt.'+opt+';');
mainChart.setOption(chartOpt);
});
$('div[data-dsp]').on('click', function(event) {
var dsp = $(this).data('dsp');
if($(this).parent().hasClass('cpt-disabled')) {
$(this).parent().removeClass('cpt-disabled');
$(this).parent().removeClass('cpt-ggt-edtitm-disabled');
$(this).parent().removeClass('dtm-edtitm-disabled');
$(this).parent().find('div').removeClass('cpt-disabled');
$(this).parent().find('div').removeClass('cpt-sltggt-disabled');
$(this).parent().find('div').removeClass('dtm-edtitm-ggt-disabled');
$(this).parent().find('div').removeClass('cpt-chkbtn-disabled');
for(var i=0; i<$(this).parent().find('div[data-opt]').length; i++) {
var obj = $(this).parent().find('div[data-opt]')[i];
if($(obj).hasClass('cpt-chkbtn-i-active')) {
var opt = $(obj).data('opt');
eval('chartOpt.'+opt+';');
mainChart.setOption(chartOpt);
}
}
} else {
$(this).parent().addClass('cpt-disabled');
$(this).parent().addClass('cpt-ggt-edtitm-disabled');
$(this).parent().addClass('dtm-edtitm-disabled');
$(this).parent().find('div').addClass('cpt-disabled');
$(this).parent().find('div').addClass('cpt-sltggt-disabled');
$(this).parent().find('div').addClass('dtm-edtitm-ggt-disabled');
$(this).parent().find('div').addClass('cpt-chkbtn-disabled');
eval('chartOpt.'+dsp+'false;');
mainChart.setOption(chartOpt);
}
console.info(dsp);
});
$(':input').on('change', function(event) {
console.info($(this).val());
console.info($(this).parents('div[data-dsp]').length);
});
});
var mainChart = null;
var chartOpt = null;
function initChart() {
// 基于准备好的dom，初始化echarts实例
mainChart = echarts.init(document.getElementById('main'));
// 指定图表的配置项和数据
chartOpt = {
title : {
text: '某站点用户访问来源',
subtext: '纯属虚构',
x:'center'
},
tooltip : {
trigger: 'item',
formatter: "{a} <br/>{b} : {c} ({d}%)"
},
legend: {
orient: 'vertical',
left: 'left',
data: ['直接访问','邮件营销','联盟广告','视频广告','搜索引擎']
},
series : [
{
name: '访问来源',
type: 'pie',
radius : '55%',
center: ['50%', '60%'],
data:[
{value:335, name:'直接访问'},
{value:310, name:'邮件营销'},
{value:234, name:'联盟广告'},
{value:135, name:'视频广告'},
{value:154, name:'搜索引擎'}
],
itemStyle: {
emphasis: {
shadowBlur: 10,
shadowOffsetX: 0,
shadowColor: 'rgba(0, 0, 0, 0.5)'
}
}
}
]
};
// 使用刚指定的配置项和数据显示图表。
mainChart.setOption(chartOpt);
}
|
'use strict';
const path = require('path');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const CaseSensitivePathsPlugin = require('case-sensitive-paths-webpack-plugin');
const ManifestPlugin = require('webpack-manifest-plugin');
const webpack = require('webpack');
const devMode = process.env.NODE_ENV !== 'production';
const autoprefixer = require('autoprefixer');
const hotloader = [
'webpack-dev-server/client?http://localhost:3000',
'webpack/hot/only-dev-server'
];
const app = [path.resolve(__dirname, '../src/index.js')];
function getFilename(name, ext) {
return devMode ? `${name}.${ext}` : `${name}.[chunkhash].${ext}`;
}
let plugins = [
new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/),
new webpack.DefinePlugin({
'process.env': {
'NODE_ENV': JSON.stringify(devMode ? 'development' : 'production')
}
}),
new MiniCssExtractPlugin({
filename: devMode ? '[name].css' : '[name].[hash].css',
chunkFilename: devMode ? '[id].css' : '[id].[hash].css'
}),
new ManifestPlugin({
fileName: 'asset-manifest.json'
})
];
if (devMode) {
plugins = plugins.concat([
new CaseSensitivePathsPlugin(),
new webpack.HotModuleReplacementPlugin()
]);
}
const nodeLibs = Object.keys(require('node-libs-browser'));
const excludedLibs = {};
nodeLibs.forEach(lib => {
excludedLibs[lib] = false;
});
module.exports = {
node: excludedLibs,
mode: devMode ? 'development' : 'production',
devtool: devMode ? 'cheap-module-eval-source-map' : undefined,
entry: {
bundle: devMode ? hotloader.concat(app) : app
},
output: {
path: path.resolve(__dirname, devMode ? '../public' : '../static/build'),
filename: getFilename('[name]', 'js'),
chunkFilename: getFilename('[name]', 'js'),
publicPath: devMode ? 'http://localhost:3000/' : '/'
},
resolve: {
extensions: [
'.js', '.jsx', '.json',
'.css', '.scss',
'.jpeg', '.jpg', '.gif', '.png', '.svg', '.woff', '.ttf', '.wav', '.mp3'
],
modules: [
path.resolve(__dirname, '../src'),
'node_modules'
]
},
plugins,
module: {
rules: [
{
test: /\.jsx?$/,
loader: 'babel-loader',
sideEffects: false,
include: path.join(__dirname, '../src')
},
{
test: /\.s?css$/,
use: [
devMode ? 'style-loader' : MiniCssExtractPlugin.loader,
{
loader: 'css-loader',
options: {
modules: true,
importLoaders: 1,
localIdentName: '[name]__[local]___[hash:base64:5]'
}
},
{
loader: 'postcss-loader',
options: {
ident: 'postcss',
plugins: () => [
require('postcss-flexbugs-fixes'),
autoprefixer({
browsers: [
'>1%',
'last 4 versions',
'Firefox ESR',
'not ie < 9', // React doesn't support IE8 anyway
],
flexbox: 'no-2009',
}),
],
},
},
]
},
{
test: /\.ya?ml$/,
use: ['json-loader', 'yaml-loader']
},
{
test: /\.jpe?g$|\.gif$|\.png$|\.svg$|\.woff$|\.ttf$|\.wav$|\.mp3$/,
use: {
loader: 'file-loader',
options: {
name: '[path][name].[hash].[ext]'
}
}
}
]
}
};
|
import React from 'react';
import { connect } from 'react-redux';
import { removeFromCart } from '../../Redux/Action/CartAction';
const Cart = (props) => {
console.log(props)
const{cart,removeFromCart} = props
return (
<div>
<h2>This is cart{cart.length}</h2>
<ul>
{
cart.map(ct=><li>{ct}
<button onClick={()=>removeFromCart(ct)}>X</button>
</li>)
}
</ul>
</div>
);
};
const mapstateToProps=state =>{
return{
cart: state.cart
}
}
const mapdispatchToProps={
removeFromCart:removeFromCart
}
export default connect(mapstateToProps, mapdispatchToProps) (Cart);
|
/*Criando um array*/
var cursos = new Array("HTML","CSS","JavaScript","Python","Java","C#","C++");
console.log(cursos);
/*Acessando um array*/
/*Primeiro valor do array*/
console.log("Primeiro curso-> "+cursos[0]);
/*Definindo o tamanho do array antes de inserir valores*/
var dias = new Array(7);
dias[0] = "Domingo";
dias[1] = "Segunda-Feira";
dias[2] = "Terça-Feira";
dias[3] = "Quarta-Feira";
dias[4] = "Quinta-Feira";
dias[5] = "Sexta-Feira";
dias[6] = "Sábado";
console.log("Dias da Semana -> "+dias);
/*Também é possível criar arrays sem definir seu tamanho no momento da criação*/
var frutas = new Array();
frutas[0] = "Maçã";
frutas[1] = "Banana";
frutas[2] = "Abacaxi";
frutas[3] = "Abacate";
frutas[4] = "Uva";
frutas[5] = "Morango";
frutas[6] = "Manga";
frutas[7] = "Pêssego";
frutas[8] = "Ameixa";
frutas[9] = "Pera";
frutas[10] = "Melancia";
frutas[11] = "Mamão";
console.log("Frutas -> "+frutas);
/*Descobrindo a quantidade de elementos do array*/
var qtd = frutas.length;
console.log("O array frutas possui uma quantidade de "+qtd+" tipos de fruta");
/*Combinando arrays*/
var valores1 = new Array(6);
valores1[0] = 1;
valores1[1] = 2;
valores1[2] = 3;
valores1[3] = 4;
valores1[4] = 5;
var valores2 = new Array(5);
valores2[0] = 6;
valores2[1] = 7;
valores2[2] = 8;
valores2[3] = 9;
valores2[4] = 10;
var valores = valores1.concat(valores2);
valores = valores1 + valores2;
console.log("Apenas os valores do primeiro array -> "+valores1);
console.log("Apenas os valores do segundo array -> "+valores2);
console.log("Todos os valores -> "+valores);
/*Arrays associativos*/
var aluno = [];
aluno["media"] = 8.7;
aluno["nome"] = "Maria";
console.log("Parabéns! "+aluno["nome"]+" você foi aprovada com média "+aluno["media"]);
|
function log(){
console.log("button worked");
};
|
import React, { Component } from 'react'
import { Link } from 'react-router-dom'
import { isOwner } from './../lib/helpers'
/**
A single milestone
**/
class Milestone extends Component {
render(){
const { model, removeMilestone, currentUser } = this.props
return(
<div className="card">
<img className="card-img-top" src={model.image} alt=""/>
<div className="card-body">
<Link to={`/campaigns/${ model.campaignId }/milestones/${ model._id}`}>
<h4 className="card-title">{model.title}</h4>
</Link>
<div className="card-text" dangerouslySetInnerHTML={{__html: model.description}}></div>
{ isOwner(model.ownerAddress, currentUser) &&
<div>
<a className="btn btn-link" onClick={removeMilestone}>
<i className="fa fa-trash"></i>
</a>
<Link className="btn btn-link" to={`/campaigns/${ model.campaignId }/milestones/${ model._id}/edit`}>
<i className="fa fa-edit"></i>
</Link>
</div>
}
</div>
</div>
)
}
}
export default Milestone
|
function lockedProfile() {
Array.from(document.querySelectorAll('.profile button')).forEach(b => b.addEventListener('click', onToggle));
function onToggle(ev) {
const profile = ev.target.parentElement;
const isActive = profile.querySelector('input[type="radio"][value="unlock"]').checked;
if (isActive) {
const infoDiv = profile.querySelector('div');
if (ev.target.textContent == 'Show more') {
infoDiv.style.display = 'block';
ev.target.textContent = 'Hide it';
} else {
infoDiv.style.display = '';
ev.target.textContent = 'Show more';
}
}
}
}
|
// Generated by CoffeeScript 1.3.3
/*
SlideBaseClient.js
------------------------------------------------
author: [Takeharu Oshida](http://about.me/takeharu.oshida)
version: 0.1
licence: [MIT](http://opensource.org/licenses/mit-license.php)
*/
(function() {
var socket;
console.log("This is Client Side Script");
window.sbClient = {
admin: false,
lock: false,
page: {
current: 0,
last: null
},
Model: {},
Collection: {},
View: {},
Instances: {},
option: {
animation: '',
theme: 'default'
},
plugins: {},
pushMethods: {
'move': true
},
isDisplayHelp: false,
userList: {},
init: function(opts) {
var ctl, help, wrap;
if (opts == null) {
opts = {};
}
_.each(opts, function(val, key) {
return sbClient.option[key] = val;
});
wrap = document.createElement('div');
wrap.id = 'wrap';
wrap.display = 'none';
ctl = document.createElement('div');
ctl.id = 'ctl';
$(ctl).addClass('ctl').append("<button class='btn' id='back'>←</button><button class='btn' id='next'>→</button>");
help = document.createElement('div');
help.id = 'help';
$(help).addClass('help hide').append("<h4 id='usage'><span id='close'>✖</span> Usage</h4>");
$('body').append(wrap).append(ctl).append(help);
$('#close').bind('click', function() {
$('#help').addClass('hide');
return sbClient.isDisplayHelp = false;
});
return this.Instances.slideView = new sbClient.View.Slide();
},
resizeSlide: function() {
return $('.slide').each(function() {
return $(this).css({
'height': $(window).height() - 72,
'width': $(window).width() - 72
});
});
},
execEmit: function(name, data) {
var obj;
console.log("execEmit " + name);
obj = {
name: 'plugin',
plugin: {
name: name
},
data: data
};
return $('body').trigger('execEmit', obj);
},
isEnableServerPush: function(method) {
return this.pushMethods[method];
},
isEnablePlugin: function(obj) {
if (!obj.plugin || !obj.plugin.name) {
return false;
}
return this.isEnableServerPush(obj.plugin.name);
},
move: function(obj) {
if (this.isEnableServerPush('move')) {
return this.Instances.slideView.trigger('execMove', obj.data);
}
},
setUserList: function(userList) {
return this.userList = userList;
},
nextSlide: function(slide) {
var tmp;
tmp = document.createElement('div');
tmp.id = "slide_" + (slide.get('page'));
return $(tmp).addClass(slide.get('class')).addClass('slide current').append(slide.get('elements'));
},
simpleMove: function(slide) {
var next;
next = this.nextSlide(slide);
$('#wrap').empty().removeClass().append(next);
this.resizeSlide();
return this.lock = false;
},
fadeMove: function(slide) {
var next;
next = this.nextSlide(slide);
$('#wrap').fadeOut(250, function() {
$('#wrap').empty().removeClass().append(next);
return sbClient.resizeSlide();
});
return $('#wrap').fadeIn(500, function() {
return this.lock = false;
});
},
positionMove: function(x, y, z, direction, nextpage) {
if (direction < 0) {
direction += 1;
}
return $('#wrap > .slide').each(function(i, e) {
var css, xx, yy, zz;
xx = x * (i - nextpage);
yy = y * (i - nextpage);
zz = z * (i - nextpage);
css = {
"transform": "translate3d(" + xx + "px," + yy + "px," + zz + "px)"
};
return $(e).css(css);
});
},
horizontalMove: function(direction, nextpage) {
this.positionMove($(window).width(), 0, 0, direction, nextpage);
return this.lock = false;
},
verticalMove: function(direction, nextpage) {
this.positionMove(0, $(window).height(), 0, direction, nextpage);
return this.lock = false;
}
};
sbClient.Model.Slide = Backbone.Model.extend({
elements: '',
"class": '',
page: ''
});
sbClient.Collection.Slides = Backbone.Collection.extend({
model: sbClient.Model.Slide,
fetch: function() {
var self;
self = this;
_($('section')).each(function(section, index) {
var slide;
slide = new sbClient.Model.Slide({
elements: $(section).contents(),
"class": $(section).attr('class'),
page: index
});
self.add(slide);
return $(section).remove();
});
sbClient.page.last = self.length;
return self.trigger('ready');
}
});
sbClient.View.Slide = Backbone.View.extend({
el: $('body'),
initialize: function() {
var self;
self = this;
self.collection = new sbClient.Collection.Slides();
_.bindAll(this, 'render', 'dispHelp', 'moveSlide', 'handleKey');
self.$el.bind('keydown', self.handleKey);
self.$el.bind('swipeleft', self.moveSlide(1));
self.$el.bind('swiperight', self.moveSlide(-1));
$('#next').bind('click', function() {
return self.moveSlide(1);
});
$('#back').bind('click', function() {
return self.moveSlide(-1);
});
self.on('execMove', function(event) {
var args, data;
args = Array.prototype.slice.apply(arguments);
data = args[0];
if (data.currentPage === sbClient.page.current) {
return self.moveSlide(data.direction);
}
});
self.collection.on('ready', function() {
return self.render();
});
return self.collection.fetch();
},
render: function() {
var append, appendAll, self;
self = this;
append = function(className, page, css) {
var id, slide, tmp;
slide = (self.collection.where({
page: page
}))[0];
id = slide.get('page');
tmp = document.createElement('div');
tmp.id = "slide_" + id;
$(tmp).addClass(className).addClass(slide.get('class')).append(slide.get('elements'));
if (css) {
$(tmp).css(css);
}
sbClient.resizeSlide();
return $("#wrap").append($(tmp));
};
appendAll = function(x, y, z) {
return self.collection.each(function(slide, i) {
var css;
css = {
"transform": "translate3d(" + (x * i) + "px," + (y * i) + "px," + (z * i) + "px)"
};
if (i === 0) {
append("slide current transform", 0, css);
return location.hash = i;
} else {
return append("slide transform", i, css);
}
});
};
switch (sbClient.option.animation) {
case 'horizontal':
appendAll($(window).width(), 0, 0);
break;
case 'vertical':
appendAll(0, $(window).height(), 0);
break;
case 'fade':
append('slide current', 0);
break;
default:
append('slide current', 0);
}
return sbClient.lock = false;
},
handleKey: function(event) {
var alt, cmd, code, ctrl, shift;
code = event.keyCode || event.which;
ctrl = event.ctrlKey;
alt = event.altKey;
shift = event.shiftKey;
cmd = event.metaKey;
if ((code === 32) || (code === 39)) {
if (sbClient.isDisplayHelp) {
return;
}
event.preventDefault;
this.moveSlide(1);
}
if ((code === 8) || (code === 37)) {
if (sbClient.isDisplayHelp) {
return;
}
event.preventDefault;
this.moveSlide(-1);
}
if ((ctrl || cmd) && shift && code === 191) {
event.preventDefault;
return this.dispHelp();
}
},
moveSlide: function(direction) {
var next, nextpage, obj, self;
self = this;
if (sbClient.lock) {
return;
}
nextpage = sbClient.page.current + direction;
next = self.collection.at(nextpage);
if (next) {
obj = {
name: 'move',
data: {
direction: direction,
currentPage: sbClient.page.current
}
};
$('body').trigger('execEmit', obj);
sbClient.lock = true;
switch (sbClient.option.animation) {
case 'horizontal':
sbClient.horizontalMove(direction, nextpage);
break;
case 'vertical':
sbClient.verticalMove(direction, nextpage);
break;
case 'fade':
sbClient.fadeMove(next);
break;
default:
sbClient.simpleMove(next);
}
sbClient.page.current = nextpage;
location.hash = sbClient.page.current;
return sbClient.lock = false;
}
},
dispHelp: function() {
console.log("Help!");
if (sbClient.isDisplayHelp) {
$('#help').removeClass('disp').addClass('hide');
return sbClient.isDisplayHelp = false;
} else {
$('#help').removeClass('hide').addClass('disp');
return sbClient.isDisplayHelp = true;
}
}
});
sbClient.Model.Plugin = Backbone.Model.extend({
defaults: {
id: '',
name: '',
callback: '',
element: '',
initialScript: function() {}
},
initialize: function() {
var self;
self = this;
return $(function() {
var name, script;
name = self.get('name');
sbClient.plugins[name] = self;
sbClient.pushMethods[name] = true;
$('#help').append(self.get('element'));
script = self.get('initialScript') || {};
return script();
});
}
});
socket = typeof io !== "undefined" && io !== null ? io.connect("http://" + location.host) : void 0;
if (socket != null) {
socket.on('error', function(reason) {
return console.error('Unable to connect Socket.IO', reason);
});
}
if (socket != null) {
socket.on('connect', function() {
console.log('client connected');
$('body').on('execEmit', function(event, obj) {
return socket.emit(obj.name, obj);
});
socket.on('users', function(userList) {
return sbClient.setUserList(userList);
});
socket.on('move', function(obj) {
return sbClient.move(obj);
});
socket.on('plugin', function(obj) {
var func;
if (sbClient.isEnablePlugin(obj)) {
func = sbClient.plugins[obj.plugin.name].get("callback") || {};
return func(obj.data);
}
});
return socket.on('disconnect', function() {
$('body').off('execEmit');
return console.log('disconnected Bye!');
});
});
}
$(function() {
sbClient.resizeSlide();
$(window).bind('resize', function() {
return sbClient.resizeSlide();
});
return $('a').bind('click', function(e) {
e.stopPropagation();
e.preventDefault();
return window.open(this.href, '_blank');
});
});
}).call(this);
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.