text
stringlengths 7
3.69M
|
|---|
layui.config({
base : "js/"
}).use(['form','layer','jquery','laypage'],function(){
var form = layui.form(),
layer = parent.layer === undefined ? layui.layer : parent.layer,
laypage = layui.laypage,
$ = layui.jquery;
//执行加载页面数据
Load();
//加载页面函数
function Load() {
$.post("../../Handle.ashx", { "parameter": "Links" }, function (data) {
//data.Data[index].ID
var data = JSON.parse(data);
var newArray = [];
//转换
newsData = data.Data;
//正常加载信息
//执行加载数据的方法
linksList(newsData);
});
};
//添加友情链接
$(".linksAdd_btn").click(function(){
var index = layui.layer.open({
title : "添加友情链接",
type : 2,
content : "linksAdd.html",
success : function(layero, index){
layui.layer.tips('点击此处返回友情链接列表', '.layui-layer-setwin .layui-layer-close', {
tips: 3
});
}
})
//改变窗口大小时，重置弹窗的高度，防止超出可视区域（如F12调出debug的操作）
$(window).resize(function(){
layui.layer.full(index);
})
layui.layer.full(index);
})
//操作
$("body").on("click",".links_edit",function(){ //修改
var webID, webUrl, webName, webEmail,sort;
var Eq = $(this).parent("td").parent("tr").index();
Eq = Eq + 1;
//var Eq = 0;
sort = $("tr").eq(Eq).find(".sort").text();
webID = $("tr").eq(Eq).find(".webid").text();
webUrl = $("tr").eq(Eq).find(".webUrl").text();
webName = $("tr").eq(Eq).find(".webName").text();
webEmail = $("tr").eq(Eq).find(".ContactEMail").text();
//console.log(Eq);
//console.log(webID);
//console.log(webUrl);
//console.log(webName);
//console.log(webEmail);
//revise
$.post("../../Handle.ashx", { "parameter": "ReviseLinks", "webID": webID, "webUrl": webUrl, "webName": webName, "webEmail": webEmail, "sort": sort }, function (data) {
//layer.alert('您点击了友情链接编辑按钮，但系统正在开发中，所以暂时不存在编辑内容，后期会添加，敬请谅解。。。', { icon: 6, title: '友链编辑' });
var data = JSON.parse(data);
layer.msg(data.Info);
});
})
$("body").on("click",".links_del",function(){ //删除
var _this = $(this);
layer.confirm('确定删除此信息？', { icon: 3, title: '提示信息' }, function (index) {
$.post("../../Handle.ashx", { "parameter": "deleteLinks", "id": _this.attr("data-id") }, function (data) {
var data = JSON.parse(data);
layer.msg(data.Info);
//_this.parents("tr").remove();
for (var i = 0; i < linksData.length; i++) {
if (linksData[i].webID == _this.attr("data-id")) {
linksData.splice(i, 1);
linksList(linksData);
}
}
layer.close(index);
});
});
})
function linksList(that){
//渲染数据
function renderDate(data,curr){
var dataHtml = '';
if(!that){
currData = linksData.concat().splice(curr*nums-nums, nums);
}else{
currData = that.concat().splice(curr*nums-nums, nums);
}
if(currData.length != 0){
for (var i = 0; i < currData.length; i++) {
var s = currData[i].tjtime//乱码的时间
var data1 = s.substring(6, 16)//截取
var tiems = getLocalTime(data1)//转换
function getLocalTime(nS) {//时间转换函数
return new Date(parseInt(nS) * 1000).toLocaleString().substr(0, 17)
}
dataHtml += '<tr>'
+ '<td class="webid">' + currData[i].ID + '</td>'
+ '<td class="webUrl" contenteditable="true">' + currData[i].URLLink + '</td>'
+ '<td class="webName" align="left" contenteditable="true">' + currData[i].Name + '</td>'
+ '<td class="sort" contenteditable="true">' + currData[i].SerialNumber + '</td>'
+ '<td class="ContactEMail" contenteditable="true">' + currData[i].ContactEMail + '</td>'
+ '<td>' + tiems + '</td>'//时间
//+ '<td>' + currData[i].Switch + '</td>'//启用 要改
+'<td>'
+ '<a class="layui-btn layui-btn-mini links_edit"><i class="iconfont icon-edit"></i> 修改</a>'
+ '<a class="layui-btn layui-btn-danger layui-btn-mini links_del" data-id="' + data[i].ID + '"><i class="layui-icon"></i> 删除</a>'
+'</td>'
+'</tr>';
}
}else{
dataHtml = '<tr><td colspan="7">暂无数据</td></tr>';
}
return dataHtml;
}
//分页
var nums = 8; //每页出现的数据量
if(that){
linksData = that;
}
laypage({
cont : "page",
pages : Math.ceil(linksData.length/nums),
jump : function(obj){
$(".links_content").html(renderDate(linksData,obj.curr));
$('.links_list thead input[type="checkbox"]').prop("checked",false);
form.render();
}
})
}
})
|
const fs = require('fs');
const path = require('path');
const inquirer = require('inquirer');
const EthereumUtils = require('ethereumjs-util');
const AEToken = require('../build/AEToken.json');
const api = require('./api');
const DEPLOYED_ADDRESS_FILEPATH = path.resolve(__dirname, '../.last-contract-address');
let defaultAddress = undefined;
try {
defaultAddress = fs.readFileSync(DEPLOYED_ADDRESS_FILEPATH).toString().trim();
} catch (e) {}
let ok = true;
inquirer.prompt([ {
default: defaultAddress,
type: 'input',
name: 'address',
message: 'What is the contract address:',
validate: (input) => {
return EthereumUtils.isValidAddress(input);
}
} ])
.then(({ address }) => {
const contract = api.newContract(AEToken.abi, address);
return contract.instance.prefilled.call();
})
.then((result) => {
if (!ok) {
process.exit(1);
}
console.log("contract launched: ", result);
})
.catch((error) => {
console.error(error);
process.exit(1);
});
|
class ClanLocation {
constructor(clanLocationData) {
this.id = clanLocationData.id;
this.name = clanLocationData.name;
this.isCountry = clanLocationData.isCountry;
}
}
module.exports = ClanLocation;
|
import React, { Component } from 'react';
import {
Platform,
StyleSheet,
Text,
View,
TouchableOpacity,
FlatList,
ActivityIndicator,
RefreshControl,
NetInfo,
Image,
Modal,
ToastAndroid,
AsyncStorage,
} from 'react-native';
import Base64 from 'base-64'
import checkConnection from "./functions/checkConnection";
import fetchAPI from "./functions/fetchAPI";
import asyncSetItem from "./functions/asyncSetItem"
import asyncGetItem from "./functions/asyncGetItem"
import displayModal from "./functions/displayModal"
import backHandler from "./functions/backHandler";
export default class App extends Component<{}> {
constructor(props) {
super(props);
this.state = {
refreshing: false,
isLoading: true,
modalVisible: false,
data:'',
selectedText:'',
address:'',
};
}
static screenName = 'movies';
_onRefresh() {
this.setState({refreshing: true, isLoading: true, });
this.handleConnection()
}
componentWillMount() {
backHandler(App.screenName)
NetInfo.isConnected.addEventListener(
'connectionChange',
this.handleConnection
);
this.handleConnection();
}
openModal(iYear) {
this.setState(displayModal(iYear))
this.setState({modalVisible:true});
}
closeModal() {
this.setState({modalVisible:false});
}
handleConnection= () => {
checkConnection()
.then( (isConnected)=> {
this.proceedHandleConnection(isConnected)
})
}
proceedHandleConnection=((isConnected)=>{
if (isConnected) {
this.fetchMovies();
this.setState({refreshing: false, isLoading: false,});
}
else{
asyncGetItem('MovieList')
.then((value) => {
this.proceedHandleConnectionIfNotConnected(value)
})
.catch((error) => {
ToastAndroid.show(
'you need an active internet connection...',
ToastAndroid.LONG,
ToastAndroid.BOTTOM
)
});
}
})
proceedHandleConnectionIfNotConnected=((value)=>{
if(value==null){
ToastAndroid.show(
'you need an active internet connection to fetch movies...',
ToastAndroid.LONG,
ToastAndroid.BOTTOM
)
this.setState({refreshing: false, isLoading: false,});
}
else{
ToastAndroid.show(
'you are offline...',
ToastAndroid.LONG,
ToastAndroid.BOTTOM
)
asyncGetItem('MovieList')
.then((myArray) => {
//alert(JSON.parse(myArray))
this.setState({data: JSON.parse(myArray), isLoading: false});
this.setState({refreshing: false, isLoading: false,});
})
}
})
fetchMovies= () =>{
fetchAPI('https://facebook.github.io/react-native/movies.json')
.then((responseJson)=>{
asyncSetItem('MovieList', JSON.stringify(responseJson.movies))
.then(()=> {
this.setState({data: responseJson.movies, isLoading: false});
})
}).catch((error) => {
ToastAndroid.show(
'unable to fetch movies...',
ToastAndroid.LONG,
ToastAndroid.BOTTOM
);
});
}
render() {
const {isLoading} = this.state;
return (
<View style={styles.container}>
<Modal
transparent={ true}
visible={this.state.modalVisible}
animationType={'slide'}
onRequestClose={() => this.closeModal()}
>
<View style={styles.innerContainer}>
<Text style={{color:'white', marginLeft: 30, marginRight: 30, textAlign:'center'}}>{this.state.selectedText} </Text>
<Image
style={{height:180, width:120}}
source={{uri: this.state.address}}
/>
<TouchableOpacity onPress={() => this.closeModal()}>
<Text style={{color:'white', fontSize:21, }}> Close </Text>
</TouchableOpacity>
</View>
</Modal>
<View style={styles.header}>
<View style={styles.inHeader}>
</View>
<Image source={{uri: 'http://icons.iconseeker.com/png/fullsize/sticker-system/movie-7.png'}} style={styles.hImage}/>
</View>
<View style={styles.container}>
{isLoading && (
<ActivityIndicator
style={{ height: 90 }}
color="#C00"
size="large"
/>
)}
<FlatList
accessibilityLabel={"list"}
refreshControl={
<RefreshControl
refreshing={this.state.refreshing}
onRefresh={this._onRefresh.bind(this)}
/>}
style={{flexWrap:'nowrap', }}
data={this.state.data}
renderItem={({item}) =>
<TouchableOpacity onPress={()=>{this.openModal(item.releaseYear)}}>
<View style={styles.text} >
<Image source={{uri: 'http://www.escapeintolife.com/wp-content/uploads/2010/07/dk.png'}}
style={styles.mImage} />
<View style={{flexDirection:'column', flexWrap:'nowrap'}}>
<Text style={{color:'rgb(0,0,0)',}}> Title: {item.title}</Text>
<Text style={{color:'rgb(100,100,100)'}}> {item.releaseYear}</Text>
</View>
</View>
</TouchableOpacity>
}
keyExtractor={(item, index) => index}
/>
</View>
</View>
);
}
}
const styles = StyleSheet.create({
header: {
height:120,
justifyContent: 'space-around',
alignItems: 'center',
backgroundColor: 'transparent',
},
inHeader: {
position:'absolute',
top:0,
height:70,
width:430,
alignItems: 'center',
backgroundColor: 'rgb(25,145,238)',
},
hImage:{
position:'absolute',
top:6,
height:102,
width:100,
margin: 5,
flexWrap:'nowrap',
},
container: {
flex: 1,
//backgroundColor: 'rgb(250,250,250)',
},
modalContainer: {
flex:1,
backgroundColor: 'transparent',
},
innerContainer: {
position:'absolute',
top:200,
bottom:0,
left:0,
right:0,
alignItems:'center',
justifyContent:'space-around',
backgroundColor: 'rgba(0,0,0,0.9)',
},
button: {
height:50,
width:300,
backgroundColor: 'rgb(0,197,206)',
alignItems: 'center',
justifyContent: 'center',
borderRadius: 10,
//align: 'end',
},
text: {
flexDirection: 'row',
height:90,
alignItems:'center',
elevation:3,
backgroundColor:'rgb(255,255,255)',
margin:6,
flexWrap:'nowrap',
},
mImage:{
height:81,
width:50,
margin: 5,
flexWrap:'nowrap',
}
});
|
import Vue from 'vue'
// Google Maps
// https://github.com/s-oehding/vue-google-maps
import * as VueGoogleMaps from 'vue2-google-maps'
Vue.use(VueGoogleMaps, {
load: {
key: 'AIzaSyBT99ywTt8pGhgHkeYY9kxbtOjlFH8OqRc'
}
})
import Navbar from './components/partials/Navbar'
Vue.component('navbar', Navbar)
import Preloader from './components/partials/Preloader'
Vue.component('preloader', Preloader)
import Sidebar from './components/partials/Sidebar'
Vue.component('sidebar', Sidebar)
import PageContent from './components/partials/PageContent'
Vue.component('pagecontent', PageContent)
import Gravatar from './components/Gravatar'
Vue.component('gravatar', Gravatar)
import Forecast from './components/forecast/Forecast'
Vue.component('forecast', Forecast)
import ForecastGraph from './components/forecast/ForecastGraph'
Vue.component('forecast-graph', ForecastGraph)
import DateTime from './components/DateTime'
Vue.component('datetime', DateTime)
import GMap from './components/google/GMap'
Vue.component('g-map', GMap)
|
import Mock from 'mockjs';
Mock.setup({timeout:500})//设置网络延迟
// let Random = Mock.Random()
Mock.mock('introduction/', 'POST', {
// Mock.Random 提供的完整方法（占位符）：https://github.com/nuysoft/Mock/wiki/Mock.Random
"code":200,
"userId":"@id()",
"date":"@date",
"image":"@image('300x300', 'red', '#fff', 'jpg', '这是一张随机生成的图片！')"
})
|
const helper = {
toggleVisibility: (goHidden, goVisibile) => {
goHidden.style.visibility = 'hidden';
goVisibile.style.visibility = 'visible';
},
toggleCssClass: (element, removeClass, addClass) => {
element.classList.add(addClass);
element.classList.remove(removeClass);
},
audioIsPlaying: () => {
return japaneseAudioRecording
&& japaneseAudioRecording.currentTime > 0
&& !japaneseAudioRecording.paused
&& !japaneseAudioRecording.ended
&& japaneseAudioRecording.readyState > 2;
},
toggleAudio: (audioElem) => {
if (helper.audioIsPlaying()) {
audioElem.pause();
}
else {
audioElem.play();
}
},
progressBarWidth: (phraseProgressPiles) => {
let progressPercent = 0;
let pointsEarned = 0;
let totalPointsAvailable = 4 * phraseJSON.length;
for (let i = 1; i < phraseProgressPiles.length; i++ ) {
pointsEarned += phraseProgressPiles[i].length * i
}
progressPercent = (pointsEarned / totalPointsAvailable) * 100;
return (Math.max(1,progressPercent)) + '%';
},
updateProgressBar: () => {
document.getElementById('progress-bar').style.width = helper.progressBarWidth(phraseProgressPiles);
}
,
findLowestProgPile: (phraseProgressPiles, lowestProgressPile) => {
for (let i = 4; i >= 0; i--) {
if (phraseProgressPiles[i].length > 0){
lowestProgressPile = i;
}
}
return lowestProgressPile;
},
elementsToUpdateNextCard: {
'english-text': 'englishText',
'japanese-text': 'japaneseText',
'english-number': 'cardNumber',
'japanese-number': 'cardNumber'
},
returnCurrentCard: (phraseProgressPiles,lowestProgressPile ) => {
return phraseJSON[phraseProgressPiles[lowestProgressPile][0]]
}
,updateTextOnFlashcard: (currentCard) => {
Object.keys(helper.elementsToUpdateNextCard).forEach(element => {
document.getElementById(element).innerText = currentCard[helper.elementsToUpdateNextCard[element]];
} )
},
getCurrentAudio: (currentCard) => {
return new Audio(currentCard.audioLink);
},
placeJapaneseAudio: () => {
document.getElementById('audio-link').addEventListener('click',() => {
helper.toggleAudio(japaneseAudioRecording);
});
}
}
|
String.prototype.padCenter = function (num, val) {
if (!num || !val) {
return this
}
var len = strWidth(this)
var valLen = val.length
var left, right;
num -= len
if (num % 2 != 0) {
left = parseInt(num / 2)
right = parseInt(num / 2) + 1
var start = val.repeat(left)
var end = val.repeat(right)
return start + this + end
} else {
left = parseInt(num / 2)
var start = val.repeat(left)
var end = val.repeat(left)
return start + this + end
}
}
function strWidth(str) {
var w = str.length, l = w;
for (var i = 0; i < l; i++)
if (str.charCodeAt(i) > 128)
w++;
return w;
}
module.exports = String
|
import { createRouter } from 'router5'
import browserPlugin from 'router5/plugins/browser'
import listenersPlugin from 'router5/plugins/listeners'
const routes = [
{name: 'home', path: '/'},
{name: 'login', path: '/login'},
{name: 'welcome', path: '/welcome'}
]
const settings = {
defaultRoute: 'home',
defaultParams: {},
trailingSlash: false,
useTrailingSlash: undefined
}
const Router = createRouter(routes, settings)
Router.usePlugin(browserPlugin({
useHash: true,
hashPrefix: '!'
}))
Router.usePlugin(listenersPlugin())
export default Router
|
var express = require('express');
var router = express.Router();
/* GET home page. */
router.get('/', function(req, res, next) {
res.render('login', { title: '登录' });
});
router.post('/req', function(req, res, next) {
let logindata = [
{name: 'admin', password: 'zhangaobolilei'},
{name: 'admin1', password: 'zhangaobo'},
{name: 'admin2', password: 'lilei'},
{name: 'admin3', password: 'ceshi'},
];
let data;
for(let i=0; i<logindata.length; i++){
if(logindata[i].name === req.body.name && logindata[i].password === req.body.password){
data = {
code:200,
msg:"登录成功"
};
req.session.loginInfo = {
name: req.body.name,
password: req.body.password,
states:1
};
break;
}else{
data = {
code:500,
msg:"用户名或密码错误"
};
}
}
res.send(JSON.stringify(data));
});
module.exports = router;
|
import * as React from "react";
function Footer(props) {
return (
<div className="footer">
<div className="ownership">
<span>版权所有 2004-2017 ICP证：沪B2-20150087</span>
</div>
</div>
);
}
export default Footer;
|
const client = () => {
const that = {}
that.clients = []
that.fillObject = clients => {
clients.forEach(el => {
that.clients[el.id_client] = new objClient(el)
})
}
/**
* Metodo cria a table usada para pesquisa dos clientes ao incluir um traffic
*/
that.fillTableForSearchTrafficClient = () => {
const table = z('form_search_body')
let html = ''
that.clients.forEach(el => {
html +=
`<tr id_client="${el.id_client}">
<td>${el.name}</td>
<td>${el.phone ? el.phone : ''}</td>
</tr>
`
})
table.innerHTML = html
}
/**
* Metodo cria a table usada para pesquisa dos clientes na tela de clientes
*/
that.fillTableForSearchClient = () => {
const table = z('table_clients')
that.clients.forEach(el => {
that.append(that.clients[el.id_client], 'table_clients')
})
}
/**
* Metodo realiza a alteração da tabela de pesquisa de clientes com um novo cliente criado
* @param {object} client
*/
that.append = (client, id) => {
const table = z(id)
const old = document.querySelector(`#${id} tr[id_client="${config.cache.id_client}"]`)
if (old) {
old.remove()
}
const tr = document.createElement('tr')
tr.setAttribute('id_client', client.id_client)
const tdName = document.createElement('td')
tdName.textContent = client.name
const tdPhone = document.createElement('td')
tdPhone.textContent = client.phone ? client.phone : ''
tr.appendChild(tdName)
tr.appendChild(tdPhone)
table.appendChild(tr)
}
/**
* Metodo invocado principalmente pelo traffic para atualizar os objetos na memoria
* @param {object} client
*/
that.updateLocalObject = (client) => {
config.cache.id_client = client.id_client
if (!that.clients[client.id_client]) {
that.clients[client.id_client] = new objClient(client)
return that.append(that.clients[client.id_client], 'form_search_body')
}
that.clients[client.id_client].set(client)
}
/**
* Metodo seleciona o cliente dentro de um search criado pelo formSearchClient
* @param {event click} e
*/
that.selectUserFromSearch = (e) => {
const id_client = e.target.parentNode.getAttribute('id_client')
that.fillFormClient(id_client)
z('form_search').style.display = 'none'
}
/**
* Meodo realiza a pesquisa de clientes na memoria
* @param {event da digitação} e
*/
that.formSearchClient = e => {
const val = e.target.value.toLowerCase()
const table = z('form_search_body')
const search = z('form_search')
if (val.length === 0) {
search.style.display = 'none'
return false
}
search.style.display = 'table'
let anyRegister = false
const length = table.rows.length
if (length === 0) return search.style.display = 'none'
for (let i = 0; i < length ; i++) {
const td = table.rows[i].cells[0].innerText;
const isSimilar = td.toLowerCase().indexOf(val) >= 0;
if (isSimilar) {
anyRegister = true
table.rows[i].style.display = ''
continue
}
if (i === (length - 1) && anyRegister === false) {
search.style.display = 'none'
}
table.rows[i].style.display = 'none'
}
}
/**
* Metodo responsavel por poreencher os dados do cliente no formulario do traffic e colocar a variavel no cache
* @param {int} id_client
*/
that.fillFormClient = (id_client) => {
config.cache.id_client = id_client
config.form.name.value = that.clients[id_client].name
config.form.phone.value = that.clients[id_client].phone
}
/**
* Metodo realiza a pesquisa na tela de clientes
*/
that.searchClientTable = e => {
const val = e.target.value.toLowerCase()
const table = z('table_clients')
const length = table.rows.length
for (let i = 0; i < length ; i++) {
const td = table.rows[i].cells[0].innerText;
const td2 = table.rows[i].cells[1].innerText;
const isSimilar = td.toLowerCase().indexOf(val) >= 0;
const isSimilar2 = td2.toLowerCase().indexOf(val) >= 0;
if (isSimilar || isSimilar2) {
table.rows[i].style.display = ''
continue
}
table.rows[i].style.display = 'none'
}
}
/**
* Metodo pega todos os clientes cadastrados no servidor e carrega pra memoria
*/
that.getClientsToMemory = () => {
lib.ajax({
s: 'client',
a: 'get',
type: 'GET',
data: {},
}, (response) => {
that.fillObject(response.clients)
that.fillTableForSearchTrafficClient()
that.fillTableForSearchClient()
})
}
that.editClient = () => {
that.clients[config.cache.id_client].update({
client: {
id_client: config.cache.id_client,
name: z('form_client_name').value.trim(),
phone: z('form_client_phone').value.trim()
}
}, (response) => {
if (response.status === false) {
return bootbox.alert(response.err)
}
const tr = document.querySelector(`#table_clients tr[id_client="${config.cache.id_client}"]`)
tr.childNodes[0].textContent = that.clients[config.cache.id_client].name
tr.childNodes[1].textContent = that.clients[config.cache.id_client].phone
that.append(that.clients[config.cache.id_client], 'form_search_body')
that.append(that.clients[config.cache.id_client], 'form_search_body')
bootbox.alert('Cliente atualizado com sucesso!')
})
}
that.getEditClient = e => {
const id_client = e.target.parentNode.getAttribute('id_client')
const client = that.clients[id_client]
z('form_client_name').value = client.name
z('form_client_phone').value = client.phone
config.cache.id_client = id_client
}
that.headerClients = () => {
config.show('clients')
}
that.headerReportClients = () => {
const table = z('table_report_clients')
table.innerHTML = '<i class="fa fa-spinner fa-spin fa-3x fa-fw"></i>'
config.show('reportClients')
let html = ''
lib.ajax({
s: 'report',
a: 'bestClients',
type: 'GET',
data: {},
}, (response) => {
response.clients.forEach(client => {
html += `<tr>
<td>${client.name}</td>
<td>${client.phone ? client.phone : ''}</td>
<td>${client.total}</td>
</tr>`
})
table.innerHTML = html
z('totalSpanReportClients').textContent = response.clients.length
})
}
/**
* Metodo construct
*/
that.init = () => {
that.getClientsToMemory()
z('reportBestClients', that.headerReportClients)
z('header_clients', that.headerClients)
z('search_table_input', that.searchClientTable, 'input')
z('form_client_save', that.editClient)
z('table_clients', that.getEditClient)
z('form_parking_name', that.formSearchClient, 'input')
z('form_search_body', that.selectUserFromSearch)
return that
}
return that.init()
}
loadMananger(() => {
clientView = client()
})
|
const Joi = require('joi');
module.exports = (options) => (req, res, next) => {
if (options && options.body && Object.keys(options.body).length) {
const schema = Joi.object().keys(options.body);
const {
error,
value
} = Joi.validate({
...req.query,
...req.body
}, schema);
if (error) {
return res.badRequest(error.details.map(d => d.message));
}
}
next();
}
|
class Cat {
constructor(age) {
this._age = age;
}
get age() {
return this._age;
}
set age(newAge) {
this._age = newAge;
}
}
let tom = new Cat(22);
console.log(tom.age);
tom.age = 32;
console.log(tom.age);
////////////////////////////////////////
class Person {
constructor(firstName, lastName) {
this._firstName = firstName;
this._lastName = lastName;
}
get fullname() {
return this._firstName + ' ' + this._lastName;
}
set firstName(newFirstName) {
this._firstName = newFirstName;
}
set lastName(newLastName) {
this._lastName = newLastName;
}
}
let pesho = new Person("Petar", "Ivanov");
console.log(pesho.fullname);
pesho.firstName = "John";
console.log(pesho.fullname);
|
//Mdns define
var mdns = require('mdns'),
portastic = require('portastic'),
//amount = process.argv[2],
amount = 1,
mdnsService = new Array();
//Server define
var server,
ip,
port = 8000,
tls = require('tls'),
fs = require("fs"),
os = require('os'),
encode = "ascii",
options = {
key: fs.readFileSync('./privatekey.pem'),
cert: fs.readFileSync('./certificate.pem'),
rejectUnauthorized: false
};
var networkInterfaces = os.networkInterfaces();
ip = networkInterfaces['en0'][1].address;
//AC define
var AC = {
"profile": {
"saa": {
"class": 8,
"saa_version": 4,
"device_id": 1,
"brand": "HITACHI",
"model": "RAS-28NB"
},
"module": {
"firmware_version": 262,
"mac_address": "A0:24:85:42:E9:43",
"local_ip": "",
"ssid": "HITACHI N300RE"
}
},
"status": {
"H00": 1,
"H01": 0,
"H02": 0,
"H03": 20,
"H04": 24,
"H06": 0,
"H0E": 0,
"H11": 5,
"H14": 53,
"H17": 0,
"H1E": 0,
"H1F": 0,
"H20": 0,
"H21": 0,
"H29": 0
},
"calendar": [],
"timer": 0,
"poll_interval": 60,
"heartbeat_interval": 90,
"saa_interval": 30,
"fields": ["H00", "H01", "H02", "H03", "H04", "H06", "H0E", "H11", "H14", "H17", "H1E", "H1F", "H20", "H21", "H29"],
"users": []
};
//console.log("Info: build " + amount + " device .");
server = tls.createServer(options, onSocket);
portastic.find({
min: 8000,
max: 65535,
retrieve: amount
})
.then(function(ports) {
server.listen(ports[0], function() {
console.log("Server is listen to " + ip + ":" + ports[0]);
});
createMdns(ports);
});
//Server
function onSocket(socket) {
socket.setEncoding(encode);
socket.on('data', function(post) {
//console.log('Get data :\n' + post.toString());
var command = post.toString().split('\n')[3];
var type = command.split('_')[0];
var data = command.split(',');
console.log(command);
var respond = "";
if (type == "INI") {
//console.log("Add Device");
} else if (type == 'GET') {
respond = JSON.stringify(AC);
} else if (type == 'SET') {
for (var i = 0; i < data.length; i++) {
if (i == 0) {
AC.status[data[i].split("_")[2]] = parseInt(data[i].split("_")[3]);
console.log(data[i].split("_")[2] + "->" + data[i].split("_")[3]);
} else {
AC.status[data[i].split("_")[0]] = parseInt(data[i].split("_")[1]);
console.log(data[i].split("_")[0] + "->" + data[i].split("_")[1]);
}
}
respond = JSON.stringify(AC);
}
socket.setTimeout(1000);
socket.write('HTTP/1.1 200 OK\r\n' +
'Content-Length: ' + respond.length + '\r\n' +
'\r\n');
socket.write(respond);
socket.end();
socket.pipe(socket);
});
}
function createMdns(port) {
for (var i = 0; i < port.length; i++) {
mdnsService[i] = mdns.createAdvertisement(mdns.tcp('_hitachi'), port[i], {
name: 'HITACHI_RAS-' + i,
txtRecord: {
path: "/",
id: "A0:24:85:42:E9:" + ((i < 10) ? "0" + i : i),
vs: "255",
err: "0",
st: "0"
}
});
}
}
|
var React = require("react")
class Paginator extends React.Component {
constructor(props) {
super(props)
this.state = {
page: 1
}
this.goToPage = this.goToPage.bind(this)
}
goToPage(count) {
var newCount = this.props.page + count
this.props.setPageQuery(newCount)
}
render() {
var repos = this.state.repos
return (
<div>
<table>
<thead>
<tr>
<td>Page {this.props.page}</td>
<td onClick={() => this.goToPage(-1)}><button disabled={this.props.page < 2}>Previous</button></td>
<td onClick={() => this.goToPage(1)}><button>Next</button></td>
</tr>
</thead>
</table>
</div>
)
}
}
module.exports = Paginator
|
"use strict";
var C;
var mallocs = {};
function record_malloc(v, n, stack){
mallocs[v] = {n: n, stack: stack.split('\n').splice(1)};
}
function record_free(v){
delete mallocs[v];
}
function malloc_info(topdown){
function subdiv(x){
var t = {me: [], sub: 0};
for(var a in x){
let m = x[a];
t.sub += m.n;
if(m.stack.length == 0)
t.me.push(m.n);
else{
let h = m.stack[topdown ? m.stack.length - 1 : 0];
if(!(h in t)) t[h] = {};
t[h][a] = {n: m.n, stack: topdown ? m.stack.slice(0, m.stack.length - 1) : m.stack.slice(1)};
}
}
for(var a in t){
if(a != 'me' && a != 'sub')
t[a] = subdiv(t[a]);
}
return t;
}
return subdiv(mallocs);
}
Module['onRuntimeInitialized'] = () => {
C = {
mallocz: Module.cwrap('mallocz', 'number', ['number', 'number']),
free: Module.cwrap('free', null, ['number']),
passtokey: Module.cwrap('passtokey', null, ['number', 'string']),
authpak_hash: Module.cwrap('authpak_hash', null, ['number', 'string']),
authpak_new: Module.cwrap('authpak_new', null, ['number', 'number', 'number', 'number']),
authpak_finish: Module.cwrap('authpak_finish', 'number', ['number', 'number', 'number']),
form1M2B: Module.cwrap('form1M2B', 'number', ['number', 'number', 'array']),
form1B2M: Module.cwrap('form1B2M', 'number', ['number', 'number', 'array']),
hkdf_x_plan9: Module.cwrap('hkdf_x_plan9', null, ['array', 'array', 'number']),
memset: Module.cwrap('memset', null, ['number', 'number', 'number']),
memmove: Module.cwrap('memmove', null, ['number', 'number', 'number']),
p_sha256: Module.cwrap('p_sha256', null, ['number', 'number', 'number', 'number', 'string', 'number', 'number', 'number']),
chacha_setiv: Module.cwrap('chacha_setiv', null, ['number', 'array']),
ccpoly_encrypt: Module.cwrap('ccpoly_encrypt', null, ['number', 'number', 'array', 'number', 'number', 'number']),
ccpoly_decrypt: Module.cwrap('ccpoly_encrypt', 'number', ['number', 'number', 'array', 'number', 'number', 'number']),
setupChachastate: Module.cwrap('setupChachastate', null, ['number', 'number', 'number', 'number', 'number', 'number']),
sha2_256: Module.cwrap('sha2_256', 'number', ['array', 'number', 'number', 'number']),
memimageinit: Module.cwrap('memimageinit', null, []),
memlalloc0: Module.cwrap('memlalloc0', 'number', ['number', 'number', 'number', 'number']),
allocmemimage: Module.cwrap('allocmemimage', 'number', ['number', 'number']),
memfillcolor: Module.cwrap('memfillcolor', null, ['number', 'number']),
memload: Module.cwrap('memload', 'number', ['number', 'number', 'number', 'number', 'number']),
memunload: Module.cwrap('memunload', 'number', ['number', 'number', 'number', 'number']),
memdraw: Module.cwrap('memdraw', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number']),
byteaddr: Module.cwrap('byteaddr', null, ['number', 'number']),
memlalloc: Module.cwrap('memlalloc', null, ['number', 'number', 'number', 'number', 'number']),
rerrstr: Module.cwrap('rerrstr', null, ['number', 'number']),
memimageflags: Module.cwrap('memimageflags', 'number', ['number', 'number', 'number']),
memldelete: Module.cwrap('memldelete', null, ['number']),
freememimage: Module.cwrap('freememimage', null, ['number']),
memlorigin: Module.cwrap('memlorigin', null, ['number', 'number', 'number']),
memellipse: Module.cwrap('memellipse', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']),
memarc: Module.cwrap('memellipse', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']),
memline: Module.cwrap('memline', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']),
mempoly: Module.cwrap('mempoly', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']),
memfillpoly: Module.cwrap('memfillpoly', null, ['number', 'number', 'number', 'number', 'number', 'number', 'number']),
memltofrontn: Module.cwrap('memltofrontn', null, ['number', 'number']),
memltorearn: Module.cwrap('memltofrontn', null, ['number', 'number']),
record_malloc: record_malloc,
record_free: record_free,
};
main();
};
function withBuf(n, f) {
var t = C.mallocz(n, 1);
var t_array = () => Module.HEAPU8.subarray(t, t + n);
try{
var r = f(t, t_array);
return r;
}finally{
C.memset(t, 0, n);
C.free(t);
}
}
function withBufP(n, f){
var t = C.mallocz(n, 1);
var t_array = () => Module.HEAPU8.subarray(t, t + n);
return Promise.resolve(f(t, t_array)).finally(() => {
C.memset(t, 0, n);
C.free(t);
});
}
function errstr() {
return withBuf(256, buf => {
C.rerrstr(buf, 256);
return UTF8ToString(buf, 256);
});
}
function Packet(data) {
this.data = new Uint8Array(data);
this.closed = false;
this.readers = [];
}
Packet.prototype.nbread = function(check) {
if(this.closed) return undefined;
var n = check(this.data);
if(typeof n !== 'number') throw new Error("NOPE");
if(n < 0 || n > this.data.length)
return null;
var r = this.data.subarray(0,n);
this.data = this.data.subarray(n);
return r;
}
Packet.prototype.readerr = function(check) {
if(this.closed) throw new Error("closed");
var b = this.nbread(check);
if(b === null) throw new Error("EOF");
return b;
}
Packet.prototype.read = function(check) {
if(this.closed) return undefined;
var tryread = resolve => () => {
let b = this.nbread(check);
if(b === null)
return false;
resolve(b);
return true;
};
return new Promise((resolve, reject) => {
if(!tryread(resolve)())
this.readers.push(tryread(resolve));
});
}
Packet.prototype.write = function(b) {
if(this.closed) throw new Error("closed");
var n = new Uint8Array(this.data.length + b.length);
n.set(this.data, 0);
n.set(b, this.data.length);
this.data = n;
while(this.readers.length > 0 && this.readers[0]())
this.readers.shift();
}
Packet.prototype.close = function() {
this.closed = true;
while(this.readers > 0)
this.readers.shift()();
}
function Socket(ws) {
this.ws = ws;
this.packet = new Packet();
this.ws.onmessage = event => {
this.packet.write(new Uint8Array(event.data));
};
}
Socket.prototype.read = function(check) {
return this.packet.read(check);
};
Socket.prototype.write = function(buf) {
this.ws.send(buf);
return Promise.resolve(buf.length);
}
Socket.prototype.close = function(buf) {
this.ws.close();
this.packet.close();
}
function dial(str) {
return new Promise((resolve, reject) => {
var ws = new WebSocket(str);
ws.binaryType = 'arraybuffer';
ws.onopen = () => resolve(new Socket(ws));
ws.onerror = reject;
});
}
function readstr(chan) {
function strcheck(b) {
let n = b.indexOf(0);
if(n < 0) return -1;
return n + 1;
}
return chan.read(strcheck).then(from_cstr);
}
function VBuffer(data) {
if(data === undefined){
this.a = new Uint8Array(256);
this.p = 0;
}else{
this.a = data;
this.p = data.length;
}
this.rp = 0;
}
VBuffer.prototype.data = function() {
return this.a.subarray(0, this.p);
}
VBuffer.prototype.embiggen = function() {
let n = new Uint8Array(2*this.a.length);
n.subarray(0, this.a.length).set(this.a);
this.a = n;
};
VBuffer.prototype.put = function(b) {
while(this.p + b.length > this.a.length)
this.embiggen();
this.a.set(b, this.p);
this.p += b.length;
};
VBuffer.prototype.get = function(n) {
if(this.rp + n > this.p)
throw new Error("EOF");
let r = this.a.subarray(this.rp, this.rp + n);
this.rp += n;
return r;
};
function pack(type, data) {
let b = new VBuffer();
type.put(b, data);
return b;
}
function unpack(type, data) {
return type.get(new VBuffer(data));
}
function Bytes(n) {
return {
put: (b,c) => {
if(c.length !== n)
throw new Error("length error");
b.put(c);
},
get: b => b.get(n),
len: n
};
};
const u8 = {
put: (b,c) => b.put([c]),
get: b => b.get(1)[0],
len: 1
};
const u16 = {
put: (b,c) => b.put([c,c>>8]),
get: b => { let x = b.get(2); return x[1] << 8 | x[0]; },
len: 2
};
const u24 = {
put: (b,c) => b.put([c,c>>8,c>>16]),
get: b => { let x = b.get(3); return x[2] << 16 | x[1] << 8 | x[0]; },
len: 3
};
const u32 = {
put: (b,c) => b.put([c,c>>8,c>>16,c>>24]),
get: b => { let x = b.get(4); return x[3] << 24 | x[2] << 16 | x[1] << 8 | x[0]; },
len: 4
};
const u64 = {
put: (b,c) => {
let a = new Uint8Array(8);
for(var i = 0; i < 8; i++)
a[i] = c / 2**(8*i);
b.put(a);
},
get: b => { let x = b.get(8); return x[3] << 24 | x[2] << 16 | x[1] << 8 | x[0]; },
len: 8
/*TODO*/
};
const U8 = u8;
const U16 = {
put: (b,c) => b.put([c>>8,c]),
get: b => { let x = b.get(2); return x[0] << 8 | x[1]; },
len: 2
};
const U24 = {
put: (b,c) => b.put([c>>16,c>>8,c]),
get: b => { let x = b.get(3); return x[0] << 16 | x[1] << 8 | x[2]; },
len: 3
};
const U32 = {
put: (b,c) => b.put([c>>24,c>>16,c>>8,c]),
get: b => { let x = b.get(4); return x[0] << 24 | x[1] << 16 | x[2] << 8 | x[3]; },
len: 4
};
const U64 = {
put: (b,c) => {
let a = new Uint8Array(8);
for(var i = 0; i < 8; i++)
a[7-i] = c / 2**(8*i);
b.put(a);
},
len: 8
};
function Struct(s) {
return {
put: (b,o) => {
for(var i = 0; i < s.length; i += 2){
let n = s[i];
let fn = s[i+1];
if(n === null)
fn.put(b, o, o);
else{
if(!(n in o))
throw new Error('field ' + n + ' not found');
fn.put(b, o[n], o);
}
}
},
get: b => {
let o = {};
for(var i = 0; i < s.length; i += 2){
let n = s[i];
let fn = s[i+1];
if(n == null)
Object.assign(o, fn.get(b, o));
else
o[n] = fn.get(b, o);
}
return o;
},
len: (()=>{
let n = 0;
for(let i = 0; i < s.length; i += 2)
n += s[i+1].len;
return n;
})()
};
}
function Length(count,data,offset) {
if(offset === undefined) offset = 0;
return {
put: (b,l,o) => {
let p0 = b.p;
count.put(b, 0);
let p1 = b.p;
data.put(b, l, o);
let p2 = b.p;
b.p = p0;
count.put(b, p2 - p1 + offset, o);
b.p = p2;
},
get: (b,o) => {
let c = count.get(b, o) - offset;
let e = b.rp + c;
let op = b.p;
if(b.p < e) throw new Error("short record");
b.p = e;
let l = data.get(b, o);
if(b.rp !== e) throw new Error("short record");
b.p = op;
return l;
}
};
}
function NArray(count,data) {
return {
put: (b,l,o) => {
count.put(b, l.length);
for(var i = 0; i < l.length; i++)
data.put(b, l[i], o);
},
get: (b,o) => {
let l = [];
let c = count.get(b, o);
for(var i = 0; i < c; i++)
l.push(data.get(b, o));
return l;
}
};
}
function FnArray(countfn,data) {
return {
put: (b,l,o) => {
if(l.length !== countfn(o))
throw new Error('inconsistent object');
for(var i = 0; i < l.length; i++)
data.put(b, l[i], o);
},
get: (b,o) => {
let l = [];
let c = countfn(o);
for(var i = 0; i < c; i++)
l.push(data.get(b, o));
return l;
}
};
}
function Vector(count,data) {
return {
put: (b,l,o) => {
let p0 = b.p;
count.put(b, 0);
let p1 = b.p;
for(var i = 0; i < l.length; i++)
data.put(b, l[i], o);
let p2 = b.p;
b.p = p0;
count.put(b, p2 - p1, o);
b.p = p2;
},
get: (b,o) => {
let l = [];
let c = count.get(b, o);
let e = b.rp + c;
let op = b.p;
if(b.p < e) throw new Error("short record");
b.p = e;
while(b.rp < e)
l.push(data.get(b, o));
if(b.rp !== e) throw new Error("short record");
b.p = op;
return l;
}
};
}
function OpaqueVector(count) {
return {
put: (b,l) => {
count.put(b, l.length);
b.put(l);
},
get: b => {
let l = count.get(b);
return b.get(l);
}
}
}
function from_cstr(b) {
var n = b.indexOf(0);
if(n >= 0)
b = b.subarray(b, n);
return new TextDecoder("utf-8").decode(b);
}
function to_cstr(b,n) {
var b = new TextEncoder("utf-8").encode(b);
if(b.length >= n) return b.subarray(0, n);
var c = new Uint8Array(n);
c.set(b);
return c;
}
function FixedString(n) {
return {
put: (b,c) => b.put(to_cstr(c, n)),
get: b => from_cstr(b.get(n)),
len: n
};
}
function VariableString(count) {
return {
put: (b,c) => OpaqueVector(count).put(b, new TextEncoder("utf-8").encode(c)),
get: b => new TextDecoder("utf-8").decode(OpaqueVector(count).get(b))
};
}
function Optional(data) {
return {
put: (b,c) => {if(c !== null) data.put(b, c);},
get: b => {if(b.p === b.rp) return null; return data.get(b);}
};
}
function Select(fn, data) {
return {
put: (b,c,o) => {
let n = fn(o);
if(!(n in data)) throw new Error("Select: not found: " + n);
data[n].put(b,c,o);
},
get: (b,o) => {
let n = fn(o);
if(!(n in data)) throw new Error("Select: not found: " + n);
return data[n].get(b,o);
}
};
}
|
import React from "react";
import axios from 'axios';
import styles from "./ArticleModal.css";
import Content from '../Content/Content';
import MercuryParsed from './MercuryParsed/MercuryParsed';
import Loader from '../Loader/Loader';
export default class ArticleModal extends React.Component {
constructor() {
super();
this.state = {
isOpen: false,
content: {},
isLoading: false,
};
this.close = this.close.bind(this);
};
open(link) {
this.loadParsed(link);
this.setState({
isLoading: true
});
};
close() {
this.setState({
isOpen: false
});
};
//so it will load only if the article is clicked
loadParsed(link) {
const headers = {
'Content-Type': 'application/json',
'x-api-key': 'xcVXumcyUav3tFRU1HVqOum0aAMcMRmreo3RnCxN'
};
axios.get("https://mercury.postlight.com/parser?url=" + link, {headers: headers})
.then(res => {
if(res.data)
this.setState({
isOpen: true,
content: res.data,
isLoading: false,
});
});
};
render() {
var modalContent = null;
if(this.state.isOpen === true)
modalContent = (<MercuryParsed close={this.close}>{this.state.content}</MercuryParsed>)
if(this.state.isLoading === true)
modalContent = <Loader> </Loader>
return modalContent;
};
};
|
describe('viewport 테스트', () => {
context('720 resolution', () => {
beforeEach(() => {
cy.viewport(1280, 720)
})
it('비정상 아이디로 로그인', function () {
// 사이트 접속
// 환경과 서비스명를 입력받아서 해당 사이트 접속하도록 구현 필요
cy.viewport(1280, 720)
cy.visit('/')
//로그인 페이지로 이동하는 PATH
cy.contains('로그인').click()
cy.contains('이메일로 시작하기').click()
// 아아디 & 비밀번호
//테스트 데이터에서 가져오도록 구현 필요
//유지보수를 위해서는 별도 모듈에서 관리 필요
cy.get('form').within(($form) => {
cy.get('input[name=email]')
.type('fake@email.com', { delay: 100 })
.should('have.value', 'fake@email.com')
cy.get('input[name=password]')
.type('test1234')
cy.root().submit()
})
//기대결과
cy.contains('로그인 정보가 일치하지 않습니다').should('be.visible')
})
it ('정상적인 아이디로 로그인', function() {
// 사이트 접속
// 환경과 서비스명을 이용해서 사이트 접속하도록 구현 필요
cy.visit('/')
//로그인 페이지로 이동하는 PATH
cy.contains('로그인').click()
cy.contains('이메일로 시작하기').click()
// 이메일을 입력한다.
// DB에서 가져오는 구조로 구현 필요
cy.get('input[name=email]')
.type('jinhwan.choi@fastcampus.co.kr',{delay:100})
.should('have.value','jinhwan.choi@fastcampus.co.kr')
// 비밀번호를 입력한다.
// DB에서 가져오는 구조로 구현 필요
cy.get('input[name=password]')
.type('test1234')
//로그인 버튼을 누른다.
cy.get('.btn').click()
//홈화면으로 이동하였는지 확인
//기대결과
cy.get('.em').contains('최진환').should('be.visible')
})
})
context('iphone-5 resolution', () => {
beforeEach(() => {
cy.viewport('iphone-5')
})
it('비정상 아이디로 로그인', function () {
// 사이트 접속
cy.visit('/')
//로그인 페이지로 이동하는 PATH
cy.get('.nav-opener > svg').click()
cy.contains('로그인').click()
cy.contains('이메일로 시작하기').click()
// 아아디 & 비밀번호
//테스트 데이터에서 가져오도록 구현 필요
//유지보수를 위해서는 별도 모듈에서 관리 필요
cy.get('form').within(($form) => {
cy.get('input[name=email]')
.type('fake@email.com', { delay: 100 })
.should('have.value', 'fake@email.com')
cy.get('input[name=password]')
.type('test1234')
cy.root().submit()
})
cy.contains('로그인 정보가 일치하지 않습니다').should('be.visible')
})
it('정상적인 아이디로 로그인', function () {
// 사이트 접속
// 환경과 서비스명을 이용해서 사이트 접속하도록 구현 필요
cy.visit('/')
//로그인 페이지로 이동하는 PATH
cy.get('.nav-opener > svg').click()
cy.contains('로그인').click()
cy.contains('이메일로 시작하기').click()
// 이메일을 입력한다.
// DB에서 가져오는 구조로 구현 필요
cy.get('input[name=email]')
.type('jinhwan.choi@fastcampus.co.kr', { delay: 100 })
.should('have.value', 'jinhwan.choi@fastcampus.co.kr')
// 비밀번호를 입력한다.
// DB에서 가져오는 구조로 구현 필요
cy.get('input[name=password]')
.type('test1234')
//로그인 버튼을 누른다.
cy.get('.btn').click()
//홈화면으로 이동하였는지 확인
//모바일일때만 눌러야 됨
cy.get('.nav-opener > svg').click()
cy.contains('최진환').should('be.visible')
//홈으로 이동하기
cy.get('.nav-aside__close > .icon').click()
})
})
})
describe('모바일테스트', () => {
const sizes = ['iphone-5', 'ipad-2', 'iphone-x', 'iphone-xr', [384, 854]]
sizes.forEach((size) => {
it('${size} 에서 비정상 아이디로 로그인 테스트', () => {
if (Cypress._.isArray(size)) {
cy.viewport(size[0], size[1])
} else {
cy.viewport(size)
}
// 사이트 접속
cy.visit('/')
//로그인 페이지로 이동하는 PATH
cy.get('.nav-opener > svg').click()
cy.contains('로그인').click()
cy.contains('이메일로 시작하기').click()
// 아아디 & 비밀번호
//테스트 데이터에서 가져오도록 구현 필요
//유지보수를 위해서는 별도 모듈에서 관리 필요
cy.get('form').within(($form) => {
cy.get('input[name=email]')
.type('fake@email.com', { delay: 100 })
.should('have.value', 'fake@email.com')
cy.get('input[name=password]')
.type('test1234')
cy.root().submit()
})
cy.contains('로그인 정보가 일치하지 않습니다').should('be.visible')
})
})
})
|
'use strict';
angular
.module('playgroundApp')
.config(
function ($stateProvider) {
$stateProvider
.state(
'welcome',
{
url: '/',
templateUrl: 'app/welcome/welcome.view.html',
controller: 'WelcomeCtrl'
}
);
}
);
|
export const isStalled = status_history => {
let missedDueDates = 0;
let missed = false;
let dateA = null;
let dateB = null;
if (!status_history.length) return false;
status_history = status_history.sort(
(a, b) => new Date(b.date) - new Date(a.date)
);
for (let i = 1; i < status_history.length; i++) {
dateA = new Date(status_history[i - 1].new_due_date);
dateB = new Date(status_history[i].date);
missed = dateB > dateA;
if (missed) missedDueDates++;
if (missedDueDates > 1) return true;
}
dateA = new Date(status_history[status_history.length - 1].new_due_date);
dateB = new Date();
missed = dateB > dateA;
if (missed) missedDueDates++;
if (missedDueDates > 1) return true;
return false;
};
|
const asyncRoute = require('./asyncRoute');
module.exports = {
asyncRoute,
};
|
import { getReturn, ClientReturn } from "reshow-return";
import urlStore from "../../stores/urlStore";
const UrlReturn = getReturn({
displayName: "UrlReturn",
options: {
storeLocator: () => urlStore,
},
});
export default ClientReturn(UrlReturn);
|
P.models.exercises.Description = P.Model.extend({
urlRoot: '/api/exercise-description',
validation: {
name: {
required: true
}
},
constructor: function(attrs) {
attrs = attrs || {};
attrs.description = new P.helpers.Markdown(attrs.description);
attrs.images = this._parseImgs(attrs.images);
P.Model.prototype.constructor.call(this, attrs);
},
_parseImgs: function(rawData) {
var self = this,
images;
if (!rawData || !_.isArray(rawData)) {
return new P.models.exercises.ImageCollection();
}
images = _.map(rawData, function(img) {
// images don't have an id attribute, but Backbone needs one to perform
// as expected.
// The url is figured by the 'options' attribute
img.id = img.options;
img.exercise = self;
img.sort_rank = parseInt(img.sort_rank, 10);
return img;
});
return new P.models.exercises.ImageCollection(images);
},
/**
* Put the response into the expected structure.
*
* @param {object} attrs Model attributes
* @param {object} options Options from Backbone.sync
*/
parse: function(attrs, options) {
var data = P.Model.prototype.parse.apply(this, arguments),
document = _.clone(data);
if (data.who && data.who.id) {
document.who = data.who.id;
}
if (_.isObject(data.description)) {
document.description = new P.helpers.Markdown(data.description);
}
if (data.images) {
document.images = this._parseImgs(data.images);
}
return document;
},
/**
* If the exercise has a designated thumbnail, return it..otherwise null.
*/
thumbnail: function() {
var images = this.get('images'),
thumb;
if (images) {
thumb = images.findWhere({
'sort_rank': 0
});
}
return thumb || null;
},
toJSON: function() {
var attrs = this.attributes,
response = {
name: attrs.name || '',
description: attrs.description || '',
};
if (this.id !== undefined) {
response.id = parseInt(this.id, 10);
}
if (attrs.who !== undefined) {
response.who = parseInt(attrs.who, 10);
}
if (_.isObject(attrs.description)) {
response.description = attrs.description.toJSON();
}
return response;
},
toTmplCtx: function() {
var ctx = this.toJSON();
ctx.description = this.get('description');
return ctx;
}
});
|
// user
export const USER_LOGIN = 'USER_LOGIN';
export const USER_REGISTER = 'USER_REGISTER';
export const USER_LOGIN_OUT = 'USER_LOGIN_OUT';
// shopCar
export const CART_ADD = 'CART_ADD';
export const CART_REMOVE = 'CART_REMOVE';
export const CART_UPDATE = 'CART_UPDATE';
export const CART_UPDATE_COUNT = 'CART_UPDATE_COUNT';
|
import React, { Component } from 'react';
import { Route, Switch,NavLink,Redirect } from 'react-router-dom';
import classes from './Login.css'
import Register from '../Register/Register'
import Aux from '../hoc/Aux'
import axios from 'axios'
import { connect } from 'react-redux';
import * as actionTypes from '../../actions';
class Login extends Component {
constructor(props) {
super(props);
this.state = {
userId: '',
password:''
};
this.loginHandler = this.loginHandler.bind(this);
}
loginHandler = (event)=> {
if(event.target.email.value)
{
let role=''
if(event.target.password.value != ''&& event.target.password.value != null){
this.setState({
userId: event.target.email.value,
password : event.target.password.value
},()=>{
axios.post('http://localhost:3001/user/login', this.state)
.then(response => {
alert(response.data.message);
role=response.data.user.role
localStorage.setItem("username",response.data.user.email)
localStorage.setItem("role",response.data.user.role)
this.props.history.push('/user')
}).then(data=>this.props.onStoreResult(this.state.userId)).then(data=>this.props.onStoreRole(role)).catch((err)=>{
alert(err.response.data.message);
// <Redirect to='/user' />
})
});
}
else
alert("Please enter Password");
event.preventDefault();
}
else{
alert("Please enter Email ID");
}
}
render() {
return(
<Aux>
<body>
<form id="loginform" onSubmit={this.loginHandler}>
<div className="container">
<div className="row main">
<div className="main-login main-center">
<div className="form-group">
<label for="email" className="cols-sm-2 control-label">Email</label>
<div className="cols-sm-10">
<div className="input-group">
<span className="input-group-addon"><i className="fa fa-envelope fa" aria-hidden="true"></i></span>
<input type="text" className="form-control" name="email" id="email" placeholder="Enter your Email"/>
</div>
</div>
</div>
<div className="form-group">
<label for="password" className="cols-sm-2 control-label">Password</label>
<div className="cols-sm-10">
<div className="input-group">
<span className="input-group-addon"><i className="fa fa-lock fa-lg" aria-hidden="true"></i></span>
<input type="password" className="form-control" name="password" id="password" placeholder="Enter your Password"/>
</div>
{/* {'name'+this.state.userId} */}
</div>
</div>
<div className="form-group ">
<button type="submit"
className="btn btn-primary btn-lg btn-block login-button"
>Login</button>
</div>
<div className="login-register">
<NavLink
className="nav-link"
to={'/register'}
activeStyle={{
color: '#fa923f'
}}>Register
</NavLink>
</div>
<Route exact path="/register" component={Register} />
</div>
</div>
</div>
</form></body>
</Aux>
);
};
}
const mapStateToProps = state => {
return {
name: state.user.name,
role: state.user.role
}
};
const mapDispatchToProps = dispatch => {
return {
onStoreResult: (username) => dispatch({type: actionTypes.setName, name:username}),
onStoreRole: (role) => dispatch({type: actionTypes.setRole, role:role})
}
};
export default connect(null, mapDispatchToProps)(Login);
|
import ReactGridLayout from "react-grid-layout";
import classNames from "classnames";
import sizeMe from "react-sizeme";
import { hot } from "react-hot-loader";
import { lazy, Suspense, useEffect, useReducer } from "react";
import VegaChartLoading from "../../components/Vega/VegaChartLoading";
import { Subscription } from "rxjs";
const Panel = lazy(() => import("./DashboardPanel"));
const GRID_CELL_HEIGHT = 50;
let lastGridWidth = 1200;
let ignoreNextWidthChange = false;
const GridWrapper = ({
size,
layout,
children,
onDragStop,
onResize,
onResizeStop,
rowHeight,
onLayoutChange,
className,
isResizable,
isDraggable,
viewPanel,
}) => {
const width = size.width > 0 ? size.width : lastGridWidth;
if (width !== lastGridWidth) {
if (ignoreNextWidthChange) {
ignoreNextWidthChange = false;
} else if (!viewPanel && Math.abs(width - lastGridWidth) > 8) {
lastGridWidth = width;
}
}
return (
<ReactGridLayout
className={className}
width={lastGridWidth}
layout={layout}
cols={12}
rowHeight={rowHeight}
containerPadding={[0, 0]}
onLayoutChange={onLayoutChange}
isResizable={isResizable}
isDraggable={isDraggable}
onDragStop={onDragStop}
onResize={onResize}
onResizeStop={onResizeStop}
useCSSTransforms={false}
isBounded={false}
// transformScale={0}
>
{children}
</ReactGridLayout>
);
};
const SizedReactLayoutGrid = sizeMe({ monitorWidth: true })(GridWrapper);
const DashboardGrid = ({ dashboard, viewPanel, handleRange, scrollTop }) => {
const panelMap = {};
const panelRef = {};
const eventSubs = new Subscription();
const [ignored, forceUpdate] = useReducer((x) => x + 1, 0);
const handleTrigger = () => {
forceUpdate();
};
useEffect(() => {
eventSubs.add(
dashboard.events.subscribe(
{ type: "dashboard-panels-changed" },
handleTrigger
)
);
return () => {
eventSubs.unsubscribe();
};
}, []);
const isInView = (panel) => {
if (panel.isViewing || panel.isEditing) {
return true;
}
const elem = panelRef[panel.id.toString()];
if (!elem) {
return false;
}
const top = elem.offsetTop;
const height = panel.gridPos.h * GRID_CELL_HEIGHT + 40;
const bottom = top + height;
const buffer = 250;
const viewTop = scrollTop || 0;
if (viewTop > bottom + buffer) {
return false;
}
const viewHeight = isNaN(window.innerHeight)
? window.clientHeight
: window.innerHeight;
const viewBot = viewTop + viewHeight;
if (top > viewBot + buffer) {
return false;
}
return !dashboard.otherPanelInFullscreen(panel);
};
const renderPanels = () => {
const panelElements = [];
for (const panel of dashboard.panels) {
const panelClasses = classNames({
"react-grid-item--fullscreen": panel.isViewing,
});
const id = panel.id.toString();
panel.isInView = isInView(panel);
panelElements.push(
<div
key={`${panel.id}`}
className={panelClasses}
id={`panel-${id}-${panel.estype}-${panel.title}`}
>
{renderPanel(panel)}
</div>
);
}
return panelElements;
};
const renderPanel = (panel) => {
return (
<Suspense fallback={<VegaChartLoading />}>
<Panel
panel={panel}
dashboard={dashboard}
isViewing={panel.isViewing}
handleRange={handleRange}
/>
</Suspense>
);
};
const buildLayout = () => {
const layout = [];
for (const panel of dashboard.panels) {
const stringId = panel.id.toString();
panelMap[stringId] = panel;
if (!panel.gridPos) {
console.log("panel without gridpos");
continue;
}
const panelPos = {
i: stringId,
x: panel.gridPos.x,
y: panel.gridPos.y,
w: panel.gridPos.w,
h: panel.gridPos.h,
};
layout.push(panelPos);
}
return layout;
};
const onLayoutChange = (newLayout) => {
for (const newPos of newLayout) {
panelMap[newPos?.i].updateGridPos(newPos);
}
dashboard.sortPanelsByGridPos();
};
const updateGridPos = (item, layout) => {
panelMap[item?.i].updateGridPos(item);
// react-grid-layout has a bug (#670), and onLayoutChange() is only called when the component is mounted.
// So it's required to call it explicitly when panel resized or moved to save layout changes.
onLayoutChange(layout);
};
const onResize = (layout, oldItem, newItem) => {
panelMap[newItem.i].updateGridPos(newItem);
};
const onResizeStop = (layout, oldItem, newItem) => {
updateGridPos(newItem, layout);
};
const onDragStop = (a, b, c) => {
console.log(a, b, c);
};
const { isDraggable, isResizable } = dashboard;
return (
<SizedReactLayoutGrid
className={classNames({ layout: true })}
layout={buildLayout()}
viewPanel={viewPanel}
rowHeight={GRID_CELL_HEIGHT}
onLayoutChange={onLayoutChange}
onResize={onResize}
onResizeStop={onResizeStop}
isDraggable={isDraggable}
isResizable={isResizable}
onDragStop={onDragStop}
>
{renderPanels()}
</SizedReactLayoutGrid>
);
};
export default hot(module)(DashboardGrid);
|
$(document).ready(function() {
$("#msgValidacion").text("");
$("#msgValidacion").hide();
////////////Si esta en la interfaz de ListarMisLibros
if ($('#tblListaMisLibros').length){
$("#panelDetalleLibro").hide();
}
inicializar();
//Boton buscar libro
$("#btnBuscarLibro").click(function(){
buscarLibro();
});
});
/**
*Funcion encargada de inicialiar variables
*/
function inicializar(){
//Cargar combos
cargarCombos('EDITORIAL','cbxEditorial');
cargarCombos('AUTOR','cbxAutor');
////////////Si esta en la interfaz de ListarMisLibros
if ($('#tblListaMisLibros').length){
//Listar Libros
listarMisLibros();
$("#panelDetalleLibro").hide();
}
///////////Si esta en la interfaz de buscarLibro
//Se inicializa el formulario
if($("#formSearchLibro").length){
$("#formSearchLibro")[0].reset();
}
}
/**
*Funcion encargada de listar los libros
*/
function listarMisLibros(){
$.ajax({
type : "POST",
async: false,
dataType: 'json',
url : "../../../util/ControllerGeneral.php",
data : {
llamadoAjax : "true",
opcion : "listadoSolicitudes"
}
}).done(function(data) {
var html = "";
$.each(data, function (index, item)
{
html += '<tr>';
html += '<td>'+item.libro.titulo+'</td>';
html += '<td>'+item.libro.isbn+'</td>';
html += '<td>'+item.libro.codigoTopografico+'</td>';
if(item.libro.editorial != null){
html += '<td>'+item.libro.editorial.descripcion+'</td>';
}else{
html += '<td></td>';
}
html += '<td>'+item.estado+'</td>';
html += '<td><input type="radio" name="rbtSeleccion" value='+item.idSolicitud+' onClick="verDetalleSolicitud('+item.idSolicitud+')" ></td>';
html += '</tr>';
});
$("#tblListaMisLibros").append(html);
$("#tblListaMisLibros").dataTable({
"bJQueryUI": true,
"sPaginationType": "full_numbers"
});
});
}
/**
*Funcion encargada de desplegar los atributos de una solicitud seleccionada
* @param {Object} idSolicitud
*/
function verDetalleSolicitud(idSolicitud){
//$("#formListarlibros")[0].reset();
$("#panelDetalleLibro").show();
$.ajax({
type : "POST",
async: false,
dataType: 'json',
url : "../../../util/ControllerGeneral.php",
data : {
llamadoAjax : "true",
opcion : "verDetalleSolicitud",
idSolicitud: idSolicitud
}
}).done(function(data) {
if(data != null){
$("#tbxTitulo").val(data.libro.titulo);
$("#tbxIsbn").val(data.libro.isbn);
$("#tbxCodTopografico").val(data.libro.codigoTopografico);
$("#tbxTemas").val(data.libro.temas);
$("#tbxPaginas").val(data.libro.paginas);
$("#tbxValor").val(data.libro.valor);
if(data.libro.editorial != null){
$("#tbxEditorial").val(data.libro.editorial.descripcion);
}else{
$("#tbxEditorial").val('');
}
if(data.libro.area != null){
$("#tbxArea").val(data.libro.area.descripcion);
}else{
$("#tbxArea").val('');
}
//Pais/Ciudad.
if(data.libro.ciudad != null){
$("#tbxPais").val(data.libro.ciudad.pais.nombre);
$("#tbxCiudad").val(data.libro.ciudad.nombre);
}else{
$("#tbxPais").val('');
$("#tbxCiudad").val('');
}
$("#tbxEstadoLibro").val(data.libro.estado);
$("#tbxAnio").val(data.libro.anio);
//Datos solicitud
$("#tbxFechaReserva").val(data.fechaReserva);
$("#tbxFechaDevolucion").val(data.fechaDevolucion);
$("#tbxEstadoReserva").val(data.estado);
$("#tbxEstadoReserva").css('background-color', '#FFFFFF');
$("#tbxEstadoReserva").css('color', '#434343');
if(data.estado == "PRESTADO"){
$("#tbxEstadoReserva").css('background-color', '#3E663B');
$("#tbxEstadoReserva").css('color', '#FFFFFF');
}
if(data.estado == "EN MORA"){
$("#tbxEstadoReserva").css('background-color', '#D82020');
$("#tbxEstadoReserva").css('color', '#FFFFFF');
}
if(data.estado == "FINALIZADO"){
$("#tbxEstadoReserva").css('background-color', '#858585');
$("#tbxEstadoReserva").css('color', '#FFFFFF');
}
}
});
}
/**
*Funcion encargada de cargar los combos dinamicamente
* @param {Object} tabla
* @param {Object} combo
*/
function cargarCombos(tabla,combo){
$.ajax({
type : "POST",
async: false,
dataType: 'json',
url : $("#baseUrl").val()+"util/CargarCombos.php",
data : {
llamadoAjax : "true",
opcion : "cargarCombo",
tabla : tabla
}
}).done(function(data) {
var html = "";
html += '<option value="">Seleccione...</option>';
var selected = "";
$.each(data, function (index, item)
{
if(tabla == 'EDITORIAL'){
html += '<option value='+item.ID_EDITORIAL+'>'+item.DESCRIPCION+'</option>';
}
if(tabla == 'AREA'){
html += '<option value='+item.ID_AREA+'>'+item.DESCRIPCION+'</option>';
}
if(tabla == 'SEDE'){
html += '<option value='+item.ID_SEDE+'>'+item.DESCRIPCION+'</option>';
}
if(tabla == 'PAIS'){
html += '<option value='+item.ID_PAIS+'>'+item.NOMBRE+'</option>';
}
if(tabla == 'AUTOR'){
var nombreAutor = item.PRIMER_NOMBRE+" "+item.SEGUNDO_NOMBRE+" "+
item.PRIMER_APELLIDO+" "+item.SEGUNDO_APELLIDO;
html += '<option value='+item.ID_AUTOR+'>'+nombreAutor+" "+'</option>';
}
});
$('#'+combo).append(html);
});
}
/**
*Funcion encargada de setear los datos de busqueda de un libro
*/
function buscarLibro(){
$.ajax({
type : "POST",
async: false,
url : "../../../util/ControllerGeneral.php",
data : {
llamadoAjax : "true",
opcion : "buscarLibro",
titulo: $("#tbxTitulo").val(),
isbn: $("#tbxIsbn").val(),
codTopografico: $("#tbxCodTopografico").val(),
temas: $("#tbxTemas").val(),
idEditorial: $("#cbxEditorial").val(),
idAutor: $("#cbxAutor").val()
}
}).done(function(data) {
$("#formSearchLibro").submit();
});
}
|
const express = require("express");
const app = express();
const dogs = require("./routes/dog");
const home = require("./routes/admin");
const cats = require("./routes/cat");
app.use("/dogs" , dogs);
app.use("/cats" , cats);
app.use("/" , home);
app.use((req , res) => {
res.status(404).send("The Page Was Not Found");
})
app.listen(3000 , ()=>{
console.log("[INFO] Server now listening on PORT 3000");
})
|
// На счету пользователя есть 23580 кредитов, значение хранится в переменной credits(создай и присвой).Пользователь решает купить ремонтных дроидов, которые стоят по 3000 кредитов за штуку.Цена одного дроида хранится в переменной pricePerDroid(создай и присвой).
// При посещении страницы, используя prompt, необходимо спросить количество дроидов которые пользователь хочет купить и сохранить в переменную.
// Напиши скрипт который:
// Если в prompt была нажата кнопка Cancel, выводит в консоль сообщение 'Отменено пользователем!'.
// В противном случае, рассчитывает общую цену заказа и сохраняет в переменной totalPrice.
// Проверяет сможет ли пользователь оплатить заказ:
// если сумма к оплате превышает количество кредитов на счету, выводи в консоль сообщение 'Недостаточно средств на счету!'.
// в противном случае необходимо посчитать остаток кредитов на счету и вывести сообщение 'Вы купили [число] дроидов, на счету осталось [число] кредитов.'.
// let credits = 23580;
// const pricePerDroid = 3000;
// const orderQuantity = prompt('Сколько дроидов вы хотите купить?');
// let totalPrice = 0;
// if (orderQuantity === null) {
// console.log('Отменено пользователем!');
// } else if (orderQuantity <= 0) {
// alert('Введите корректное значение!');
// } else {
// totalPrice = pricePerDroid * Number(orderQuantity);
// if (totalPrice > credits) {
// console.log('Недостаточно средств на счету!');
// } else {
// credits -= totalPrice;
// console.log(`Вы купили ${orderQuantity} дроидов, на счету осталось ${credits} кредитов.`);
// }
// }
const orderPieces = 1;
const credits = 23580;
const pricePerDroid = 3000;
const CANCELED_BY_USER = 'Отменено пользователем!';
const ACCESS_DENIED = 'Недостаточно средств на счету!';
let totalPrice; // Write code on this line
let balanceCredit; // Write code on this line
let message;
if (orderPieces === null) {
message = CANCELED_BY_USER;
} else {
totalPrice = pricePerDroid * orderPieces;
if (totalPrice > credits) {
message = ACCESS_DENIED;
} else {
balanceCredit = credits - totalPrice;
message = `Вы купили ${orderPieces} дроидов, на счету осталось ${balanceCredit} кредитов`;
}
}
console.log(message);
//если orderPieces равно 4
// то значение message будет равно
// 'Вы купили 4 дроидов, на счету осталось 11580 кредитов'
//если orderPieces равно null
// то значение message будет равно
// 'Отменено пользователем!'
//если orderPieces равно 10
// то значение message будет равно
// 'Недостаточно средств на счету!'
|
import React from 'react';
import FilterItem from './FilterItem/FilterItem'
import classes from './FilterBar.module.css';
const FilterBar = (props) => {
let tagsJsx = props.selectedTags.map(tag => <FilterItem tag={tag} removeTag={props.removeTag} />)
return (
<div className={classes.filterBar}>
<div className={classes.tagRow}>
{tagsJsx}
</div>
<button className={classes.button}>click me</button>
</div>
);
}
export default FilterBar;
|
import './scss/style.scss';
import GameBoard from './js/gameBoard';
import Player from './js/player';
import Ship from './js/ship';
import UI from './js/ui';
const arrayShipsH = [Ship(5), Ship(4), Ship(3), Ship(3), Ship(2)];
const arrayShipsC = [Ship(5), Ship(4), Ship(3), Ship(3), Ship(2)];
const gameBoardH = GameBoard();
const gameBoardC = GameBoard();
const playerComputer = Player('Player Computer', 'C', arrayShipsC);
const playerHuman = Player('Player Human', 'H', arrayShipsH);
playerHuman.setTurn(true);
playerComputer.setTurn(false);
playerHuman.setShips(gameBoardH);
playerComputer.setShips(gameBoardC);
UI.renderInitialBoards(playerHuman, gameBoardH);
UI.renderInitialBoards(playerComputer, gameBoardC);
const buttons = document.querySelectorAll('.button-position-player2');
const eventComputer = new Event('EventComputer');
const sectionPlayer1 = document.getElementById('section-player-1');
const playHuman = (event) => {
if (!gameBoardC.isOver() && playerHuman.getTurn() && !gameBoardH.isOver()) {
const row = parseInt(event.target.dataset.row, 10);
const column = parseInt(event.target.dataset.column, 10);
playerHuman.attackRival(gameBoardC, { row, column });
UI.renderAttack(playerComputer, gameBoardC, { row, column }, event);
if (gameBoardC.getHit()) {
playerHuman.setTurn(true);
playerComputer.setTurn(false);
UI.renderMessage(playerHuman, gameBoardC);
} else {
playerHuman.setTurn(false);
playerComputer.setTurn(true);
UI.disablePlayer();
UI.renderMessage(playerComputer, gameBoardH);
setTimeout(() => {
sectionPlayer1.dispatchEvent(eventComputer);
}, 1000);
}
}
};
const playComputer = () => {
if (!gameBoardC.isOver() && playerComputer.getTurn() && !gameBoardH.isOver()) {
playerComputer.attackRival(gameBoardH);
UI.renderAttack(playerHuman, gameBoardH);
if (gameBoardH.getHit()) {
playerHuman.setTurn(false);
playerComputer.setTurn(true);
UI.renderMessage(playerComputer, gameBoardH);
setTimeout(() => {
sectionPlayer1.dispatchEvent(eventComputer);
}, 1000);
} else {
setTimeout(() => {
UI.disablePlayer();
UI.renderMessage(playerHuman, gameBoardC);
}, 1000);
playerHuman.setTurn(true);
playerComputer.setTurn(false);
}
}
};
buttons.forEach(button => button.addEventListener('click', playHuman));
sectionPlayer1.addEventListener('EventComputer', playComputer);
|
module.exports = {
ci: {
collect: {
url: ['http://localhost:8080/'],
startServerCommand: 'http-server dist/sidenav -a localhost',
},
upload: {
target: 'temporary-public-storage',
},
},
};
|
var path = require('path')
, vdom = require('virtual-dom');
module.exports = $.plugins.FS.views.loading(function (frame, index, file) {
var playerId = frame.id + '_' + file.path;
if (!App.Model.Sound.Players()[playerId]) loadAudioPlayer(file.path, playerId);
if (!App.Model.Sound.Metadata()[file.path]) loadAudioMetadata(file.path);
//if (!App.Model.Sound.Spectrograms()[file.path]) loadSpectrogram(file.path);
//if (!App.Model.Sound.Waveforms()[file.path]) loadWaveform(file.path);
return require('vdom-thunk')(module.exports.widget, frame, index, file);
});
module.exports.widget = widget;
function loadAudioPlayer (src, playerId) {
setTimeout(function () {
App.Model.Sound.Players.put(playerId, $.plugins.Sound.devices.player(src))
}, 0);
}
function loadAudioMetadata (src) {
setTimeout(function () {
App.Model.Sound.Metadata.put(src, 'loading');
var url = '/api/Sound/GetMetadata?' + JSON.stringify([src])
, xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.onload = function () {
App.Model.Sound.Metadata.put(src, JSON.parse(xhr.response).data);
}
xhr.onerror = function () {
App.Model.Sound.Metadata.put(src, 'failed');
}
xhr.send();
})
}
function widget (frame, index, file) {
var id = frame.id
, src = file.path
, model = App.Model.Sound
, playerId = id + '_' + src;
return {
type: "Widget"
, init: function () {
this.element = vdom.create(this.render(model()));
model(this.patch.bind(this)); // TODO centralize to prevent hanging references
return this.element;
}
, update: function (prev, el) {
console.debug('player update', prev, el);
this.element = this.element || prev.element;
this.timer = this.timer || prev.timer;
}
, destroy: function (el) {
console.debug('player destroy', el);
var player = model.Players()[playerId];
if (player) player.stop();
if (this.timer) clearInterval(this.timer);
}
, patch: function (state) {
this.element = vdom.patch(this.element,
vdom.diff(this._vdom, this.render(state)));
}
, render: function (state) {
var self = this
, player = state.Players ? state.Players[playerId] : null
, cues = state.Cues ? state.Cues[src] || [] : [];
if (!player) {
return this._vdom = h('.AudioPlayer_Missing',
[ 'No player '
, h('em', playerId)
]);
}
player.onupdate = update;
var knob = __.__.Control.views.knob;
return this._vdom = h('.AudioPlayer',
[ $.plugins.Workspace.views.frameHeader(frame, index)//header()
, progressBar()
, controlBar()
, frame.showCues ? cuesView() : null
, frame.showInfo ? infoView() : null ]);
// templates
function progressBar () {
return h('.AudioPlayer_Section',
[ h('button.AudioPlayer_Button_Cue',
{ onclick: stop }, 'CUE')
, h('.AudioPlayer_ProgressBar',
{ onmousedown: seek },
h('.AudioPlayer_ProgressBar_Background',
h('.AudioPlayer_ProgressBar_Foreground',
{ style: { width:
(player.position && player.duration)
? player.position / player.duration * 100 + '%'
: 0 }})))
, h('.AudioPlayer_Position',
player.status === 'loading'
? '\nloading\n'
: $.lib.formatTime(player.position) + "\n" +
$.lib.formatTime(Math.max(player.duration - player.position, 0)) + "\n" +
$.lib.formatTime(player.duration))
]) }
function controlBar () {
return h('.AudioPlayer_Section.AudioPlayer_ControlBar',
[ h('button.AudioPlayer_Button_Play' + (player.status === 'playing' ? '.Playing' : ''),
{ onclick: play }, '⏯')
, h('.AudioPlayer_ControlBar_Group',
[ knob('Speed', String(Math.round(player.speed * 1000) / 1000) + 'x')
, knob('Pitch', String(player.pitch) + ' ct') ])
, h('.AudioPlayer_ControlBar_Group',
[ h('button.AudioPlayer_Info_Toggle', { onclick: toggleInfo }, $.lib.icon('info-circle'))
, h('button.AudioPlayer_Cues_Add', { onclick: toggleCues }, $.lib.icon('map-marker')) ])
, h('.AudioPlayer_ControlBar_Group',
[ knob('Volume', '0.00dB') ]) ]) }
function cuesView () {
return h('.AudioPlayer_Section.AudioPlayer_Cues',
h('.AudioPlayer_Cues_List',
cues.map(function (c, i) {
return cue(i+1, c.label, c.time); }))) }
function infoView () {
return h('.AudioPlayer_Info',
h('table.AudioPlayer_Info_Table',
Object.keys(model.Metadata()[src] || {}).sort().map(tag))) }
// utilities
function getPlayer () {
var player = model.Players.get(playerId);
if (player && (player = player())) return player;
}
// actions
function play () {
var player = getPlayer()
if (!player) return console.warn("can not play", playerId);
player[player.status === 'playing' ? 'stop' : 'play']().then(update);
}
function stop () {
var player = getPlayer()
if (!player) return console.warn("can not stop", playerId);
player.stop().then(function () { player.seek(0); update() });
}
function seek (event) {
var player = getPlayer()
if (!player) return console.warn("can not seek", playerId);
var cls = 'AudioPlayer_ProgressBar_Background'
, bg = event.currentTarget.getElementsByClassName(cls)[0]
, rect = bg.getBoundingClientRect()
, pos = (event.clientX - rect.left) / rect.width;
player.seek(pos * player.duration).then(update);
}
function update () {
// trigger update via model
model.Players.put(playerId, model.Players()[playerId]);
}
function toggleInfo () {
App.Model.Workspace.Frames.get(index).put('showInfo', !frame.showInfo)
}
function toggleCues () {
App.Model.Workspace.Frames.get(index).put('showCues', !frame.showCues)
}
function cue (number, label, time) {
return h('.AudioPlayer_Cue',
[ h('.AudioPlayer_Cue_Label',
[ h('.AudioPlayer_Cue_Number', { onclick: jump }, String(number))
, label ])
, h('.AudioPlayer_Cue_Time', $.lib.formatTime(time)) ])
function jump () {
player.seek(time);
update();
}
}
function addCue () {
var cues = model.Cues()[src]
, newCue = { label: 'New Cue', time: player.position }
if (cues) {
model.Cues[src].push($.lib.model(newCue));
} else {
model.Cues.put(src, $.lib.model([ newCue ]))
}
}
function tag (id) {
var val = (model.Metadata()[src] || {})[id] || '';
return h('tr',
[ h('td', { style: { fontWeight: 'bold'
, paddingRight: '12px' } }, id)
, h('td', { style: { whiteSpace: 'nowrap' } }, val) ])
}
function close () {
App.API('Workspace/Close', id);
}
}
, loadVoices: function (src) {
var self = this
, player = this.player = $.plugins.sound.player(src)
, button = getControl('Button_Play')
, bar = getControl('ProgressBar_Background')
, barFg = getControl('ProgressBar_Foreground')
, position = getControl('Position');
player.onupdate = function (player) {
progress(player.position, player.duration);
}
bar.onmousedown = scrubStart;
button.classList.remove('playing');
button.onclick = play;
function play () {
self.player.play();
button.classList.add('Playing');
button.onclick = pause;
}
function pause () {
self.player.stop();
button.classList.remove('Playing');
button.onclick = play;
}
function progress (pos, dur) {
barFg.style.width = pos / dur * 100 + '%';
position.innerText =
$.lib.formatTime(pos) + "\n" +
$.lib.formatTime(dur - pos) + "\n" +
$.lib.formatTime(dur);
}
function scrubStart (event) {
bar.onmousemove = scrub;
bar.onmouseup = scrubStop;
player.seek(scrub(event));
}
function scrubStop (event) {
bar.onmousemove = bar.onmouseup = null;
player.seek(scrub(event));
}
function scrub (event) {
var bg = getControl('ProgressBar_Background')
, rect = bg.getBoundingClientRect()
, pos = (event.clientX - rect.left) / rect.width
progress(pos * player.duration, player.duration);
return pos * player.duration;
}
function getControl (cls) {
return self.element.getElementsByClassName('AudioPlayer_' + cls)[0];
}
}
}
}
function drawSpectrogram (canvas, buffer) {
var audioCtx = new OfflineAudioContext(
buffer.numberOfChannels,
buffer.length,
buffer.sampleRate)
, drawCtx = canvas.getContext('2d')
, source = audioCtx.createBufferSource()
, analyser = audioCtx.createAnalyser()
, script = audioCtx.createScriptProcessor(2048, 1, 1);
source.buffer = buffer;
source.connect(analyser);
analyser.smoothingTimeConstant = 0;
analyser.fftSize = 1024;
analyser.connect(script);
script.onaudioprocess = drawFrame;
script.connect(audioCtx.destination);
audioCtx.startRendering();
var i = 0;
function drawFrame (event) {
var array = new Uint8Array(analyser.frequencyBinCount);
analyser.getByteFrequencyData(array);
console.log("-->", ++i, array);
}
}
function renderWaveform () {
setTimeout(function () {
var opts = { width: self.element.offsetWidth, height: 72, samples: self.element.offsetWidth
, colors: { waveform: '#ccc', waveformHover: '#ccc' }}
, viewer = require('waveform-viewer')(opts);
viewer.appendTo(self.element.firstChild);
viewer.load(self.data);
}, 1)
}
|
import * as ActionType from "./contants";
import axios from "axios";
const actListMovieRequest = () => {
return {
type: ActionType.LIST_MOVIE_REQUEST,
}
}
const actListMovieSuccess = (data) => {
return {
type: ActionType.LIST_MOVIE_SUCCESS,
payload: data,
}
}
const actListMovieFail = (data) => {
return {
type: ActionType.LIST_MOVIE_FAIL,
payload: data,
}
}
export const actFetchListMovie = () => {
//Gọi axios trong action
return (dispatch) => {
//request
dispatch(actListMovieRequest);
axios({
url: "https://movie0706.cybersoft.edu.vn/api/QuanLyPhim/LayDanhSachPhim?maNhom=GP01",
method: "GET",
})
.then((result) => {
//Success
dispatch(actListMovieSuccess(result.data));
})
.catch((err) => {
//Fail
dispatch(actListMovieFail(err));
})
}
}
|
"use strict";
var request = require('request');
var assert = require('assert');
var nconf = require('nconf');
var fs = require('fs');
var baseUrl = require('../../common').baseUrl;
var csMock = require('../mock/customerSuccess');
var customerMock = require('../mock/customerSession');
describe('api', function () {
var cid, csid;
before(function (done) {
csMock.create(function (res) {
var data = JSON.parse(res.body);
csid = data.msg.csid;
done();
});
});
before(function (done) {
customerMock.create(function (res) {
var customer = JSON.parse(res.body);
cid = customer.msg.cid;
done();
});
});
after(function (done) {
csMock.delete(csid, done);
});
after(function (done) {
customerMock.delete(cid, done);
});
describe('#chatHistory', function () {
describe('POST /chathistories/cs/:csid/customer/:cid', function () {
it('should response with success', function (done) {
request.post({
url: baseUrl + '/chathistories/cs/' + csid + '/customer/' + cid,
form: {}
}, function (err, res) {
assert.ifError(err);
var data = JSON.parse(res.body);
assert.equal(data.code, 200);
done();
});
});
});
describe('GET /chathistories/cs/:csid', function () {
it('should response with list', function (done) {
request.get(baseUrl + '/chathistories/cs/' + csid, function (err, res) {
assert.ifError(err);
var data = JSON.parse(res.body);
assert.equal(data.code, 200);
done();
});
});
});
describe('GET /chathistories/cs/:csid/latestmonth', function () {
it('should response with message data', function (done) {
request.get(baseUrl + '/chathistories/cs/' + csid + '/latestmonth', function (err, res) {
assert.ifError(err);
var data = JSON.parse(res.body);
assert.equal(data.code, 200);
done();
});
});
});
});
});
|
import styled from 'styled-components';
import { device } from '../Style/Breakpoints';
import { Input } from '../Style/Input.Style';
import { Button } from '../Style/Button.Style';
import { colorPalet } from '../Style/Color.palette';
const { bgApp, dark, primary } = colorPalet;
export const ListContainer = styled.section`
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
text-align: center;
padding: 3rem;
min-width: 30rem;
width: 100%;
background: ${bgApp};
@media only screen and ${device.sm} {
width: 40rem;
min-width: 40rem;
margin: 2rem auto;
border-radius: 2rem;
box-shadow: 0 0 0.6rem rgba(0, 0, 0, 0.2);
}
@media only screen and ${device.md} {
padding: 3rem auto;
width: 70rem;
min-width: 60rem;
}
@media only screen and ${device.lg} {
width: 90rem;
min-width: 80rem;
}
`;
export const NewInput = styled(Input)`
height: 3.2rem;
font-size: 1.4rem;
background-color: #f8fdef;
border: 0.1rem solid ${dark};
padding: 0 1rem;
margin-bottom: 1.5rem;
`;
export const Description = styled.div`
display: grid;
grid-template-columns: 2rem 1fr 2rem 1fr;
padding: 0 3rem;
margin: 1rem 0;
@media only screen and ${device.md} {
display: flex;
}
& span {
font-size: 1.4rem;
padding: 0 0.5rem;
}
`;
export const Dot = styled.div`
width: 1.6rem;
height: 1.6rem;
border-radius: 0.5rem;
background-color: ${(props) => props.color};
justify-self: flex-end;
@media only screen and ${device.md} {
margin-right: 0.2rem;
margin-left: 2rem;
}
`;
export const ItemContainer = styled.div`
background-color: ${(props) =>
props.purchase === 'Soon'
? '#dd6450'
: props.purchase === 'Kind of Soon'
? primary
: props.purchase === 'Not Soon'
? '#b8a46e'
: props.purchase === 'Inactive'
? '#B8B8B8'
: primary};
border-radius: 0.7rem;
padding: 1.5rem;
display: flex;
flex-direction: column;
align-items: center;
justify-content: space-evenly;
min-height: 16rem;
@media only screen and ${device.lg} {
min-height: 20rem;
}
`;
export const ItemName = styled.span`
text-transform: capitalize;
margin: 0 1rem;
font-size: 2rem;
font-weight: 700;
`;
export const DeleteButton = styled.button`
background: none;
border: none;
background-color: ${bgApp};
border-radius: 4px;
color: ${dark};
cursor: pointer;
padding: 7px;
`;
export const EditDeleteContainer = styled.div`
display: flex;
justify-content: space-around;
align-items: center;
width: 100%;
`;
export const UnorderedList = styled.ul`
list-style: none;
display: grid;
grid-template-columns: 1fr;
grid-template-rows: 1fr;
gap: 2.5rem 2rem;
margin-top: 2rem;
@media only screen and ${device.md} {
grid-template-columns: 1fr 1fr;
gap: 4rem 3rem;
}
@media only screen and ${device.lg} {
grid-template-columns: 1fr 1fr 1fr;
}
`;
export const FilterContainer = styled.div`
display: flex;
`;
export const LastPurchase = styled.p`
font-size: 1.6rem;
margin: 1rem 0;
`;
export const NumberPurchase = styled.p`
font-size: 1.6rem;
margin: 1rem 0;
`;
export const NextDate = styled.p`
font-size: 1.6rem;
margin: 1rem 0;
`;
export const NewButton = styled(Button)`
background: none;
box-shadow: none;
margin-bottom: 1.2rem;
padding: 0 0.3rem;
i {
font-size: 1.8rem;
color: ${dark};
}
&:hover {
background: none;
}
`;
export const HiddenCheckbox = styled.input.attrs({ type: 'checkbox' })`
border: 0;
clip: rect(0 0 0 0);
clip-path: inset(50%);
height: 1px;
margin: -1px;
overflow: hidden;
padding: 0;
position: absolute;
white-space: nowrap;
width: 1px;
`;
export const Icon = styled.svg`
fill: none;
stroke: white;
stroke-width: 2px;
`;
export const StyledCheckbox = styled.div`
display: inline-block;
width: 16px;
height: 16px;
background: ${(props) => (props.checked ? dark : 'papayawhip')};
border-radius: 3px;
transition: all 150ms;
${HiddenCheckbox}:focus + & {
box-shadow: 0 0 0 3px ${dark};
}
${Icon} {
visibility: ${(props) => (props.checked ? 'visible' : 'hidden')};
}
`;
export const CheckboxContainer = styled.div`
display: inline-block;
vertical-align: middle;
`;
|
const ExpressError=require('../utils/ExpressError')
const catchAsync = require ('../utils/catchAsync');
// const mongoose = require('mongoose');
const {isLoggedIn} = require ('../middleware')
const Campground = require('../models/campground')
const express = require ('express');
const app=express();
const router = express.Router();
const {campgroundSchema} = require('../schemas');
const methodOverride= require('method-override')
app.use(methodOverride('_method'))
const validateCampground = (req,res,next) => {
const {error}=campgroundSchema.validate(req.body);
if(error){
const msg = error.details.map (el => el.message).join (',')
throw new ExpressError (msg, 400)
} else {
next();
}
}
router.get('/new', isLoggedIn, (req,res) => {
res.render ('campgrounds/new')
})
router.get('/', catchAsync(async (req,res) =>{
const campgrounds = await Campground.find({});
res.render('campgrounds/index',{campgrounds})
}))
router.post('/', isLoggedIn, validateCampground, catchAsync(async (req,res,next) =>{
const campground = new Campground (req.body)
await campground.save();
req.flash('success','Succesfully made a new campground!')
res.redirect(`/campgrounds/${campground._id}`);
// res.send(req.body);
// console.log(req.body);
}))
router.get('/:id', catchAsync(async (req,res) =>{
const {id}=req.params;
const campground = await Campground.findById(id).populate('reviews');
// console.log(campground)
if(!campground){
req.flash('error','Cannot find that campground!')
return(res.redirect('/campgrounds'))
}
res.render('campgrounds/show',{campground})
}))
router.get('/:id/edit',isLoggedIn, catchAsync(async (req,res) =>{
const {id}=req.params;
const campground = await Campground.findById(id);
// console.log(campground)
if(!campground){
req.flash('error','Cannot find that campground!')
return(res.redirect('/campgrounds'))
}
res.render('campgrounds/edit',{campground})
}))
router.put('/:id',isLoggedIn, validateCampground, catchAsync(async (req,res) =>{
const {id}=req.params;
const campground = await Campground.findByIdAndUpdate(id,req.body,{new:true});
// console.log(campground)
req.flash('success','Succesfully updated the campground!')
res.redirect(`/campgrounds/${id}`)
}))
router.delete('/:id',isLoggedIn, catchAsync(async (req,res) =>{
const {id}=req.params;
await Campground.findByIdAndDelete(id);
// console.log(campground)
req.flash('success','Succesfully deleted a campground!');
res.redirect(`/campgrounds`);
}))
module.exports = router;
|
import { useState, useEffect } from 'react'
import axios from 'axios'
import { PayPalButton } from 'react-paypal-button-v2'
import { useDispatch, useSelector } from 'react-redux'
import { useParams, Link, useLocation } from 'react-router-dom'
import { Row, Col, ListGroup, Card, Image } from 'react-bootstrap'
import Spinner from '../components/Spinner'
import { ORDER_PAY_RESET, ORDER_DETAILS_RESET } from '../constants/orderConstants'
import { getOrderById, payOrder } from '../actions/orderActions'
import Message from '../components/Message'
const OrderView = () => {
const [sdkReady, setSdkReady] = useState(false)
const [liqData, setLiqData] = useState('')
const [liqSignature, setLiqSignature] = useState('')
const dispatch = useDispatch()
const { id } = useParams()
const location = useLocation()
const { order, error, loading } = useSelector(state => state.orderDetails)
const { loading: payLoading, success: paySuccess } = useSelector(state => state.orderPay)
useEffect(() => {
dispatch({type: ORDER_DETAILS_RESET})
}, [])
useEffect(() => {
const addPayPalScript = async () => {
const { data: clientId } = await axios.get('/api/pay/paypal/config')
const script = document.createElement('script')
script.type = 'text/javascript'
script.src = `https://www.paypal.com/sdk/js?client-id=${clientId}`
script.async = true
script.onload = () => {
setSdkReady(true)
}
document.body.appendChild(script)
}
if(!order || paySuccess) {
dispatch({type: ORDER_PAY_RESET})
dispatch(getOrderById(id))
} else if(!order.isPaid) {
if(!window.paypal) {
addPayPalScript()
} else {
setSdkReady(true)
}
}
}, [id, dispatch, paySuccess, order, sdkReady])
useEffect(() => {
const fetchLiqPayConfig = async () => {
const configData = {
order_id: order._id ,
amount: order.totalPrice,
currency: 'USD',
description: `Order: ${order._id}`,
result_url: `http://localhost:3000${location.pathname}`
}
const { data: { data, signature } } = await axios.post('/api/pay/liqpay/config', configData)
setLiqData(data)
setLiqSignature(signature)
}
if(order) fetchLiqPayConfig()
}, [order])
const successPaymentHandler = (paymentResult) => {
dispatch(payOrder(order._id, paymentResult))
}
return (
<>
{
loading ? <Spinner />
: error ? <Message variant="danger">{error}</Message>
: (
<>
<h1>Order {order._id}</h1>
<Row className="pt-3">
<Col md={8} className="px-3">
<ListGroup variant="flush">
<ListGroup.Item>
<h2>Shipping</h2>
<div><strong>Name: </strong> {order.user.name}</div>
<div><strong>Email: </strong> <a href={`mailto:${order.user.email}`}> { order.user.email}</a></div>
<p>
<b>Adress: </b>
{order.shippingAddress.address},
{order.shippingAddress.city},
{order.shippingAddress.postalCode},
{order.shippingAddress.country}
</p>
</ListGroup.Item>
<ListGroup.Item>
<h2>Payment method</h2>
<p>
<b>Method: </b>
{order.paymentMethod}
</p>
{
order.isPaid
? <Message variant="success">Paid on {order.paidAt}</Message>
: <Message variant="danger">Not paid</Message>
}
{
order.isDilivered
? <Message variant="success">Delivired on {order.deliveredAt}</Message>
: <Message variant="danger">Not delivered</Message>
}
</ListGroup.Item>
<ListGroup.Item className="my-4" >
<h2>Order Items</h2>
{
order.orderItems.length === 0
? <Message>Order is empty</Message>
: (
<ListGroup variant='flush'>
{
order.orderItems.map((item, index) => (
<ListGroup.Item key={item.product}>
<Row>
<Col md={2} className="px-4">
<Image src={item.image} alt={item.name} fluid rounded />
</Col>
<Col>
<Link to={`/products/${item.product}`}>
{item.name}
</Link>
</Col>
<Col md={4} >
{item.qty} x ${item.price} = ${item.qty * item.price}
</Col>
</Row>
</ListGroup.Item>
))
}
</ListGroup>
)
}
</ListGroup.Item>
</ListGroup>
</Col>
<Col md={4}>
<Card>
<ListGroup variant="flush">
<ListGroup.Item className="pt-3">
<h2>Order Summary</h2>
</ListGroup.Item>
<ListGroup.Item>
<Row>
<Col>Items:</Col>
<Col>${order.totalPrice - order.taxPrice}</Col>
</Row>
</ListGroup.Item>
<ListGroup.Item>
<Row>
<Col>Shipping:</Col>
<Col>${order.shippingPrice}</Col>
</Row>
</ListGroup.Item>
<ListGroup.Item>
<Row>
<Col>Tax:</Col>
<Col>${order.taxPrice}</Col>
</Row>
</ListGroup.Item>
<ListGroup.Item>
<Row>
<Col>Total:</Col>
<Col>${order.totalPrice}</Col>
</Row>
</ListGroup.Item>
{
!order.isPaid &&
<> {
order.paymentMethod === 'PayPal'
&&
<ListGroup.Item>
{
payLoading && <Spinner />
}
{
!sdkReady
? <Spinner />
: <PayPalButton
amount={order.totalPrice}
onSuccess={successPaymentHandler}
/>
}
</ListGroup.Item>
}
{
order.paymentMethod === 'liqpay'
&&
<ListGroup.Item>
{
payLoading && <Spinner />
}
{
!liqData || !liqSignature
? <Spinner />
: (
<form
method="POST"
target="_blank"
action="https://www.liqpay.ua/api/3/checkout"
acceptCharset="utf-8"
style={{display: 'flex', justifyContent: 'center'}}
>
<input type="hidden" name="data" value={liqData}/>
<input type="hidden" name="signature" value={liqSignature}/>
<input type="image" alt="liqpay" src="http://static.liqpay.ua/buttons/p1ru.radius.png"/>
</form>
)
}
</ListGroup.Item>
}
</>
}
</ListGroup>
</Card>
</Col>
</Row>
</>
)
}
</>
)
}
export default OrderView
|
// @flow
import * as Types from "./types"
export default (input: Types.Input) => {
return {
html: input.html,
css: input.css
}
}
|
import React, { Component } from 'react'
import { connect } from 'react-redux'
export default function (ComposedComponent) {
//because of declaring contextTypes as static,
//we can access Authentication.contextTypes
class Authentication extends Component {
static contextTypes = {
router: React.PropTypes.object
}
componentWillMount() {
if (!this.props.authenticated) {
this.context.router.push('/')
}
}
//called when a component will be RErendered(new props)
componentWillUpdate(nextProps) {
if (!nextProps.authenticated) {
this.context.router.push('/')
}
}
render() {
return <ComposedComponent {...this.props} />
}
}
function mapStateToProps(state) {
return { authenticated: state.authenticated }
}
return connect(mapStateToProps)(Authentication)
}
// //TO BE DELETED
// // not in ths file we want to use this HOC
// import Authentication //this is my HOC
// import Resources //this is the component i want to wrap
// const ComposedComponent = Authentication(Resources)
// //In some render method
// < ComposedComponent />
|
module.exports = {
up: (queryInterface, Sequelize) => queryInterface.createTable('locals', {
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: Sequelize.INTEGER,
},
name: {
type: Sequelize.STRING,
},
photo: {
type: Sequelize.STRING,
},
ubicacion: {
type: Sequelize.STRING,
},
horarioA: {
type: Sequelize.STRING,
},
horarioC: {
type: Sequelize.STRING,
},
precio: {
type: Sequelize.INTEGER,
},
capacidad: {
type: Sequelize.INTEGER,
},
createdAt: {
allowNull: false,
type: Sequelize.DATE,
},
updatedAt: {
allowNull: false,
type: Sequelize.DATE,
},
}),
down: (queryInterface) => queryInterface.dropTable('locals'),
};
|
/**
* Created by az on 2017/7/17.
*/
import QbDropDown from './QbDropDown';
import QbDropDownDivider from './QbDropDownDivider';
import QbDropDownItem from './QbDropDownItem';
export {QbDropDown, QbDropDownDivider, QbDropDownItem};
|
const express=require('express');
const router=express.Router();
const verify=require('../config/verify');
const order_controller=require('../controller/order.controller');
//getting all order.this should only be accessable by the admin or gallery
router.get('/',order_controller.getOrders)
// when new art order is made or adding a new order
router.post('/',order_controller.newOrder)
//getting an order
router.get('/:orderid',order_controller.getOrder)
//deleting an order
router.delete('/:orderid',order_controller.deleteOrder)
module.exports=router;
|
/**
* User: willerce
* Date: 7/24/12
* Time: 9:13 PM
*/
var mongoskin = require('mongoskin');
exports.config = {
//site settings
name:'未志',
version:'0.0.3',
postNum: process.env.POST_NUM || '5',//每页显示文章个数
session_secret: process.env.SESSION_SECRET || 'a743894a0e',//session加密串
cookie_secret: process.env.COOKIE_SECRET ||'a743894a0e',//session加密串
auth_cookie_name: process.env.AUTH_COOKIE_NAME || 'nd_secret',//cookie 名字
spam_cookie_name: process.env.SPAM_COOKIE_NAME || 'nd_spam',//防spam cookie的名字
port : process.env.PORT || 3000,//端口号
theme : process.env.THEME || 'one',//主题名称
akismet_key : process.env.AKISMET_KEY || '', //akismet api key，不开启请设置为空
// Feed Setting
rss:{
max_rss_items:"5",
title:"未志",
description:"willerce，写给未来的自己。",
link: process.env.RSS_LINK || "http://willerce.com",
language:"zh-cn",
managingEditor:"willerce@gmail.com (willerce)",
webMaster:"willerce@gmail.com (willerce)",
generator:"noderce",
author:{
name:"willerce",
uri:"http://willerce.com"
}
}
};
//mongodb settings
exports.db = mongoskin.db(process.env.MONGOLAB_URI || "mongodb://localhost/noderce");//数据库连接串
|
module.exports = {
GMAPS_API_KEY: 'AIzaSyA6dJ-pHJauxy2TsTq7OMESe_H5ThOMmLM'
};
|
var ns1 = window.Gus.ES6 || {}
ns1.MyObjectExtClass = class ObjectExtensionClass{
constructor(control){
this.exampleCtl = control;
}
objectSetPrototypeOf(){
// setPrototypeOf
let a = {x:1};
let b = {y:2};
Object.setPrototypeOf(a,b);
console.log(`console.log(a.y): ${a.y}`);
// assign
let target = {};
Object.assign(target,a,b);
console.log(`console.log(target) : ${JSON.stringify(target, null, 2)}`);
// not enumerable
let target1 = {};
Object.defineProperty(b,'c',{value:10,enumerable:false});
Object.assign(target1,a,b);
console.log(`console.log(target1) : ${JSON.stringify(target1, null, 2)}`);
// assign will not walk the prototype chain.
b.z = 5;
let c = {c:20};
Object.setPrototypeOf(b, c);
let target2 = {};
Object.assign(target2, a, b);
console.log(`console.log(target2) : ${JSON.stringify(target2, null, 2)}`);
const newLocal = `<section><h2> Object Extensions </h2><h4> Example 1 setPrototypeOf and assign</h4>
<pre><code class="language-javascript">
// setPrototypeOf
let a = {x:1};
let b = {y:2};
Object.setPrototypeOf(a,b);
console.log(\`console.log(a.y): \${a.y}\`);
// assign
let target = {};
Object.assign(target,a,b);
console.log(\`console.log(target) : \${JSON.stringify(target, null, 2)}\`);
// not enumerable
let target1 = {};
Object.defineProperty(b,'c',{value:10,enumerable:false});
Object.assign(target1,a,b);
console.log(\`console.log(target1) : \${JSON.stringify(target1, null, 2)}\`);
// assign will not walk the prototype chain.
b.z = 5;
let c = {c:20};
Object.setPrototypeOf(b, c);
let target2 = {};
Object.assign(target2, a, b);
console.log(\`console.log(target2) : \${JSON.stringify(target2, null, 2)}\`);
</code></pre>
</section>
<aside class="text-info bg-light mb-3">
<cite title="Results">Result - </cite>■ console.log(a.y) : ${a.y} ■
<br>■ console.log(target) : ${JSON.stringify(target, null, 2)} ■
<br>■ console.log(target1) : ${JSON.stringify(target1, null, 2)} ■
<br>■ console.log(target2) : ${JSON.stringify(target2, null, 2)} ■
</aside>`;
$(this.exampleCtl).append(newLocal);
}
objectis() {
let amount1 = NaN;
let amount = 0, total = -0;
console.log(`amount1 === amount1: ${amount1 === amount1}`);
console.log(`Object.is(amount, amount) : ${Object.is(amount, amount)}`);
console.log(`Object.is(amount, total) : ${Object.is(amount,total)}`);
const newLocal = `<section><h2> Object extensions - is </h2><h4> Example 1 </h4>
<pre><code class="language-javascript">
let amount1 = NaN;
let amount = 0, total = -0;
console.log(\`amount1 === amount1: \${amount1 === amount1}\`);
console.log(\`Object.is(amount, amount) : \${Object.is(amount, amount)}\`);
console.log(\`Object.is(amount, total) : \${Object.is(amount,total)}\`);
</code></pre>
</section>
<aside class="text-info bg-light mb-3">
<cite title="Results">Result - </cite>■ amount1 === amount1: ${amount1 === amount1} ■
<br>■ Object.is(amount, amount) : ${Object.is(amount, amount)} ■
<br>■ Object.is(amount, total) : ${Object.is(amount,total)} ■
</aside>`;
$(this.exampleCtl).append(newLocal);
}
}
let MyObjectExtClass = ns1.MyObjectExtClass;
export {MyObjectExtClass as default};
|
import React from "react";
import styled from "styled-components";
import Headline from "../components/Headline";
import Grid from "../components/Grid";
import BrandName from "../components/Brand";
const Main = styled.div`
display: flex;
flex-direction: row;
justify-content: space-around;
align-items: center;
background-color: #004242;
border: solid;
border-color: #004242;
`;
const MenuButton = styled.button`
height: 100px;
width: 300px;
border: solid 5px #a2ebef;
border-radius: 40px;
font-size: 50px;
background-color: transparent;
color: #a2ebef;
`;
function LogIn({ history }) {
function handleClick() {
history.push("familyMenu");
}
function showData() {
history.push("babysitterMenu");
}
return (
<Grid type="logIn">
<BrandName />
<Main>
<Headline size="L">LOGIN</Headline>
</Main>
<Main>
<MenuButton onClick={handleClick}>Family</MenuButton>
</Main>
<Main>
<MenuButton onClick={showData}>Babysitter</MenuButton>
</Main>
</Grid>
);
}
export default LogIn;
|
export const pageData = {
'house-cleaning': {
nameSingle: 'house cleaner',
namePlural: 'House Cleaners',
imgUrl:
'https://images.unsplash.com/photo-1501876725168-00c445821c9e?ixlib=rb-0.3.5&ixid=eyJhcHBfaWQiOjEyMDd9&s=2a1a9a1d07a8a1cb53aa3686da2ef497&auto=format&fit=crop&w=1350&q=80',
},
handyman: {
nameSingle: 'handyman',
namePlural: 'Handymen',
imgUrl:
'https://images.unsplash.com/photo-1502343019212-cc6a09783255?ixlib=rb-0.3.5&ixid=eyJhcHBfaWQiOjEyMDd9&s=25ae56b35a4d8c9545ea0087bc552379&auto=format&fit=crop&w=1400&q=80',
},
'personal-training': {
nameSingle: 'personal trainer',
namePlural: 'Personal Trainers',
imgUrl:
'https://images.unsplash.com/photo-1517130038641-a774d04afb3c?ixlib=rb-0.3.5&ixid=eyJhcHBfaWQiOjEyMDd9&s=3b3ee8e35af1e664b13f70ef440fd441&auto=format&fit=crop&w=1400&q=80',
},
'local-moving': {
nameSingle: 'mover',
namePlural: 'Movers',
imgUrl:
'https://images.unsplash.com/photo-1520038410233-7141be7e6f97?ixlib=rb-0.3.5&ixid=eyJhcHBfaWQiOjEyMDd9&s=9af3b2bb5fbb37be767fbe40967c14b1&auto=format&fit=crop&w=1353&q=80',
},
'dog-training': {
nameSingle: 'dog trainer',
namePlural: 'Dog Trainers',
imgUrl:
'https://images.unsplash.com/photo-1520513498690-924f6d3de0e0?ixlib=rb-0.3.5&s=8b20fe90de3393009d36452fa8945f4a&auto=format&fit=crop&w=1400&q=80',
},
};
|
const {Router} = require("express")
const Course = require("../models/course" )
const router = Router()
router.get("/",async (req,res)=>{
let courses = await Course.find().populate('userId', 'email name').lean().select('price title img')
//console.log(courses)
res.render('courses',{
title:"Курсы",
isCourses: true,
courses
})
})
router.get('/:id/edit', async(req, res)=>{
if(!req.query.allow)
{
return res.redirect('/')
}
let course = await Course.findById(req.params.id).lean()
res.render('course-edit',{
title: `Редактировать ${course.title}`,
course
})
})
router.post('/edit',async(req,res)=>{
const {id} = req.body
delete req.body.id
await Course.findByIdAndUpdate(id, req.body).lean()
res.redirect("/courses")
})
router.post('/remove', async(req, res)=>{
try{
await Course.deleteOne({_id: req.body.id})
res.redirect("/courses")
}
catch(e)
{
console.log(e)
}
})
router.get('/:id',async (req,res)=>{
const course = await Course.findById(req.params.id).lean()
res.render('course',{
layout: 'empty',
title: `Курс ${course.title}`,
course
})
})
module.exports = router
|
const optionsDivIdPrefix = "option-div";
function addNewOption(optionTitle) {
const optionsList = $("#options-list");
const newIndex = optionsList[0].childElementCount;
const optionDivId = `${optionsDivIdPrefix}-${newIndex}`;
const optionDivMarkup = `
<li class="input-group my-1" id="${optionDivId}">
<input class="form-control" type="text" placeholder="Set your option" value="${optionTitle}">
<div class="input-group-append">
<button class="btn btn-outline-primary" type="button" onclick="deleteOption('${optionDivId}')">
<span aria-hidden="true">×</span>
</button>
</div>
</li>`;
optionsList.append(optionDivMarkup);
}
function deleteOption(optionId) {
$(`#${optionId}`).remove();
}
function onAddOptionClick() {
addNewOption("New option")
}
function onSpinClick() {
// Find all `li` tags which ids starts with `option-div` and get the values of the underlying inputs
const options = [...$(`li[id^="${optionsDivIdPrefix}"] input`)].map(x => x.value);
// Clear slots-machine contatiner
const slotsRoot = $("#slots-machine")
slotsRoot.empty();
// Prepare markup
const optionsListTemplate =
"<ul>" +
options
.map(option => `<li>${option}</li>`)
.join("") +
"</ul>";
const optionSpinnerMarkups = [];
for (const optionIndex in options) {
optionSpinnerMarkups.push(`
<div id="slots-${optionIndex}">
${optionsListTemplate}
</div>
`);
}
// Insert markups in DOM
optionSpinnerMarkups.forEach(markup => slotsRoot.append(markup));
// Determine final sequence of options
const finalOptionsSequence = shuffleSchedule(1, options.length);
// Save shuffle result if the original options list is not empty
if (finalOptionsSequence.length) {
const shuffled = finalOptionsSequence.map(index => options[index - 1]);
saveShuffle({original: options, shuffled});
}
// Run spinners
const startSpinTime = Number(query.spinTime) > 0 ? Number(query.spinTime) : 600; // ms
const spinTimeStep = 150; // ms
let spinTime = startSpinTime;
for (const optionIndex in finalOptionsSequence) {
$(`#slots-${optionIndex} ul`).playSpin({
time: spinTime,
endNum: [finalOptionsSequence[optionIndex]],
easing: "easeOutElastic"
});
spinTime += spinTimeStep;
}
}
// Generates shuffle of integer indexes between `a` and `b` (including both)
// using the Fisher–Yates shuffle algorithm:
// https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
function shuffleSchedule(a, b) {
const result = [];
// Initiate schedule
for (let i = a; i <= b; i++) {
result.push(i);
}
for (let i = b - 1; i >= a; i--) {
const j = Math.floor(Math.random() * (i + 1));
const temp = result[j];
result[j] = result[i];
result[i] = temp;
}
return result;
}
const predefinedOptions = query.options ?
Array.isArray(query.options) ?
query.options : [query.options] :
[
"Apple",
"Pineapple",
"Banana",
"Pear",
"Kiwi",
"Mango",
"Orange"
];
$(document).ready(() => {
for (const option of predefinedOptions) {
addNewOption(option);
}
});
|
import { css } from 'emotion'
let baseSpeed = "0.15s"
export let buttonTransition = css`
transition:
background ${baseSpeed} ease-in-out,
background-color ${baseSpeed} ease-in-out,
color ${baseSpeed} ease-in-out,
outline-color ${baseSpeed} ease-in-out,
outline-syle ${baseSpeed} ease-in-out,
outline-width ${baseSpeed} ease-in-out,
box-shadow ${baseSpeed} ease-in-out,
text-shadow ${baseSpeed} ease-in-out
;
`;
|
export default [
{title: 'Github', icon: 'github.svg', url: 'https://github.com/kRyM1337'},
{title: 'LinkedIn', icon: 'linkedin.svg', url: 'https://linkedin.com/in/leonidyanchis/'},
{
title: 'Education',
icon: 'education.svg',
url: 'https://asuonline.asu.edu/online-degree-programs/undergraduate/bachelor-science-software-engineering/',
},
{title: 'Email', icon: 'email.svg', url: 'mailto:leonid.yanchis@gmail.com?Subject=Hello%20Leonid'},
{title: 'Instagram', icon: 'instagram.svg', url: 'https://www.instagram.com/thosevisualsbro/'},
{title: 'Soundcloud', icon: 'soundcloud.svg', url: 'https://soundcloud.com/krym1337'},
]
|
import React from "react";
class Updating extends React.Component {
constructor(props) {
super(props);
}
render() {
return <div className="container">
<p>The componentShouldUpdate() method is called after the component is updated in the DOM.</p>
<a href="https://www.w3schools.com/react/showreact.asp?filename=demo2_react_lifecycle_shouldcomponentupdate2" target="_blank">
<button>Example</button>
</a>
</div>;
}
}
export default Updating;
|
import React from "react";
import styled from "styled-components";
import { Comment } from "semantic-ui-react";
const Author = styled(Comment.Author)`
&&& {
font-size: 14px;
font-weight: 800;
color: #4f4b65;
}
`;
const CreatedAt = styled(Comment.Metadata)`
&&&&& {
font-size: 14px;
font-weight: 400;
color: #4f4b65;
}
`;
const CommentText = styled(Comment.Text)`
&&&&& {
font-size: 16px;
font-weight: 400;
color: #4f4b65;
}
`;
const Avatar = styled(Comment.Avatar)`
&&&&& {
width: 48px;
}
`
const StyledComment = styled(Comment)`
&&&&& {
margin-bottom: 32px;
}
`
const ReviewMessage = () => (
<StyledComment>
<Avatar src="https://react.semantic-ui.com/images/avatar/small/matt.jpg" />
<Comment.Content>
<Author as="a">Matt</Author>
<CreatedAt>
<div>Today at 5:42PM</div>
</CreatedAt>
<CommentText>
新宿歌舞伎町にある100億円の巨大ロボットと女性ダンサーが躍るレストランです。空前絶後のエンターテイメントショーを見ながら、飲食をお楽しみ下さい！
Robot restaurant is for one-time experience in Japan. Not sure if you
will like or hate but it will be A memory of Japan.
</CommentText>
</Comment.Content>
</StyledComment>
);
export default ReviewMessage;
|
const ChannelTerminal = require('./channelTerminal')
const Subject = require('../subject/subject')
const ReplaySubject = require('../subject/replaySubject')
const CurrentSubject = require('../subject/currentSubject')
class Channel {
constructor(type = 'relay') {
if (type == 'relay') {
this.oneTerminalSubject = new ReplaySubject()
this.otherTerminalSubject = new ReplaySubject()
}
if ((type = 'common')) {
this.oneTerminalSubject = new Subject()
this.otherTerminalSubject = new Subject()
}
if ((type = 'current')) {
this.oneTerminalSubject = new CurrentSubject()
this.otherTerminalSubject = new CurrentSubject()
}
this.oneTerminalSubject
.filter(v => false)
._subscribeProxy(this.otherTerminalSubject)
this.otherTerminalSubject
.filter(v => false)
._subscribeProxy(this.oneTerminalSubject)
this.oneChannel = new ChannelTerminal(
this.oneTerminalSubject,
this.otherTerminalSubject
)
this.otherChannel = new ChannelTerminal(
this.otherTerminalSubject,
this.oneTerminalSubject
)
}
}
module.exports = Channel
|
// page for showing one transform snippet
import React, { useEffect, useState } from 'react'
import { navigate } from 'gatsby'
import Snippet from '../../../components/snippets/Snippet'
import SnippetHeader from '../../../components/snippets/SnippetHeader'
import Link from '../../../components/Link'
import Button from '../../../components/Button'
import { fetchSnippet, deleteSnippet } from '../../../utils/snippet-crud'
const SnippetView = ({ id }) => {
const [snippet, setSnippet] = useState()
let showEdit = false
if (typeof window !== 'undefined') {
showEdit = !!localStorage.getItem('snippet-token')
}
useEffect(() => {
async function fetchData (id) {
const res = await fetchSnippet(id)
setSnippet(res)
}
fetchData(id)
}, [])
const handleDelete = async () => {
let token
if (typeof window !== 'undefined') {
token = localStorage.getItem('snippet-token')
}
const res = await deleteSnippet(id, token)
if (res.meta?.code === 200) {
navigate('/docs/transform-snippets')
}
}
return (
<div className='px-5 md:px-10 lg:px-20 my-14 mx-auto' style={{ maxWidth: 1080 }}>
<SnippetHeader showSearch />
{snippet && (
<Snippet snippet={snippet}/>
)}
{showEdit && (
<>
<Link to={`/docs/transform-snippets/${id}/edit`}><Button>Edit</Button></Link>
<Button className='ml-4' type='secondary' onClick={handleDelete}>Delete</Button>
</>
)}
</div>
)
}
export default SnippetView
|
import React, { Component } from "react";
import "./index.css";
import "antd/dist/antd.css";
import TopNav from "../../components/topNav";
import Search from "../../components/Search/Search";
import RightNav from "../../components/RightNav/RightNav.js";
import Lunbo from "../../components/LunBo";
import { Row, Col, Divider, Image, Button, Popover } from "antd";
import Card from "../../components/Card";
import { Link } from "react-router-dom";
const style = { background: "white", padding: "8px 0", height: "15vh" };
const content = (date) => {
// console.log(date)
<Card date={date} />;
};
export default class index extends Component {
constructor(props) {
super(props);
this.state = {
names: [],
citys: [],
position: [],
divide: [], //职业分类
person_id: localStorage.getItem('person_id'),
};
}
componentDidMount() {
fetch("http://42.192.102.128:3000/common/positionDivide")
.then((res) => res.json())
.then((res) => {
this.setState({
divide: res.list,
});
console.log(res.list[0].type_name);
console.log(res.list[0].direction[0].direction_name);
});
fetch("http://42.192.102.128:3000/common/city")
.then((res) => res.json())
.then((res) => {
this.setState({
citys: res.list,
});
// console.log(res.list)
});
fetch("http://42.192.102.128:3000/common/postHot")
.then((res) => res.json())
.then((res) => {
this.setState({
position: res.list,
});
console.log("hot", res.list);
});
}
render() {
const { names } = this.state;
const { citys } = this.state;
const { position } = this.state;
return (
<div>
<TopNav current="home" personId={this.state.person_id} />
<Row>
<Col span={23}>
<Row
justify="center"
align="middle"
style={{
height: "12%",
width: "100%",
backgroundColor: "#F3F3F3",
}}
>
<Col span={14}>
<Search />
</Col>
</Row>
<Divider
style={{ margin: 0, height: "2px", backgroundColor: "#D0DDE3" }}
/>
<Row
justify="start"
align="middle"
style={{ width: "100%", backgroundColor: "#F3F3F3" }}
>
<Col span={2}></Col>
<Col
span={7}
style={{
backgroundColor: "white",
border: "1px solid #BBBBBB",
marginLeft: "2%",
padding: "1%",
paddingRight: "0",
}}
>
{this.state.divide.map((item, index) => (
<Row
justify="space-around"
align="middle"
style={{ marginBottom: "1%" }}
>
{" "}
{/*获取后台数据循环*/}
<Col
span={4}
style={{ fontWeight: "bold", fontSize: "18px" }}
>
{item.type_name}
</Col>
<Col span={5}>{item.direction[0].direction_name}</Col>
<Col span={5}>{item.direction[1].direction_name}</Col>
<Col span={1}>
<Popover
placement="right"
content={<Card date={item.direction} />}
trigger="hover"
>
{/* <Button>
更多 */}
<i className="iconfont"></i>
{/* </Button> */}
</Popover>
</Col>
</Row>
))}
</Col>
<Col span={2}></Col>
<Col span={10}>
<Lunbo />
</Col>
</Row>
{/* 分割线颜色 */}
<Row
style={{ backgroundColor: "#F3F3F3" }}
justify="center"
align="middle"
>
<Col span={8}>
<Divider style={{ border: "grey", fontSize: "25px" }}>
热门岗位
</Divider>
</Col>
</Row>
<Row
style={{ backgroundColor: "#F3F3F3", paddingTop: "2%" }}
justify="center"
align="middle"
>
<Col span={2}></Col>
<Col span={20}>
<Row
style={{ backgroundColor: "#F3F3F3" }}
justify="space-around"
align="middle"
>
{position.map((item, index) => (
<Col span={7}>
<Link
to={{
pathname: "/position/positions",
search: "?code=" + item.post_id,
}}
display="none"
>
<Col
span={24}
style={{
marginBottom: "7%",
backgroundColor: "white",
padding: "5%",
border: "1px solid #BBBBBB",
}}
>
<Row justify="space-between" align="middle">
<Col
style={{
fontWeight: "bold",
fontSize: "16px",
color: "black",
}}
>
{item.post_name}
</Col>
<Col style={{ color: "#EA7835" }}>
{item.wages_min}k-{item.wages_max}k
</Col>
</Row>
<Row
justify="start"
align="middle"
style={{
paddingTop: "5px",
fontSize: "13px",
color: "black",
}}
>
<Col>{item.city}</Col>
<Divider
type="vertical"
style={{ backgroundColor: "#BBBBBB" }}
/>
{item.experience_min == item.experience_max ? (
<Col>经验不限</Col>
) : (
<Col>
{item.experience_min}年-{item.experience_max}年
</Col>
)}
<Divider
type="vertical"
style={{ backgroundColor: "#BBBBBB" }}
/>
<Col>{item.education}</Col>
</Row>
<Divider
style={{
marginTop: "10px",
height: "2px",
backgroundColor: "#F3F3F3",
}}
/>
<Row
justify="start"
align="middle"
style={{
marginTop: "-15px",
fontSize: "13px",
color: "black",
}}
>
<img
width="15%"
style={{ marginBottom: "0px" }}
src={item.logo}
/>
<Col style={{ marginLeft: "5px" }}>
{item.company_name}
</Col>
<Col style={{ marginLeft: "30px" }}>
{item.industry_area}
</Col>
<Divider
type="vertical"
style={{ backgroundColor: "#BBBBBB" }}
/>
<Col>{item.financing}</Col>
</Row>
</Col>
</Link>
</Col>
))}
</Row>
</Col>
<Col span={2}></Col>
</Row>
<Row
style={{
backgroundColor: "#F3F3F3",
height: "10vh",
paddingTop: "2%",
paddingBottom: "5%",
}}
justify="center"
>
<Link to={{ pathname: "/position" }}>
<Button
style={{
paddingTop: "0px",
height: "35px",
width: "180px",
backgroundColor: "#3fb0e6",
color: "white",
fontFamily: "lisu",
fontSize: "25px",
borderRadius: "6px",
textAlign: "center",
lineHeight: "35px",
}}
>
查看更多
</Button>
</Link>
</Row>
<Row style={{ backgroundColor: "#F3F3F3" }} justify="center">
<Col span={8}>
<Divider style={{ border: "grey", fontSize: "25px" }}>
热门城市
</Divider>
</Col>
</Row>
<Row
style={{
backgroundColor: "#F3F3F3",
paddingLeft: "3%",
paddingRight: "3%",
paddingTop: "2%",
}}
justify="space-around"
align="middle"
>
{citys.map((item, index) => (
<Col span={5} style={{ marginBottom: "3%" }}>
<Row justify="space-around" align="middle">
<img
width="100vh"
height="100vh"
style={{ borderRadius: "50%", marginBottom: "10px" }}
src={item.image}
/>
</Row>
<Row justify="space-around" align="middle">
{item.city}
</Row>
</Col>
))}
</Row>
<Row
style={{ backgroundColor: "#F3F3F3", height: "10vh" }}
justify="center"
>
<Link to={{ pathname: "/city" }}>
<Button
style={{
paddingTop: "0px",
height: "35px",
width: "180px",
backgroundColor: "#3fb0e6",
color: "white",
fontFamily: "lisu",
fontSize: "25px",
borderRadius: "6px",
textAlign: "center",
lineHeight: "35px",
}}
>
查看更多
</Button>
</Link>
</Row>
</Col>
<Col span={1}>
<RightNav />
</Col>
</Row>
</div>
);
}
}
|
/**
* Created by Whiteout on 06.03.2017.
*/
$(document).ready(function () {
$('#next').on('click', function () {
})
});
|
'use strict';
const iso7064 = require('../src/iso-7064');
test('iso-7064.compute - invalid parameter type', () => {
expect(() => iso7064.compute(null)).toThrow('Expecting \'rawValue\' of type \'string\', found: \'null\'');
expect(() => iso7064.compute(undefined)).toThrow('Expecting \'rawValue\' of type \'string\', found: \'undefined\'');
expect(() => iso7064.compute([])).toThrow('Expecting \'rawValue\' of type \'string\', found: \'object\'');
});
test('iso-7064.compute - invalid parameter format', () => {
expect(() => iso7064.compute('')).toThrow('Invalid data format; expecting: \'/^[0-9A-Z]{1,}$/\', found: \'\'');
expect(() => iso7064.compute('012?456')).toThrow('Invalid data format; expecting: \'/^[0-9A-Z]{1,}$/\', found: \'012?456\'');
expect(() => iso7064.compute('abc')).toThrow('Invalid data format; expecting: \'/^[0-9A-Z]{1,}$/\', found: \'abc\'');
expect(() => iso7064.compute('969500T3M-BS4SQAMHJ4A')).toThrow('Invalid data format; expecting: \'/^[0-9A-Z]{1,}$/\', found: \'969500T3M-BS4SQAMHJ4A\'');
});
test('iso-7064.compute - valid parameter', () => {
expect(iso7064.compute('0')).toBe(0);
expect(iso7064.compute('96')).toBe(96);
expect(iso7064.compute('97')).toBe(0);
expect(iso7064.compute('A')).toBe(10);
expect(iso7064.compute('F')).toBe(15);
expect(iso7064.compute('A0')).toBe(3);
expect(iso7064.compute('F3')).toBe(56);
expect(iso7064.compute('73RSY1B0Y45D9WU')).toBe(43);
expect(iso7064.compute('X5T2VBF6SB89')).toBe(1);
expect(iso7064.compute('969500T3M8S4SQAMHJ')).toBe(50);
expect(iso7064.compute('4OD84MFXFHP6VMBET34PJD')).toBe(79);
expect(iso7064.compute('Q27GGRHG8F8EH8JVHFK00IL2XWWJOGK0NQR')).toBe(83);
expect(iso7064.compute('724500VKKSH9QOLTFR')).toBe(38);
expect(iso7064.compute('4563546Q27287857GGRHG8758678F8EH8J4857485VHFK08740IL2XWWJOG987987897K0N8725867QR128')).toBe(49);
expect(iso7064.compute('969500T3M8S4SQAMHJ')).toBe(50);
expect(iso7064.compute('969500KSV493XWY0PS')).toBe(54);
expect(iso7064.compute('7245005WBNJAFHBD0S')).toBe(55);
expect(iso7064.compute('724500VKKSH9QOLTFR')).toBe(38);
expect(iso7064.compute('724500884QS64MG71N')).toBe(76);
expect(iso7064.compute('724500884QS64MG71N64')).toBe(1);
});
test('iso-7064.computeWithoutCheck - invalid parameter type', () => {
expect(() => iso7064.computeWithoutCheck(null)).toThrow('Cannot read properties of null (reading \'length\')');
expect(() => iso7064.computeWithoutCheck(undefined)).toThrow('Cannot read properties of undefined (reading \'length\')');
expect(iso7064.computeWithoutCheck([])).toBe(0);
});
test('iso-7064.computeWithoutCheck - invalid parameter format (no error but funny result)', () => {
expect(iso7064.computeWithoutCheck('')).toBe(0);
expect(iso7064.computeWithoutCheck('012?456')).toBe(44);
expect(iso7064.computeWithoutCheck('abc')).toBe(66);
expect(iso7064.computeWithoutCheck('969500T3M-BS4SQAMHJ4A')).toBe(78);
});
test('iso-7064.computeWithoutCheck - valid parameter', () => {
expect(iso7064.computeWithoutCheck('0')).toBe(0);
expect(iso7064.computeWithoutCheck('96')).toBe(96);
expect(iso7064.computeWithoutCheck('97')).toBe(0);
expect(iso7064.computeWithoutCheck('A')).toBe(10);
expect(iso7064.computeWithoutCheck('F')).toBe(15);
expect(iso7064.computeWithoutCheck('A0')).toBe(3);
expect(iso7064.computeWithoutCheck('F3')).toBe(56);
expect(iso7064.computeWithoutCheck('73RSY1B0Y45D9WU')).toBe(43);
expect(iso7064.computeWithoutCheck('X5T2VBF6SB89')).toBe(1);
expect(iso7064.computeWithoutCheck('969500T3M8S4SQAMHJ')).toBe(50);
expect(iso7064.computeWithoutCheck('4OD84MFXFHP6VMBET34PJD')).toBe(79);
expect(iso7064.computeWithoutCheck('Q27GGRHG8F8EH8JVHFK00IL2XWWJOGK0NQR')).toBe(83);
expect(iso7064.computeWithoutCheck('724500VKKSH9QOLTFR')).toBe(38);
expect(iso7064.computeWithoutCheck('4563546Q27287857GGRHG8758678F8EH8J4857485VHFK08740IL2XWWJOG987987897K0N8725867QR128')).toBe(49);
expect(iso7064.computeWithoutCheck('969500T3M8S4SQAMHJ')).toBe(50);
expect(iso7064.computeWithoutCheck('969500KSV493XWY0PS')).toBe(54);
expect(iso7064.computeWithoutCheck('7245005WBNJAFHBD0S')).toBe(55);
expect(iso7064.computeWithoutCheck('724500VKKSH9QOLTFR')).toBe(38);
expect(iso7064.computeWithoutCheck('724500884QS64MG71N')).toBe(76);
expect(iso7064.computeWithoutCheck('724500884QS64MG71N64')).toBe(1);
});
|
'use strict';
import React from 'react';
const TrashCanGlyph = () => (
<svg
className="trashcan-glyph"
width="24px"
height="24px"
viewBox="0 0 24 24">
<path
d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2v-12h-12v12zm13-15h-3.5l-1-1h-5l-1 1h-3.5v2h14v-2z" />
</svg>
);
export default TrashCanGlyph;
|
import React, { Component } from "react"
import AddForumForm from './AddForumForm';
import ListForums from './ListForums';
import JoinedForums from './JoinedForums';
export default function ForumAccordion(props) {
return (
<div id="myGroup" className='left'>
<button class="btn dropdown" data-toggle="collapse" data-target="#view">
<i class="icon-chevron-right"></i> View a Forum
</button>
<button class="btn dropdown" data-toggle="collapse" data-target="#join">
<i class="icon-chevron-right"></i> Join a Forum
</button>
<button class="btn dropdown" data-toggle="collapse" data-target="#create">
<i class="icon-chevron-right"></i> Create a Forum
</button>
<div class="accordion-group pb-4 mb-0">
<div class="collapse" id="join" data-parent="#myGroup">
<ListForums/>
</div>
<div class="collapse indent" id="view" data-parent="#myGroup">
<JoinedForums onChange={props.handleChange}/>
</div>
<div class="collapse indent" id="create" data-parent="#myGroup">
<AddForumForm/>
</div>
</div>
</div>
)
}
|
// JavaScript - Node v8.1.3
function mapEmUp(input, mappers) {
var output = [];
var flag = true;
for (var inputIndex in input) {
flag = true;
for (var i in mappers) {
if (mappers[i][0](input[inputIndex])) {
output.push(mappers[i][1](input[inputIndex]));
flag = false;
break;
}
}
if (flag) {
output.push(-1);
}
}
return output;
}
|
// Вивести позиції (не індекси) букв “о” і прибрати всі “l” з тексту.
// let text = 'Hello World!';
// Очікуваний результат:
// 5
// 8
// Heo Word!
let text = 'Hello World!'
function displaySymbolPositionInText(text, symbol) {
let lastIndex = 0;
while (lastIndex !== -1) {
lastIndex = text.indexOf(symbol, lastIndex + 1)
if (lastIndex !== -1) {
console.log(lastIndex + 1)
}
}
}
displaySymbolPositionInText(text, 'o')
console.log(text.replace(/[l]/gim,''))
|
import React,{Component} from 'react'
export default class Error503 extends Component {
render(){
return (
<div className="errorWrapper">
<div className="leftImg">
<img src={`${process.env.PUBLIC_URL}/images/icon/503.png`} alt=""/>
</div>
<div className="rightText">
<h6>系统维护</h6>
<p>程序员小哥哥正在努力开发中，敬请期待～</p>
</div>
</div>
)
}
}
|
// server.js
"use strict";
const jsonServer = require('json-server');
const server = jsonServer.create();
const router = jsonServer.router('app/db.json')
const middlewares = jsonServer.defaults({
static: "app/"
});
const path = require("path");
const PORT = 3000;
const HOST_NAME = "localhost";
const HOST = `${HOST_NAME}:${PORT}`;
// To handle POST, PUT and PATCH you need to use a body-parser
// You can use the one used by JSON Server
server.use(jsonServer.bodyParser);
// Set default middlewares (logger, static, cors and no-cache)
server.use(middlewares);
// Use default router
server.use("/api", router);
// Add custom routes before JSON Server router
server.get('/', (req, res) => {
res.sendFile(path.join(__dirname, "app/assets/index.html"));
})
server.listen(PORT, () => {
console.log(`JSON Server is running on ${HOST}`);
});
|
//收藏
$('.course-file-collect').on('click', function() {
var collectionType= getUrlParamByName('type');
var content_id=getUrlParamByName('id');
var title= $('.course-file-title').text();
var conlectionFlag=$('.course-file-collect').attr('clickFlag')||1;
var status=getUrlParamByName('state')||0;
var path=getUrlParamByName('path');
if(path=='cou'){
content_id=getUrlParamByName('itemId');
}
if(conlectionFlag==0){
$('.course-file-collect').attr('clickFlag',1)
}else{
$('.course-file-collect').attr('clickFlag',0)
}
$('.course-file-collect').toggleClass('course-file-collect-s')
$.ajax({
type: "post",
url: contextPath + "/collection/isCollection",
dataType: "json",
data: {'resourceKey':content_id,'type':collectionType,'title':title,'conlectionFlag':conlectionFlag,'status':status},
success: function(data) {
}
});
})
/*分享*/
//$('.course-file-share').on('click', function() {
// $(this).addClass('course-file-share-s')
// })
$(document).ready(function() {
/*分享*/
$(".share-list-box").hover(function() {
$(this).find(".sharelist").css("display", "block");
$(this).find(".sharelist").stop().animate({
height: "24px"
}, 300);
}, function() {
$(this).find(".sharelist").css("display", "none");
$(this).find(".sharelist").stop().animate({
height: "0"
}, 300);
});
window._bd_share_config = {
/*common : {
bdText :"",//'自定义分享内容'
bdDesc :"",//'自定义分享摘要'
bdUrl : "",//'自定义分享url地址'
bdPic : ""//'自定义分享图片'
},*/
//分享图标设置，tag是指定哪个data-tag，bdSize图标大小设置，尺寸有16,24,32三种
share : {
"bdSize" : 16
},
slide : [{
bdImg : 0,
bdPos : "right",
bdTop : 100
}]
}
//引入baidu分享js
with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?cdnversion='+~(-new Date()/36e5)];
//var url = window.location.href;
/*function bdshare1(text,desc,url,pic){
}*/
var height = $(window).height() - $('.header').height() - $('.footer').height()-80 + 'px';
$('.course-file-box').css('min-height', height);
var href=getUrlParamByName('href');
if(href=='banner'||href=='searchList'){
$('.course-file-collect').hide();
}
var content_id=getUrlParamByName('id');
var path=getUrlParamByName('path')||'';
if(path=='lib'){
var url=contextPath + "/kb/detail"
var param={'id':content_id};
}else if(path=='cou'){
var url=contextPath + "/train/courseDetail";
var itemId=getUrlParamByName('itemId');
var collectionId=getUrlParamByName('teamId');
var param={'trainingId':content_id,'courseItemId':itemId,'collectionId':collectionId};
}else if(path=='sear'){
var url=contextPath + "/message/noticeDetail"
var param={'id':content_id};
}else{
var url=contextPath + "/cms/detail"
var param={'id':content_id};
}
$.ajax({
type: "post",
url: url,
dataType: "json",
data: param,
success: function(data) {
var data=data.data;
$('.course-file-title').text(data.title);
$('.course-file-lacation').text(data.orgName);
$('.course-file-date').text(data.createTime);
$('.course-file-text').html(data.content);
var path=getUrlParamByName('path');
if(data.videos){
//if(path=='cou'){
// var src=(data.videos)[0].accessUrl;
//}else{
// var src=(JSON.parse(data.videos))[0].accessUrl;
//}
if(path=="cou"){
var videos = data.videos;
}else{
var videos = JSON.parse(data.videos);
}
var flag=false
console.log(videos)
//if(JSON.parse(videos)[0].accessUrl.match(/\.(flv)$/i)== null){
if(videos[0].accessUrl.match(/\.(flv)$/i)== null){
flag=true;
}else{
flag=false
}
var flashvars = {f:videos[0].accessUrl,c: 0,v: 40,wh: '12:9',e: 6,h: 4,st: 1,fc: 1,i:contextPath+'/resources/edcapp/img/right.png'};
var videoUrl=[videos[0].accessUrl];
CKobject.embed('http://www.ckplayer.com/ckplayer/6.5/ckplayer.swf', 'videoFlv', 'ckplayer_a1', '955px', '530px',flag,flashvars,videoUrl);
}
if(data.pdfs&&!(data.type==0&&data.showType==0)){
if(path=='cou'){
var pdf=(data.pdfs)[0].accessUrl;
}else{
var pdf=(JSON.parse(data.pdfs))[0].url;
}
//location.href=contextPath+'/resources/HoneyComb1.1/pdfjs/web/viewer.html?file='+pdf
$(".course-file-text").attr('href',pdf)
$(".course-file-text").media({
width: 955,
height: 1200
})
$('.course-file-text').append('<div class="shadow"></div>')
var shadowWidth=$('.course-file-text').width()-(window.innerWidth-$(window).width())+'px';
$('.shadow').css('width',shadowWidth)
}
if((data.type==0&&data.showType==0)&&data.pdfs){
if(path=='cou'){
var name=(data.pdfs)[0].name;
var href=(data.pdfs)[0].accessUrl;
}else{
var name=(JSON.parse(data.pdfs))[0].name;
var href=(JSON.parse(data.pdfs))[0].accessUrl;
}
$('.course-file-link').text(name);
$('.course-file-link').attr('href',href)
}
if(data.likeFlag==0||data.likeFlag==1){
$('.course-file-praise').text(data.likeCount);
$('.course-file-praise').attr('clickFlag',0);
if(data.likeFlag==1){
$('.course-file-praise').addClass('course-file-collect-s')
$('.course-file-praise').attr('clickFlag',1);
$('.course-file-praise').css({'display':'inline-block','background-color':'#a8a8a8'});
}
}
}
});
/*收藏*/
if(!href=="banner"){
var collectionType= getUrlParamByName('type');
$.ajax({
type: "post",
url: contextPath + "/collection/collectionResult",
dataType: "json",
data: {'resourceKey':content_id,'type':collectionType},
success: function(data) {
if(data.data==true){
$('.course-file-collect').addClass('course-file-collect-s')
$('.course-file-collect').attr('clickFlag',0);
}
}
});
}
/*点赞*/
if(href=="kb/library"||href=="train/detail"){
$('.course-file-praise').css({'display':'inline-block','background-color':'#efefef'});
}
/*点赞*/
$('.course-file-praise').on('click', function() {
$(this).toggleClass('course-file-praise-s');
var clickFlag=$(this).attr('clickflag');
var likeFlag;
if(clickFlag==0){
likeFlag=1;
$('.course-file-praise').css({'display':'inline-block','background-color':'#a8a8a8'});
$(this).attr('clickFlag',1)
var num=Number($('.course-file-praise').text())
$('.course-file-praise').text((num+1))
}
if(clickFlag==1){
likeFlag=0;
$('.course-file-praise').css({'display':'inline-block','background-color':'#efefef'});
$(this).attr('clickFlag',0)
var num=Number($('.course-file-praise').text())
$('.course-file-praise').text((num-1))
}
$.ajax({
type: "post",
url: contextPath + "/course/like",
dataType: "json",
data: {'id':content_id,'like':likeFlag},
success: function(data) {
if(data.data==true){
$('.course-file-collect').addClass('course-file-collect-s')
$('.course-file-collect').attr('clickFlag',0);
}
}
});
})
})
|
(global.webpackJsonp = global.webpackJsonp || []).push([ [ "pages/index/_event" ], {
4358: function(e, n, t) {},
"8d69": function(e, n, t) {
t.r(n);
var a = t("c4ec"), c = t.n(a);
for (var o in a) [ "default" ].indexOf(o) < 0 && function(e) {
t.d(n, e, function() {
return a[e];
});
}(o);
n.default = c.a;
},
c2fd: function(e, n, t) {
var a = t("4358");
t.n(a).a;
},
c4ec: function(e, n, t) {
function a(e) {
return e && e.__esModule ? e : {
default: e
};
}
Object.defineProperty(n, "__esModule", {
value: !0
}), n.default = void 0;
var c = a(t("ba1b"));
a(t("b4fd")), a(t("0d75")), a(t("80d6"));
var o = {
data: function() {
return {
events: [],
show: !1,
current: 0
};
},
mounted: function() {
var e = this;
setTimeout(function() {
c.default.getEvents({
page: 1,
per: 3
}).then(function(n) {
e.events = n.items;
});
}, 500);
},
destroyed: function() {},
methods: {
clickLog: function(e) {
var n = e.currentTarget.dataset, t = (n.id, n.buildingid);
wx.navigateTo({
url: "/pages/building/main?building_id=".concat(t)
});
}
}
};
n.default = o;
},
d86a: function(e, n, t) {
t.r(n);
var a = t("ef74"), c = t("8d69");
for (var o in c) [ "default" ].indexOf(o) < 0 && function(e) {
t.d(n, e, function() {
return c[e];
});
}(o);
t("c2fd");
var u = t("f0c5"), i = Object(u.a)(c.default, a.b, a.c, !1, null, "6e1cc9f1", null, !1, a.a, void 0);
n.default = i.exports;
},
ef74: function(e, n, t) {
t.d(n, "b", function() {
return a;
}), t.d(n, "c", function() {
return c;
}), t.d(n, "a", function() {});
var a = function() {
var e = this;
e.$createElement;
e._self._c;
}, c = [];
}
} ]), (global.webpackJsonp = global.webpackJsonp || []).push([ "pages/index/_event-create-component", {
"pages/index/_event-create-component": function(e, n, t) {
t("543d").createComponent(t("d86a"));
}
}, [ [ "pages/index/_event-create-component" ] ] ]);
|
import React from "react";
import PropTypes from "prop-types";
const ListItem = ({ title, desc }) => {
return (
<div className="listItemComponent" data-test="listItemComponent">
<h2 data-test="titleClassName">{title}</h2>
<h4 data-test="descClassName">{desc}</h4>
</div>
);
};
ListItem.prototype = {
title: PropTypes.string,
desc: PropTypes.string
};
export default ListItem;
|
import React from 'react';
import ReactDOM from 'react-dom';
import {Label} from './Label';
const {expect, test} = global;
test('Render a Label component without htmlFor and without classNames', () => {
const div = document.createElement('div');
ReactDOM.render(<Label>A</Label>, div);
expect(div.querySelector('label').textContent).toBe('A');
expect(div.querySelector('label').className).toBe('atom-label');
expect(div.querySelector('label').htmlFor).toBe('');
});
test('Render a Label component with classNames', () => {
const div = document.createElement('div');
ReactDOM.render(<Label className="myClass1 myClass2">B</Label>, div);
expect(div.querySelector('label').textContent).toBe('B');
expect(div.querySelector('label').className).toContain('atom-label');
expect(div.querySelector('label').className).toContain('myClass1');
expect(div.querySelector('label').className).toContain('myClass2');
expect(div.querySelector('label').htmlFor).toBe('');
});
test('Render a Label component with htmlFor reference', () => {
const div = document.createElement('div');
ReactDOM.render(<Label htmlFor="input-field-email">C</Label>, div);
expect(div.querySelector('label').textContent).toBe('C');
expect(div.querySelector('label').className).toContain('atom-label');
expect(div.querySelector('label').htmlFor).toBe('input-field-email');
});
|
import React, { Fragment } from 'react'
import { connect } from 'react-redux'
import { compose } from 'redux'
import { withRouter } from 'react-router-dom'
import Loading from './Loading'
import Message from './Message'
export const Fixed = ({ general, match }) => {
return (
<Fragment>
{general.loading !== 0 && <Loading />}
{general.msg.length !== 0 &&
general.msg.map((msg, index) => (
<Message key={msg.id} msg={msg} index={index} />
))}
</Fragment>
)
}
const mapStateToProps = (state) => ({
general: state.general,
})
export default compose(withRouter, connect(mapStateToProps, {}))(Fixed)
|
/* 🤖 this file was generated by svg-to-ts*/
export const EOSIconsEmojiEvents = {
name: 'emoji_events',
data: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19 5h-2V3H7v2H5c-1.1 0-2 .9-2 2v1c0 2.55 1.92 4.63 4.39 4.94A5.01 5.01 0 0011 15.9V19H7v2h10v-2h-4v-3.1a5.01 5.01 0 003.61-2.96C19.08 12.63 21 10.55 21 8V7c0-1.1-.9-2-2-2zM5 8V7h2v3.82C5.84 10.4 5 9.3 5 8zm14 0c0 1.3-.84 2.4-2 2.82V7h2v1z"/></svg>`
};
|
var all__d_8js =
[
[ "c", "all__d_8js.html#afdc09aee85179f8ac6b537658b74c7ef", null ],
[ "searchData", "all__d_8js.html#ad01a7523f103d6242ef9b0451861231e", null ]
];
|
//Scrivi un programma che stampi i numeri da 1 a 100
//Al posto dei multipli di 3 stampa Fizz
//Al posto dei multipli di 5 stampa Buzz
//Al posto dei multipli di 3 stampa FizzBuzz
//insieme di numeri vuoto
var numeri = [];
//dimensione dell'insieme
var lunghezzaArray = 100;
//valore da assegnare a ogni posizione dell array
var contatore = 0;
//variabili per il resto
var fizz;
var buzz;
for (var i = 0; i < lunghezzaArray; i++) {
//contatore per riempire le posizioni progressivamente
contatore++;
//calcolo del resto per ogni valore dell array
fizz = contatore % 3;
buzz = contatore % 5;
//controllo se il valore è sia multiplo di 3 che di 5
if (fizz == 0 && buzz == 0) {
numeri[i] = 'FizzBuzz';
}
//controllo se il valore è solo multiplo di 3
else if (fizz == 0) {
numeri[i] = 'Fizz';
}
//controllo se il valore è solo multiplo di 5
else if (buzz == 0) {
numeri[i] = 'Buzz';
}
//il numero dell' array non è multiplo di 3 e 5
else {
numeri[i] = contatore;
}
//stampo i valori dell array
console.log(numeri[i]);
}
|
import React from 'react';
import classes from './Title.css';
const Title = (props) => {
return (
<div className={classes.titleBox}>
<p>{props.children}</p>
</div>
)
}
export default Title;
|
const Command = require("../../structures/Command");
class Prefix extends Command {
constructor() {
super();
this.config = {
name: "prefix"
}
this.extra = {
perms: ["manageGuild"]
}
}
async run(Osiris, msg, args, userEntry, guildEntry) {
if (!msg.member.permission.has('manageGuild')) {
return msg.channel.createMessage('You do not have permissions to use this command. ')
}
let prefix = args[0];
guildEntry.prefix = prefix;
await Osiris.db.updateGuild(guildEntry);
msg.channel.createMessage("updated prefix")
}
}
module.exports = new Prefix;
|
import React, {useEffect} from 'react';
import {getUser} from '../../actions/Profile';
import {useSelector, useDispatch} from 'react-redux'
import {useParams} from 'react-router-dom'
import Container from './profileStyle/Container'
import { Typography } from '@material-ui/core';
const Profile = () =>{
const dispatch = useDispatch();
const info = useSelector(state => state.Profile.userInfo);
const id = useParams();
console.log(id.id)
useEffect(() => {
dispatch(getUser(id.id))
},[])
return (
<Container>
</Container>
)
}
export default Profile;
|
import Vue from 'vue'
import App from './App.vue'
// import router from './router'
import 'swiper/dist/css/swiper.min.css'
import VueRouter from 'vue-router'
import home from './components/HelloWorld.vue'
import detail from './components/detail.vue'
import axios from 'axios'
import VueAxios from 'vue-axios'
import VueLazyload from 'vue-lazyload'
Vue.use(VueRouter)
Vue.use(VueLazyload)
var router = new VueRouter({
routes:[
{
path:'/',
component:home,
},{
path:'/detail',
component:detail
}
]
})
Vue.use(VueAxios,axios)
Vue.config.productionTip = false
new Vue({
router,
render: h => h(App)
}).$mount('#app')
|
import { randomWord } from '../lib/game'
import { showGuess} from '../lib/game'
import { NEW_GAME, MAKE_GUESS } from './types'
export const newGame = () => ({
type: NEW_GAME,
payload: randomWord()
})
export const makeGuess = () => ({
type: MAKE_GUESS,
payload: showGuess()
})
|
require("../common/vendor.js"), (global.webpackJsonp = global.webpackJsonp || []).push([ [ "pages/activity_a/thematic/main" ], {
"3b97": function(t, e, n) {
n.d(e, "b", function() {
return o;
}), n.d(e, "c", function() {
return i;
}), n.d(e, "a", function() {});
var o = function() {
var t = this;
t.$createElement;
t._self._c;
}, i = [];
},
"82ea": function(t, e, n) {
var o = n("f10c");
n.n(o).a;
},
"8c2f": function(t, e, n) {
(function(t) {
function e(t) {
return t && t.__esModule ? t : {
default: t
};
}
n("6cdc"), e(n("66fd")), t(e(n("c4e8")).default);
}).call(this, n("543d").createPage);
},
bd93: function(t, e, n) {
n.r(e);
var o = n("dbe8"), i = n.n(o);
for (var c in o) [ "default" ].indexOf(c) < 0 && function(t) {
n.d(e, t, function() {
return o[t];
});
}(c);
e.default = i.a;
},
c4e8: function(t, e, n) {
n.r(e);
var o = n("3b97"), i = n("bd93");
for (var c in i) [ "default" ].indexOf(c) < 0 && function(t) {
n.d(e, t, function() {
return i[t];
});
}(c);
n("82ea");
var a = n("f0c5"), r = Object(a.a)(i.default, o.b, o.c, !1, null, "d8544390", null, !1, o.a, void 0);
e.default = r.exports;
},
dbe8: function(t, e, n) {
function o(t) {
return t && t.__esModule ? t : {
default: t
};
}
function i(t, e, n, o, i, c, a) {
try {
var r = t[c](a), u = r.value;
} catch (t) {
return void n(t);
}
r.done ? e(u) : Promise.resolve(u).then(o, i);
}
function c(t) {
return function() {
var e = this, n = arguments;
return new Promise(function(o, c) {
function a(t) {
i(u, o, c, a, r, "next", t);
}
function r(t) {
i(u, o, c, a, r, "throw", t);
}
var u = t.apply(e, n);
a(void 0);
});
};
}
Object.defineProperty(e, "__esModule", {
value: !0
}), e.default = void 0;
var a = o(n("a34a")), r = o(n("ba1b")), u = o(n("327a")), s = o(n("d408")), f = n("63ae"), l = {
"现房推荐": "现房项目,看得见、摸得着、入住快、风险低,买一套,少一套",
"刚需推荐": "刚需福利贴,杭州哪里还有低总价小户型？各区好盘值得一览",
"毛坯合集": "毛坯房快绝迹了，全杭州就剩这么几个！",
"闭眼摇合集": "杭州高性价比楼盘合集，闭眼摇系列~",
"倒挂楼盘": "最高倒挂1.5万/㎡，这些倒挂盘买到就是赚到！"
}, d = {
"闭眼摇合集": "https://cdn.vip-wifi.com/hzfangchan/config/share-img/share-byy.png",
"刚需推荐": "https://cdn.vip-wifi.com/hzfangchan/config/share-img/share-gxtj.png"
}, h = {
"倒挂楼盘": {
img_src: "https://cdn.vip-wifi.com/hzfangchan/version-img/1.14.25/activity_a/thematic/upside-top.png",
show_filter: !0,
navigation_style: {
frontColor: "#000000",
backgroundColor: "#ffffff"
}
}
}, m = !1, p = 320 * (wx.getSystemInfoSync().windowWidth / 750), g = function(t) {
return new Promise(function(e) {
if (wx.createSelectorQuery) {
var n = wx.createSelectorQuery();
n.selectAll(t).boundingClientRect(), n.selectViewport().scrollOffset(), n.exec(function(t) {
e({
top: t[0][0] ? t[0][0].top : 1,
bottom: t[0][0] ? t[0][0].bottom : 1,
scrollTop: t[1].scrollTop
});
});
}
});
}, v = {
mixins: [ u.default, s.default ],
components: {
HouseItem: function() {
Promise.all([ n.e("common/vendor"), n.e("components/business/house_item") ]).then(function() {
return resolve(n("ae38"));
}.bind(null, n)).catch(n.oe);
},
TopFilter: function() {
n.e("components/buildings_top_filter/index").then(function() {
return resolve(n("71eb"));
}.bind(null, n)).catch(n.oe);
},
BottomTip: function() {
n.e("components/views/bottom_tip").then(function() {
return resolve(n("7a99"));
}.bind(null, n)).catch(n.oe);
},
EmptyBox: function() {
n.e("components/views/empty_box").then(function() {
return resolve(n("8c0b"));
}.bind(null, n)).catch(n.oe);
},
ListLoading: function() {
n.e("components/views/loading").then(function() {
return resolve(n("7756"));
}.bind(null, n)).catch(n.oe);
}
},
onShareAppMessage: function() {
var t = this.$root.$mp.query.thematic, e = encodeURIComponent("/pages/activity_a/thematic/main?thematic=".concat(t)), n = {
title: l[t],
path: "/pages/find_building/main?sub_page=".concat(e),
imageUrl: d[t] || ""
};
return this.getShareInfo(n);
},
data: function() {
return {
tabs_fixed_top: !1,
thematic: "",
img_src: "",
filter_tabs: [ "区域", "价格", "面积", "装修" ],
decoration: "",
zone_ids: "",
area: "",
total_price: "",
price: "",
layout: "",
metro: "",
zone_section_ids: "",
show_filter: !1
};
},
computed: {
show_list_container: function() {
return this.items && this.items.length > 0;
}
},
onLoad: function() {
var t = decodeURIComponent(this.$root.$mp.query.thematic || "");
this.thematic = t;
var e = h[t] || "", n = e.img_src, o = e.show_filter, i = e.navigation_style;
this.img_src = n, this.show_filter = o, this.getData(), i && wx.setNavigationBarColor(i);
},
onPageScroll: function(t) {
var e = this;
if (!m) {
m = !0;
g(".banner").then(function(t) {
if (t) {
var n = t.bottom;
t.top, e.tabs_fixed_top = n < 0, m = !1;
}
});
}
},
methods: {
getData: function() {
var t = this, e = this.$root.$mp.query.thematic, n = {
feature: decodeURIComponent(e || ""),
page: this.page
};
[ "decoration", "zone_ids", "zone_section_ids", "area", "total_price", "price", "layout", "metro" ].forEach(function(e) {
t[e] && (n[e] = t[e]);
}), this.loading = !0, r.default.getBuildings(n).then(function(e) {
t.handleData(e, {
handleItem: f.mapHouseItem
});
});
},
changeFilter: function(t) {
var e = this;
return c(a.default.mark(function n() {
return a.default.wrap(function(n) {
for (;;) switch (n.prev = n.next) {
case 0:
return Object.keys(t).forEach(function(n) {
e[n] = t[n];
}), e.page = 1, n.next = 4, e.getData();
case 4:
e.$nextTick(e.checkTopFilterPosition);
case 5:
case "end":
return n.stop();
}
}, n);
}))();
},
checkTopFilterPosition: function() {
wx.pageScrollTo({
scrollTop: p
});
}
}
};
e.default = v;
},
f10c: function(t, e, n) {}
}, [ [ "8c2f", "common/runtime", "common/vendor" ] ] ]);
|
#!/usr/bin/env node
var log = (o)=>console.log(o);
log("Hello from arrow");
var program = require("commander");
program
.arguments("<file>")
.option("-i,--input"," The file to remove blank lines from")
|
import { ElLoading } from 'element-plus';
let loading = null;
function start(target = '.hall__main') {
loading = ElLoading.service({ target });
}
function close() {
if (loading) {
loading.close();
}
}
export default {
start,
close,
};
|
( function() {
'use strict';
var bookCard = {
templateUrl : './book-card.html',
controller : 'BookCardController',
bindings : {
book : '<'
}
};
angular.module( 'components' )
.component( 'bookCard', bookCard );
} )();
|
'use strict';
(function () {
angular
.module("vkscanner", ['ui.router'])
.config(['$stateProvider', '$urlRouterProvider', function ($stateProvider, $urlRouterProvider) {
$stateProvider
.state('filters', {
url: '/filters',
views: {
'content': {
templateUrl: 'components/filter/filter.html'
}
}
})
.state('filters.main', {
url: '/:filterId',
views: {
'content': {
templateUrl: 'components/filter/filter.html'
}
}
})
.state('posts', {
url: '/posts',
views: {
'content': {
template: '<post-list></post-list>'
}
}
})
.state('404', {
url: '/404',
views: {
'content': {
templateUrl: 'components/404/404.html'
}
}
});
$urlRouterProvider.otherwise('/404');
}])
.controller('mainController', mainController);
function mainController() {
}
})();
|
var mongoose = require('mongoose');
var nodemailer = require('nodemailer');
var From = 'frommailid';
var transporter = nodemailer.createTransport({
service: 'gmail',
auth: {
user: 'frommailid',
pass: ''
}
});
exports.userCRUD = userCRUD;
function userCRUD(app, router, userModel) {
router.get('/getusers', function(req, res) {
userModel.find({ isAdmin: { $ne: true } }, { password: 0 }).sort({ addedDate: -1 }).exec(function(err, data) {
res.json({ success: true, data: data })
});
})
router.get('/getusers/:id', function(req, res) {
userModel.findById(req.params.id, { password: 0 }, function(err, data) {
if (err) {
res.json({ success: false, msg: "No user with this id" })
} else {
res.json({ success: true, data: data })
}
})
})
router.put('/updateuser/:id', function(req, res) {
var user = {};
if (req.body.email) {
user.email = req.body.email;
}
if (req.body.firstname) {
user.firstname = req.body.firstname
}
if (req.body.lastname) {
user.lastname = req.body.lastname
}
userModel.findOneAndUpdate({ '_id': mongoose.Types.ObjectId(req.params.id) }, { $set: user }, function(err, data) {
if (err) {
res.json({ success: false, msg: "No user with this id" })
} else {
res.json({ success: true, data: data, msg: "User Updated Succesfully" })
}
})
})
router.delete('/removeuser/:id', function(req, res) {
userModel.remove({ '_id': mongoose.Types.ObjectId(req.params.id) }, function(err, data) {
if (err) {
res.json({ success: false, msg: "No user with this id" })
} else {
res.json({ success: true, data: data, msg: "User Deleted Succesfully" })
}
})
})
router.post('/adduser', function(req, res) {
var user = new userModel();
user.password = req.body.password;
user.email = req.body.email;
user.lastname = req.body.lastname;
user.firstname = req.body.firstname;
user.addedDate = new Date();
user.save(function(err, data) {
if (err) {
res.json({ success: false, msg: "Error in User Creation", data: err })
} else {
/* if (req.body.sendPassword) {
var mailOptions = {
from: From,
to: data.email,
subject: 'Project Tracking Management - Please Check Your Password',
html: '<p>User Name: <b>' + data.email + '</b> <hr/> Password:+'
data.password + ' <b></b> <hr/></p>'
}
transporter.sendMail(mailOptions, function(error, response) {
if (error) {
console.log("error" + JSON.stringify(error))
console.log("mail Not send Some Error Occursc" + JSON.stringify(error));
} else {
console.log('Mail Send Successfully');
}
});
}*/
res.json({ success: true, data: data, msg: "User Created Succesfully" })
}
})
})
router.post('/loginuser', function(req, res) {
userModel.findOne({ email: req.body.email, password: req.body.password }, { password: 0 }, function(err, data) {
if (err) {
res.json({ success: false, msg: "Error in Log in " })
} else {
if (data) {
res.json({ success: true, data: data, msg: "User Logged in Succesfully" })
} else {
res.json({ success: false, msg: "Error in Log in " })
}
}
})
})
}
|
var path = require('path');
var express = require('express');
var exphbs = require('express-handlebars');
var fs = require('fs');
var app = express();
var port = process.env.PORT || 3000;
var postData = require('./posts');
app.engine('handlebars', exphbs({ defaultLayout: 'main'}));
app.set('view engine', 'handlebars');
app.use(express.json());
app.use(express.static('public'));
app.get('/', function (req, res) {
//res.status(200).sendFile(path.join(__dirname, 'public', 'index.html'));
res.status(200).render('home', {
posts: postData
});
});
app.post('/post', function( req, res, next) {
console.log("--------")
console.log(req.body);
postData.push({
item: req.body.item,
photo: req.body.photo,
price: req.body.price,
comments: req.body.comments,
contacts: req.body.contacts,
password: req.body.password
});
var content = JSON.stringify(postData, null, "\t");
fs.writeFile('./posts.json', content, (err) => {
if (err) throw err;
});
res.status(200).send("Posted Successfully!");
});
app.post('/delete', function(req, res, next){
console.log(req.body.num);
var num = parseInt(req.body.num,10);
console.log(num);
console.log("-=-Before-=-");
console.log(postData);
console.log("-=-After-=-");
postData.splice(num,1);
console.log(postData);
var content = JSON.stringify(postData);
fs.writeFile('./posts.json', content, (err) => {
if (err) throw err;
});
});
app.get('*', function (req, res) {
res.status(200).render('404');
});
app.listen(port, function () {
console.log("== Server is listening on port", port);
});
|
import availableCardsReducer from '../availableCardsReducer';
import * as actions from '../../actions';
import * as mocks from '../../mocks/mockCards';
describe("Available Cards Reducer", () => {
it("should return the default state", () => {
const expected = [];
expect(availableCardsReducer(undefined, 'abc')).toEqual(expected);
});
it("should add an available card", () => {
const expected = [mocks.mockCard];
expect(availableCardsReducer(undefined,
actions.addAvailableCard(mocks.mockCard))).toEqual(expected);
});
it("should add multiple available cards", () => {
const expected = mocks.mockCards;
expect(availableCardsReducer(undefined,
actions.addAvailableCards(mocks.mockCards))).toEqual(expected);
});
it("should remove an available card", () => {
const expected = [mocks.mockCard];
expect(availableCardsReducer(mocks.mockCards,
actions.removeAvailableCard(2))).toEqual(expected);
});
});
|
// See http://www.basecamphq.com/api/
// Error Handler
window.onerror = errorHandler;
// Constants
var BASECAMP_URL = "http://freja.projectpath.com";
Freja.AssetManager.HTTP_METHOD_TUNNEL = null;
// 3rd party libraries.
var helpers = new wHELPERS(); // misc. javascript functions
// ---------------------------------------------------------------------------------------------
// ASSETS
// ---------------------------------------------------------------------------------------------
// Views
var project_view = getView("views/project.xsl");
var projectSelector_view = getView("views/project_selector.xsl");
var todoList_view = getView("views/todo_list.xsl");
var messageList_view = getView("views/message_list.xsl");
var message_view = getView("views/message.xsl");
var comment_view = getView("views/comment.xsl");
var milestoneList_view = getView("views/milestone_list.xsl");
var categoryList_view = getView("views/category_list.xsl");
// Models
var projects = getModel("models/projects.xml"); // Snapshot. Live data: getModel(addProxyToUrl("/project/list")));
var todos = null;
var messages = null;
var milestones = null;
var categories = null;
var comments = null;
// Variables
var currentProjectId = null;
// Project Dependent Assets
function loadProjectAssets(projectId) {
if(!projectId)
currentProjectId = projects.get("//project[status='active']/id");
else
currentProjectId = projectId;
// snapshots (used for development only)
// todos = getModel("models/todos.xml");
// messages = getModel("models/posts.xml");
// milestones = getModel("models/milestones.xml");
// categories = getModel("models/categories.xml");
// Live data
todos = getModel(addProxyToUrl("/projects/"+currentProjectId+"/todos/lists"));
messages = getModel(addProxyToUrl("/projects/"+currentProjectId+"/msg/archive")); //
milestones = getModel(addProxyToUrl("/projects/"+currentProjectId+"/milestones/list"));
categories = getModel(addProxyToUrl("/projects/"+currentProjectId+"/post_categories"));
requestTemplate = getModel("models/new_request.xml"); // xml wrapper for posted data
messageTemplate = getModel("models/new_post.xml"); // skeleton for new data
commentTemplate = getModel("models/new_comment.xml"); // skeleton for new data
//Freja._aux.connect(messages, 'onload', loadAllComments);
todoList_view.render(todos, 'placeholder_todos');
messageList_view.render(messages, 'placeholder_messages');
milestoneList_view.render(milestones, 'placeholder_milestones');
categoryList_view.render(categories, 'placeholder_categories');
}
Freja._aux.connect(projects, 'onload', function(){loadProjectAssets()});
// ---------------------------------------------------------------------------------------------
// INITIALIZATION
// ---------------------------------------------------------------------------------------------
function init() {
projectSelector_view.render(projects, 'placeholder_projectSelector');
}
// ---------------------------------------------------------------------------------------------
// VIEW BEHAVIORS
// ---------------------------------------------------------------------------------------------
todoList_view.behaviors["editToDoListLink"] = {
onclick : function(node) {
var id = extractId(node.id);
}
}
messageList_view.behaviors["editMessageLink"] = {
onclick : function(node) {
var id = extractId(node.id);
if(!isMessageFullyLoaded(id)) {
loadFullMessage(id); // prefetch full message
}
editMessage(id);
return false;
}
}
messageList_view.behaviors["trashMessageLink"] = {
onclick : function(node) {
if(confirm('Are you sure you want to delete this message?')) {
var id = extractId(node.id);
var trashed = messages.document.selectSingleNode("//post[id='"+id+"']");
trashed.setAttribute('synchronized','false');
synchronize(messages,"/msg/delete/"+id);
trashed.parentNode.removeChild(trashed);
messageList_view.render(messages, 'placeholder_messages');
}
return false;
}
}
messageList_view.behaviors["newMessageLink"] = {
onclick : function(node) {
id = createMessage();
message_view.render(messages, 'placeholder_messages', {messageId: id});
return false;
}
}
messageList_view.behaviors["refreshCommentsLink"] = {
onclick : function(node) {
id = extractId(node.id);
// loadComments(id);
messageList_view.render(messages, 'placeholder_messages');
showModelSnapshot(messages);
return false;
}
}
messageList_view.behaviors["newCommentLink"] = {
onclick : function(node) {
messageId = extractId(node.id);
id = createComment(messageId);
comment_view.render(messages, 'placeholder_messages', {commentId: id});
return false;
}
}
messageList_view.behaviors["editCommentLink"] = {
onclick : function(node) {
var id = extractId(node.id);
editComment(id);
// if(!isCommentLoaded(id)) {
// loadComment(id); // prefetch full message
// }
return false;
}
}
messageList_view.behaviors["trashCommentLink"] = {
onclick : function(node) {
if(confirm('Are you sure you want to delete this comment?')) {
var id = extractId(node.id);
var trashed = messages.document.selectSingleNode("//comment[id='"+id+"']");
trashed.setAttribute('synchronized','false');
synchronize(messages,"/msg/delete_comment/"+id);
trashed.parentNode.removeChild(trashed);
messageList_view.render(messages, 'placeholder_messages');
}
return false;
}
}
message_view.behaviors["editMessageForm"] = {
onsubmit : function(node) {
var id = extractId(node.id);
messages.updateFrom(message_view);
messageList_view.render(messages, 'placeholder_messages');
if(isTempId(id)) {
// new message
synchronize(messages,"/projects/"+currentProjectId+"/msg/create" , null, function() { messageList_view.render(messages, 'placeholder_messages');} );
} else {
// edit message
synchronize(messages,"/msg/update/"+id, null, function() { messageList_view.render(messages, 'placeholder_messages');} );
}
return false;
}
}
message_view.behaviors["cancelAction"] = {
onclick : function(node) {
messageList_view.render(messages, 'placeholder_messages');
return false;
}
}
message_view.behaviors["getMessageBodyLink"] = {
onclick : function(node) {
var id = extractId(node.id);
if(isMessageFullyLoaded(id)) {
editMessage(id);
} else {
loadFullMessage(id, function() {editMessage(id)});
}
return false;
}
}
comment_view.behaviors["editCommentForm"] = {
onsubmit : function(node) {
var id = extractId(node.id);
messages.updateFrom(comment_view);
messageList_view.render(messages, 'placeholder_messages');
if(isTempId(id)) {
// new comment
synchronize(messages,"/msg/create_comment" , null, function() { messageList_view.render(messages, 'placeholder_messages');} );
} else {
// edit comment
synchronize(messages,"/msg/update_comment/", {comment_id: id}, function() { messageList_view.render(messages, 'placeholder_messages');} );
}
return false;
}
}
comment_view.behaviors["cancelAction"] = {
onclick : function(node) {
messageList_view.render(messages, 'placeholder_messages');
return false;
}
}
milestoneList_view.behaviors["editMilestoneLink"] = {
onclick : function(node) {
var id = extractId(node.id);
return false;
}
}
categoryList_view.behaviors["editCategoryLink"] = {
onclick : function(node) {
var id = extractId(node.id);
return false;
}
}
projectSelector_view.behaviors["projectSelector"] = {
onchange: function(node) {
var projectId = node.options[node.selectedIndex].value;
loadProjectAssets(projectId);
}
}
// ---------------------------------------------------------------------------------------------
// MESSAGE MANAGEMENT
// ---------------------------------------------------------------------------------------------
function isMessageFullyLoaded(id) {
var message = messages.document.selectSingleNode("//post[id='"+id+"']");
if(message) {
// message is in our message list, but could be the abbreviated version.
if(message.selectSingleNode('extended-body'))
return true;
}
return false;
}
function loadFullMessage(id, callback) {
var newMessage = getModel(addProxyToUrl("/msg/get/"+id));
Freja._aux.connect(newMessage,'onload', function() {
var importedNode = newMessage.document.documentElement;
if(messages.document.importNode) {
importedNode = messages.document.importNode(importedNode,true);
} // else use cloneNode?
var currentNode = messages.document.selectSingleNode("//post[id='"+id+"']");
if(currentNode) {
currentNode.parentNode.insertBefore(importedNode,currentNode);
currentNode.parentNode.removeChild(currentNode);
} else {
messages.document.documentElement.appendChild(importedNode);
}
callback();
// need to destroy newMessage ?
});
}
function createMessage() {
if(!messageTemplate) {
// problem, template is not loaded.
return;
}
var tmpid = getRandomId();
messageTemplate.set('/post/id', tmpid);
messageTemplate.set('/post/category-id', '4007205');
if(messages.document.importNode) {
var newMessage = messages.document.importNode(messageTemplate.document.documentElement,true);
} // else try cloneNode
messages.document.documentElement.insertBefore(newMessage, messages.document.documentElement.firstChild);
return tmpid;
}
function editMessage(id) {
messages.set("/post[id='"+id+"']/@edit", 'true');
message_view.render(messages, 'placeholder_messages', {messageId: id});
}
function editComment(id) {
comment_view.render(messages, 'placeholder_messages', {commentId: id});
}
function createComment(messageId) {
var tmpid = getRandomId();
commentTemplate.set('/comment/post-id', messageId);
commentTemplate.set('/comment/id', tmpid);
if(messages.document.importNode) {
var newComment = messages.document.importNode(commentTemplate.document.documentElement,true);
} // else try cloneNode
var parentMessage = messages._query._find(messages.document,"//post[id='"+messageId+"']");
if(parentMessage) {
var parentMessage = parentMessage.parentNode; // _find returns a text node
var commentList = parentMessage.getElementsByTagName('comments');
if(commentList.length==0) {
var commentRoot = messages.document.createElement('comments');
commentRoot = parentMessage.appendChild(commentRoot);
} else
var commentRoot = commentList[0];
commentRoot.appendChild(newComment);
}
return tmpid;
}
function loadAllComments() {
var posts = messages.document.getElementsByTagName('post');
for (var i=0;i<posts.length;i++) {
loadComments(posts[i]);
}
}
function loadComments(message) {
var messageId = message.getElementsByTagName('id')[0].firstChild.nodeValue;
var messageComments = getModel(addProxyToUrl("/msg/comments/"+messageId));
Freja._aux.connect(messageComments, 'onload',
function() {
attachComments(message,messageComments);
} );
}
function attachComments(message, messageComments) {
var newComments = messages.document.importNode(messageComments.document.documentElement, true);
message.appendChild(newComments,true);
}
// ---------------------------------------------------------------------------------------------
// Synchronize:
// 1. Takes the given model, finds XML elements that are out-of-sync (@synchronized=fase).
// 2. Copies each out-of-sync element to a new XML document within a <request> element.
// 3. Adds additional elements if provided in the additionalParameters object.
// 4. Sends the <request> XML to the given url (withUrl)
// 5. If responses is OK, replaces the out-of-sync element in the model with the received data.
// 6. Clear @synchronized attribute
// 7. Callback (if provided)
// ---------------------------------------------------------------------------------------------
function synchronize(model, withUrl, additionalParameters, callback) {
// get first record to be synchronized
var outofsync = model.document.selectSingleNode("//*[@synchronized='false']");
if(outofsync) {
// clean synchronized attribute before using outofsync to build the request
// (basecamp API doesn't like foreign attributes)
outofsync.removeAttribute('synchronized');
// clean previous request if any.
var requestNode = requestTemplate.document.documentElement
while(requestNode.firstChild)
requestNode.removeChild(requestNode.firstChild);
// prepare request
requestTemplate.url = addProxyToUrl(withUrl);
// add request parameters if any
if(additionalParameters) {
for(var p in additionalParameters) {
var paramElement = requestTemplate.document.createElement(p);
paramElement.appendChild(requestTemplate.document.createTextNode(additionalParameters[p]));
requestNode.appendChild(paramElement);
}
}
// add data to request
requestNode.appendChild(requestTemplate.document.importNode(outofsync, true));
// clean tmp ids
var idNodes = requestNode.getElementsByTagName('id');
for(var i=idNodes.length-1; i>=0; i--) {
if(idNodes[i].firstChild && isTempId(idNodes[i].firstChild.nodeValue)) {
idNodes[i].parentNode.removeChild(idNodes[i]);
}
}
// clean whatever basecamp API chokes on
var nodes = requestNode.getElementsByTagName('updated-on');
for(var i=nodes.length-1; i>=0; i--) {
nodes[i].parentNode.removeChild(nodes[i]);
}
showModelSnapshot(requestTemplate);
showHTTPResponse("WAITING...");
// send request
var d = requestTemplate.save();
d.addCallback(function(obj) {
showHTTPResponse("OK:\n"+obj.responseText);
var updatedData = model.document.importNode(obj.responseXML.documentElement, true);
if(updatedData) {
// Replace current model data with what we've received.
// (mostly to get the record's id, but more new data may be present)
while(outofsync.firstChild)
outofsync.removeChild(outofsync.firstChild);
while(updatedData.firstChild) {
outofsync.appendChild(updatedData.firstChild);
}
}
outofsync.setAttribute('synchronized','true');
//showModelSnapshot(model);
if(callback)
callback();
});
d.addErrback(function(obj) {
showHTTPResponse("ERROR:\n"+obj.responseText);
outofsync.setAttribute('synchronized','failed');
});
outofsync.setAttribute('synchronized','pending');
//is there more to synchronize?
//outofsync = model.document.selectSingleNode("//*[@synchronized='false']");
}
}
// ---------------------------------------------------------------------------------------------
// MISC.
// ---------------------------------------------------------------------------------------------
function extractId(obj) {
// parameter: 'anystring__id' or [event object] or [object]
// Get the id attribute if necessary and returns the part after the '__'.
// Used to encode a Model element id in a unique html id.
if(!obj) obj = window.event;
switch(typeof obj) {
case 'string':
id = obj;
break;
case 'object':
if(!obj.id)
obj = helpers.getSourceElement(obj);
id = obj.id;
break;
case 'undefined':
return null;
break;
default:
alert('extractId, unhandled object type: ' + typeof obj);
return null;
break;
}
id = id.substr(id.lastIndexOf('__')+2);
return id;
}
// Temp ids are used locally but do not match Basecamp record ids.
function isTempId(id) {
if(id.indexOf('tmpid-')==0)
return true
return false;
}
function getRandomId() {
var seed = (new Date()).getTime();
seed = seed.toString().substr(6);
for (var i=0; i<3;i++)
seed += String.fromCharCode(48 + Math.floor((Math.random()*10)));
return "tmpid-" + seed
}
function addProxyToUrl(resourceUrl) {
return "proxy/php/proxy.php?url="+encodeURIComponent(BASECAMP_URL+resourceUrl);
}
// ---------------------------------------------------------------------------------------------
// debug misc.
// ---------------------------------------------------------------------------------------------
function showModelSnapshot(model) {
var xml = Freja._aux.serializeXML(model.document);
var dbg = document.getElementById('placeholder_debug');
dbg.innerHTML = "<textarea cols='60' rows='15'>"+(new Date()).toLocaleTimeString() + ' ' + xml+"</textarea>";
dbg.style.display = "block";
}
function showHTTPResponse(txt) {
var dbg = document.getElementById('placeholder_debug2');
dbg.innerHTML = "<textarea cols='60' rows='15'>"+ (new Date()).toLocaleTimeString()+ ' ' +txt+"</textarea>";
dbg.style.display = "block";
}
// ---------------------------------------------------------------------------------------------
// errorHandler
// ---------------------------------------------------------------------------------------------
function errorHandler(desc,page,line,chr) {
alert(
'Sorry, a JavaScript error occurred! \n'
+'\nError description: \t'+desc
+'\nPage address: \t'+page
+'\nLine number: \t'+line
)
return true
}
// let's go!
window.onload = init;
|
import { APIReq, GetUserID } from '.'
export const CreateLink = async (linkObj) => {
const response = await APIReq("/links", "POST", linkObj)
return response
}
export const GetUserLinks = async () => {
const response = await APIReq("/links/user/"+ await GetUserID())
return response
}
|
import React from 'react';
import logo from './logo.svg';
import './App.css';
const App = () => {
return(
<div>
<div>Header</div>
<div>Hello my World</div>
<div className="App">
<ul>
<li>fish</li>
<li>cat</li>
<li>plane</li>
</ul>
</div>
</div>
);
}
const Header = () => {
return(
<div>
<ul>
<li><a href="#">Home</a></li>
<li><a href="#">About As</a></li>
<li><a href="#">Project</a></li>
<li><a href="#">Team</a></li>
<li><a href="#">Contact</a></li>
</ul>
</div>
);
}
export default App;
|
define(['apps/system3/business/business',
'apps/system3/business/project/project.controller.maintain',
'apps/system3/business/project/project.service'], function (app) {
app.module.controller("business.controller.project", function ($scope,$timeout,$uibModal, projectService, attachService) {
// 查询条件
$scope.filter = {
pagesize: $scope.pageSize,
pageindex: 1,
trash: false,
orderby: 'ID'
};
// 表格配置
$scope.gridOptions = {
multiSelect: true,
enableGridMenu: false,
enableColumnResizing: true,
paginationPageSizes: $scope.pageSizes,
paginationPageSize: $scope.pageSize,
useExternalPagination: true,
useExternalSorting: false,
enableRowSelection: true,
enableRowHeaderSelection: true,
columnDefs: [
{
name: 'Number', displayName: $scope.local.proj.number, enableColumnMenu: $scope.screenModel == 1,
width: 120, maxWidth: 200, minWidth: 70, pinnedLeft: $scope.screenModel == 1
},
{
name: 'Name', displayName: $scope.local.proj.name, enableColumnMenu: $scope.screenModel == 1, minWidth: 200
},
{
name: 'Manager', displayName: $scope.local.proj.manager, enableColumnMenu: false, width: '100',
cellFilter: 'enumMap:"user"'
},
{
name: 'Customer.Name', displayName: $scope.local.proj.customer, width: '200', enableColumnMenu: false,
},
{
name: 'Type', displayName: $scope.local.proj.type, width: '150', enableColumnMenu: false,
cellFilter: 'enumMap:"ProjectType"'
},
{
name: 'VolLevel', displayName: $scope.local.proj.vollevel, enableColumnMenu: false, width: '100',
cellFilter: 'enumMap:"VolLev"'
},
{
name: 'CreateDate', displayName: $scope.local.proj.createdate, enableColumnMenu: false, width: '150',
cellFilter: 'TDate'
},
{
name: 'DeliveryDate', displayName: $scope.local.proj.deliverydate, enableColumnMenu: false, width: '150',
cellFilter: 'TDate'
}
],
rowTemplate: "<div " +
"ng-click=\"grid.appScope.gridApi.selection.toggleRowSelection(row.entity)\" ng-dblclick=\"grid.appScope.update(row.entity)\" " +
"ng-repeat=\"(colRenderIndex, col) in colContainer.renderedColumns track by col.colDef.name\" class=\"ui-grid-cell\" " +
"ng-class=\"{ 'ui-grid-row-header-cell': col.isRowHeader }\" ui-grid-cell ></div>",
onRegisterApi: function (gridApi) {
$scope.gridApi = gridApi;
$scope.gridApi.core.on.sortChanged($scope, function (grid, sortColumns) {
$scope.filter.orderby = sortColumns;
if (sortColumns.length == 0) {
$scope.filter.orderby = null;
} else {
$scope.filter.orderby = sortColumns[0].field;
$scope.filter.orderdirection = sortColumns[0].sort.direction;
}
});
gridApi.pagination.on.paginationChanged($scope, function (newPage, pageSize) {
$scope.filter.pagesize = pageSize,
$scope.filter.pageindex = newPage;
});
gridApi.selection.on.rowSelectionChanged($scope, function (row, e) {
$scope.selectedRows = gridApi.selection.getSelectedRows();
if (row.isSelected) {
$scope.currentProject = row.entity;
}
});
}
};
// 加载页面数据
$scope.loadSource = function () {
$scope.gridPanel.block();
projectService.getProjects($scope.filter).then(function (result) {
$scope.gridOptions.data = result.Source;
$scope.gridOptions.totalItems = result.TotalCount;
$scope.gridApi.selection.selectRow($scope.gridOptions.data[0]);
$scope.gridPanel.unblock();
})
};
// 重置查询条件
$scope.clearFilter = function () {
$scope.filter = {
pagesize: $scope.pageSize,
pageindex: 1,
orderby: 'ID'
};
};
// 新建
$scope.create = function () {
$uibModal.open({
animation: false,
size: 'lg',
templateUrl: 'apps/system3/business/project/view/project-maintain.html',
controller: 'business.controller.project.maintain',
resolve: {
maintainParams: function () {return {}}
}
}).result.then(function (info) {
bootbox.alert("创建成功");
$scope.gridOptions.data.push(info);
});
};
// 更新
$scope.update = function (info) {
$uibModal.open({
animation: false,
size: 'lg',
templateUrl: 'apps/system3/business/project/view/project-maintain.html',
controller: 'business.controller.project.maintain',
resolve: {
maintainParams: function () {
return {
entityInfo: info,
}
}
}
}).result.then(function (info) {
bootbox.alert("更新成功");
});
};
// 删除
$scope.delete = function () {
if ($scope.selectedRows == undefined) {
bootbox.alert($scope.local.msg.noRowSelected);
}
var ids = $scope.selectedRows.map(function (obj) {
return obj.ID;
});
if ($scope.filter.trash) {
// 回收站状态，恢复选中对象
bootbox.confirm($scope.local.msg.confirmBackup, function (result) {
if (result === true) {
projectService.backup(ids).then(function () {
angular.forEach($scope.selectedRows, function (proj) {
$scope.gridOptions.data.removeObj(proj);
})
bootbox.alert("恢复成功");
});
}
});
} else {
bootbox.confirm($scope.local.msg.confirmDelete, function (result) {
if (result === true) {
projectService.batchRemove(ids).then(function () {
angular.forEach($scope.selectedRows, function (proj) {
$scope.gridOptions.data.removeObj(proj);
})
bootbox.alert("删除成功");
});
}
});
}
};
// 监听筛选条件查询数据
$scope.$watch("filter", function (newval, oldval) {
if (newval.txtfilter != undefined && newval.txtfilter != "") {
return;
}
$scope.loadSource();
}, true);
});
});
|
import { BaseClass } from '../../src/index.js';
describe('BaseClass', function(){
const Derived = BaseClass.extend({});
const instance = new Derived();
it('should have `extend` method', function(){
expect(BaseClass.extend).to.be.a('function');
});
it('`extend` should create Derived class', function(){
expect(instance).to.be.instanceOf(BaseClass);
});
});
|
import React, { Component } from 'react'
import './index.css'
import AuthProvider from '../../../../funStore/AuthProvider'
import promiseXHR from '../../../../funStore/ServerFun'
import {API_PATH} from '../../../../constants/OriginName'
import {sendEvent} from '../../../../funStore/CommonFun'
export default class AccurateBlock extends Component {
constructor() {
super();
this.state = {
templateItemsSet: []
}
}
componentWillMount() {
// 根据类型获取模板元素
const url = `${API_PATH}/groupadmin-api/authsec/group/join/template/type/items?_type=4`
AuthProvider.getAccessToken().then((reslove,reject)=> {
return promiseXHR(url ,{type:'Bearer',value:reslove},null,'get')
}).then(res => {
const resData = JSON.parse(res)
const {params} = this.props
if(resData.resultCode==100){
// 模板初始化设置 初始设置 非 活动说明，标题，提交，协议； 添加 mandatory字段： 0可选，1必填
let templateItemsSet = resData.resultContent.map(v => {
if(params.id){
return params.template.templateItems.find(i => i.code==v.code)
?{...v,selected:true,isError: false,mandatory:0}
:{...v,selected:false,isError: false,mandatory:0}
}else{
return v.code == 'DESCRIPTION'
||v.code == 'H5_FORM_TITLE'
||v.code == 'SUBMIT'
||v.code == 'TERMS'
||v.code == 'PHONE'
||v.code == 'CITY'
?{...v,selected:true,isError: false,mandatory:0}
:{...v,selected:false,isError: false,mandatory:0}
}
})
this.setState({
templateItemsSet
})
this.props.initTemplateItem(templateItemsSet)
}else{
throw '获取模板元素失败'
}
}).catch(err => {
console.log(err)
})
}
componentWillReceiveProps(nextProps){
if(this.props.params.id!=nextProps.params.id){
let templateItemsSet = this.state.templateItemsSet
templateItemsSet = templateItemsSet.map(v => {
return nextProps.params.template.templateItems.find(i => i.code==v.code)?{
...v,
selected: true
}:{
...v,
selected: false
}
})
this.setState({templateItemsSet})
}
}
clickHandle=(item)=>{
let {templateItemsSet} = this.state
let {disabled} = this.props
if(disabled) return
let sortItems = templateItemsSet.filter(v => v.code !='DESCRIPTION'&&v.code !='H5_FORM_TITLE'&&v.code !='SUBMIT'&&v.code != 'TERMS'&&v.selected)
if(sortItems.length<4||item.selected||item.code == 'DESCRIPTION'||item.code == 'H5_FORM_TITLE'||item.code == 'SUBMIT'||item.code == 'TERMS'){
// 最多只有4个元素
let {setparamsHandle} = this.props
templateItemsSet = templateItemsSet.map(v => {
return v.id == item.id?{
...v,
selected: !v.selected
}:v
})
this.setState({templateItemsSet})
setparamsHandle(item)
}else{
sendEvent('message', {
txt: "最多只能添加4个输入模块",
code: 1003
})
}
}
render() {
let { templateItemsSet} = this.state;
let {setparamsHandle,disabled} = this.props
return (
<div className="AccurateBlockBox">
<div className='AccurateBlock'>
{
templateItemsSet.map((item, index) => {
return (
item.code=='SUBMIT'
?null
:<div className={`AccurateBlockItem ${item.selected?'active':'normal'} ${disabled?'disabled':''}`} key={index} onClick={()=>{this.clickHandle(item)}}>
{item.name}
<span className='icon-check'></span>
</div>
)
})
}
</div>
{/* <div className="tips">
小提示：点击左图“模版预览”中的任何功能模块都能及时编辑的哦～
</div> */}
</div>
)
}
}
|
const leaderBoard = document.querySelector("#table-scores");
const scoreBoardReset = document.querySelector("#get-top-scores");
const gameButton = document.querySelector("#submit-new-energiser");
const userButton = document.querySelector("#submit-new-user");
userButton.addEventListener("click", submitUser);
gameButton.addEventListener("click", updateScores);
// Take in put from the Website Form
// inputs.value
//Add event listener - submit button
//Submits into in the correct format to send to our database via a get request
// Post to our database
async function updateScores() {
const response = await fetch("http://localhost:3000/energiser/game", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(gameEntry())
});
const data = await response.json(); // we need to send a reasponse of some kind that acknowledges weve recipeved the input
console.log(data);
}
async function submitUser() {
const response = await fetch("http://localhost:3000/energiser", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(userEntry())
});
const data = await response.json(); // we need to send a reasponse of some kind that acknowledges weve recipeved the input
console.log(data.userId);
alert(`This is your User ID: ${data.userId}. Please use to enter energiser scores.`);
}
function gameEntry(){
const date = document.querySelector("#date").value;
const gamePlayed = document.querySelector("#games-played").value;
const userId = document.querySelector("#user-id").value;
const wins = document.querySelector("#wins").value;
const points = document.querySelector("#points").value;
document.querySelector("#enter-new-game").reset();
return {
date,
gamePlayed,
userId,
wins,
points
};
}
function userEntry(){
const first_name = document.querySelector("#first-name").value;
const second_name = document.querySelector("#last-name").value;
const user_name = document.querySelector("#user-name").value;
document.querySelector("#enter-new-user").reset();
return {
first_name,
second_name,
user_name
};
}
//Game Pic Selection
const pictionaryPic = document.querySelector("#pictionary-pic");
const mindPic = document.querySelector("#mind-pic");
const scattergoriesPic = document.querySelector("#scattergories-pic");
scoreBoardReset.addEventListener("click", resetScoreBoard);
//Game Event Listeners
pictionaryPic.addEventListener("click", getPictionaryTop5);
mindPic.addEventListener("click", getMindTop5);
scattergoriesPic.addEventListener("click", getScattergoriesTop5);
//Create Functions that get top5 for all game categories
async function getPictionaryTop5(){
console.log("Hello");
const response = await fetch("http://localhost:3000/energiser/getPictionaryTop5");
const {payload} = await response.json();
console.log(payload);
pictionaryRun(payload);
}
async function getScattergoriesTop5(){
console.log("Hello");
const response = await fetch("http://localhost:3000/energiser/getScattergoriesTop5");
const {payload} = await response.json();
console.log(payload);
scattergoriesRun(payload);
}
async function getMindTop5(){
console.log("Hello");
const response = await fetch("http://localhost:3000/energiser/getMindTop5");
const {payload} = await response.json();
console.log(payload);
mindRun(payload);
}
function pictionaryRun(payload){
mindPic.src="";
scattergoriesPic.src="";
addLeaderCols();
payload.forEach(addLeaderRows);
}
function scattergoriesRun(payload){
mindPic.src="";
pictionaryPic.src="";
addLeaderCols();
payload.forEach(addLeaderRows);
}
function mindRun(payload){
scattergoriesPic.src="";
pictionaryPic.src="";
addLeaderCols();
payload.forEach(addLeaderRows);
}
// Creates the Rows for the Table
function addLeaderCols(){
const row = document.createElement("tr");
const rowFN = document.createElement("th");
const rowTW = document.createElement("th");
const rowTP = document.createElement("th");
rowFN.innerText = "First Name";
rowTW.innerText = "Total Wins";
rowTP.innerText = "Total Points";
row.appendChild(rowFN);
row.appendChild(rowTW);
row.appendChild(rowTP);
leaderBoard.appendChild(row);
leaderBoard.classList.add("col-names");
};
// Creates the Leaders Rows
function addLeaderRows(player){
const row = document.createElement("tr");
const rowFN = document.createElement("th");
const rowTW = document.createElement("th");
const rowTP = document.createElement("th");
rowFN.innerText = player.first_name;
rowTW.innerText = player.total_wins;
rowTP.innerText = player.total_points;
row.appendChild(rowFN);
row.appendChild(rowTW);
row.appendChild(rowTP);
leaderBoard.appendChild(row);
};
function resetScoreBoard(){
leaderBoard.innerHTML = "";
pictionaryPic.src="Pictionary3.png";
scattergoriesPic.src="Scategories.jpeg";
mindPic.src="Mind2.jpg";
}
|
function RegisterGCM() {
//register device to GCM & send key to server
var push = PushNotification.init({
"android": { "senderID": "268098525942" },
"ios": { "alert": "true", "badge": "true", "sound": "true" },
"windows": {}
});
push.on('registration', function (data) {
//send deviceid to application server
// console.log(JSON.stringify(data));
url = WebUrlService.url + "sendNotification/" + data.registrationId;
$scope.Login_Information = url;
$http.get(url).then(function (response) {
// $scope.Info = response.data.sendNotificationResult;
});
});
push.on('notification', function (data) {
$scope.Info = data.message;
// data.message,
// data.title,
// data.count,
// data.sound,
// data.image,
// data.additionalData
});
push.on('error', function (e) {
console.log(data.message);
});
}
|
// @flow
function fibonacciFactory(fib : number => number) : number => number {
return (n : number) => {
if (n < 3) return 1;
return fib(n - 1) + fib(n - 2);
}
}
function y<A, B>(fn: (A => B) => (A => B)) : A => B {
function result (arg : A) : B {
const completeFunction : A => B = fn(result);
return completeFunction(arg);
};
return result;
}
const fibonacci = y(fibonacciFactory);
function testFib(fib : number => number) {
console.log([1, 2, 3, 4, 5, 6, 7].map(fib));
}
testFib(fibonacci);
const fibonacci2 = fibonacciFactory(fibonacci);
testFib(fibonacci2);
const fibonacci3 = fibonacciFactory(fibonacciFactory(fibonacci));
testFib(fibonacci3);
|
/**
* Configure your Gatsby site with this file.
*
* See: https://www.gatsbyjs.org/docs/gatsby-config/
*/
module.exports = {
plugins: ["gatsby-theme-casper"],
siteMetadata: {
title: 'Ghost',
description: 'The professional publishing platform',
coverImage: 'img/blog-cover.jpg',
logo: 'img/ghost-logo.png',
lang: 'en',
siteUrl: 'https://gatsby-casper.netlify.com',
facebook: 'https://www.facebook.com/ghost',
twitter: 'https://twitter.com/tryghost',
showSubscribe: true,
mailchimpAction: 'https://twitter.us19.list-manage.com/subscribe/post?u=a89b6987ac248c81b0b7f3a0f&id=7d777b7d75',
mailchimpName: 'b_a89b6987ac248c81b0b7f3a0f_7d777b7d75',
mailchimpEmailFieldName: 'MERGE0',
googleSiteVerification: 'GoogleCode',
footer: 'is based on Gatsby Casper',
postsPerPage: 6,
},
}
|
import React from "react";
import Chart from "react-apexcharts";
import './linechart.css';
export const Linechart = ({ y }) => {
const getOptions = () => {
return {
chart: {
zoom: {
enabled: false
},
animations: {
enabled: true,
easing: 'linear',
dynamicAnimation: {
speed: 1000
}
},
background: 'none'
},
theme: {
mode: 'dark'
},
stroke: {
width: 3,
colors: ['#ffc107', '#34c3ff'],
},
xaxis: {
labels: {
show: false
},
},
yaxis: {
min: 0,
max: 100
},
tooltip: {
enabled: false
},
legend: {
show: false
}
}
}
return (
<Chart
options={getOptions()}
series={y}
type="line"
width="500"
/>
);
}
|
Objective
Create a <div> box with an onClick handle event that changes the background color when clicked.
When the box is clicked, we want a clickCounter indicating how many times it was clicked.
We want the box color to toggle back to it's original color! (Hint: create a toggle function)
Updated functional component to a class component (App.js)
Set state ( color & clickCounter)
When the button is clicked onChange function called where setstate function is used to modify the counter
value
Ternary operator is used to toggle between blue and orange color
|
$("#boxTrigger").on("click", function(){
var div = document.createElement("div");
div.className = "foo";
$(this).closest("body").find(".container").append(div);
});
$("#boxDelete").on("click", function(){
$(this).closest("body").find(".container").empty();
});
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.