text
stringlengths 7
3.69M
|
|---|
import React,{Component} from 'react';
import {Dropdown} from 'react-bootstrap';
export default class Header extends Component {
constructor(props) {
super (props);
this.state = {
inputValue: '',
isVisible: false
}
}
// the button handler
inputValue(e) {
this.setState({inputValue:e.target.value});
}
enter(e) {
console.log(this.state.inputValue);
fetch('/names/'+this.state.inputValue)
.then(res => {return res.json()})
.then(data => {
console.log(data[0].list);
// return data;
})
}
//make the categories hyperlinks(with no link)
//attach a drop down menu on scroll
render (){
return (
<div id= 'header'>
<img src = {"https://www.visitdevonport.com.au/wp-content/uploads/2019/07/Target.png"} id = 'headPic' alt = 'logo'></img>
<Dropdown>
<Dropdown.Toggle variant="success" id="header-button">
Categories
</Dropdown.Toggle>
<Dropdown.Menu>
<Dropdown.Item eventKey="1">Main Menu</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Grocery</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Household Essentials</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Halloween</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Woman</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Men</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Young Adult</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Kids</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Baby</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Shoes</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Home</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Furniture</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Kitchen & Dining</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Patio & Garden</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Toys</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Electronics</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Video Games</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Movies, Music & Books</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Sports & Outdoors</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Beauty</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Personal Care</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Health</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Pets</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Luggage</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">School & Office Supplies</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Party Supplies</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Christmas</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Gift Cards</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Gift Ideas</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Clearance</Dropdown.Item>
<Dropdown.Divider />
</Dropdown.Menu>
</Dropdown>
<Dropdown>
<Dropdown.Toggle variant="success" id="header-button">
Deals
</Dropdown.Toggle>
<Dropdown.Menu>
<Dropdown.Item href="#/action-1">Clearance</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-2">Weekly Ad</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-3">Top Deals</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-4">RedCard Exclusives</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Target Circle Offers</Dropdown.Item>
<Dropdown.Divider />
</Dropdown.Menu>
</Dropdown>
<Dropdown>
<Dropdown.Toggle variant="success" id="header-button">
Whats New
</Dropdown.Toggle>
<Dropdown.Menu>
<Dropdown.Item href="#/action-1">#Target Style</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-2">New in Beauty</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-3">New in Woman's</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-4">Home New Arrivals</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Kids' New Arrivals</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Home Fall Trends & Inspo</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Collector's Spot</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Target Finds</Dropdown.Item>
<Dropdown.Divider />
</Dropdown.Menu>
</Dropdown>
<Dropdown>
<Dropdown.Toggle variant="success" id="header-button">
Pickup & Delivery
</Dropdown.Toggle>
<Dropdown.Menu>
<Dropdown.Item href="#/action-1">Order Pickup</Dropdown.Item>
<Dropdown.Item href="#/action-2">Same Day Delivery</Dropdown.Item>
<Dropdown.Item href="#/action-3">Drive Up</Dropdown.Item>
</Dropdown.Menu>
</Dropdown>
<input id='searchbar' type = 'text' className = 'searchbar' placeholder = 'Search' onChange = {(e) => { this.inputValue(e) }}></input>
<button id = 'button' onClick = {(e) => {this.enter(e.target.value)}}>Click</button>
<Dropdown>
<Dropdown.Toggle variant="success" id="header-button">
Sign in
</Dropdown.Toggle>
<Dropdown.Menu>
<Dropdown.Item href="#/action-1">Sign in</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-2">Create account</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-3">Orders</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-1">O Circle</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-1">Gift Cards</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-4">RedCard</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">Buy it Again</Dropdown.Item>
<Dropdown.Divider />
<Dropdown.Item href="#/action-5">My Store</Dropdown.Item>
<Dropdown.Divider />
</Dropdown.Menu>
</Dropdown>
</div>
)
}
}
|
$(function(){
//script 영역 ajax 예
$.ajax({
url:'data.xml',
dataType: 'xml',
success: function(data){
//실행문
//console.log(data);
//특정데이터를 가져오는 방법 1번
//console.log($(data).find("item"));
//특정데이터를 가져오는 방법 2번
console.log($(data).find("item"));
$("item",data).each(function(){
//console.log($(this).find("link").text());
//console.log($("link",this).text());
//link text 가져오기
let linkText = $("link",this).text();
//description text 가져오기
let desText=$("description",this).text();
$("dl").append("<dt><a href='"+linkText+"'>"+linkText+"</a></dt><dd>"+desText+"</dd>")
});
}
});
//버튼에 온클래스를 추가하여 dl 노출을 toggle형태로 구현하시오.
//toggleClass사용
// $("button").click(function(){
// $(this).toggleClass("on");
// });
//if 사용
// let thisClass = $(this).attr("class");
// console.log(thisClass);
// if( thisClass == "" || thisClass == undefined ){
// //"":attr로 클래스가 추가된 상태지만 romoveClass했으므} 빈상태임.
// $(this).addClass("on");
// }else{
// $(this).removeClass("on");
// }
//hasClass사용->html파일에 class="on"추가.
$("button").click(function(){
if( $(this).hasClass("on") ){
$(this).removeClass("on");
}else{
$(this).addClass("on");
}
});
});
|
import React from "react";
import PostContainer from "../Post/PostContainer";
import Communities from "../Communities/Communities";
import Trending from "../Trending/Trending";
function FrontPage() {
return (
<div className="postContainer">
<Communities />
<PostContainer />
<Trending />
</div>
);
}
export default FrontPage;
|
/* ************************************ */
/* Define helper functions */
/* ************************************ */
var post_trial_gap = function() {
return gap;
}
/* Append gap and current trial to data and then recalculate for next trial*/
var appendData = function() {
gap = Math.floor( Math.random() * 500 ) + 500
jsPsych.data.addDataToLastTrial({ITT: gap, trial_num: current_trial})
current_trial = current_trial + 1
}
var practice_index = 0
var getFeedback = function() {
if (response_array[practice_index] == -1) {
practice_index += 1
return '<div class = centerbox><div class = center-text><font size = 20>Correct</font></p></div>'
} else {
practice_index +=1
return '<div class = centerbox><div class = center-text><font size = 20>Incorrect</font></p></div>'
}
}
/* ************************************ */
/* Define experimental variables */
/* ************************************ */
var correct_responses = jsPsych.randomization.repeat([['go',32, 'respond'],['nogo',-1, 'not respond']],1)
var gap = 0
var current_trial = 0
var train_stimuli = [
{
image: '<div class = centerbox><div id = "stim1"></div></div>',
data: { correct_response: correct_responses[0][1], condition: correct_responses[0][0], trial_id: 'practice', exp_id: 'go-nogo'}
},
{
image: '<div class = centerbox><div id = "stim2"></div></div>',
data: { correct_response: correct_responses[1][1], condition: correct_responses[1][0], trial_id: 'practice', exp_id: 'go-nogo'}
}
];
//set one of the stims to 'go' for block 1 and the other to 'go' for block 2
test_stim_responses = jsPsych.randomization.repeat([[['go',32, 'respond'],['nogo',-1, 'not respond']],[['nogo',-1, 'not respond'],['go',32, 'respond']]],1)
//set up block stim. test_stim_responses indexed by [block][stim][type]
var test_stimuli_block = [
{
image: '<div class = centerbox><div id = "stim1"></div></div>',
data: { correct_response: test_stim_responses[0][0][1], condition: test_stim_responses[0][0][0], trial_id: 'test_block', exp_id: 'go-nogo'}
},
{
image: '<div class = centerbox><div id = "stim2"></div></div>',
data: { correct_response: test_stim_responses[0][1][1], condition: test_stim_responses[0][1][0], trial_id: 'test_block', exp_id: 'go-nogo'}
}
];
var practice_trials = jsPsych.randomization.repeat(train_stimuli, 10, true);
var test_trials_block = jsPsych.randomization.repeat(test_stimuli_block, 50, true);
var response_array = [];
for (i = 0; i < practice_trials.data.length; i++) {
response_array.push(practice_trials.data[i]['correct_response'])
}
/* ************************************ */
/* Set up jsPsych blocks */
/* ************************************ */
/* define static blocks */
var welcome_block = {
type: 'text',
text: '<div class = centerbox><p class = block-text>Welcome to the Go-NoGo experiment. Press <strong>enter</strong> to begin.</p></div>',
cont_key: 13,
timing_post_trial: 0
};
var instructions_block = {
type: 'instructions',
pages: ['<div class = centerbox><p class = block-text>In this experiment blue and orange squares will appear on the screen. You will be told to respond to one of the colored squares by pressing the space bar. You should only respond to this color and withhold any response to the other color.</p></div>'],
allow_keys: false,
show_clickable_nav: true,
timing_post_trial: 1000
};
var end_block = {
type: 'text',
text: '<div class = centerbox><p class = center-block-text>Finished with this task.</p><p class = center-block-text>Press <strong>enter</strong> to continue.</p></div>',
cont_key: 13,
timing_post_trial: 0
};
var start_practice_block = {
type: 'text',
text: '<div class = centerbox><p class = block-text>We will begin with practice. If you see the <font color="orange">orange</font> square you should <strong>' + correct_responses[0][2] + '</strong>. If you see the <font color="blue">blue</font> square you should <strong>' + correct_responses[1][2] + '</strong>.</p><p class = block-text>You will get feedback telling you if you were correct.</p></div>',
timing_post_trial: 1000
};
var start_test_block = {
type: 'text',
text: '<div class = centerbox><p class = block-text>We will now begin the first test block. You will no longer get feedback about your responses.</p><p class = block-text>If you see the <font color="orange">orange</font> square you should <strong>' + test_stim_responses[0][0][2] + '</strong>. If you see the <font color="blue">blue</font> square you should <strong>' + test_stim_responses[0][1][2] + '</strong>. Press <strong>enter</strong> to begin.</p></div>',
cont_key: 13,
timing_post_trial: 1000
};
var reset_block = {
type: 'call-function',
func: function() {
current_trial = 0
},
timing_post_trial: 0
}
/* define practice block */
var practice_block = {
type: 'categorize',
stimuli: practice_trials.image,
is_html: true,
key_answer: response_array,
correct_text: '<div class = centerbox><div class = center-text><font size = 20>Correct</font></div></div>',
incorrect_text: '<div class = centerbox><div class = center-text><font size = 20>Incorrect</font></div></div>',
timeout_message: getFeedback,
choices: [32],
data: practice_trials.data,
timing_response: 2000,
timing_stim: 2000,
timing_feedback_duration: 1000,
show_stim_with_feedback: false,
timing_post_trial: post_trial_gap,
on_finish: appendData
}
/* define test block */
var test_block = {
type: 'single-stim',
stimuli: test_trials_block.image,
is_html: true,
choices: [32],
data: test_trials_block.data,
timing_response: 2000,
timing_post_trial: post_trial_gap,
on_finish: appendData
};
/* create experiment definition array */
var gonogo_experiment = [];
gonogo_experiment.push(welcome_block);
gonogo_experiment.push(instructions_block);
gonogo_experiment.push(start_practice_block)
gonogo_experiment.push(practice_block);
gonogo_experiment.push(reset_block)
gonogo_experiment.push(start_test_block);
gonogo_experiment.push(test_block);
gonogo_experiment.push(end_block)
|
import config from './config'
import { createActions } from '../common/actions'
const prefix = config.entityName.toUpperCase()
export const Actions = createActions(prefix, [
'SUBMIT_CHANGE_PASSWORD'
])
export const ActionCreators = {
submitChangePassword: (changePasswordForm, cb) => ({type: Actions.SUBMIT_CHANGE_PASSWORD, changePasswordForm, cb})
}
|
import React, {
Component
} from 'react';
import fetchMethod from '../../getdataCom';
import {
getSingerList
} from "../../server/api";
import SingerInfo from './singerInfo';
import {
List
} from 'antd-mobile';
const Item = List.Item;
export class SingerList extends Component {
constructor(props) {
super(props);
this.state = {
list: []
};
}
componentDidMount() {
let {classid} = this.props.match.params;
// console.log(classid);
getSingerList({
classid
}).then((resdata) => {
this.setState({
list: resdata
})
})
}
render() {
let {list} = this.state;
return (
<List>
{list.map((item)=>{
return (
<div className='list-rankitem' key = {item.singerid}>
<Item
thumb={item.imgurl.replace('{size}',400)}
wrap
onClick={() => {
this.props.history.push({
pathname: `/singer/info/${item.singerid}`,
state:{
title:item.singername,
navClass:false
}
});
}}
>{item.singername}</Item>
</div>
)
})}
</List>
);
}
}
export default SingerList;
|
import * as SqliteTypes from '../lib/Types';
import { SchemaField, ModelSchema, SqlBuilder } from '../lib';
import schemaContact from './fixtures/schemaContact';
it('SqlBuilder can generate UPDATE-statement correctly', () => {
const schema = new ModelSchema( schemaContact )
const sql = new SqlBuilder(schema)
const entity = {
id: 10,
first_name: 'Alfons',
last_name: 'Zitterbacke',
street: 'Friedenseck 8',
postalcode: '15232',
city: 'Frankfurt (Oder)'
}
const result = {
stmt: 'UPDATE contact SET first_name=?, last_name=?, street=?, postalcode=?, city=? WHERE id=?',
params: ['Alfons', 'Zitterbacke', 'Friedenseck 8', '15232', 'Frankfurt (Oder)', 10]
}
expect(sql.update(entity)).toEqual(result)
});
|
const functions = require("firebase-functions");
const admin = require("firebase-admin");
const cors = require("cors");
const { Rcon } = require("rcon-client");
let db = admin.firestore();
const RCON_PASSWORD = "lages1";
exports.main = functions.https.onRequest((request, response) => {
return cors()(request, response, () => {
const config = JSON.parse(request.body);
db.collection("_config")
.doc("status")
.get()
.then((doc) => {
return Promise.all([
doc,
db.collection("_config").doc("config").set(
{
useRandomFlashbang: config.bombFlashbang,
useRandomGranade: config.bombGranade,
useRandomMolotov: config.bombMolotov,
useRandomSmoke: config.bombSmoke,
},
{ merge: true }
),
]);
})
.then(([doc, result]) => {
const status = doc.data();
return new Promise(async (resolve) => {
const rcon = new Rcon({
host: status.ip,
port: status.port,
password: RCON_PASSWORD,
});
rcon.on("authenticated", () => {
resolve(rcon);
});
await rcon.connect();
});
})
.then((rcon) => {
const commands = generateCommands(config);
return Promise.all([rcon, rcon.send(commands)]);
})
.then(([rcon, result]) => {
response.send(result);
return rcon.end();
})
.catch((error) => {
console.log("ERROR: ", error);
response.status(500).send(error);
return;
});
});
});
const generateCommands = (config) => {
let command = "";
switch (config.gameType) {
case "casual":
command += "game_type 0;game_mode 0;";
break;
case "competitive":
command += "game_type 0;game_mode 1;mp_autokick 0;";
break;
case "wingman":
command += "game_type 0;game_mode 2;";
break;
case "armrace":
command += "game_type 1;game_mode 0;";
break;
case "demolition":
command += "game_type 1;game_mode 1;";
break;
case "deathmatch":
command += "game_type 1;game_mode 2;";
break;
case "guardian":
command += "game_type 4;game_mode 0;";
break;
case "co-op_strike":
command += "game_type 4;game_mode 1;";
break;
case "danger_zone":
command += "game_type 6;game_mode 0;";
break;
default:
break;
}
command += `changelevel ${config.map};bot_kick;`;
return command;
};
|
//Server
const express = require('express');
const bodyParser = require('body-parser');
const http = require('http');
const cors = require('cors');
const indexRouter = require('./routes/index');
const formRouter = require('./routes/form');
const commandsRouter = require('./routes/commands')
const app = express();
const database = require('./database/database.js');
const chatbot = require('./chatbot');
let port = 9001;
app.set('port', port)
let server = http.createServer(app);
server.listen(port);
app.use(cors());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
//Routes
app.use('/index', indexRouter);
app.use('/form', formRouter);
app.use('/commands', commandsRouter);
app.get('/', (req, res) => {
res.send('Test message!');
});
app.post('/', (req, res) => {
console.log(req.body);
res.send({Response: "Server received POST"});
})
app.listen(9000, () => console.log(`Listening on port ${port}`));
module.exports = app;
// //Chatbot
// //OBS Websocket
// const OBSWebSocket = require('obs-websocket-js');
// const obs = new OBSWebSocket();
// //Database
// const MongoClient = require('mongodb').MongoClient;
// let url = "mongodb://localhost:27017/Chatbot"
// MongoClient.connect(url, function(err, db) {
// if(err) {
// throw err
// } else {
// console.log("Database Connected");
// db.close();
// console.log("Database Connection closed");
// }
// });
// Database using Mongoose
// const mongoose = require('mongoose');
// let dbUrl = "mongodb://localhost:27017/Chatbot"
// await mongoose.connect(dbUrl, {
// useNewUrlParser: true,
// useUnifiedTopology: true
// });
|
// generatedy by JSX compiler 0.9.59 (2013-08-08 21:45:23 +0900; 45c866115f50499f6899410900427d146fd1f06e)
var JSX = {};
(function (JSX) {
/**
* extends the class
*/
function $__jsx_extend(derivations, base) {
var ctor = function () {};
ctor.prototype = base.prototype;
var proto = new ctor();
for (var i in derivations) {
derivations[i].prototype = proto;
}
}
/**
* copies the implementations from source interface to target
*/
function $__jsx_merge_interface(target, source) {
for (var k in source.prototype)
if (source.prototype.hasOwnProperty(k))
target.prototype[k] = source.prototype[k];
}
/**
* defers the initialization of the property
*/
function $__jsx_lazy_init(obj, prop, func) {
function reset(obj, prop, value) {
delete obj[prop];
obj[prop] = value;
return value;
}
Object.defineProperty(obj, prop, {
get: function () {
return reset(obj, prop, func());
},
set: function (v) {
reset(obj, prop, v);
},
enumerable: true,
configurable: true
});
}
/**
* sideeffect().a /= b
*/
function $__jsx_div_assign(obj, prop, divisor) {
return obj[prop] = (obj[prop] / divisor) | 0;
}
/*
* global functions, renamed to avoid conflict with local variable names
*/
var $__jsx_parseInt = parseInt;
var $__jsx_parseFloat = parseFloat;
function $__jsx_isNaN(n) { return n !== n; }
var $__jsx_isFinite = isFinite;
var $__jsx_encodeURIComponent = encodeURIComponent;
var $__jsx_decodeURIComponent = decodeURIComponent;
var $__jsx_encodeURI = encodeURI;
var $__jsx_decodeURI = decodeURI;
var $__jsx_ObjectToString = Object.prototype.toString;
var $__jsx_ObjectHasOwnProperty = Object.prototype.hasOwnProperty;
/*
* profiler object, initialized afterwards
*/
function $__jsx_profiler() {
}
/*
* public interface to JSX code
*/
JSX.require = function (path) {
var m = $__jsx_classMap[path];
return m !== undefined ? m : null;
};
JSX.profilerIsRunning = function () {
return $__jsx_profiler.getResults != null;
};
JSX.getProfileResults = function () {
return ($__jsx_profiler.getResults || function () { return {}; })();
};
JSX.postProfileResults = function (url, cb) {
if ($__jsx_profiler.postResults == null)
throw new Error("profiler has not been turned on");
return $__jsx_profiler.postResults(url, cb);
};
JSX.resetProfileResults = function () {
if ($__jsx_profiler.resetResults == null)
throw new Error("profiler has not been turned on");
return $__jsx_profiler.resetResults();
};
JSX.DEBUG = false;
function StopIteration() {
Error.call(this);
this.name = "StopIteration";
if (Error.captureStackTrace) Error.captureStackTrace(this, StopIteration);
};
$__jsx_extend([StopIteration], Error);
function Config() {
};
$__jsx_extend([Config], Object);
function Spark(posX, posY, size, color) {
var angle;
var velocity;
this.state = 0;
this.posX = posX;
this.posY = posY;
this.size = size;
this.color = color;
angle = Math.random() * 6.283185307179586;
velocity = Math.random() * 6.0;
this.velX = Math.cos(angle) * velocity;
this.velY = Math.sin(angle) * velocity;
};
$__jsx_extend([Spark], Object);
Spark.prototype._decay$ = function () {
var size$0;
this.velX *= 0.98;
this.velY *= 0.98;
size$0 = this.size *= 0.98;
if (size$0 < 0.5 && this.state === 0) {
this.color = Firework$randomColor$();
this.size = 2.0;
this.state++;
}
};
function Spark$_decay$LSpark$($this) {
var size$0;
$this.velX *= 0.98;
$this.velY *= 0.98;
size$0 = $this.size *= 0.98;
if (size$0 < 0.5 && $this.state === 0) {
$this.color = Firework$randomColor$();
$this.size = 2.0;
$this.state++;
}
};
Spark._decay$LSpark$ = Spark$_decay$LSpark$;
Spark.prototype._move$ = function () {
this.posX += this.velX + (Math.random() - 0.5);
this.posY += this.velY + (Math.random() - 0.5) + 2.0;
};
function Spark$_move$LSpark$($this) {
$this.posX += $this.velX + (Math.random() - 0.5);
$this.posY += $this.velY + (Math.random() - 0.5) + 2.0;
};
Spark._move$LSpark$ = Spark$_move$LSpark$;
Spark.prototype._render$LFireworkView$ = function (view) {
view.cx.beginPath();
view.cx.arc(this.posX, this.posY, this.size, 0, 6.283185307179586, true);
view.cx.fillStyle = (Math.random() > 0.2 ? this.color : "white");
view.cx.fill();
};
function Spark$_render$LSpark$LFireworkView$($this, view) {
view.cx.beginPath();
view.cx.arc($this.posX, $this.posY, $this.size, 0, 6.283185307179586, true);
view.cx.fillStyle = (Math.random() > 0.2 ? $this.color : "white");
view.cx.fill();
};
Spark._render$LSpark$LFireworkView$ = Spark$_render$LSpark$LFireworkView$;
Spark.prototype._isLiving$LFireworkView$ = function (view) {
return (this.size <= 0.01 ? false : this.posX <= 0 ? false : this.posX >= view.width || this.posY >= view.height ? false : true);
};
function Spark$_isLiving$LSpark$LFireworkView$($this, view) {
return ($this.size <= 0.01 ? false : $this.posX <= 0 ? false : $this.posX >= view.width || $this.posY >= view.height ? false : true);
};
Spark._isLiving$LSpark$LFireworkView$ = Spark$_isLiving$LSpark$LFireworkView$;
Spark.prototype.draw$LFireworkView$ = function (view) {
Spark$_decay$LSpark$(this);
this.posX += this.velX + (Math.random() - 0.5);
this.posY += this.velY + (Math.random() - 0.5) + 2.0;
Spark$_render$LSpark$LFireworkView$(this, view);
return (this.size <= 0.01 ? false : this.posX <= 0 ? false : this.posX >= view.width || this.posY >= view.height ? false : true);
};
function Spark$draw$LSpark$LFireworkView$($this, view) {
Spark$_decay$LSpark$($this);
$this.posX += $this.velX + (Math.random() - 0.5);
$this.posY += $this.velY + (Math.random() - 0.5) + 2.0;
Spark$_render$LSpark$LFireworkView$($this, view);
return ($this.size <= 0.01 ? false : $this.posX <= 0 ? false : $this.posX >= view.width || $this.posY >= view.height ? false : true);
};
Spark.draw$LSpark$LFireworkView$ = Spark$draw$LSpark$LFireworkView$;
function Firework(view, x, y) {
var color;
var i;
this.sparks = [ ];
this.view = view;
color = "lime";
for (i = 0; i < 360; ++ i) {
this.sparks.push(new Spark(x, y, 2.0, color));
}
};
$__jsx_extend([Firework], Object);
function Firework$randomColor$() {
var blightness;
var rgb;
var i;
blightness = 60;
rgb = [ ];
for (i = 0; i < 3; ++ i) {
rgb[i] = (Math.min(Math.random() * 0xFF + blightness | 0, 255) | 0);
}
return "rgb(" + (rgb[0] + "") + "," + (rgb[1] + "") + "," + (rgb[2] + "") + ")";
};
Firework.randomColor$ = Firework$randomColor$;
Firework.prototype.update$ = function () {
var i;
var s;
for (i = 0; i < this.sparks.length; ++ i) {
s = this.sparks[i];
if (! Spark$draw$LSpark$LFireworkView$(s, this.view)) {
this.sparks.splice(i, 1);
}
}
return this.sparks.length > 0;
};
function Firework$update$LFirework$($this) {
var i;
var s;
for (i = 0; i < $this.sparks.length; ++ i) {
s = $this.sparks[i];
if (! Spark$draw$LSpark$LFireworkView$(s, $this.view)) {
$this.sparks.splice(i, 1);
}
}
return $this.sparks.length > 0;
};
Firework.update$LFirework$ = Firework$update$LFirework$;
function FireworkView(canvas) {
var $this = this;
var rect;
this.fireworks = [ ];
this.numSparks = 0;
this.cx = canvas.getContext("2d");
this.width = (canvas.width | 0);
this.height = (canvas.height | 0);
rect = canvas.getBoundingClientRect();
this.left = (rect.left | 0);
this.top = (rect.top | 0);
canvas.addEventListener("mousedown", (function (e) {
var me;
me = e;
FireworkView$explode$LFireworkView$II($this, (me.clientX | 0), (me.clientY | 0));
}));
canvas.addEventListener("touchstart", (function (e) {
var te;
te = e;
FireworkView$explode$LFireworkView$II($this, (te.touches[0].pageX | 0), (te.touches[0].pageY | 0));
}));
};
$__jsx_extend([FireworkView], Object);
FireworkView.prototype.explode$II = function (x, y) {
this.fireworks.push(new Firework(this, x - this.left, y - this.top));
};
function FireworkView$explode$LFireworkView$II($this, x, y) {
$this.fireworks.push(new Firework($this, x - $this.left, y - $this.top));
};
FireworkView.explode$LFireworkView$II = FireworkView$explode$LFireworkView$II;
FireworkView.prototype.update$ = function () {
var i;
var fw;
var cx$0;
if (this.fireworks.length === 0) {
FireworkView$explode$LFireworkView$II(this, (this.width / 2 + this.left | 0), (this.height / 3 | 0));
}
this.numSparks = 0;
for (i = 0; i < this.fireworks.length; ++ i) {
fw = this.fireworks[i];
if (Firework$update$LFirework$(fw)) {
this.numSparks += fw.sparks.length;
} else {
this.fireworks.splice(i, 1);
}
}
(cx$0 = this.cx).fillStyle = "rgba(0, 0, 0, 0.3)";
cx$0.fillRect(0, 0, this.width, this.height);
};
function FireworkView$update$LFireworkView$($this) {
var i;
var fw;
var cx$0;
if ($this.fireworks.length === 0) {
FireworkView$explode$LFireworkView$II($this, ($this.width / 2 + $this.left | 0), ($this.height / 3 | 0));
}
$this.numSparks = 0;
for (i = 0; i < $this.fireworks.length; ++ i) {
fw = $this.fireworks[i];
if (Firework$update$LFirework$(fw)) {
$this.numSparks += fw.sparks.length;
} else {
$this.fireworks.splice(i, 1);
}
}
(cx$0 = $this.cx).fillStyle = "rgba(0, 0, 0, 0.3)";
cx$0.fillRect(0, 0, $this.width, $this.height);
};
FireworkView.update$LFireworkView$ = FireworkView$update$LFireworkView$;
function FPSWatcher(elementId) {
this.start = Date.now();
this.frameCount = 0;
this.elementId = elementId;
};
$__jsx_extend([FPSWatcher], Object);
FPSWatcher.prototype.update$I = function (numSparks) {
var message;
var id$0;
++ this.frameCount;
if (this.frameCount % 100 === 0) {
message = "FPS: " + ((this.frameCount / (Date.now() - this.start) * 1000 | 0) + "") + " (sparks: " + (numSparks + "") + ")";
(id$0 = this.elementId, dom.document.getElementById(id$0)).innerHTML = message;
}
};
function FPSWatcher$update$LFPSWatcher$I($this, numSparks) {
var message;
var id$0;
++ $this.frameCount;
if ($this.frameCount % 100 === 0) {
message = "FPS: " + (($this.frameCount / (Date.now() - $this.start) * 1000 | 0) + "") + " (sparks: " + (numSparks + "") + ")";
(id$0 = $this.elementId, dom.document.getElementById(id$0)).innerHTML = message;
}
};
FPSWatcher.update$LFPSWatcher$I = FPSWatcher$update$LFPSWatcher$I;
function _Main() {
};
$__jsx_extend([_Main], Object);
function _Main$main$AS(args) {
var canvas;
var view;
var watcher;
var value1$0;
var value2$0;
var value1$2;
var value2$2;
canvas = dom.document.getElementById("night-sky");
value1$0 = canvas.width;
value2$0 = dom.window.innerWidth;
canvas.width = (value1$0 <= value2$0 ? value1$0 : value2$0);
value1$2 = canvas.height;
value2$2 = dom.window.innerHeight;
canvas.height = (value1$2 <= value2$2 ? value1$2 : value2$2);
view = new FireworkView(canvas);
watcher = new FPSWatcher("fps");
dom.window.setInterval((function () {
FireworkView$update$LFireworkView$(view);
FPSWatcher$update$LFPSWatcher$I(watcher, (view.numSparks | 0));
}), 0);
};
_Main.main = _Main$main$AS;
_Main.main$AS = _Main$main$AS;
function dom() {
};
$__jsx_extend([dom], Object);
function dom$id$S(id) {
return dom.document.getElementById(id);
};
dom.id$S = dom$id$S;
function dom$getElementById$S(id) {
return dom.document.getElementById(id);
};
dom.getElementById$S = dom$getElementById$S;
function dom$createElement$S(tag) {
return dom.document.createElement(tag);
};
dom.createElement$S = dom$createElement$S;
function EventInit() {
this.bubbles = false;
this.cancelable = false;
};
$__jsx_extend([EventInit], Object);
function CustomEventInit() {
this.bubbles = false;
this.cancelable = false;
this.detail = null;
};
$__jsx_extend([CustomEventInit], EventInit);
function MutationObserverInit() {
this.childList = false;
this.attributes = false;
this.characterData = false;
this.subtree = false;
this.attributeOldValue = false;
this.characterDataOldValue = false;
this.attributeFilter = null;
};
$__jsx_extend([MutationObserverInit], Object);
function UIEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
};
$__jsx_extend([UIEventInit], EventInit);
function FocusEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
this.relatedTarget = null;
};
$__jsx_extend([FocusEventInit], Object);
function MouseEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
this.screenX = 0;
this.screenY = 0;
this.clientX = 0;
this.clientY = 0;
this.ctrlKey = false;
this.shiftKey = false;
this.altKey = false;
this.metaKey = false;
this.button = 0;
this.buttons = 0;
this.relatedTarget = null;
this.region = null;
};
$__jsx_extend([MouseEventInit], UIEventInit);
function WheelEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
this.screenX = 0;
this.screenY = 0;
this.clientX = 0;
this.clientY = 0;
this.ctrlKey = false;
this.shiftKey = false;
this.altKey = false;
this.metaKey = false;
this.button = 0;
this.buttons = 0;
this.relatedTarget = null;
this.deltaX = 0;
this.deltaY = 0;
this.deltaZ = 0;
this.deltaMode = 0;
};
$__jsx_extend([WheelEventInit], Object);
function KeyboardEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
this.char = "";
this.key = "";
this.location = 0;
this.ctrlKey = false;
this.shiftKey = false;
this.altKey = false;
this.metaKey = false;
this.repeat = false;
this.locale = "";
this.charCode = 0;
this.keyCode = 0;
this.which = 0;
};
$__jsx_extend([KeyboardEventInit], Object);
function CompositionEventInit() {
this.bubbles = false;
this.cancelable = false;
this.view = null;
this.detail = 0;
this.data = null;
this.locale = "";
};
$__jsx_extend([CompositionEventInit], Object);
function ProgressEventInit() {
this.bubbles = false;
this.cancelable = false;
this.lengthComputable = false;
this.loaded = 0;
this.total = 0;
};
$__jsx_extend([ProgressEventInit], EventInit);
function XMLHttpRequestOptions() {
this.anon = false;
};
$__jsx_extend([XMLHttpRequestOptions], Object);
function ScrollOptions() {
this.x = 0;
this.y = 0;
this.behavior = "";
};
$__jsx_extend([ScrollOptions], Object);
function TrackEventInit() {
this.bubbles = false;
this.cancelable = false;
this.track = null;
};
$__jsx_extend([TrackEventInit], EventInit);
function PopStateEventInit() {
this.bubbles = false;
this.cancelable = false;
this.state = null;
};
$__jsx_extend([PopStateEventInit], EventInit);
function HashChangeEventInit() {
this.bubbles = false;
this.cancelable = false;
this.oldURL = "";
this.newURL = "";
};
$__jsx_extend([HashChangeEventInit], EventInit);
function PageTransitionEventInit() {
this.bubbles = false;
this.cancelable = false;
this.persisted = false;
};
$__jsx_extend([PageTransitionEventInit], EventInit);
function ErrorEventInit() {
this.bubbles = false;
this.cancelable = false;
this.message = "";
this.filename = "";
this.lineno = 0;
this.column = 0;
};
$__jsx_extend([ErrorEventInit], EventInit);
function DragEventInit() {
MouseEventInit.call(this);
this.dataTransfer = null;
};
$__jsx_extend([DragEventInit], MouseEventInit);
function CloseEventInit() {
this.bubbles = false;
this.cancelable = false;
this.wasClean = false;
this.code = 0;
this.reason = "";
};
$__jsx_extend([CloseEventInit], EventInit);
function StorageEventInit() {
this.bubbles = false;
this.cancelable = false;
this.key = null;
this.oldValue = null;
this.newValue = null;
this.url = "";
this.storageArea = null;
};
$__jsx_extend([StorageEventInit], EventInit);
function MessageEventInit() {
this.bubbles = false;
this.cancelable = false;
this.data = null;
this.origin = "";
this.lastEventId = "";
this.source = null;
this.ports = null;
};
$__jsx_extend([MessageEventInit], EventInit);
function EventSourceInit() {
this.withCredentials = false;
};
$__jsx_extend([EventSourceInit], Object);
function IDBObjectStoreParameters() {
this.keyPath = null;
this.autoIncrement = false;
};
$__jsx_extend([IDBObjectStoreParameters], Object);
function IDBIndexParameters() {
this.unique = false;
this.multiEntry = false;
};
$__jsx_extend([IDBIndexParameters], Object);
function IDBVersionChangeEventInit() {
this.bubbles = false;
this.cancelable = false;
this.oldVersion = 0;
this.newVersion = null;
};
$__jsx_extend([IDBVersionChangeEventInit], EventInit);
function NotificationOptions() {
this.titleDir = "";
this.body = "";
this.bodyDir = "";
this.tag = "";
this.iconUrl = "";
};
$__jsx_extend([NotificationOptions], Object);
function RTCSessionDescriptionInit() {
this.type = "";
this.sdp = "";
};
$__jsx_extend([RTCSessionDescriptionInit], Object);
function RTCIceCandidateInit() {
this.candidate = "";
this.sdpMid = "";
this.sdpMLineIndex = 0;
};
$__jsx_extend([RTCIceCandidateInit], Object);
function RTCIceServer() {
this.url = "";
this.credential = null;
};
$__jsx_extend([RTCIceServer], Object);
function RTCConfiguration() {
this.iceServers = null;
};
$__jsx_extend([RTCConfiguration], Object);
function DataChannelInit() {
this.reliable = false;
};
$__jsx_extend([DataChannelInit], Object);
function RTCPeerConnectionIceEventInit() {
this.bubbles = false;
this.cancelable = false;
this.candidate = null;
};
$__jsx_extend([RTCPeerConnectionIceEventInit], EventInit);
function MediaStreamEventInit() {
this.bubbles = false;
this.cancelable = false;
this.stream = null;
};
$__jsx_extend([MediaStreamEventInit], EventInit);
function DataChannelEventInit() {
this.bubbles = false;
this.cancelable = false;
this.channel = null;
};
$__jsx_extend([DataChannelEventInit], EventInit);
function MediaStreamConstraints() {
this.video = null;
this.audio = null;
};
$__jsx_extend([MediaStreamConstraints], Object);
function MediaTrackConstraints() {
this.mandatory = null;
this.optional = null;
};
$__jsx_extend([MediaTrackConstraints], Object);
function HitRegionOptions() {
this.path = null;
this.id = "";
this.parentID = null;
this.cursor = "";
this.control = null;
this.label = null;
this.role = null;
};
$__jsx_extend([HitRegionOptions], Object);
function WebGLContextAttributes() {
this.alpha = false;
this.depth = false;
this.stencil = false;
this.antialias = false;
this.premultipliedAlpha = false;
this.preserveDrawingBuffer = false;
};
$__jsx_extend([WebGLContextAttributes], Object);
function WebGLContextEventInit() {
this.bubbles = false;
this.cancelable = false;
this.statusMessage = "";
};
$__jsx_extend([WebGLContextEventInit], EventInit);
function DeviceOrientationEventInit() {
this.bubbles = false;
this.cancelable = false;
this.alpha = null;
this.beta = null;
this.gamma = null;
this.absolute = false;
};
$__jsx_extend([DeviceOrientationEventInit], EventInit);
function DeviceMotionEventInit() {
this.bubbles = false;
this.cancelable = false;
this.acceleration = null;
this.accelerationIncludingGravity = null;
this.rotationRate = null;
this.interval = null;
};
$__jsx_extend([DeviceMotionEventInit], EventInit);
var js$0 = (function () { var global = (function () { return this; }()); return { global: global, eval: global.eval, invoke: function(invocant, methodName, args) { return invocant[methodName].apply(invocant, args); } }; }());
Config.quantity = 360;
Config.size = 2.0;
Config.decay = 0.98;
Config.gravity = 2.0;
Config.speed = 6.0;
Config.canvasId = "night-sky";
Config.fpsElementId = "fps";
Spark.rad = 6.283185307179586;
$__jsx_lazy_init(dom, "window", function () {
return js$0.global.window;
});
$__jsx_lazy_init(dom, "document", function () {
return js$0.global.document;
});
var $__jsx_classMap = {
"system:lib/built-in.jsx": {
StopIteration: StopIteration,
StopIteration$: StopIteration
},
"fireworks.jsx": {
Config: Config,
Config$: Config,
Spark: Spark,
Spark$NNNS: Spark,
Firework: Firework,
Firework$LFireworkView$II: Firework,
FireworkView: FireworkView,
FireworkView$LHTMLCanvasElement$: FireworkView,
FPSWatcher: FPSWatcher,
FPSWatcher$S: FPSWatcher,
_Main: _Main,
_Main$: _Main
},
"system:lib/js/js/web.jsx": {
dom: dom,
dom$: dom,
EventInit: EventInit,
EventInit$: EventInit,
CustomEventInit: CustomEventInit,
CustomEventInit$: CustomEventInit,
MutationObserverInit: MutationObserverInit,
MutationObserverInit$: MutationObserverInit,
UIEventInit: UIEventInit,
UIEventInit$: UIEventInit,
FocusEventInit: FocusEventInit,
FocusEventInit$: FocusEventInit,
MouseEventInit: MouseEventInit,
MouseEventInit$: MouseEventInit,
WheelEventInit: WheelEventInit,
WheelEventInit$: WheelEventInit,
KeyboardEventInit: KeyboardEventInit,
KeyboardEventInit$: KeyboardEventInit,
CompositionEventInit: CompositionEventInit,
CompositionEventInit$: CompositionEventInit,
ProgressEventInit: ProgressEventInit,
ProgressEventInit$: ProgressEventInit,
XMLHttpRequestOptions: XMLHttpRequestOptions,
XMLHttpRequestOptions$: XMLHttpRequestOptions,
ScrollOptions: ScrollOptions,
ScrollOptions$: ScrollOptions,
TrackEventInit: TrackEventInit,
TrackEventInit$: TrackEventInit,
PopStateEventInit: PopStateEventInit,
PopStateEventInit$: PopStateEventInit,
HashChangeEventInit: HashChangeEventInit,
HashChangeEventInit$: HashChangeEventInit,
PageTransitionEventInit: PageTransitionEventInit,
PageTransitionEventInit$: PageTransitionEventInit,
ErrorEventInit: ErrorEventInit,
ErrorEventInit$: ErrorEventInit,
DragEventInit: DragEventInit,
DragEventInit$: DragEventInit,
CloseEventInit: CloseEventInit,
CloseEventInit$: CloseEventInit,
StorageEventInit: StorageEventInit,
StorageEventInit$: StorageEventInit,
MessageEventInit: MessageEventInit,
MessageEventInit$: MessageEventInit,
EventSourceInit: EventSourceInit,
EventSourceInit$: EventSourceInit,
IDBObjectStoreParameters: IDBObjectStoreParameters,
IDBObjectStoreParameters$: IDBObjectStoreParameters,
IDBIndexParameters: IDBIndexParameters,
IDBIndexParameters$: IDBIndexParameters,
IDBVersionChangeEventInit: IDBVersionChangeEventInit,
IDBVersionChangeEventInit$: IDBVersionChangeEventInit,
NotificationOptions: NotificationOptions,
NotificationOptions$: NotificationOptions,
RTCSessionDescriptionInit: RTCSessionDescriptionInit,
RTCSessionDescriptionInit$: RTCSessionDescriptionInit,
RTCIceCandidateInit: RTCIceCandidateInit,
RTCIceCandidateInit$: RTCIceCandidateInit,
RTCIceServer: RTCIceServer,
RTCIceServer$: RTCIceServer,
RTCConfiguration: RTCConfiguration,
RTCConfiguration$: RTCConfiguration,
DataChannelInit: DataChannelInit,
DataChannelInit$: DataChannelInit,
RTCPeerConnectionIceEventInit: RTCPeerConnectionIceEventInit,
RTCPeerConnectionIceEventInit$: RTCPeerConnectionIceEventInit,
MediaStreamEventInit: MediaStreamEventInit,
MediaStreamEventInit$: MediaStreamEventInit,
DataChannelEventInit: DataChannelEventInit,
DataChannelEventInit$: DataChannelEventInit,
MediaStreamConstraints: MediaStreamConstraints,
MediaStreamConstraints$: MediaStreamConstraints,
MediaTrackConstraints: MediaTrackConstraints,
MediaTrackConstraints$: MediaTrackConstraints,
HitRegionOptions: HitRegionOptions,
HitRegionOptions$: HitRegionOptions,
WebGLContextAttributes: WebGLContextAttributes,
WebGLContextAttributes$: WebGLContextAttributes,
WebGLContextEventInit: WebGLContextEventInit,
WebGLContextEventInit$: WebGLContextEventInit,
DeviceOrientationEventInit: DeviceOrientationEventInit,
DeviceOrientationEventInit$: DeviceOrientationEventInit,
DeviceMotionEventInit: DeviceMotionEventInit,
DeviceMotionEventInit$: DeviceMotionEventInit
}
};
/**
* launches _Main.main(:string[]):void invoked by jsx --run|--executable
*/
JSX.runMain = function (sourceFile, args) {
var module = JSX.require(sourceFile);
if (! module) {
throw new ReferenceError("entry point module not found in " + sourceFile);
}
if (! module._Main) {
throw new ReferenceError("entry point _Main not found in " + sourceFile);
}
if (! module._Main.main) {
throw new ReferenceError("entry point _Main.main(:string[]):void not found in " + sourceFile);
}
module._Main.main(args);
};
/**
* launches _Test#test*():void invoked by jsx --test
*/
JSX.runTests = function (sourceFile, tests) {
var module = JSX.require(sourceFile);
if (! module) return;
var testClass = module._Test;
if (!testClass) return; // skip if there's no test class
if(tests.length === 0) {
var p = testClass.prototype;
for (var m in p) {
if (p[m] instanceof Function && m.match(/^test\w*$/)) {
tests.push(m);
}
}
}
var testCase = new testClass();
if (testCase.beforeClass != null)
testCase.beforeClass(tests);
for (var i = 0; i < tests.length; ++i) {
(function (method) {
if (method in testCase) {
testCase.run(method, function() { testCase[method](); });
}
else {
throw new ReferenceError("No such test method: " + method);
}
}(tests[i]));
}
if (testCase.afterClass != null)
testCase.afterClass();
};
/**
* call a function on load/DOMContentLoaded
*/
function $__jsx_onload (event) {
window.removeEventListener("load", $__jsx_onload);
document.removeEventListener("DOMContentLoaded", $__jsx_onload);
JSX.runMain("fireworks.jsx", []);
}
window.addEventListener("load", $__jsx_onload);
document.addEventListener("DOMContentLoaded", $__jsx_onload);
})(JSX);
|
// Strings = Texto
console.log('Felipe Oliveira');
console.log("'Felipe Oliveira'")
console.log('"Felipe Oliveira"')
console.log(`'Felipe' "Oliveira"`)
// Number = Número
console.log(35, 15.85)
|
/**
* 线上环境
*/
//const server_host = "http://localhost:8000/json/";
const API = {
ENTRY: {
// MESSAGE: "./../../../json/mock.json"
// MESSAGE: server_host + "./../../../json/mock.json"
},
HOME: {
// MESSAGE:
}
};
export default API;
|
function attachEvents() {
const URL = 'https://baas.kinvey.com/appdata/kid_rk1uKtCtz';
const username = 'User';
const pswd = 'user';
const base_64 = btoa(`${username}:${pswd}`);
const auth = { 'Authorization': 'Basic' + base_64 };
let posts = {};
$('#btnLoadPosts').click(LoadPosts);
$('#btnViewPost').click(LoadComments);
function LoadPosts() {
$.ajax({
method: 'GET',
url: `${URL}/posts`,
headers: auth
}).then(function (res) {
$('#posts').empty();
for (let post of res) {
$('#posts').append(
$(`<option value="${post._id}">${post.title}</option>`)
);
posts[post._id] = post.body;
}
}).catch(displayError);
}
function LoadComments() {
let postId = $('#posts').val();
let postTitle = $('#posts').find('option:selected').text();
$('#post-title').text(postTitle);
$('#post-body').text(posts[postId]);
$.ajax({
method: 'GET',
url: `${URL}/comments/?query={"post_id":"${postId}`,
headers: auth
}).then(function (res) {
$('#post-comments').empty();
for (let com of res) {
$('#post-comments')
.append(`<li>${com.text}</li>`);
}
}).catch(displayError);
}
function displayError(err) {
let errorDiv = $('<div>').text('Error: ' +
err.status + ' (' + err.statusText + ')');
$(document.body).prepend(errorDiv);
setTImeout(function () {
$(errorDiv).fadeOut(function () {
$(errorDiv).remove();
});
}, 3000);
}
}
|
const express = require('express');
const router = express.Router();
const TX = require('../../blockchain-structure/tx');
router.post('/tx', async (req, res) => {
try {
let tx = TX({
sign: req.body,
tx: JSON.parse(req.body.msg)
});
if (tx) {
if (mySession === WAIT_TO_COLLECT_SIGN && await tx.Validate(globalState)) {
if (await globalState.PushTx(tx)) {
res.end('Valid tx');
return;
}
}
txCache.push(tx);
res.end();
} else {
res.end('Invalid type');
}
} catch (e) {
res.end(e.message);
console.log(e);
}
});
module.exports = router;
|
define(function() {
var stdout = function(msg) {
console.log(msg);
};
return {
stdout: stdout
};
});
|
'use strict'
module.exports = {
up: (queryInterface, Sequelize) => {
return queryInterface.bulkInsert(
'Users',
[
{
firstname: 'Pasta',
lastname: 'Boy',
email: 'lenin1916@gmail.com',
password: 'password',
admin: false,
isEmailVerified: true,
createdAt: '2017-11-08',
updatedAt: '2017-11-08'
}
],
{}
)
return queryInterface.bulkInsert(
'Tickets',
[
{
numbers: '{55, 55, 55, 55, 55, 55}',
lottoname: 'powerball',
lottodate: '2017-11-08',
contacted: false,
userID: 1,
createdAt: '2017-11-08',
updatedAt: '2017-11-08'
}
],
{}
)
},
down: (queryInterface, Sequelize) => {
return queryInterface.bulkDelete('Users', null, {})
}
}
|
import React from 'react';
import Product from '../product/Product';
import axios from 'axios';
import './home.css'
import Paginationp from '../pagination/Pagination'
class Home extends React.Component {
constructor(props){
super(props)
this.state = {
allproducts:[],
orginalList:[],
sort:'',
category:'',
currentPage:1,
postPerpage:1,
}
}
componentDidMount(){
if(localStorage.getItem('loggedIn') === null){
this.props.history.push('/');
}
this.getAllproducts();
}
getAllproducts=()=>{
axios.get('http://localhost:3000/allProducts/?username='+localStorage.getItem('username')).then((res)=>{
this.setState({
allproducts:res.data
});
this.setState({
orginalList:res.data
})
})
}
deleteItem=(id)=>{
axios.delete('http://localhost:3000/allProducts/'+id).then((res)=>{
this.getAllproducts();
},(err)=>{
console.log(err);
})
}
updateItem=(id)=>{
this.props.history.push('/editproduct/'+id);
}
renderall=()=>{
const indexofLastPost=this.state.currentPage*this.state.postPerpage;
const indexofFirstPost=indexofLastPost-this.state.postPerpage;
const currentPosts=this.state.allproducts.slice(indexofFirstPost,indexofLastPost);
return currentPosts.map((prod)=>{
return (
<div className='product-card' key={prod.id}>
<Product
key={prod.id}
id={prod.id}
name={prod.name}
price={prod.price}
stock={prod.stock}
imageUrl={prod.imageUrl}
description={prod.description}
category={prod.category}
itemdelete={this.deleteItem}
itemupdate={this.updateItem}
>
</Product>
</div>
)
})
}
searchProducts=(e)=>{
console.log(this.state.orginalList)
if(e.target.value!==''){
//let filterdValues=this.state.allproducts
let filterdValues=this.state.orginalList.filter((f)=>{
return f.name.toLocaleLowerCase().includes(e.target.value.toLocaleLowerCase());
})
this.setState({allproducts:filterdValues});
}else{
this.setState({sort:''})
this.setState({category:''})
this.getAllproducts();
}
}
selectCategory=(e)=>{
this.setState({category:e.target.value})
if(e.target.value!==''){
axios.get('http://localhost:3000/allProducts/?q='+e.target.value).then((res)=>{
this.setState({allproducts:res.data});
this.setState({orginalList:res.data});
})
}else{
this.getAllproducts()
}
}
selectSort=(e)=>{
this.setState({sort:e.target.value})
if(e.target.value!==''){
if(e.target.value==='name'){
let products=this.state.allproducts
products.sort((a,b)=>{
if(a.name.toLocaleLowerCase()<b.name.toLocaleLowerCase()){return -1}
if(a.name.toLocaleLowerCase()>b.name.toLocaleLowerCase()){return 1}
return 0
})
this.setState({allproducts:products});
}
if(e.target.value==='price'){
let products=this.state.allproducts
products.sort((a,b)=>{
if(parseInt(a.price)<parseInt(b.price)){return -1}
if(parseInt(a.price)>parseInt(b.price)){return 1}
return 0
})
this.setState({allproducts:products});
}
if(e.target.value==='stock'){
let products=this.state.allproducts
products.sort((a,b)=>{
if(parseInt(a.stock)<parseInt(b.stock)){return -1}
if(parseInt(a.stock)>parseInt(b.stock)){return 1}
return 0
})
this.setState({allproducts:products});
}
}else{
this.getAllproducts()
}
}
paginate=(pagenumber)=>this.setState({currentPage:pagenumber});
render() {
return (
<div>
<div className="home">
<h1>Welcome Home!</h1>
<div className="home-search">
<div className="input searchBox">
<input type="text" name="search" className="searchBox" placeholder="Serach for Products" onChange={this.searchProducts}/>
</div>
<div className="input1">
<select onChange={this.selectSort} value={this.state.sort}>
<option value=''>Sort Products</option>
<option value='name'>By Name</option>
<option value='price'>By price</option>
<option value='stock'>By Stock</option>
</select>
<select onChange={this.selectCategory} value={this.state.category}>
<option value=''>Select Category</option>
<option value="Groceries">Groceries</option>
<option value="Electronics">Electronics</option>
<option value="Vegitables">Vegitables</option>
<option values="Fruits">Fruits</option>
</select>
</div>
</div>
<div className="pagination">
<Paginationp postsPerPage={this.state.postPerpage} totalPosts={this.state.allproducts.length} paginate={this.paginate}></Paginationp>
</div>
{this.renderall()}
</div>
</div>
);
}
}
export default Home;
|
import React from 'react'
import Footer from './Components/Footer'
import { Link } from 'react-router-dom'
import online from './Images/online.jpg'
import women from './Images/women.jpg'
import astro from './Images/astronaut.jpg'
import find from './Images/find.jpg'
import near from './Images/near.jpg'
import './CSS/Home.css'
import { IconButton, Button } from '@material-ui/core'
import SearchIcon from '@material-ui/icons/Search';
import getCollection from './Database/getCollection'
import getUser from './Database/getUser'
import firebase, { db } from './firebase'
import play_store from './Images/store.png'
import phone from './Images/Phone.png'
import blogs from './Images/Home/blog-home.jpg'
import webinar from './Images/Home/home-webinars.jpg'
const top_cards = [
{
name: "Classes Near You",
img: near,
url: "0"
},
{
name: "Online Classes",
img: online,
url: "online"
},
{
name: "Classes Only For Women",
img: women,
url: "women"
},
{
name: "Individual Classes",
img: astro,
url: "individual"
},
{
name: "Unable To Find",
img: find,
url: "find"
}
]
class Home extends React.Component {
state = {
categories: null,
user: null,
search: 0,
}
componentDidMount() {
getCollection("ImagesClassesTrending").then(snapshot => {
this.setState({ categories: snapshot })
})
getUser().then(user => {
this.setState({ user: user })
})
}
handleLogin = () => {
var provider = new firebase.auth.GoogleAuthProvider();
firebase.auth().signInWithPopup(provider).then(user => {
this.setState({ user: user.user.displayName })
}).catch(function (error) {
// Handle Errors here.
var errorMessage = error.message;
// The email of the user's account used.
var email = error.email;
// The firebase.auth.AuthCredential type that was used.
var credential = error.credential;
db.collection("LoginErrors").doc(email).set(
{
errorMessage: errorMessage,
email: email,
credential: credential
}
)
});
}
render() {
return (
<div>
<div>
<div className="home-overlay " style={{ color: "white", textAlign: "center" }} >
<div style={{ height: "28vh", display: "flex", justifyContent: "flex-end", width: "100%" }} >
<div style={{ paddingRight: "15%", paddingTop: "30px" }} >
{
this.state.user === -1 || this.state.user === null ? (
<Button onClick={this.handleLogin} style={{ textTransform: "none", color: "white" }} >Sign In</Button>
) : (
<Link to="/pidgin/login" ><Button style={{ textTransform: "none", color: "white" }} >{this.state.user}</Button></Link>
)
}
</div>
</div>
<div className="wrap" >
<div >
<div style={{ fontSize: "80px", fontFamily: "Friendly", marginBottom: "40px" }} >
Pidgin
</div>
<div className="delivering-education">
Delivering Education
</div>
<div className="wrap" >
<input
className="home-search-input"
onChange={(e) => { this.setState({ search: e.target.value }) }}
placeholder="Search classes, courses and more.." />
<div style={{ backgroundColor: "#04BF7B", height: '56px', width: "56px" }} className="wrap" >
<IconButton onClick={() => { this.props.history.push("/pidgin/search/" + this.state.search) }} >
<SearchIcon style={{ color: "white" }} />
</IconButton>
</div>
</div>
</div>
</div>
</div>
<div className="home-wallpaper" ></div>
<div className="wrap" style={{ margin: "40px 0px" }} >
<div className="home-width-container">
<div className="wrap" style={{ justifyContent: "space-around", flexWrap: "wrap" }} >
{
top_cards.map(item => {
return (
<Link to={"pidgin/search/" + item.url} >
<div className="home-top-card" >
<div className="home-top-card-image" style={{ backgroundImage: "url(" + item.img + ")" }}>
</div>
<div style={{ textAlign: "center", fontSize: "13px", marginTop: "5px" }} >
{item.name}
</div>
</div>
</Link>
)
})
}
</div>
<div style={{ marginTop: "100px", marginBottom: "50px" }} >
<div style={{ fontSize: "40px", marginBottom: "10px" }} >
Categories
</div>
<div>
Explore amazing courses with visionary teachers around you
</div>
<div className="wrap wrap-responsive" style={{ justifyContent: "left", minHeight: "200px" }} >
{
this.state.categories &&
this.state.categories.map(item => {
return (
<Link to={"pidgin/search/" + item.type} >
<div className="home-top-card"
style={{
height: "200px",
width: "180px",
backgroundImage: "url(" + item.image + ")",
backgroundSize: "cover",
margin: "10px",
border: "none"
}} >
<div style={{ fontSize: "18px", marginTop: "5px", color: "white", fontWeight: "300", backgroundImage: "linear-gradient(black, rgba(0,0,0,0))", borderRadius: "10px", padding: "10px 20px", margin: "-0.5px", }} >
{item.type}
<div style={{ fontSize: "13px", color: "white", marginTop: "-5px" }} >
See All
</div>
</div>
</div>
</Link>
)
})
}
</div>
</div>
<div className="wrap" style={{flexWrap:"wrap",margin:"80px 0px"}} >
<div className="home-blogs-workshops" >
<div style={{ fontSize: "40px", marginBottom: "10px" }} >
Blogs
</div>
<Link to="/pidgin/blogs" >
<div>
<img src={blogs} className="home-blogs-workshops-image" alt="blogs" />
</div>
</Link>
</div>
<div className="home-blogs-workshops" >
<div style={{ fontSize: "40px", marginBottom: "10px" }} >
Workshops
</div>
<a href='/pidgin/workshops' >
<div>
<img src={webinar} className="home-blogs-workshops-image" alt="workshops" />
</div>
</a>
</div>
</div>
</div>
</div>
<div className="wrap" style={{ backgroundColor: "#fcfcfc", justifyContent: "center", marginBottom: "100px", flexWrap: "wrap" }} >
<div style={{ margin: "0px 20px" }} >
<img style={{ boxShadow: "0px 0px 20px rgba(0,0,0,0.5)", borderRadius: "25px" }} height="300px" src={phone} aly="app" />
</div>
<div>
<h1>Get the Pidgin App</h1>
<div>
<img src={play_store} width="200px" />
</div>
</div>
</div>
</div>
<Footer />
</div>
)
}
}
export default Home;
|
/**
Hello World
**/
//console.log("hello world")
/**
Events
**/
/*var events = require('events');
var eventEmitter = new events.EventEmitter();
eventEmitter.on("connection",function(){
console.log("connection");
eventEmitter.emit("data_recieved");
});
eventEmitter.on("data_recieved",function(){
console.log("data_recieved");
});
eventEmitter.emit("connection");*/
/**
Streams
RWDT - Read Stream, Write Stream, Duplex Stream, Transform Stream
Read Stream.
**/
/*var fs = require('fs');
var data = '';
var readStream = fs.createReadStream('input.txt');
readStream.setEncoding('utf-8');
readStream.on('data',function(chunk){
data+=chunk;
});
readStream.on('end',function(){
console.log(data);
});
readStream.on('error', function(err){
console.log(err.stack);
});
console.log("Program Ended");*/
/*
* Streams
* Write Stream
*/
/* var fs = require("fs");
var data = 'Simply Easy Learning';
// Create a writable stream
var writerStream = fs.createWriteStream('output.txt');
// Write the data to stream with encoding to be utf8
writerStream.write(data,'UTF8');
// Mark the end of file
writerStream.end();
// Handle stream events --> finish, and error
writerStream.on('finish', function() {
console.log("Write completed.");
});
writerStream.on('error', function(err){
console.log(err.stack);
});
console.log("Program Ended");*/
/*
* Streams
* Piping the streams
*/
/*var fs = require("fs");
// Create a readable stream
var readerStream = fs.createReadStream('input.txt');
// Create a writable stream
var writerStream = fs.createWriteStream('output.txt');
// Pipe the read and write operations
// read input.txt and write data to output.txt
readerStream.pipe(writerStream);
console.log("Program Ended");*/
/*
* Streams
* Chaining
*/
/*var fs = require("fs");
var zlib = require('zlib');
// Compress the file input.txt to input.txt.gz
fs.createReadStream('input.txt')
.pipe(zlib.createGzip())
.pipe(fs.createWriteStream('input.txt.gz'));
console.log("File Compressed.");*/
/*
* File System
*/
var fs = require("fs");
// Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
return console.error(err);
}
console.log("File opened successfully!");
});
|
import admin from "@/store/api/admin";
import watchdoge from "@/store/api/watchdoge";
export default {
namespaced: true,
modules: {
admin,
watchdoge
}
};
|
let knightHead = document.querySelector('.knight-head');
let knightBody = document.querySelector('.knight-body');
let knightSeperator = document.querySelector('.knight-seperator');
let leftSection = document.querySelector('.left-section');
let logInPanel = document.querySelector('.log-in-panel');
let logInBtn = document.querySelector('.log-in-btn');
let logo = document.querySelector('.logo');
let arrows = document.querySelector('.arrows');
window.addEventListener('load', () => {knightSeperatorAnimation(); backToTopAnimation();});
logInBtn.addEventListener('click', () => {
logInPanel.style.opacity = 1;
logInPanelAnimation();
});
// backToTop.addEventListener('click', () => {});
function knightSeperatorAnimation() {
TweenMax.from(knightSeperator, 1, {
x: -200,
y: 200,
opacity: 0,
ease: Back.easeOut,
onComplete: () => {
knightHead.style.opacity = 1;
knightBody.style.opacity = 1;
knightHeadAnimation();
knightBodyAnimation();
},
});
}
function knightHeadAnimation() {
TweenMax.from(knightHead, 1.2, {
x: -100,
y: 100,
opacity: 0,
ease: Back.easeOut,
});
}
function knightBodyAnimation() {
TweenMax.from(knightBody, 1.2, {
x: 100,
y: -100,
opacity: 0,
ease: Back.easeOut,
onStart: () => {
leftSection.style.opacity = 1;
logInBtn.style.opacity = 1;
titleInAnimation();
logInBtnAnimation();
}
});
}
function titleInAnimation() {
TweenMax.from(leftSection, 1.2, {
x: -100,
opacity: 0,
ease: Back.easeOut,
});
}
function logInPanelAnimation() {
if(logInPanel.classList.contains('active')) {
TweenMax.to(logInPanel, 1.2, {
y: -100,
rotationY: 360,
opacity: 0,
ease: Back.easeOut,
onStart: () => {rotateKnight()},
onComplete: () => {
TweenMax.to(logInPanel, 0.1, {y:0,rotationY:0});
},
});
logInPanel.classList.toggle('active');
} else {
TweenMax.from(logInPanel, 1.2, {
y: -100,
rotationY: -360,
opacity: 0,
ease: Back.easeOut,
onStart: () => {rotateKnight()},
});
logInPanel.classList.toggle('active');
}
}
function logInBtnAnimation() {
TweenMax.from(logInBtn, 1.2, {
y: -100,
opacity: 0,
ease: Back.easeOut,
});
}
let knightActive = false;
function rotateKnight() {
if (knightActive === false) {
TweenMax.to(logo, .4, {
rotationY: 180,
marginRight: -16,
});
knightActive = true;
} else {
TweenMax.to(logo, .4, {
rotationY: 0,
marginRight: 16,
});
knightActive = false;
}
}
function backToTopAnimation() {
TweenMax.to(arrows, 1.5, {
y: -10,
opacity: 1,
repeat: -1,
});
}
|
// @ts-check
/* eslint-disable react/prefer-stateless-function */
import React from 'react';
// BEGIN (write your solution here)
class ListGroup extends React.Component{
renderChildren () {
return React.Children.map(this.props.children, (child, i) => {
return <li className="list-group-item">{child}</li>
});
}
render () {
return <ul className="list-group">{this.renderChildren()}</ul>
}
}
export default ListGroup;
// END
|
'use strict';
describe('Service: interactionAPI', function () {
// load the service's module
beforeEach(module('statsGhApp'));
// instantiate service
var interactionAPI;
beforeEach(inject(function (_interactionAPI_) {
interactionAPI = _interactionAPI_;
}));
it('should do something', function () {
expect(!!interactionAPI).toBe(true);
});
});
|
$(document).ready(function ()
{
ControllerProducto.init();
});
ControllerProducto = {
init: function ()
{
var self = this;
self.$frm = $('[name="frmProducto"]');
$('[name="btnGuardar"]', self.$frm).click(function ()
{
if (self.validar())
{
var data = self.data();
console.log(data);
$.ajax({
method: 'post',
dataType: 'json',
url: "../../procesos/producto.php",
data: data,
//use contentType, processData for sure.
contentType: false,
processData: false,
beforeSend: function () {
//Company_Controller.beforeProcessBar();
//console.log('Hold on...');
},
xhr: function () {
var myXhr = $.ajaxSettings.xhr();
//console.log(myXhr);
//if (myXhr.upload) {
//myXhr.upload.addEventListener('progress', Company_Controller.uploadProgressBar, false);
//}
return myXhr;
},
success: function (data, textStatus, jqXHR) {
//fResponse(data);
if (data.isSuccess)
{
setTimeout(function () {
$(location).attr('href', "administrar_productos.php");
}, 1500);
}
alert(data.message);
},
error: function () {
//console.log('error');
alert('Ocurrio un error en el envio');
}
});
}
});
$('[name="btnCancelar"]', self.$frm).click(function ()
{
var msg = confirm("¿Realmente desea cancelar? ");
if (msg)
window.location.assign("administrar_productos.php");
});
},
validar: function ()
{
var self = this;
var cboCategoria = $('[name="cboCategoria"]', self.$frm).val();
if (cboCategoria == 0)
{
alert('Error: Seleccione la categoria del producto');
$('[name="cboCategoria"]', self.$frm).focus();
return false;
}
var txtNombre = $('[name="txtNombre"]', self.$frm).val();
if (txtNombre.length == 0)
{
alert('Error: Ingrese el nombre del producto');
$('[name="txtNombre"]', self.$frm).focus();
return false;
}
var txtDescripcion = $('[name="txtDescripcion"]', self.$frm).val();
if (txtDescripcion.length == 0)
{
alert('Error: Ingrese la descripción del producto');
$('[name="txtDescripcion"]', self.$frm).focus();
return false;
}
var txtPresentacion = $('[name="txtPresentacion"]', self.$frm).val();
if (txtPresentacion.length == 0)
{
alert('Error: Ingrese la presentación del producto');
$('[name="txtPresentacion"]', self.$frm).focus();
return false;
}
return true;
},
data: function ()
{
var self = this;
var formData = new FormData(self.$frm[0]);
return formData;
}
};
|
'use strict';
angular.module('welcome').controller('WelcomeCtrl', ['$scope',
function($scope) {
}]);
|
$(document).ready(function () {
$('[data-toggle="tooltip"]').tooltip();
$('#pageTitle').text("Consul Tree | " + window.location.hostname);
convertMultipleSelectionTo1();
$.getJSON("config/config.json", function (consul) {
if (consul) if (consul.length !== 0) {
var selectedConsulJson, tree;
setToLocalStorage('consulConfig', consul);
getConsulLocations();
checkRights(userRights);
selectedConsulJson = getSetConfig();
tree = {
'contextmenu': {'items': customMenu},
'check_callback': true,
'plugins': ['contextmenu', 'types', 'state', 'search'],
'core': {
"multiple": false,
"animation": 0,
"check_callback": true,
"themes": {
'name': 'default',
'responsive': true,
"stripes": true
},
'data': []
}
};
if (getFromLocalStorage('treeBackup')) {
setToLocalStorage('jstree', getFromLocalStorage('treeBackup'));
removeFromLocalStorage('treeBackup');
}
getTree(tree, selectedConsulJson.url + "?keys");
}
});
});
|
$('#searchButton').click(function () {
var fromDate = $('#fromDate').val();
fromDate = fromDate.replace(/\//g, '$');
var toDate = $('#toDate').val();
toDate = toDate.replace(/\//g, '$');
var tr = '';
$('#noteList tbody').empty();
$.get('/PatientPanel/SearchNote/' + (fromDate) + '/' + (toDate), function (result) {
if (result.statusCode == 200) {
$.each(JSON.parse(result.responseText), function (key, value) {
tr += '<tr>';
tr += '<td>' + value.NoteID + '</td>';
tr += '<td>' + value.TurnsID + '</td>';
tr += '<td>' + value.noteTitle + '</td>';
tr += '<td>' + value.doctorFullName + '</td>';
tr += '<td>' + value.createDateTime + '</td>';
tr += '<td> <a href="/PatientPanel/Details/' + value.NoteID + '" class="btn btn-sm btn-primary">جزييات</a> </td>'
tr += '</tr>';
});
$('#notFound').remove();
$('#noteList tbody').html(tr);
}
else {
var notFound = '<div id="notFound" class="container alert alert-danger text-center"><h4>!هيچ داده اي يافت نشد</h4></div>';
$('#statusSearch').html(notFound);
//$('#noteList ').addClass('text-center');
}
});
})
//function replace
|
progress(0);
eqLogic_id = null;
$('.bt_Freebox_OS_Next').off('click').on('click', function () {
funNext();
});
$('.bt_Freebox_OS_Previous').off('click').on('click', function () {
funPrev();
});
$('.bt_eqlogic_standard').on('click', function () {
logs('info', "================= Lancement recherche des équipements standards");
SearchArchi();
progress(85);
});
$('.bt_eqlogic_tiles').on('click', function () {
logs('info', "================= Lancement recherche des tiles");
SearchTile();
progress(90);
});
$('.bt_eqlogic_control_parental').on('click', function () {
logs('info', "================= Lancement recherche des contrôles parentaux");
SearchParental();
progress(95);
});
$('.bt_Freebox_OS_Save').on('click', function () {
logs('info', "================= Sauvegarde des Paramètres");
ip = $('#input_freeboxIP').val();
//VersionAPP = $('#input_freeAppVersion').val();
VersionAPP = null;
Categorie = $('#sel_object_default').val();
SetSetting(ip, VersionAPP, Categorie);
});
$('.bt_Freebox_Autorisation').on('click', function () {
logs('info', "================= Lancement autorisation Freebox");
autorisationFreebox();
});
$('.bt_Freebox_resetAPI').on('click', function () {
logs('info', "================= Lancement Reset de la version API");
ResetAPI();
});
$('.bt_Freebox_droitVerif').on('click', function () {
logs('info', "================= Lancement vérification des droits");
GetSessionData();
});
$('.bt_Freebox_droitVerif_pass').on('click', function () {
logs('info', "================= Ignorer vérification des droits");
funNext();
});
$('.bt_Freebox_OS_ResetConfig').on('click', function () {
logs('info', "================= Reset de la configuration");
SetDefaultSetting();
GetSetting();
$('.bt_Freebox_OS_Next').show();
});
$('.bt_Freebox_Room').on('click', function () {
logs('info', "================= Lancement Recherche des pièces");
//SearchTile_room();
});
$('.bt_Freebox_OS_Save_room').on('click', function () {
checkvalue = $('.checkbox_freeboxTiles:checked').val();
if (checkvalue == null) {
logs('info', "================= Cron Global Titles : NOK");
cron_tiles = '0';
} else {
logs('info', "================= Cron Global Titles : OK");
cron_tiles = '1';
};
/*checkvalueCmd = $('.checkbox_freeboxCmdbyCmd:checked').val();
if (checkvalueCmd == null) {
logs('info', "================= Actualisation par commande : NOK");
CmdbyCmd = '0';
} else {
logs('info', "================= Actualisation par commande : OK");
CmdbyCmd = '1';
};*/
console.log('CRON TILES : ' + cron_tiles)
//console.log('CMD BY CMD : ' +CmdbyCmd)
//SetSettingTiles(cron_tiles, CmdbyCmd);
SetSettingTiles(cron_tiles);
logs('info', "================= Sauvegarde des Pièces des Tiles");
//SaveTitelRoom();
});
function updateMenu(objectclass) {
$('.li_Freebox_OS_Summary.active').removeClass('active');
$(objectclass).addClass('active');
$('.Freebox_OS_Display').hide();
$('.Freebox_OS_Display.' + $(objectclass).attr('data-href')).show();
}
function autorisationFreebox() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "connect",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
if (!data.result.success) {
$('div_alert').showAlert({
message: data.result.msg,
level: 'danger'
});
if (data.result.error_code == "new_apps_denied")
$('.textFreebox').text('L\'association de nouvelles applications est désactivée. Merci de modifier les réglages de votre Freebox et relancer ensuite l\'authentification');
logs('error', "L\'association de nouvelles applications est désactivée ou la version du Freebox Server n'est pas correct");
return;
} else {
sendToBdd(data.result);
$('.textFreebox').text('{{Merci d\'appuyer sur le bouton V de votre Freebox, afin de confirmer l\'autorisation d\'accès à votre Freebox.}}');
logs('info', '(' + data.result.error_code + ') ' + "Attente appuie sur le bouton V");
$('.img-freeboxOS').attr('src', 'plugins/Freebox_OS/core/img/authentification.jpg');
progress(40);
setTimeout(AskTrackAuthorization, 3000);
}
}
});
}
function SearchArchi() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SearchArchi",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
}
});
}
function SearchTile() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SearchTile",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
}
});
}
function SearchTile_room() { // Ligne 148
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SearchTile_group", //Ligne 153
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
pieces = data.result.piece;
object = data.result.objects;
$("#table_room tr").remove();
$('#table_room thead').append("<tr><th style=\"width: 320px\">{{Pièces Freebox}}</th><th>{{Objects Jeedom}}</th></tr>");
for (var i = 0; i < pieces; i++) { // Ligne 164
var piece = pieces[i];
var tr = '<tr class="piece">';
tr += '<td>';
tr += '<input class="titleRoomAttr form-control" data-l1key="PieceName" value="' + piece + '" disabled/>';
tr += '</td>';
tr += '<td><select id="' + piece + '" class="titleRoomAttr form-control" data-l1key="object_id">' + object + '</td>';
tr += '</tr>';
$('#table_room tbody').append(tr);
value = data.result.config[piece];
$('#' + piece).val(value);
}
}
});
}
function SearchParental() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SearchParental",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
}
});
}
function sendToBdd(jsonParser) {
var fbx_app_token = jsonParser.result.app_token;
var fbx_track_id = jsonParser.result.track_id;
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "sendToBdd",
app_token: fbx_app_token,
track_id: fbx_track_id
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
if (!data) {
$('#div_alert').showAlert({
message: data,
level: 'danger'
});
logs('error', +data);
return;
}
}
});
}
function AskTrackAuthorization() {
if ($('.li_Freebox_OS_Summary.active').attr('data-href') == "authentification") {
$('.textFreebox').hide();
$('.bt_Freebox_OS_Next').hide();
$('.bt_Freebox_OS_Previous').hide();
$('.Freebox_OK').hide();
$('.Freebox_OK_NEXT').hide();
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "ask_track_authorization",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
if (!data.result.success) {
$('#div_alert').showAlert({
message: data.result.msg,
level: 'danger'
});
logs('error', +data.result.msg);
} else {
$('.textFreebox').show();
$('.bt_Freebox_OS_Next').show();
$('.bt_Freebox_OS_Previous').show();
switch (data.result.result.status) {
case "unknown":
$('.textFreebox').text('{{L\'application a un token invalide ou a été révoqué, il faut relancer l\'authentification. Merci}}');
logs('error', "ERREUR : " + '(' + data.result.result.status + ') ' + "L\'application a un token invalide ou a été révoqué, il faut relancer l\'authentification");
Good();
progress(-1);
break;
case "pending":
$('.textFreebox').text('{{Vous n\'avez pas encore validé l\'application sur la Freebox.}}');
setTimeout(AskTrackAuthorization, 3000);
break;
case "timeout":
$('.textFreebox').text('{{Vous n\'avez pas validé à temps, il faut relancer l\'authentification. Merci}}');
logs('error', "ERREUR : " + '(' + data.result.result.status + ') ' + "Vous n\'avez pas validé à temps, il faut relancer l\'authentification");
Good();
progress(-1);
break;
case "granted":
$('.textFreebox').text('{{Félicitation votre Freebox est maintenant reliée à Jeedom.}}');
logs('info', '(' + data.result.result.status + ') ' + "Félicitation votre Freebox est maintenant reliée à Jeedom");
$('.Freebox_OK').show();
$('.Freebox_OK_NEXT').show();
$('.Freebox_OS_Display.' + $(this).attr('rights')).show();
progress(45);
break;
case "denied":
$('.textFreebox').text('{{Vous avez refusé, il faut relancer l\'authentification. Merci}}');
logs('error', '(' + data.result.result.status + ') ' + "Vous avez refusé, il faut relancer l\'authentification");
progress(-1);
Good();
break;
default:
$('.textFreebox').text('{{REST OK : track_authorization -> Error 4 : Inconnue}}');
logs('error', '(' + data.result.result.status + ') ' + "REST OK : track_authorization -> Error 4 : Inconnue");
Good();
break;
}
}
}
});
} else {
$('.textFreebox').show();
$('.bt_Freebox_OS_Next').show();
$('.bt_Freebox_OS_Previous').show();
$('.Freebox_OK').show();
$('.Freebox_OK_NEXT').show();
}
}
function Good() {
$('.bt_Freebox_OS_Previous').hide();
$('.bt_Freebox_OS_NEXT').hide();
$('.alert-info Freebox_OK').text('{{Authentification réussi}}');
logs('info', "Authentification réussi");
}
function progress(ProgressPourcent) {
if (ProgressPourcent == -1) {
$('#div_progressbar').removeClass('progress-bar-success progress-bar-info progress-bar-warning');
$('#div_progressbar').addClass('active progress-bar-danger');
$('#div_progressbar').width('100%');
$('#div_progressbar').attr('aria-valuenow', 100);
$('#div_progressbar').html('N/A');
return;
}
if (ProgressPourcent == 100) {
$('#div_progressbar').removeClass('active progress-bar-info progress-bar-danger progress-bar-warning');
$('#div_progressbar').addClass('progress-bar-success');
$('#div_progressbar').width(ProgressPourcent + '%');
$('#div_progressbar').attr('aria-valuenow', ProgressPourcent);
$('#div_progressbar').html('FIN');
return;
}
$('#div_progressbar').removeClass('active progress-bar-info progress-bar-danger progress-bar-warning');
$('#div_progressbar').addClass('progress-bar-success');
$('#div_progressbar').width(ProgressPourcent + '%');
$('#div_progressbar').attr('aria-valuenow', ProgressPourcent);
$('#div_progressbar').html(ProgressPourcent + '%');
}
function GetSetting() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "GetSetting",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
$('#input_freeboxIP').val(data.result.ip);
logs('info', "IP : " + data.result.ip);
//$('#input_freeAppVersion').val(data.result.VersionAPP);
//logs('info', "Version API : " + data.result.VersionAPP);
$('#input_freeNameAPP').val(data.result.NameAPP);
logs('info', "Nom API : " + data.result.NameAPP);
$('#input_IdApp').val(data.result.IdApp);
logs('info', "Id API : " + data.result.IdApp);
$('#input_DeviceName').val(data.result.DeviceName);
logs('info', "Nom Jeedom : " + data.result.DeviceName);
$('#sel_object_default').val(data.result.Categorie);
logs('info', "Objet par défaut : " + data.result.Categorie);
logs('info', "Version API Freebox : " + data.result.API);
$('#input_API').val(data.result.API);
console.log('IP : ' + data.result.ip)
console.log('Nom API : ' + data.result.DeviceName)
console.log('Objet par défaut : ' + data.result.Categorie)
console.log('Version API : ' + data.result.API)
if (data.result.DeviceName == null || data.result.DeviceName == "") {
$('.bt_Freebox_OS_Next').hide();
$('.textFreebox').text('Votre Jeedom n\'a pas de Nom, il est impossible de continuer l\'appairage');
logs('error', "ERREUR : " + "Votre Jeedom n\'a pas de Nom, il est impossible de continuer l\'appairage");
$('#div_alert').showAlert({
message: 'Votre Jeedom n\'a pas de Nom, il est impossible de continuer l\'appairage',
level: 'danger'
});
} else {
$('.textFreebox').text('');
$('.Freebox_OK_NEXT').show();
}
if (data.result.LogLevel == 100) {
var debugHides = document.getElementsByClassName('debugFreeOS');
for (var i = 0; i < debugHides.length; i++) {
var debugHide = debugHides[i];
debugHide.classList.remove("debugHide");
}
} else {
var debugShows = document.getElementsByClassName('debugFreeOS');
for (var i = 0; i < debugShows.length; i++) {
var debugShow = debugShows[i];
debugShow.classList.add("debugHide");
}
}
}
});
}
function GetSettingTiles() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "GetSettingTiles",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
if (data.result.CronTiles == 0) {
logs('info', "================= Cron Global Titles ACTIVATION : NOK");
console.log('Cron Global Titles ACTIVATION - FALSE - : ' + data.result.CronTiles);
$('.checkbox_freeboxTiles').prop('checked', false);
} else {
logs('info', "================= Cron Global Titles ACTIVATION : OK");
console.log('Cron Global Titles ACTIVATION - TRUE - : ' + data.result.CronTiles);
$('.checkbox_freeboxTiles').prop('checked',true);
};
/*if (data.result.CmdbyCmd == 0) {
logs('info', "================= Actualisation par commande : NOK");
console.log('Actualisation par commande - FALSE - : ' + data.result.CmdbyCmd);
$('.checkbox_freeboxCmdbyCmd').prop('checked', false);
} else {
logs('info', "================= Actualisation par commande : OK");
console.log('Actualisation par commande - TRUE - : ' + data.result.CmdbyCmd);
$('.checkbox_freeboxCmdbyCmd').prop('checked',true);
};*/
}
});
}
function ResetAPI() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "ResetAPI",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
//GetSetting();
}
});
}
function SetSetting(ip, VersionAPP, Categorie) {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SetSetting",
ip: ip,
//VersionAPP: VersionAPP,
Categorie: Categorie,
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
GetSetting();
}
});
}
function SetSettingTiles(CronTiles) {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "SetSettingTiles",
cron_tiles: cron_tiles,
//fCmdbyCmd: CmdbyCmd,
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
GetSetting();
$('.Freebox_OK_NEXT').show();
}
});
}
function SetDefaultSetting() {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "resetSetting",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
GetSetting();
}
});
}
function GetSessionData() {
$('.textFreebox').hide();
$('.bt_Freebox_OS_Next').hide();
$('.bt_Freebox_OS_Previous').hide();
$('.Freebox_OK').hide();
$('.Freebox_OK_NEXT').hide();
$('.bt_Freebox_droitVerif').show();
$('.bt_Freebox_OS').show();
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "GetSessionData",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
if (data.result.success) {
var permissions = data.result.result.permissions;
UpdateStatus("calls", permissions.calls);
UpdateStatus("camera", permissions.camera);
UpdateStatus("contacts", permissions.contacts);
UpdateStatus("downloader", permissions.downloader);
UpdateStatus("explorer", permissions.explorer);
UpdateStatus("home", permissions.home);
UpdateStatus("parental", permissions.parental);
UpdateStatus("player", permissions.player);
UpdateStatus("profile", permissions.profile);
UpdateStatus("pvr", permissions.pvr);
UpdateStatus("settings", permissions.settings);
UpdateStatus("tv", permissions.tv);
UpdateStatus("vm", permissions.vm);
UpdateStatus("wdo", permissions.wdo);
if (permissions.calls &&
permissions.camera &&
permissions.downloader &&
permissions.home &&
permissions.parental &&
permissions.player &&
permissions.vm &&
permissions.profile &&
permissions.settings) {
logs('info', "================= Les droits sont OK");
$('.textFreebox').show();
$('.bt_Freebox_OS_Next').show();
$('.bt_Freebox_OS_Previous').show();
$('.Freebox_OK').show();
$('.Freebox_OK_NEXT').show();
$('.bt_Freebox_droitVerif').hide();
$('.bt_Freebox_OS').hide();
progress(65);
}
}
}
});
}
function getBox(type) {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "GetBox",
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
result = data.result.Type_box_tiles;
if (result !== "OK") {
if (type == "next") {
funNext();
} else {
funPrev()
}
logs('info', "================= BOX COMPATIBLE AVEC LES TILES : NOK");
} else {
logs('info', "================= BOX COMPATIBLE AVEC LES TILES : OK");
//SearchTile_room();
}
}
});
}
function UpdateStatus(item, index) {
if (index == true) {
document.getElementById(item).classList.add('alert-success');
document.getElementById(item).classList.remove('alert-danger');
document.getElementById(item).innerHTML = "OK";
} else {
document.getElementById(item).classList.add('alert-danger');
document.getElementById(item).classList.remove('alert-success');
document.getElementById(item).innerHTML = "NOK";
}
}
function SaveTitelRoom() {
titelRoomArrays = $('#table_room').find('.piece').getValues('.titleRoomAttr');
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "setRoomID",
data: titelRoomArrays
},
dataType: 'json',
error: function (request, status, error) {
handleAjaxError(request, status, error);
},
success: function (data) {
//SearchTile_room();
}
});
}
function funNext() {
updateMenu($('.li_Freebox_OS_Summary.active').next());
$('.bt_Freebox_OS_Next').show();
$('.bt_Freebox_OS_Previous').show();
logs('info', "================= Etape : " + $('.li_Freebox_OS_Summary.active').attr('data-href'));
switch ($('.li_Freebox_OS_Summary.active').attr('data-href')) {
case 'home':
progress(0);
break;
case 'setting':
progress(15);
GetSetting();
break;
case 'authentification':
progress(25);
break;
case 'rights':
progress(50);
GetSessionData();
break;
case 'room':
progress(75);
GetSettingTiles();
getBox("next");
break;
case 'scan':
progress(80);
break;
case 'end':
progress(100);
break;
}
}
function funPrev() {
updateMenu($('.li_Freebox_OS_Summary.active').prev());
$('.bt_Freebox_OS_Next').show();
$('.bt_Freebox_OS_Previous').show();
switch ($('.li_Freebox_OS_Summary.active').attr('data-href')) {
case 'home':
progress(0);
break;
case 'setting':
progress(15);
GetSetting();
break;
case 'authentification':
progress(25);
break;
case 'rights':
progress(50);
GetSessionData();
break;
case 'room':
progress(75);
getBox("prev");
break;
case 'scan':
progress(80);
break;
case 'end':
progress(100);
break;
}
}
function logs(loglevel, logText) {
$.ajax({
type: "POST",
url: "plugins/Freebox_OS/core/ajax/Freebox_OS.ajax.php",
data: {
action: "setLogs",
loglevel: loglevel,
logsText: logText
},
dataType: 'json',
error: function (request, status, error) {},
success: function (data) {}
});
}
|
import React, { Component } from 'react';
import homePageImg from '../../images/homeImage.jpg';
import "./index.css";
export class Home extends Component {
render() {
return (
<div className="container">
<img id="home-img" src={homePageImg} />
<h1 className="hot">More stuff will go below this</h1>
</div>
)
}
}
export default Home;
|
/**
* @file Aside.js
* @author leeight
*/
import u from 'lodash';
import {defineComponent} from 'san';
import SearchBox from './components/SearchBox';
/* eslint-disable */
const template = `<div class="aside">
<div class="searchbox">
<ui-searchbox
search-btn="{{false}}"
value="{=keyword=}"
width="145"
placeholder="请输入关键字" />
</div>
<dl s-for="block, i in filteredBlocks">
<dt>{{block.title}}</dt>
<dd s-if="!block.collapse">
<ul>
<li on-click="onClick(item)"
class="{{item === activedItem ? 'selected' : item.disabled ? 'disabled' : ''}}"
s-for="item in block.items">{{item.text}}</li>
</ul>
</dd>
</dl>
</div>`;
/* eslint-enable */
export default defineComponent({
template,
components: {
'ui-searchbox': SearchBox
},
initData() {
return {
activedItem: null,
keyword: '',
blocks: []
};
},
computed: {
filteredBlocks() {
const keyword = this.data.get('keyword');
const blocks = this.data.get('blocks');
const filteredBlocks = [];
u.each(blocks, block => {
const items = [];
u.each(block.items, item => {
if (item.text.indexOf(keyword) !== -1) {
items.push(item);
}
});
if (items.length) {
filteredBlocks.push({
title: block.title,
items
});
}
});
return filteredBlocks;
}
},
toggleItems(bi) {
const key = `blocks[${bi}].collapse`;
const collapse = this.data.get(key);
this.data.set(key, !collapse);
},
getItemByText(text) {
const blocks = this.data.get('blocks');
for (let i = 0; i < blocks.length; i++) {
const items = blocks[i].items;
for (let j = 0; j < items.length; j++) {
const item = items[j];
if (item.text === text) {
return item;
}
}
}
return blocks[0].items[0];
},
activeItemByText(text) {
let activedItem = this.getItemByText(text);
this.onClick(activedItem);
},
inited() {
this.watch('selectedItemText', text => this.activeItemByText(text));
},
attached() {
this.activeItemByText(this.data.get('selectedItemText'));
},
onClick(item) {
const activedItem = this.data.get('activedItem');
if (item.disabled || item === activedItem) {
return;
}
this.data.set('activedItem', item);
this.fire('item-selected', item);
}
});
|
var mongoose = require('mongoose');
var CounterSchema = new mongoose.Schema({
incrementId:String,
seq:Number
});
CounterSchema.methods.toJSON = function() {
var counter = this.toObject();
return counter;
};
module.exports = mongoose.model('Counter', CounterSchema);
|
define( ["assets", "collision", "explosion", "keyboard"], function(assets, collision, explosion, keyboard) {
//var FPS = 24;
var VELOCITY = 10.0*(60/FPS);
var ACCELERATION = 0.05*(60/FPS);
var DECELERATION = 0.01*(60/FPS);
var ANGLEMOVE = 0.5*(60/FPS);
var MAPSPEED = 10.0*(60/FPS);
var GRAVITY = 0.5*(60/FPS);
var BEAMALPHASPEED = 0.05*(60/FPS);
var SHADOWOFFSET = 80;
var BOUNDS = {
top: 100,
bottom: 700-200,
left: 200,
right: 1200-400
};
var entity;
var entityShadow;
var beam, beamAlpha=0.0, beamMask;
var stage;
var humanSprite, capturedList, mothershipTick=0;
var moveX =0, moveY=0, angle=0, accelX=0, accelY=0, dirX=0, dirY=0, mapPosition=0;
var ufoDamage =0;
function init(st) {
stage = st;
ufoDamage =0;
moveX =0, moveY=0, angle=0, accelX=0, accelY=0, dirX=0, dirY=0, mapPosition =0;
capturedList = [];
entityShadow = new createjs.Bitmap(assets.images.shadow);
entityShadow.alpha = 0.1;
entityShadow.y = BOUNDS.bottom+50;
entityShadow.scaleX = entityShadow.scaleY = 3;
stage.addChild(entityShadow);
entity = new createjs.Container();
entity.setBounds(-70,-50,160,120);
var ufo = new createjs.Sprite(assets.images.ufo, "run");
entity.addChild(ufo);
stage.addChild(entity);
beam = new createjs.Container();
var b2 = new createjs.Sprite(assets.images.beam, "run");
//stage.addChild(beam);
beam.addChild(b2);
beam.setBounds(0,-100,100,500);
//console.log(beam);
var g = new createjs.Graphics().beginFill("#ff0000").drawRect(-100, 0, 200, 200);
beamMask = new createjs.Shape(g);
beam.addChild(beamMask);
b2.mask = beamMask;
beamMask.visible = false;
stage.addChild(beam);
beam.alpha = 0.0;
humanSprite = new createjs.Sprite(assets.images.human,"run");
entity.alpha = 1.0;
entity.x = stage.canvas.width*0.5;
entity.y = stage.canvas.height*0.3;
entity.rotation = 10;
}
function getMoveData() {
return {
accelX: accelX,
accelY: accelY,
dirX: dirX,
dirY: dirY,
beamAlpha: beamAlpha,
mapPosition: mapPosition
}
}
function getDamage() {
return ufoDamage;
}
function addDamage(n,maxDamage) {
ufoDamage += n;
if (ufoDamage>maxDamage) {
ufoDamage = maxDamage;
}
if (ufoDamage<0) {
ufoDamage =0;
}
}
function hitGround() {
//-- ufo hit ground, add damage according to accelX and bounce up
ufoDamage += Math.floor(Math.abs(accelX)*5)+1;
dirY = -1;
accelY = -1;
explosion.create(entity.x, entity.y+30, stage);
}
function boundsCheck() {
if (entity.y >= BOUNDS.bottom) {
hitGround();
}
entity.y = (entity.y<BOUNDS.top) ? BOUNDS.top : entity.y;
entity.y = (entity.y>BOUNDS.bottom) ? BOUNDS.bottom : entity.y;
entity.x = (entity.x<BOUNDS.left) ? BOUNDS.left : entity.x;
entity.x = (entity.x>BOUNDS.right) ? BOUNDS.right : entity.x;
if (mapPosition < -stage.canvas.width) {
//entity.x = BOUNDS.right;
mapPosition = -stage.canvas.width;
}
if (mapPosition > (assets.TERRAIN_SIZE-0.5)*stage.canvas.width) {
mapPosition = (assets.TERRAIN_SIZE-0.5)*stage.canvas.width;
}
}
function updateBeam() {
beam.x = entity.x;
beam.y = entity.y+100;
if (keyboard.isDown(keyboard.SPACE)===true) {
beamAlpha = (beamAlpha<1.0) ? beamAlpha+BEAMALPHASPEED : 1.0;
assets.sounds.beam.play();
} else {
beamAlpha = (beamAlpha>0.0) ? beamAlpha-BEAMALPHASPEED : 0.0;
assets.sounds.beam.stop();
}
beam.alpha = beamAlpha;
//--shrink closer to ground
beamMask.scaleY = (720-entity.y)/720;
beam.scaleY = (500-entity.y)/500*3.2;
}
//-- adds a sprite into the player ufo
function addCaptured() {
let h=humanSprite.clone()
capturedList.push(h);
entity.addChild(h);
entity.setChildIndex( h, 0);
h.x = Math.random()*50-10;
h.y = Math.random()*20-50;
assets.sounds.points.play();
}
//-- move these off-screen
function removeCaptured() {
if (capturedList.length>0 && mothershipTick<createjs.Ticker.getTime()) {
let h = capturedList.pop();
entity.removeChild();
stage.addChild(h);
h.x = entity.x+20;
h.y = entity.y-50;
createjs.Tween.get(h).to({y:-100, rotation: Math.random()*720},3000);
mothershipTick = createjs.Ticker.getTime()+1000;
assets.sounds.points.play();
return 1;
}
return 0;
}
function update() {
//console.log(entity.x);
let movingX = 0, movingY = 0;
let curdirX = 0, curdirY =0;
if (keyboard.isDown(keyboard.LEFT)===true) {
accelX -= ACCELERATION;
dirX = -1;
angle -= ANGLEMOVE;
movingX = 1;
}
if (keyboard.isDown(keyboard.RIGHT)===true) {
// entity.x = entity.x + VELOCITY*accel;
accelX += ACCELERATION;
dirX = 1;
angle += ANGLEMOVE;
movingX =1;
}
if (keyboard.isDown(keyboard.UP)===true) {
// entity.y = entity.y + -VELOCITY*accel;
dirY = -1;
accelY -= ACCELERATION;
movingY =1;
}
if (keyboard.isDown(keyboard.DOWN)===true) {
accelY += ACCELERATION;
dirY = 1;
movingY =1;
}
mapPosition -=MAPSPEED*accelX;
angle = (angle>10) ? 10 : angle;
angle = (angle<-10) ? -10 : angle;
if (!movingX) {
//-- do this without dirX to prevent keyboard lock
//accelX += (-dirX)*DECELERATION;
accelX = (accelX>0) ? accelX-DECELERATION : accelX+DECELERATION;
accelX = (accelX<0.1 && accelX>-0.1) ? 0.0 : accelX;
if (angle>0) {
angle -=ANGLEMOVE;
} else if (angle<0) {
angle += ANGLEMOVE;
}
}
if (!movingY){
// accelY += (-dirY)*DECELERATION;
accelY = (accelY>0) ? accelY-DECELERATION : accelY+DECELERATION;
accelY = (accelY<0.1 && accelY>-0.1) ? 0.0 : accelY;
}
entity.x = entity.x + accelX*VELOCITY;
entity.y = entity.y + accelY*VELOCITY + GRAVITY; //slowly fall
accelX = (accelX>1.0) ? 1.0 : accelX;
accelX = (accelX<-1.0) ? -1.0 : accelX;
accelY = (accelY>1.0) ? 1.0 : accelY;
accelY = (accelY<-1.0) ? -1.0 : accelY;
boundsCheck();
entity.rotation = angle;
entityShadow.x = entity.x - SHADOWOFFSET;
updateBeam();
}
function getBeam() {
return beam;
}
function getUFO() {
return entity;
}
function hideUFO() {
entity.alpha = 0.0;
}
function showUFO() {
entity.alpha = 1.0;
}
//-- return a score if human is delivered to mothership
function checkMothershipCollision(ms) {
let s=0;
if(collision.checkCollision(ms,entity)) {
s=removeCaptured();
}
return s;
}
return {
init : init,
update : update,
getMoveData: getMoveData,
getBeam: getBeam,
getUFO : getUFO,
getDamage : getDamage,
addDamage : addDamage,
addCaptured : addCaptured,
checkMothershipCollision : checkMothershipCollision,
hideUFO : hideUFO,
showUFO : showUFO
}
});
|
// eslint-disable-next-line unicorn/filename-case
import React from "react";
import "./leaflet.css";
import { Map, Marker, TileLayer } from "react-leaflet";
import Trees from "./data/arbustum.json";
import icondata from "./data/tree.png"
function Leaflet() {
const icon = L.icon({
iconUrl: icondata,
iconAnchor: [10, 0],
iconSize: [50, 50]
})
return (
<Map center={[50.64, 5.57]} zoom={14}>
<TileLayer
url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
attribution='© <a href="http://osm.org/copyright">OpenStreetMap</a> contributors'
/>
{Trees.map((tree) => (
<Marker
key={tree.arbotag}
icon={icon}
position={[tree.y_phi, tree.x_lambda]}
/>
))}
</Map>
);
}
export default Leaflet;
|
import React, {Component} from 'react';
import Users from "./components/Users/Users";
import ApiService from "./sevice/apiService";
import Form from "./components/Users/Form/Form";
import Posts from "./components/Posts/Posts";
class App extends Component {
constructor() {
super();
this.state = {
showUsers: false,
showPosts: false,
usersList: [],
userPosts: [],
activeUserPosts: ''
};
}
apiService = new ApiService();
handlerGetUsers = () => {
this.apiService.getUsers()
.then(res => {
this.setState({
usersList: res,
showUsers: true
})
})
.catch(error => console.error('Error', error));
};
onUserAdded = (name) => {
this.apiService.postUser({name})
.then(res => {
this.setState({
todoData: res
})
})
.then(this.handlerGetUsers)
.catch(error => console.error('Error', error));
};
deleteUser = (id) => {
this.apiService.deleteUser(id);
let newData = this.state.usersList;
newData = newData.filter((user) => (user.id !== id));
this.setState({usersList: newData});
};
onChangeUserName = (name, id) => {
const usersList = this.state.usersList;
usersList.forEach(user => {
if (user.id === id) {
user.name = name;
}
});
this.apiService.changeUser(id, {name})
.catch(error => console.error('Error', error));
this.setState({
usersList
});
};
handlerGetPosts = (id) => {
this.apiService.getPosts(id)
.then(res => {
this.setState({
userPosts: res,
showPosts: true,
activeUserPosts: id
})
})
.catch(error => console.error('Error', error));
};
onPostAdded = (title) => {
this.apiService.postPost(this.state.activeUserPosts, {title})
.then(res => {
this.setState({
userPosts: res
})
})
.then(this.handlerGetUsers)
.catch(error => console.error('Error', error));
};
deletePost = (id) => {
this.apiService.deletePost(id);
let newData = this.state.userPosts;
newData = newData.filter((post) => (post.id !== id));
this.setState({userPosts: newData});
};
onChangePost = (title, id) => {
const userPosts = this.state.userPosts;
userPosts.forEach(post => {
if (post.id === id) {
post.title = title;
}
});
this.apiService.changePost(id, {title})
.catch(error => console.error('Error', error));
this.setState({
userPosts
});
};
render() {
let {showUsers, usersList, showPosts, userPosts} = this.state;
let usersBlock = showUsers > 0 ?
<Users usersList={usersList} onDeleted={this.deleteUser} onChangeUserName={this.onChangeUserName}
handlerGetPosts={this.handlerGetPosts}/> : false;
let postsBlock = showPosts ?
<Posts userPosts={userPosts} onPostAdded={this.onPostAdded} deletePost={this.deletePost}
onChangePost={this.onChangePost}/> : false;
return (
<div className="container">
<button type="buutton"
className="mt-2 mb-2"
onClick={this.handlerGetUsers}>Get users
</button>
<div className="col-6">
<Form onUserAdded={this.onUserAdded}/>
{usersBlock}
</div>
{postsBlock}
</div>
);
}
}
export default App;
|
export default {
development: {
cdn: './',
apiBaseUrl: '/api'
},
beta: {
cdn: './',
apiBaseUrl: '/api'
},
release: {
cdn: './',
apiBaseUrl: '/api'
}
}
|
const moduleExports = {};
moduleExports.WobjController = require('./wobjController');
moduleExports.PostController = require('./postController');
moduleExports.ObjectTypeController = require('./objectTypeController');
moduleExports.UserController = require('./UserController');
moduleExports.AppController = require('./appController');
moduleExports.ImageController = require('./imageController');
moduleExports.globalSearchController = require('./globalSearchController');
module.exports = moduleExports;
|
const express = require('express');
const fs = require('fs');//for reading ssl certificate
const https = require('https');
if (!process.env.PRODUCTION) {
require('dotenv-safe').config();//load environment variables
console.log("localhost");
}
//create ssl certificate options
const httpsOptions = {
key: fs.readFileSync('../../../myserver.key'),
cert: fs.readFileSync('../../../server.crt'),
ca: [
fs.readFileSync('./comodosha256domainvalidationsecureserverca.crt'),
fs.readFileSync('./comodorsaaddtrustca.crt')
]
};
//routes
var loginRoute = require('./routes/login');
var registerRoute = require('./routes/register');
var confirmEmailRoute = require('./routes/confirmEmail');
var forgotPasswordRoute = require('./routes/forgotPassword');
var resetPasswordRoute = require('./routes/resetPassword');
//family routes
var createFamilyRoute = require('./routes/createFamily');
var joinFamilyRoute = require('./routes/joinFamily');
var familyRoute = require('./routes/family');
var shareFamilyRoute = require('./routes/shareFamily');
//person routes
var personRoutes = require('./routes/person');
//event routes
var eventRoutes = require('./routes/events');
//middleware
var authenticate = require('./middleware/authenticate');
var dbConnection = require('./middleware/database');
var server = express();
//***************************** MIDDLEWARE ***********************************
server.use(express.json());//parse json bodies
server.use(dbConnection.routeConnection);
//****************************** UNAUTORIZED ROUTES *************************
server.post('/login', loginRoute);
server.post('/register', registerRoute);
server.get('/confirmEmail', confirmEmailRoute);
server.post('/forgotPassword', forgotPasswordRoute);
server.post('/resetPassword', resetPasswordRoute);
//*************************** AUTHROIZED ROUTES ******************************
server.use(authenticate);
//family routes
server.post('/createFamily', createFamilyRoute);
server.post('/joinFamily', joinFamilyRoute);
server.get('/family', familyRoute);
server.post('/shareFamily', shareFamilyRoute);
//person routes
server.post('/person', personRoutes.postPerson);
server.get('/person', personRoutes.getPerson);
server.put('/person', personRoutes.putPerson);
server.delete('/person', personRoutes.deletePerson);
//event routes
server.post('/event', eventRoutes.postEvent);
server.get('/event', eventRoutes.getEvent);
server.put('/event', eventRoutes.putEvent);
server.delete('/event', eventRoutes.deleteEvent);
//********************************** ERROR HANDLING ****************************
server.use((error, req, res, next) => {
//close db connection
if (res.locals.conn)
res.locals.conn.end();
if (error.status && error.body)
res.status(error.status).send(error.body);
else {
console.log(error);
res.status(500).send({success: false, message: 'Internal server error'});
}
});
//********************************** 404 ERROR ********************************
server.use((req, res, next) => {
if (res.locals.conn)
res.locals.conn.end();
res.status(404).send({success: false, message: 'path does not exist'});
});
//********************************* START SERVER ******************************
const httpsServer = https.createServer(httpsOptions, server).listen(process.env.PORT, () => {
console.log('server running at ' + process.env.PORT);
});
|
import { useState } from 'react'
import "./Add.css"
const Add = (props) => {
const [formData, setFormData] = useState({
name: '',
contact: '',
phone_number: '',
email: '',
address: '',
industry: '',
client_status: 'false',
notes: '',
sale_revenue: '',
})
const handleChange = (e) => {
const { name, value } = e.target;
setFormData(prevState => ({
...prevState,
[name]: value
}))
}
return (
// <div className='add-business-container'></div>
<form onSubmit={(e) => {
e.preventDefault();
props.handleCreate(formData);
}} className='form-add-container'>
<label className="add-label">
<div className="add-form-label">Company Name</div>
<input
className="add-input"
type='text'
name='name'
value={formData.name}
onChange={handleChange}
required={true}
/>
</label>
<label className="add-label">
<div className="add-form-label">Contact</div>
<input
className="add-input"
type='text'
name='contact'
value={formData.contact}
onChange={handleChange}
required={true}
/>
</label>
<label className="add-label">
<div className="add-form-label">Phone#</div>
<input
className="add-input"
type='text'
name='phone_number'
value={formData.phone_number}
onChange={handleChange}
required={true}
/>
</label>
<label className="add-label">
<div className="add-form-label">Email</div>
<input
className="add-input"
type='text'
name='email'
value={formData.email}
onChange={handleChange}
required={true}
/>
</label>
<label className="add-label">
<div className="add-form-label">Address</div>
<input
className="add-input"
type='text'
name='address'
value={formData.address}
onChange={handleChange}
required={true}
/>
</label>
<label className="add-label">
<div className="add-form-label">Industry</div>
<input
className="add-input"
type='text'
name='industry'
value={formData.industry}
onChange={handleChange}
required={true}
/>
</label>
<button className="add-button">Submit</button>
</form>
)
}
export default Add
|
Meteor.methods({
/**********************
* Groups
*/
// Create group
newGroup: function(group) {
return Groups.insert(group);
},
// Upsert group
upsertGroup: function(groupId, group) {
return Groups.upsert({_id: groupId}, group);
},
// Remove group
removeGroup: function(groupId) {
return Groups.remove({_id: groupId});
},
/**********************
* Conversations
*/
// Create conversation
newConversation: function(conversation) {
return Conversations.insert(conversation);
},
// Upsert conversation
upsertConversation: function(convId, conversation) {
return Conversations.upsert({_id: convId}, conversation);
},
// Remove conversation
removeConversation: function(convId) {
return Conversations.remove({_id: convId});
},
/**********************
* Messages
*/
// Create message
newMessage: function(message) {
return Messages.insert(message);
},
// Upsert message
upsertMessage: function(messageId, message) {
return Messages.upsert({_id: messageId}, message);
},
// Remove message
removeMessage: function(messageId) {
return Messages.remove({_id: messageId});
},
/**********************
* Users
*/
// new User
newUser: function(doc) {
return Accounts.createUser(doc);
},
// Upsert User
upsertUser: function(userId, object) {
return Meteor.users.upsert({
_id: userId,
}, object);
},
// Remove User
removeUser: function(userId) {
return Meteor.users.remove({_id: userId});
}
});
|
const initialState = {
id: 100,
loggedIn: false,
users: [
{
id: 1,
username: 'test',
email: 'test@gmail.com',
password: '123456'
}
],
currentUser: null,
invalidEmail: false,
invalidPassword: false,
uniqEmail: true,
uniqUsername: true
};
const reducer = (state = initialState, action) => {
switch (action.type) {
case 'USER_LOGGED_IN':
const user = state.users.find(user => user.email === action.email);
if (user && user.password !== action.password) {
return {
...state,
invalidEmail: false,
invalidPassword: true
};
};
if (user && user.password === action.password) {
return {
...state,
loggedIn: true,
currentUser: user,
invalidEmail: false,
invalidPassword: false
};
};
return {
...state,
invalidEmail: true
};
case 'USER_LOGGED_OUT':
return {
...state,
currentUser: null,
loggedIn: false
};
case 'USER_SIGN_UP':
const newUser = {
id: state.id + 1,
username: action.username,
email: action.email,
password: action.password
};
const usernameIsUniq = !state.users.some(user => user.username === newUser.username);
const emailIsUniq = !state.users.some(user => user.email === newUser.email);
if (usernameIsUniq && emailIsUniq) {
return {
...state,
users: [...state.users, newUser],
currentUser: newUser,
loggedIn: true,
uniqUsername: true,
uniqEmail: true
}
};
return {
...state,
uniqEmail: emailIsUniq ? true : false,
uniqUsername: usernameIsUniq ? true : false
};
default:
return state;
};
};
export default reducer;
|
import React, {Component} from 'react';
import {
View,
Image,
Text,
TouchableWithoutFeedback,
ScrollView,
} from 'react-native';
import httpRequest from '@/src/utils/request';
import globals from '@/src/styles/globals';
import indexStyleSheet from './help_list_styles';
const _styleSheet = indexStyleSheet;
class HelpList extends Component {
static navigationOptions = {
title: '帮助中心',
};
state = {
list: [],
};
componentDidMount() {
httpRequest('/api/v1/contents/1/175').then(r => {
this.setState({
list: r.value,
});
});
}
render() {
const {list} = this.state;
return (
//里面只能包含值或表达式，不能有逻辑语句，但可以调用包含逻辑语句的函数表达式
<ScrollView
automaticallyAdjustContentInsets={false}
onScroll={() => {
console.log('onScroll!');
}}
scrollEventThrottle={200}
style={globals.scrollViewContainer}>
<View style={_styleSheet.help}>
<View style={_styleSheet['help-link__item']}>
<View style={_styleSheet['help-link__icon']}>
<Image
style={_styleSheet['help-link__icon-help']}
source={require('@/src/assets/images/help/help_guide.png')}
/>
</View>
<View style={_styleSheet['help-link__ask']}>
{list.map(item => (
<TouchableWithoutFeedback
key={item.id}
onPress={() =>
this.props.navigation.navigate('ArticleDetail', {
url: `/api/v1/contents/${item.siteId}/${item.channelId}/${
item.id
}`,
title: item.title,
})
}
style={_styleSheet.index__Navigator}>
<View style={_styleSheet['help-link__title']}>
<Text style={_styleSheet['help-link__title-text']}>
{item.title}
</Text>
</View>
</TouchableWithoutFeedback>
))}
{/* <TouchableWithoutFeedback
onPress={() =>
this.props.navigation.navigate('Webview', {
sourceUri:
'https://www.codekid.top/#/pages/webview/attention',
title: '上课须知',
})
}
style={_styleSheet.index__Navigator}>
<View style={_styleSheet['help-link__title']}>
<Text style={_styleSheet['help-link__title-text']}>
上课须知 ？
</Text>
</View>
</TouchableWithoutFeedback>
<TouchableWithoutFeedback
onPress={() =>
this.props.navigation.navigate('Webview', {
sourceUri: 'https://www.codekid.top/#/pages/webview/guide',
title: '上课指南',
})
}
style={_styleSheet.index__Navigator}>
<View
style={[
_styleSheet['help-link__title'],
_styleSheet['help-link__title-noborder'],
]}>
<Text style={_styleSheet['help-link__title-text']}>
上课指南 ？
</Text>
</View>
</TouchableWithoutFeedback> */}
</View>
</View>
{/* <View style={_styleSheet['help-link__separator']} />
<View style={_styleSheet['help-link__item']}>
<View style={_styleSheet['help-link__icon']}>
<Image
style={_styleSheet['help-link__icon-help']}
source={require('@/src/assets/images/help/help_update.png')}
/>
</View>
<View style={_styleSheet['help-link__ask']}>
<TouchableWithoutFeedback
onPress={() =>
this.props.navigation.navigate('Webview', {
sourceUri:
'https://www.codekid.top/#/pages/webview/update_time',
title: '我们多长时间更新一次课程',
})
}
style={_styleSheet.index__Navigator}>
<View style={_styleSheet['help-link__title']}>
<Text style={_styleSheet['help-link__title-text']}>
我们多长时间更新一次课程 ？
</Text>
</View>
</TouchableWithoutFeedback>
<TouchableWithoutFeedback
onPress={() =>
this.props.navigation.navigate('Webview', {
sourceUri:
'https://www.codekid.top/#/pages/webview/update_notice',
title: '如何收到课程更新通知',
})
}
style={_styleSheet.index__Navigator}>
<View style={_styleSheet['help-link__title']}>
<Text style={_styleSheet['help-link__title-text']}>
如何收到课程更新通知 ？
</Text>
</View>
</TouchableWithoutFeedback>
</View>
</View> */}
</View>
</ScrollView>
);
}
}
export default HelpList;
|
#!/usr/bin/env node
const fs = require("fs").promises;
const { BigNumber } = require("bignumber.js");
const { Stellar, server, TimeoutInfinite } = require("./lib/sdk");
const [escrowPair, pairA, pairB] = require("../pairs.json");
const releaseFundsToB = async (
escrowPublicKey,
pairAPublicKey,
pairBPublicKey
) => {
const escrowAccount = await server.loadAccount(escrowPublicKey);
const paymentToAccountB = {
destination: pairBPublicKey,
asset: Stellar.Asset.native(),
amount: "10.0000000"
};
const now = new BigNumber(Math.floor(Date.now())).dividedToIntegerBy(1000);
// Block transaction for the next 5 minutes and then for 1h
const txOptions = {
timebounds: {
minTime: now.plus(60).toNumber(), // 1 min from now
maxTime: 0
},
fee: await server.fetchBaseFee(),
memo: Stellar.Memo.text("Release Funds to Account B")
};
let transaction = new Stellar.TransactionBuilder(escrowAccount, txOptions)
.addOperation(Stellar.Operation.payment(paymentToAccountB))
.addOperation(
Stellar.Operation.accountMerge({ destination: pairAPublicKey })
)
.setTimeout(TimeoutInfinite)
.build();
const txEnvelopeXDR = transaction.toEnvelope().toXDR("base64");
await fs.writeFile("fundsReleaseTx.x", txEnvelopeXDR, { encoding: "base64" });
};
releaseFundsToB(escrowPair.publicKey, pairA.publicKey, pairB.publicKey)
.then(() => {
console.log("ok");
})
.catch(e => {
console.error(e);
throw e;
});
|
import React, { Component } from 'react';
import Task from './task';
class Taskboard extends Component {
state = {
idcount : 0,
title : this.props.value.title,
tasks : [
]
}
deleteTask = (id) => {
var index = this.state.tasks.map(x => {
return x.id;
}).indexOf(id);
this.state.tasks.splice(index, 1);
this.setState({state : this.state});
}
addTask = () => {
let newTask = {
id : this.state.idcount,
name : "Task No. " + this.state.idcount,
description : "Content of task number " + this.state.idcount
}
this.state.tasks.push(newTask);
this.setState({idcount: this.state.idcount + 1});
// Para hacer refresh
this.setState({state : this.state});
}
renderTasks(){
return (this.state.tasks.length === 0) ? "You don't have any tasks." : "";
}
render() {
return (
<div class="card border shadow">
<div class="card-body">
<h2 class="card-title text-primary">{this.state.title}</h2>
<h5 class=""> {this.renderTasks()}</h5>
{this.state.tasks.map((e, index) => <Task key={e.id} value={e} action={this.deleteTask}/>)}
<br></br>
<div class="row justify-content-center">
<button class="btn btn-primary" onClick={this.addTask}>Add task</button>
</div>
</div>
</div>
);
}
}
export default Taskboard;
|
function min() {
let num1 = Infinity;
let num2 = Infinity;
let num3 = Infinity;
while (num1 && num2 && num3) {
let nextnum = prompt();
nextnum < num1 && nextnum < num2 && nextnum < num3
? (num1 = nextnum)
: nextnum > num1 && nextnum < num2 && nextnum < num3
? (num2 = nextnum)
: nextnum > num1 && nextnum > num2 && nextnum < num3
? (num3 = nextnum)
: nextnum;
if (nextnum == 'stop') {
return `Smallest is ${num1},2nd Smallest is ${num2},3rd Smallest is ${num3}`;
break;
}
}
}
min();
|
var searchData=
[
['initial_5fval_9',['initial_val',['../functions_8h.html#a4a4e13c878a42261e5ed3dfc55ead57e',1,'functions.h']]],
['initlu5_10',['initLU5',['../alu_8h.html#a49abaf2e2d7aa09cdbd164c27c450659',1,'alu.h']]],
['initlu9_11',['initLU9',['../alu_8h.html#a795c7d4beb5dd7f30e051dd8deae8d9a',1,'alu.h']]],
['initluhandle_12',['initLUHandle',['../functionHandles_8h.html#ad1d7cd2d49468f9e2c6c6863c865ab84',1,'functionHandles.h']]],
['initn_13',['initN',['../functions_8h.html#af65aece55efbd95595403e3aeee25e54',1,'functions.h']]],
['initxb5_14',['initXB5',['../functions_8h.html#aaf104f06bebf3e0cb4c5012304f6548d',1,'functions.h']]],
['initxb9_15',['initXB9',['../functions_8h.html#a57077dafef94091f579b7d65e2d467d8',1,'functions.h']]],
['initxbhandle_16',['initXBHandle',['../functionHandles_8h.html#a9a1395358a8d908ac70adeea5a0b36ce',1,'functionHandles.h']]],
['inputs_17',['inputs',['../functions_8h.html#af7314a0be1fea6466f56e40001b77b88',1,'functions.h']]]
];
|
/**
* First we will load all of this project's JavaScript dependencies which
* includes Vue and other libraries. It is a great starting point when
* building robust, powerful web applications using Vue and Laravel.
*/
require('./bootstrap');
import Vue from 'vue';
import axios from 'axios';
import InfiniteLoading from 'vue-infinite-loading';
import store from './store/index.js';
import router from './router';
import * as config from './config';
import http from './http';
window.state = store.state;
window.Vue = Vue;
Vue.component('app', require('./App.vue').default);
Vue.use(http, { store });
/**
* Next, we will create a fresh Vue application instance and attach it to
* the page. Then, you may begin adding components to this application
* or customize the JavaScript scaffolding to fit your unique needs.
*/
const app = new Vue({
config,
store,
router
}).$mount('#app');
|
import React from 'react';
import App from './App';
import * as hooks from '../../hooks/useData';
import { render, screen, fireEvent } from "@testing-library/react";
import { responseStatus } from '../../constants';
import { act } from 'react-dom/test-utils';
const columns = [{
id: '1',
parentFrameId: '1',
keyName: '$BodyCopyWeight',
isHidden: false,
},
{
id: '2',
parentFrameId: '1',
keyName: '$BodyCopySize',
isHidden: true,
},
{
id: '3',
parentFrameId: '1',
keyName: '$CtaText',
isHidden: false,
},
{
id: '4',
parentFrameId: '2',
keyName: '$CopyBoxColour',
isHidden: false,
},
{
id: '5',
parentFrameId: '4',
keyName: '$TermsCopy',
isHidden: false,
}
];
const variant = {
dateCreated: '2020-01-13T17:33:53+00:00',
lastUpdated: '2020-01-13T17:33:54+00:00',
creativeList: [
{
workingData: {
frames: {
first: {
content: {
$TaglineWeight: 'normal',
$PrefixText: '',
$CopyColour: 'black',
$ModelSize: 20,
$TermsCopy: 'Car Finance. 18+. <br/>Subject to status. T&Cs apply.*',
$CtaText: 'MORE ON THIS OFFER',
$BodyCopySize: 15,
$CopyBoxColour: 'transparent'
},
frameTemplateId: 304,
frameId: '1'
},
middle: [
{
content: {
$TaglineWeight: 'normal',
$PrefixText: '',
$CopyColour: 'black',
$ModelSize: 20,
$BodyCopyText: '£179 deposit*<br/><br/>',
$BodyCopySize: 15,
$CopyBoxColour: 'transparent'
},
frameTemplateId: 291,
frame_id: '2'
},
{
content: {
$TaglineWeight: 'normal',
$PrefixText: '',
$CopyColour: 'black',
$ModelSize: 20,
$BodyCopySize: 15,
$CopyBoxColour: 'transparent'
},
frameTemplateId: 291,
frame_id: '3'
}
],
last: {
content: {
$TaglineWeight: 'normal',
$TaglineText: 'Seduction never ends',
$TermsCopy: 'Car Finance',
$CtaText: 'MORE ON THIS OFFER',
$BodyCopySize: 15,
$CopyBoxColour: 'transparent'
},
frameTemplateId: 290,
frame_id: '4'
}
}
}
}
]
};
describe('App', () => {
it('renders correctly while data is loading', () => {
render(<App />);
expect(screen.queryByText('Loading...')).toBeInTheDocument();
})
it('renders correctly when got data', () => {
hooks.useData = jest.fn();
hooks.useData.mockReturnValue({
variant,
columns,
isLoading: false,
showPopup: false
});
render(<App />);
expect(screen.queryByText('First')).toBeInTheDocument();
expect(screen.queryByText('Copy Frames')).toBeInTheDocument();
expect(screen.queryByText('Cta Text')).toBeInTheDocument();
})
it('renders correctly when got error', () => {
hooks.useData = jest.fn();
hooks.useData.mockReturnValue({
isLoading: false,
error: new Error(responseStatus.INTERNAL_SERVER_ERROR)
});
render(<App />);
expect(screen.queryByText('A PROBLEM OCCURED! PLEASE TRY AGAIN LATER!')).toBeInTheDocument();
})
it('shows a popup', () => {
hooks.useData = jest.fn();
hooks.useData.mockReturnValue({
isLoading: false,
showPopup: true
});
render(<App />);
expect(screen.queryByText('You are not authorised')).toBeInTheDocument();
expect(screen.queryByText('Copy Frames')).not.toBeInTheDocument();
})
});
describe('App', () => {
it('handles Copy Frames button click', () => {
hooks.useData = jest.fn();
hooks.useData.mockReturnValue({
variant,
columns,
isLoading: false,
showPopup: false
});
render(<App />);
act(() => { fireEvent.click(screen.getByText('Copy Frames')); })
expect(screen.queryByText('BELOW FRAMES ARE COPIED SUCCESSFULLY :')).toBeInTheDocument();
expect(screen.queryByText('FIRST')).toBeInTheDocument();
expect(screen.queryByText('MIDDLE')).toBeInTheDocument();
expect(screen.queryByText('LAST')).toBeInTheDocument();
})
});
|
import React, { useState, useEffect } from 'react'
import './App.scss';
import Header from './components/Header'
import NewsTable from './components/NewsTable';
import Search from './components/Search';
import Pagination from './components/Pagination';
import fetchArticles from './functions/fetchArticles'
function App() {
const [items, setItems] = useState([])
const [isLoading, setLoading] = useState(true)
const [query, setQuery] = useState('')
const [currentPage, setCurrentPage] = useState(1)
const [itemsPerPage] = useState(5)
const [fetchTechnology, setFetchTechnology] = useState(true)
useEffect(() => {
fetchArticles(fetchTechnology, query, setItems, setLoading)
}, [query, fetchTechnology])
const indexOfLastItem = currentPage * itemsPerPage;
const indexOfFirstItem = indexOfLastItem - itemsPerPage;
const currentItems = items.slice(indexOfFirstItem, indexOfLastItem);
const paginate = pageNumber => setCurrentPage(pageNumber)
return (
<div>
<Header fetchTechnology={fetchTechnology} setFetchTechnology={setFetchTechnology} setLoading={setLoading}/>
<Search search={(q) => setQuery(q)} />
<NewsTable items={currentItems} isLoading={isLoading} />
<Pagination
itemsPerPage={itemsPerPage}
totalItems={items.length}
paginate={paginate}
/>
</div>
);
}
export default App;
|
// const multipleofFizzBuzz = require("C:/Users/adela/OneDrive/Documents/GitHub/katanfizzbuzz/tddFizzBuzz.js")
const multipleofFizzBuzz = require("../../tddFizzBuzz.js")
describe ("testingFizzBuzz", function(){
it("multiple of 3 and 5 should print FizzBuzz", function(){
expect(multipleofFizzBuzz(15)).toEqual("FizzBuzz")
})
it("multiple of 3 should print Fizz", function(){
expect(multipleofFizzBuzz(3)).toEqual("Fizz")
})
it("multiple of 5 should print Buzz", function(){
expect(multipleofFizzBuzz(5)).toEqual("Buzz")
})
it("not a multiple of 3 or 5 should print number", function(){
expect(multipleofFizzBuzz(2)).toEqual(2)
})
})
|
kitty.Sticky = function(el) {
this.el = el;
this.topPosition = this.el.offset().top;
this.height = this.el.outerHeight();
this.window = $(window);
this.viewportHeight = $(window).height();
this.viewportWidth = $(window).width();
this.window.on('scroll', $.debounce(1, $.proxy(this, "check")));
this.window.on('resize', $.debounce(1, $.proxy(this, "check")));
};
kitty.Sticky.prototype.check = function() {
if (this.window.height() > this.height) {
if (this.window.scrollTop() < this.topPosition) {
this.el.removeClass('sticky');
} else {
this.el.addClass('sticky');
}
} else {
this.el.removeClass('sticky');
}
};
|
function Each() {
const Lugar = ["joao", "Maria", "carlos"]
for (let i = 0; i < Lugar.length; i++) {
console.log(Lugar[index])
}
}
Each()
|
import React, { Component } from "react";
import SearchBar from '../component/SearchBar';
import SearchMap from "../component/SearchMap";
import BusinessCardContainer from "./BusinessCardContainer";
import { GoogleApiWrapper } from "google-maps-react";
import MyProfile from "./MyProfile";
const nyc = {
lat: 40.754932,
lng: -73.984016,
};
class SearchPage extends Component {
render() {
return (
<div>
<div className='ui centered grid'>
<SearchBar onSearchChange={this.props.onSearchChange} />
</div>
<div className='ui segment'>
<div className='ui two column grid'>
<div className='column'>
{this.props.restaurants.length === 0 ? null : (
<BusinessCardContainer
favoriteRes={this.props.favoriteRes}
restaurants={this.props.handleDisplay}
/>
)}
</div>
<div className='column'>
<SearchMap
nyc={nyc}
places={this.props.handleDisplay}
onReady={this.onReady}
google={this.props.google}
/>
</div>
</div>
</div>
</div>
);
}
}
export default GoogleApiWrapper({
apiKey: process.env.REACT_APP_GOOGLE_PLACES_API_KEY,
})(SearchPage);
|
// Tag 6 - 13.01.2020
// Klassen
// Eine Klasse ist ein Bauplan für Objekte
// Ein Objekt wird instanziiert
// Jede Klasse hat eine Konstruktor
// Mit "new" wird mit dem Konstruktor eon Objekt aus der Klasse erzeugt.
// Functionen in Klassen nennt man Methoden
// JavaScript Klassen können (ver)erben
/*
_____________________ _____________________
Fahrzeug LKW
_____________________ _____________________
return Türen
_____________________ <-- _____________________
start()
stop()
_____________________
^
|
_____________________
Auto
_____________________
Türen
Motor
_____________________
*/
extends // Vererbung
move // Übergabe
instanceof // Überprüssen um was es sich handelt
// Klassen möglich groß schreiben
// Endwerde Aufbau 1 oder Aufbau 2
// Aufbau 1
class Fahrzeuge {
constructor(width, height, velocity) {
this.width = width;
this.height = height;
this.velocity;
}
move(distane) {
console.log("Die Fahrt dauerte: ", distane / this.velocity);
}
}
// Aufbau 2
Fahrzeug.prototype.move = function(distane) {
constructor(width, height, velocity) {
this.width = width;
this.height = height;
this.velocity;
}
move(distane) {
console.log("Die Fahrt dauerte: ", distane / this.velocity);
}
}
static KlassenMethode() {
console.log("Dies ist eine KlassenMethode")
}
class Auto extends Fahrzeug { // extends (Vererbung)
constructor(width, height, velocity, doors, seats) {
super(width, height, velocity);
this.doors = doors;
this.seats = seats;
}
}
Auto.getClassName = undefined;
// Erzeugen
let f = new Auto(2, 0.5, 300, 27, 49)
|
import { createStore, applyMiddleware, combineReducers } from 'redux';
import { fetchMock } from 'fetch-mock';
import { PromiseBlackBox, ReduxBlackBox, blackBoxMiddleware } from '../lib';
const delay = ms => new Promise(res => setTimeout(res, ms));
global.console.assert = (check, msg) => { if (!check) throw new Error(msg || 'AssertionError'); };
export const jobItem = {
job: {
urn: 'urn:alpha:abc',
created: '2018-11-29T15:18:07.248044017Z',
inputs: {}
}
};
export const jobStateCompleted = {
state: 'STATE_COMPLETED',
progress: 100,
description: 'Completed',
updated: '2018-11-29T15:49:17.022455539Z',
history: [],
reason: ''
};
export const jobStateRunning = {
state: 'STATE_PROCESSING',
progress: 100,
description: 'Completed',
updated: '2018-11-29T15:49:17.022455539Z',
history: [],
reason: ''
};
export const jobNotices = {
notices: [{
severity: 'SEVERITY_INFO', code: 0, message: 'Starting job', time: '2018-11-29T15:18:23.681484Z'
}]
};
export const jobOutputs = {
outputs: {
step1: {},
step2: {},
}
};
const API_ENDPOINT = 'http://server.org';
export const JobsAPI = {
// JOBS
getJobsStatus: () =>
fetch(
`${API_ENDPOINT}/v1/jobs/status`,
{ method: 'GET', body: null }
),
createJob: request =>
fetch(
`${API_ENDPOINT}/v1/jobs`,
{ method: 'POST', body: JSON.stringify(request) }
),
getJobState: jobUrn =>
fetch(
`${API_ENDPOINT}/v1/jobs/${jobUrn}/state`,
{ method: 'GET', body: null }
),
getJobNotices: jobUrn =>
fetch(
`${API_ENDPOINT}/v1/jobs/${jobUrn}/notices`,
{ method: 'GET', body: null }
),
getJobOutputs: jobUrn =>
fetch(
`${API_ENDPOINT}/v1/jobs/${jobUrn}/outputs`,
{ method: 'GET', body: null }
),
getJobItem: jobUrn =>
fetch(
`${API_ENDPOINT}/v1/jobs/${jobUrn}/item`,
{ method: 'GET', body: null }
),
cancelJob: jobUrn =>
fetch(
`${API_ENDPOINT}/v1/jobs/${jobUrn}/cancel`,
{ method: 'POST', body: null }
),
};
const JobStates = {
STATE_UNINITIALIZED: 'STATE_UNINITIALIZED',
STATE_NOT_RECEIVED: 'STATE_NOT_RECEIVED',
STATE_RECEIVING: 'STATE_RECEIVING',
STATE_RECEIVED: 'STATE_RECEIVED',
STATE_PROCESSING: 'STATE_PROCESSING',
STATE_COMPLETED: 'STATE_COMPLETED',
STATE_FAILED: 'STATE_FAILED',
STATE_ABORTING: 'STATE_ABORTING',
STATE_ABORTED: 'STATE_ABORTED',
};
const LoadingStates = {
UNLOADED: 'UNLOADED',
LOADING: 'LOADING',
LOADED: 'LOADED',
};
const ActionTypes = {
// commands
CREATE: 'CREATE',
UNLOAD: 'UNLOAD',
LOAD: 'LOAD',
RUN: 'RUN',
ABORT: 'ABORT',
LOAD_SUCCESS: 'LOAD_SUCCESS',
UPDATE_JOB_STATE: 'UPDATE_JOB_STATE',
RUN_SUCCESS: 'RUN_SUCCESS',
ABORT_SUCCESS: 'ABORT_SUCCESS'
};
export const isRunningState = (state) => {
console.assert(JobStates[state], `Unknown state: ${state}`);
return [JobStates.STATE_RECEIVING,
JobStates.STATE_RECEIVED, JobStates.STATE_PROCESSING, JobStates.STATE_ABORTING].includes(state);
};
export const isFinishedState = (state) => {
console.assert(JobStates[state], `Unknown state: ${state}`);
return [JobStates.STATE_FAILED, JobStates.STATE_COMPLETED, JobStates.STATE_ABORTED].includes(state);
};
export const isSuccessState = (state) => {
console.assert(JobStates[state], `Unknown state: ${state}`);
return [JobStates.STATE_COMPLETED].includes(state);
};
export const isFinishedUnsuccessfullyState = (state) => {
console.assert(JobStates[state], `Unknown state: ${state}`);
return [JobStates.STATE_FAILED, JobStates.STATE_ABORTED].includes(state);
};
describe('job handler state machine', () => {
const jobHandlerReducer = (
state = {
loadingState: {
state: LoadingStates.UNLOADED,
numRefs: 0,
},
// job data
request: null,
jobUrn: null,
startTime: 0,
jobState: {
state: JobStates.STATE_NOT_RECEIVED,
progress: 0,
description: null,
},
error: null,
notices: null,
outputs: null,
runTime: 0,
},
action,
) => {
switch (action.type) {
/* CREATE COMMAND */
case ActionTypes.CREATE:
console.assert(state.loadingState.state === LoadingStates.UNLOADED, `Unexpected state: ${state.stateName}`);
return {
...state,
loadingState: { ...state.loadingState, state: LoadingStates.LOADED },
jobUrn: action.jobUrn,
request: action.request,
startTime: action.startTime
};
/* LOAD COMMAND */
case ActionTypes.LOAD:
if (state.loadingState.state === LoadingStates.UNLOADED) {
// start loading process
console.assert(state.loadingState.numRefs === 0);
return {
...state,
jobUrn: action.jobUrn,
loadingState: {
...state.loadingState,
state: LoadingStates.LOADING,
numRefs: 1
},
loadSideEffect: new PromiseBlackBox(() =>
Promise.all([
JobsAPI.getJobItem(action.jobUrn),
JobsAPI.getJobState(action.jobUrn),
JobsAPI.getJobNotices(action.jobUrn),
JobsAPI.getJobOutputs(action.jobUrn)
])
.then(resArray => Promise.all(resArray.map(res => res.json())))
.then(([item, stateRes, notices, outputs]) => (
{
type: ActionTypes.LOAD_SUCCESS,
jobUrn: action.jobUrn,
request: item.job,
state: stateRes,
notices,
outputs
})))
};
}
return {
...state,
loadingState: {
...state.loadingState,
numRefs: state.numRefs + 1
}
};
/* LOADING PROCESS */
case ActionTypes.LOAD_SUCCESS:
console.assert(state.loadingState.state === LoadingStates.LOADING, `Unexpected state: ${state.stateName}`);
// console.log(action.state);
return {
...state,
loadingState: { ...state.loadingState, state: LoadingStates.LOADED },
request: action.request,
jobState: action.state,
notices: action.notices,
outputs: action.outputs,
loadSideEffect: null,
pollingSideEffect: isRunningState(action.state.state)
? new PromiseBlackBox(() => delay(50)
.then(() => JobsAPI.getJobState(state.jobUrn).then(res => res.json()))
.then(stateRes => ({ type: ActionTypes.UPDATE_JOB_STATE, state: stateRes }))) : null
};
/* POLLING PROCESS */
case ActionTypes.UPDATE_JOB_STATE:
console.assert(state.loadingState.state === LoadingStates.LOADED, `Unexpected state: ${state.stateName}`);
// console.log(action.state);
return {
...state,
jobState: action.state,
pollingSideEffect: isRunningState(action.state.state)
? new PromiseBlackBox(() => delay(50)
.then(() => JobsAPI.getJobState(state.jobUrn).then(res => res.json()))
.then(stateRes => ({ type: ActionTypes.UPDATE_JOB_STATE, state: stateRes }))) : null
};
/* UNLOAD COMMAND */
case ActionTypes.UNLOAD:
console.assert(state.loadingState.state === LoadingStates.LOADING
|| state.loadingState.state === LoadingStates.LOADED);
if (state.loadingState.numRefs === 1) {
return {
...state,
loadingState: {
...state.loadingState,
state: LoadingStates.UNLOADED,
numRefs: 0,
},
request: null,
jobState: null,
notices: null,
outputs: null,
loadSideEffect: null,
pollingSideEffect: null,
};
}
return {
...state,
loadingState: {
...state.loadingState,
numRefs: state.numRefs - 1,
}
};
/* RUN COMMAND */
case ActionTypes.RUN:
console.assert(state.loadingState.state === LoadingStates.LOADED, `Unexpected state: ${state.stateName}`);
console.assert(state.jobState.state === JobStates.STATE_NOT_RECEIVED, `Unexpected state: ${state.stateName}`);
return {
...state,
numRefs: 0,
jobState: { ...state.jobState, state: JobStates.STATE_RECEIVING },
runSideEffect: new PromiseBlackBox(() => JobsAPI.createJob(state.request)
.then(() => ({ type: ActionTypes.RUN_SUCCESS })))
};
/* RUN PROCESS */
case ActionTypes.RUN_SUCCESS:
console.assert(state.loadingState.state === LoadingStates.LOADED, `Unexpected state: ${state.stateName}`);
console.assert(state.jobState.state === JobStates.STATE_RECEIVING, `Unexpected state: ${state.stateName}`);
return {
...state,
jobState: { ...state.jobState, state: JobStates.STATE_RECEIVED },
runSideEffect: null,
pollingSideEffect: new PromiseBlackBox(() => delay(50)
.then(() => JobsAPI.getJobState(state.jobUrn).then(res => res.json()))
.then(stateRes => ({ type: ActionTypes.UPDATE_JOB_STATE, state: stateRes })))
};
/* ABORT COMMAND */
case ActionTypes.ABORT:
console.assert(state.loadingState.state === LoadingStates.LOADED, `Unexpected state: ${state.stateName}`);
// console.assert(state.jobState.state === JobStates.STATE_RECEIVED, `Unexpected state: ${state.stateName}`);
return {
...state,
jobState: { ...state.jobState, state: JobStates.STATE_ABORTING },
abortingSideEffect: new PromiseBlackBox(() => JobsAPI.cancelJob(state.jobUrn)
.then(() => ({ type: ActionTypes.ABORT_SUCCESS }))),
pollingSideEffect: null
};
/* ABORT PROCESS */
case ActionTypes.ABORT_SUCCESS:
console.assert(state.loadingState.state === LoadingStates.LOADED, `Unexpected state: ${state.stateName}`);
console.assert(state.jobState.state === JobStates.STATE_ABORTING, `Unexpected state: ${state.stateName}`);
return {
...state,
jobState: { ...state.jobState, state: JobStates.STATE_ABORTED },
abortingSideEffect: null
};
default:
return state;
}
};
afterEach(() => fetchMock.reset());
it('handles loading and polling', async () => {
fetchMock
.get('express:/v1/jobs/:jobUrn/item',
{ status: 200, body: jobItem },
{ sendAsJson: true })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateRunning },
{ sendAsJson: true, repeat: 4 })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateCompleted },
{ sendAsJson: true, overwriteRoutes: false })
.get('express:/v1/jobs/:jobUrn/notices',
{ status: 200, body: jobNotices },
{ sendAsJson: true })
.get('express:/v1/jobs/:jobUrn/outputs',
{ status: 200, body: jobOutputs },
{ sendAsJson: true });
const store = createStore(jobHandlerReducer, undefined, applyMiddleware(blackBoxMiddleware));
expect(store.getState().loadingState.state).toBe(LoadingStates.UNLOADED);
store.dispatch({ type: ActionTypes.LOAD, jobUrn: 'abc' });
await delay(200);
expect(store.getState().loadingState.state).toBe(LoadingStates.LOADED);
expect(store.getState().jobState.state).toBe(JobStates.STATE_PROCESSING);
await delay(300);
expect(store.getState().jobState.state).toBe(JobStates.STATE_COMPLETED);
store.dispatch({ type: ActionTypes.UNLOAD, jobUrn: 'abc' });
expect(store.getState().loadingState.state).toBe(LoadingStates.UNLOADED);
});
it('handles create, run and abort', async () => {
fetchMock
.post('express:/v1/jobs',
{ status: 200, body: jobItem },
{ sendAsJson: true })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateRunning },
{ sendAsJson: true, repeat: 4 })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateCompleted },
{ sendAsJson: true, overwriteRoutes: false })
.post('express:/v1/jobs/:jobUrn/cancel',
{ status: 200 },
{ sendAsJson: true });
const store = createStore(jobHandlerReducer, undefined, applyMiddleware(blackBoxMiddleware));
expect(store.getState().loadingState.state).toBe(LoadingStates.UNLOADED);
store.dispatch({ type: ActionTypes.CREATE, jobUrn: 'abc', request: { nothing: 'here' } });
await delay(200);
expect(store.getState().loadingState.state).toBe(LoadingStates.LOADED);
expect(store.getState().jobState.state).toBe(JobStates.STATE_NOT_RECEIVED);
store.dispatch({ type: ActionTypes.RUN, jobUrn: 'abc' });
expect(store.getState().jobState.state).toBe(JobStates.STATE_RECEIVING);
await delay(100);
expect(store.getState().jobState.state).toBe(JobStates.STATE_PROCESSING);
await delay(300);
expect(store.getState().jobState.state).toBe(JobStates.STATE_COMPLETED);
store.dispatch({ type: ActionTypes.ABORT, jobUrn: 'abc' });
expect(store.getState().jobState.state).toBe(JobStates.STATE_ABORTING);
await delay(100);
expect(store.getState().jobState.state).toBe(JobStates.STATE_ABORTED);
});
it('job handler as a dependency of another process', async () => {
fetchMock
.get('express:/v1/jobs/:jobUrn/item',
{ status: 200, body: jobItem },
{ sendAsJson: true })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateRunning },
{ sendAsJson: true, repeat: 4 })
.get('express:/v1/jobs/:jobUrn/state',
{ status: 200, body: jobStateCompleted },
{ sendAsJson: true, overwriteRoutes: false })
.get('express:/v1/jobs/:jobUrn/notices',
{ status: 200, body: jobNotices },
{ sendAsJson: true })
.get('express:/v1/jobs/:jobUrn/outputs',
{ status: 200, body: jobOutputs },
{ sendAsJson: true });
const processReducer = (state = { state: 'WAITING' }, action) => {
switch (action.type) {
case 'START':
return {
...state,
state: 'STEP0',
loadSideEffect: new ReduxBlackBox(
{ type: ActionTypes.LOAD, jobUrn: 'abc' },
{ type: 'STEP_TO1' },
(act, st) => act.type === ActionTypes.LOAD_SUCCESS
|| (act.type === ActionTypes.LOAD && st.jobHandler.loadingState.state === LoadingStates.LOADED)
)
};
case 'STEP_TO1':
return {
...state,
state: 'STEP1'
};
case 'START_AGAIN':
return {
...state,
state: 'STEP2',
loadSideEffect: new ReduxBlackBox(
{ type: ActionTypes.LOAD, jobUrn: 'abc' },
{ type: 'STEP_TO3' },
(act, st) => act.type === ActionTypes.LOAD_SUCCESS
|| (act.type === ActionTypes.LOAD && st.jobHandler.loadingState.state === LoadingStates.LOADED)
)
};
case 'STEP_TO3':
return {
...state,
state: 'STEP3'
};
default:
return state;
}
};
const reducer = combineReducers({ jobHandler: jobHandlerReducer, process: processReducer });
const store = createStore(reducer, undefined, applyMiddleware(blackBoxMiddleware));
expect(store.getState().process.state).toBe('WAITING');
expect(store.getState().jobHandler.loadingState.state).toBe(LoadingStates.UNLOADED);
store.dispatch({ type: 'START' });
await delay(200);
expect(store.getState().jobHandler.loadingState.state).toBe(LoadingStates.LOADED);
expect(store.getState().jobHandler.jobState.state).toBe(JobStates.STATE_PROCESSING);
expect(store.getState().process.state).toBe('STEP1');
store.dispatch({ type: 'START_AGAIN' });
expect(store.getState().jobHandler.loadingState.state).toBe(LoadingStates.LOADED);
await delay(200);
expect(store.getState().process.state).toBe('STEP3');
});
});
|
window.myApp.controller(
"userCtrl",
[
'$scope',
'$rootScope',
'$modal',
'$log',
'$dialogs',
'APIServices',
'$http',
'cfpLoadingBar',
'$localStorage',
'$state',
'UNISPACE_CONSTANT_MESSAGES',
'UNISPACE_CONSTANT',
function($scope, $rootScope, $modal, $log, $dialogs,
APIServices, $http, cfpLoadingBar,
$localStorage, $state, UNISPACE_CONSTANT_MESSAGES,UNISPACE_CONSTANT) {
$rootScope.itemPerPageCount = 10;
/************************************************************************************************************************
* open add employee popup controller
*
*************************************************************************************************************************/
$scope.openAddUser = function()
{
var size='md'
var modalInstance = $modal
.open({
templateUrl : 'template/popup/addUser.html',
controller : 'employeePopupController',
size : size,
scope : $scope,
backdrop : 'static',
resolve :
{
items : function()
{
return $scope.items;
}
}
});
modalInstance.result.then
(
function(selectedItem) {
$scope.selected = selectedItem;
},
function() {
$log.info('Modal dismissed at: '
+ new Date());
});
};
/************************************************************************************************************************
* open edit employee popup
*
*************************************************************************************************************************/
$scope.openEditUser = function(user,index)
{
$localStorage.id = user._id;
$rootScope.editfirstName = user.firstName;
$rootScope.editlastName = user.lastName;
$rootScope.editemail = user.emailId;
var size='md'
var modalInstance = $modal
.open(
{
templateUrl : 'template/popup/editUser.html',
controller : 'employeePopupController',
size : size,
scope : $scope,
backdrop : 'static',
resolve :
{
items : function() {
return $scope.items;
}
}
});
modalInstance.result.then(
function(selectedItem)
{
$scope.selected = selectedItem;
}, function()
{
$log.info('Modal dismissed at: '
+ new Date());
}
);
};
/****
* delete user
*
*
*/
$scope.deleteUser = function(user,index){
cfpLoadingBar.start();
$http.defaults.headers.common['Access-Control-Allow-Origin'] = '*';
$http.defaults.headers.common['Authorization'] = 'Basic Ymx1ZGVudGU6Ymx1ZGVudGUxMjM=';
APIServices.deleteUser(user._id)
.success(
function(data, status) {
console.log("*********Response edit employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr.success(data);
$rootScope.cancel();
$scope.isSaveEmployeeButton = false;
cfpLoadingBar.complete()
$scope.isSaveEmployee = false;
$state.reload();
})
.error(
function(data, status) {
cfpLoadingBar.complete()
$scope.isSaveEmployeeButton = false;
$scope.isSaveEmployee = false;
if (data == null||data=='') {
toastr.remove();
toastr
.error(UNISPACE_CONSTANT_MESSAGES.INTERNET_CONNECTION);
} else {
console.log("*********Response add employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr
.error(data.error.message);
$scope.isSaveEmployee = false;
}
});
}
/************************************************************************************************************************
* get employee list API integration
*
*************************************************************************************************************************/
$scope.getEmployeeListDetails = function(){
cfpLoadingBar.start();
$http.defaults.headers.common['Access-Control-Allow-Origin'] = '*';
$http.defaults.headers.common['Authorization'] = 'Basic Ymx1ZGVudGU6Ymx1ZGVudGUxMjM=';
APIServices.getUserData()
.success(
function(data) {
console.log("*********Response get user list***********");
console.log(data);
if(data){
$scope.userList = data;
}
$scope.searchEmployeeValue = '';
cfpLoadingBar.complete();
$scope.getAllEmployeeListClicked = false;
})
.error(
function(data, status) {
cfpLoadingBar.complete();
$scope.getAllEmployeeListClicked = false;
if (data == null
|| data == '') {
toastr.remove();
toastr
.error(UNISPACE_CONSTANT_MESSAGES.INTERNET_CONNECTION);
}
if(status==401)
{
loginAlert();
return;
}
console.log("*********Response get employee list***********");
$scope.employeeList = '';
$scope.totalVenues = 0;
$scope.noEmployeeFoundMessageOnSearch = '';
$scope.searchEmployeeValue = '';
if(data != null){
$scope.NoEmployeeFoundMessage = data.error.message;
if(data.error.message == "Invalid User token."){
$scope.NoEmployeeFoundMessage = "";
}
else{
$scope.NoEmployeeFoundMessage = data.error.message;
}
}
console.log(data);
console.log(status);
});
}
}]);
/****************************************************************************************************
* employee popup controller
***************************************************************************************************/
window.myApp.controller('employeePopupController', function($scope, $rootScope,
$modalStack, $modalInstance, $state,UNISPACE_CONSTANT_MESSAGES,$localStorage,cfpLoadingBar,APIServices,$http,UNISPACE_CONSTANT) {
$scope.isEdit = false;
$rootScope.clickInProgress = false;
$rootScope.cancel = function() {
$rootScope.editEmployeeButton = false;
$rootScope.deleteEmployeeButton = false;
if ($modalInstance) {
$modalInstance.dismiss('cancel');
}
}
/****************************************************************************************************
* save user API integration
*
***************************************************************************************************/
$scope.isSaveEmployeeButton = false;
$scope.clientId = $localStorage.clientId;
$scope.saveUser = function(){
cfpLoadingBar.start()
$scope.isSaveEmployeeButton = true;
$scope.isSaveEmployee = true;
$http.defaults.headers.common['Access-Control-Allow-Origin'] = '*';
$http.defaults.headers.common['Authorization'] = 'Basic Ymx1ZGVudGU6Ymx1ZGVudGUxMjM=';
APIServices.addUser($scope.firstName,$scope.lastName,$scope.email)
.success(
function(data, status) {
console.log("*********Response add employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr.success(data);
$rootScope.cancel();
$scope.isSaveEmployeeButton = false;
cfpLoadingBar.complete()
$scope.isSaveEmployee = false;
$state.reload();
})
.error(
function(data, status) {
cfpLoadingBar.complete()
$scope.isSaveEmployeeButton = false;
$scope.isSaveEmployee = false;
if (data == null||data=='') {
toastr.remove();
toastr
.error(UNISPACE_CONSTANT_MESSAGES.INTERNET_CONNECTION);
} else {
console.log("*********Response add employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr
.error(data.error.message);
$scope.isSaveEmployee = false;
}
});
}
/****
* edit user
*
*
*/
$scope.editUser = function(){
cfpLoadingBar.start();
$http.defaults.headers.common['Access-Control-Allow-Origin'] = '*';
$http.defaults.headers.common['Authorization'] = 'Basic Ymx1ZGVudGU6Ymx1ZGVudGUxMjM=';
APIServices.addUser($localStorage.id,$scope.editfirstName,$scope.editlastName,$scope.editemail)
.success(
function(data, status) {
console.log("*********Response edit employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr.success(data);
$rootScope.cancel();
$scope.isSaveEmployeeButton = false;
cfpLoadingBar.complete()
$scope.isSaveEmployee = false;
$state.reload();
})
.error(
function(data, status) {
cfpLoadingBar.complete()
$scope.isSaveEmployeeButton = false;
$scope.isSaveEmployee = false;
if (data == null||data=='') {
toastr.remove();
toastr
.error(UNISPACE_CONSTANT_MESSAGES.INTERNET_CONNECTION);
} else {
console.log("*********Response add employee***********");
console.log(data);
console.log(status);
toastr.remove();
toastr
.error(data.error.message);
$scope.isSaveEmployee = false;
}
});
}
});
window.myApp.directive('disallowSpaces', function() {
return {
restrict: 'A',
link: function($scope, $element) {
$element.bind('input', function() {
$(this).val($(this).val().replace(/ /g, ''));
});
}
};
});
|
import { sign } from "jsonwebtoken";
import { JWT_SECRET } from "../config";
export const AssignToken = async (user) => {
let token = await sign({ user }, JWT_SECRET, { expiresIn: "1d" });
return `JWT ${token}`;
};
|
/**
* Copyright 2016 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
goog.provide('audioCat.ui.widget.PlayPointer');
goog.require('audioCat.audio.play.events');
goog.require('audioCat.ui.text.Precision');
goog.require('audioCat.ui.visualization.events');
goog.require('audioCat.ui.widget.Widget');
goog.require('goog.dom.classes');
goog.require('goog.events');
/**
* A pointer that follows playing of audio near the time-domain ruler. Also
* displays the current play time on top of it.
* @param {!audioCat.utility.DomHelper} domHelper Facilitates DOM interactions.
* @param {!audioCat.ui.window.ScrollResizeManager} resizeScrollManager
* Manages window resize and scrolling.
* @param {!audioCat.audio.play.PlayManager} playManager Manages playing of
* audio.
* @param {!audioCat.audio.play.TimeManager} timeManager Manages the time
* actually displayed to the user.
* @param {!audioCat.ui.visualization.TimeDomainScaleManager}
* timeDomainScaleManager Manages the time scale.
* @param {!audioCat.ui.text.TimeFormatter} timeFormatter Formats time.
* @constructor
* @extends {audioCat.ui.widget.Widget}
*/
audioCat.ui.widget.PlayPointer = function(
domHelper,
resizeScrollManager,
playManager,
timeManager,
timeDomainScaleManager,
timeFormatter) {
/**
* Facilitates DOM interactions.
* @private {!audioCat.utility.DomHelper}
*/
this.domHelper_ = domHelper;
/**
* Manages scrolling and resizing.
* @private {!audioCat.ui.window.ScrollResizeManager}
*/
this.resizeScrollManager_ = resizeScrollManager;
/**
* @private {!audioCat.ui.text.TimeFormatter}
*/
this.timeFormatter_ = timeFormatter;
/**
* Manages playing of audio.
* @private {!audioCat.audio.play.PlayManager}
*/
this.playManager_ = playManager;
/**
* Manages the time displayed to the user.
* @private {!audioCat.audio.play.TimeManager}
*/
this.timeManager_ = timeManager;
/**
* Manages the time-domain scale.
* @private {!audioCat.ui.visualization.TimeDomainScaleManager}
*/
this.timeDomainScaleManager_ = timeDomainScaleManager;
var container = domHelper.createDiv(goog.getCssName('playPointer'));
goog.base(this, container);
/**
* Contains the current time.
* @private {!Element}
*/
this.currentTimeContainer_ = domHelper.createDiv(
goog.getCssName('currentTimeContainer'));
domHelper.appendChild(container, this.currentTimeContainer_);
/**
* The pixel distance from the left the container is located at.
* @private {number}
*/
this.leftPixelDistance_ = 0;
/**
* Whether the play pointer is currently displayed. It's hidden when it's out
* of view. We store this value so that we don't have to access the DOM to
* find out.
* @private {boolean}
*/
this.displayed_ = true;
// This method also sets the current time display.
this.positionBasedOnTime_();
/**
* The client X value upon the previous downpress on the pointer. Meaningless
* if no previous downpress has occurred, or the previous drag has ended.
* @private {number}
*/
this.onDragClientX_ = 0;
/**
* The indicatd time upon the previous downpress on the pointer. Meaningless
* if not currently in a drag.
* @private {number}
*/
this.onDragIndicatedTime_ = 0;
// Change the pointer's left pixel distance when the indicated time changes.
goog.events.listen(timeManager,
audioCat.audio.play.events.INDICATED_TIME_CHANGED,
this.handleIndicatedTimeChange_, false, this);
// Change the pointer's left pixel distance when the zoom level changes.
goog.events.listen(timeDomainScaleManager,
audioCat.ui.visualization.events.ZOOM_CHANGED, this.handleZoomChange_,
false, this);
// Allow for dragging.
domHelper.listenForDownPress(container, this.handleDownPress_, false, this);
// Reposition the pointer upon scrolling.
resizeScrollManager.callAfterScroll(goog.bind(this.handleScroll_, this));
};
goog.inherits(audioCat.ui.widget.PlayPointer, audioCat.ui.widget.Widget);
/**
* Handles what happens when the user scrolls the page horizontally.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleScroll_ = function() {
this.positionBasedOnTime_();
};
/**
* Handles what happens when the user zooms in or out.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleZoomChange_ = function() {
this.positionBasedOnTime_();
};
/**
* Handles what happens when the user presses down on the pointer.
* @param {!goog.events.BrowserEvent} event The associated event.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleDownPress_ = function(event) {
var playManager = this.playManager_;
if (playManager.getPlayState()) {
playManager.pause();
}
var domHelper = this.domHelper_;
this.onDragClientX_ = domHelper.obtainClientX(event);
this.onDragIndicatedTime_ = this.timeManager_.getIndicatedTime();
domHelper.listenForMove(domHelper.getDocument(), this.handleMoveOnDrag_,
false, this);
domHelper.listenForUpPress(
domHelper.getDocument(), this.handleUpPressEndDrag_, false, this, true);
};
/**
* Handles what happens when the user moves around the document while dragging.
* @param {!goog.events.BrowserEvent} event The associated mouse move event.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleMoveOnDrag_ = function(event) {
this.timeManager_.setIndicatedTime(
this.computeLeftDistanceOnDrag_(this.domHelper_.obtainClientX(event)));
};
/**
* Handles what happens when the user releases the mouse to end a drag.
* @param {!goog.events.BrowserEvent} event The associated mouse event.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleUpPressEndDrag_ =
function(event) {
this.timeManager_.setStableTime(
this.computeLeftDistanceOnDrag_(this.domHelper_.obtainClientX(event)));
var domHelper = this.domHelper_;
domHelper.unlistenForMove(domHelper.getDocument(), this.handleMoveOnDrag_,
false, this);
};
/**
* Computes the indicated time while dragging. This time may be only temporary
* since the user could be actively modifying the time.
* @param {number} currentClientX The current client X time.
* @return {number} The indicated time.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.computeLeftDistanceOnDrag_ =
function(currentClientX) {
var distanceDelta = currentClientX - this.onDragClientX_;
var scale = this.timeDomainScaleManager_.getCurrentScale();
var newIndicatedTime = this.onDragIndicatedTime_ +
scale.convertToSeconds(distanceDelta);
// Negative time makes no sense. Clamp to 0.
return (newIndicatedTime > 0) ? newIndicatedTime : 0;
};
/**
* Handles what happens when the indicated time is changed.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.handleIndicatedTimeChange_ =
function() {
this.positionBasedOnTime_();
};
/**
* Positions the play pointer based on the currently indicated time, scroll,
* and time-domain scale. Also sets the current time display.
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.positionBasedOnTime_ = function() {
// Correctly position the play pointer, which also positions the time display.
var scale = this.timeDomainScaleManager_.getCurrentScale();
var indicatedTime = this.timeManager_.getIndicatedTime();
var leftDistance = scale.convertToPixels(indicatedTime);
leftDistance -= this.resizeScrollManager_.getLeftRightScroll();
// Hide the pointer if it's out of view, so it doesn't block other things.
if (leftDistance < 0) {
if (this.displayed_) {
// Hide if displayed.
goog.dom.classes.add(this.getDom(), goog.getCssName('undisplayed'));
this.displayed_ = false;
// We no longer need to take care of changing the presentation.
return;
}
} else {
// We should display the pointer.
if (!this.displayed_) {
// Show if hidden.
goog.dom.classes.remove(this.getDom(), goog.getCssName('undisplayed'));
this.displayed_ = true;
}
}
// Actually set the distance in pixels from the left.
this.setLeftPixelDistance_(leftDistance);
// Set the current time display.
this.domHelper_.setTextContent(
this.currentTimeContainer_,
this.timeFormatter_.formatTime(
indicatedTime, audioCat.ui.text.Precision.MS)
);
};
/**
* Sets the distance from the left of the play pointer in pixels.
* @param {number} pixelDistance
* @private
*/
audioCat.ui.widget.PlayPointer.prototype.setLeftPixelDistance_ =
function(pixelDistance) {
this.getDom().style.left = pixelDistance + 'px';
this.leftPixelDistance_ = pixelDistance;
};
|
let cors = require('koa-cors');
const moment = require('moment');
const multer = require('koa-multer');
const userModel = require('../db/model/files.js');
//上传配置
const storage = multer.diskStorage({
//文件保存路径
destination: function (req, file, cb) {
cb(null, 'public/documents/')
},
//修改文件名称
filename: function (req, file, cb) {
var fileFormat = (file.originalname).split(".");
cb(null, Date.now() + "." + fileFormat[fileFormat.length - 1]);
}
})
const limits = {
fieldSize: '2MB',
files: 5
}
module.exports = {
}
|
import React, { Component } from "react";
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faPhone, faMapMarkerAlt, faEnvelope, faUser, faSignInAlt, faSearch, faBars } from '@fortawesome/free-solid-svg-icons';
import './Header.scss';
class Header extends Component {
constructor(props) {
super(props);
this.state = {
sticky: 0,
open: false
};
this.handleScrollSticky = this.handleScrollSticky.bind(this);
}
componentDidMount(){
window.addEventListener("scroll", this.handleScrollSticky);
}
componentWillUnmount() {
window.addEventListener("scroll", null);
}
handleScrollSticky(sticky, event) {
if(window.pageYOffset > 100) {
this.setState({sticky: 1});
}
else {
this.setState({sticky: 0});
}
}
toggle() {
this.setState({
open: !this.state.open
});
}
render() {
const styleSticky = {
display: (this.state.sticky === 1) ? "sticky" : "",
};
return (
<div className="header">
<div className="header-top">
<div className="container">
<div className="top-info d-none d-md-flex">
<div className="call-header">
<p><i><FontAwesomeIcon icon={faPhone} /></i> (234) 0200 17813</p>
</div>
<div className="address-header">
<p><i><FontAwesomeIcon icon={faMapMarkerAlt} /></i> 95 South Park Ave, USA</p>
</div>
<div className="mail-header">
<p><i><FontAwesomeIcon icon={faEnvelope} /></i> info@findhouses.com</p>
</div>
</div>
<div className="top-social d-none d-md-flex">
<div className="login-wrap">
<ul className="d-flex">
<li><a href="login.html"><i><FontAwesomeIcon icon={faUser} /></i> Login</a></li>
<li><a href="register.html"><i><FontAwesomeIcon icon={faSignInAlt} /></i> Register</a></li>
</ul>
</div>
<div className="social-icons-header">
<div className="social-icons">
<a href="#"><i><FontAwesomeIcon icon={['fab', 'facebook-f']} /></i></a>
<a href="#"><i><FontAwesomeIcon icon={['fab', 'twitter']} /></i></a>
<a href="#"><i><FontAwesomeIcon icon={['fab', 'google-plus-g']} /></i></a>
</div>
</div>
<div className="dropdown">
<button className="btn-dropdown dropdown-toggle" type="button" id="dropdownlang" data-toggle="dropdown" aria-haspopup="true">
<img src={require('../../images/en.png')} alt="lang" /> English
</button>
<ul className="dropdown-menu" aria-labelledby="dropdownlang">
<li><img src={require('../../images/fr.png')} alt="lang" />France</li>
<li><img src={require('../../images/de.png')} alt="lang" />German</li>
<li><img src={require('../../images/it.png')} alt="lang" />Italy</li>
</ul>
</div>
</div>
</div>
</div>
<div className={"header-bottom heading sticky-header " + styleSticky.display} id="heading">
<div className="container">
<a href="index.html" className="logo">
<img src={require('../../images/logo.svg')} alt="realhome" />
</a>
<button type="button" className="search-button" onClick={this.toggle.bind(this)}>
<i><FontAwesomeIcon icon={faSearch} /></i>
</button>
<div className="get-quote d-md-none d-lg-inline-block">
<a href="submit-property.html">
<p>Submit Property</p>
</a>
</div>
<button type="button" className="button-menu d-lg-none" data-toggle="collapse" data-target="#main-menu" aria-expanded="false">
<i><FontAwesomeIcon icon={faBars} /></i>
</button>
<form action="#" id="bloq-search" className={"collapse" + (this.state.open ? ' show' : '')}>
<div className="bloq-search">
<input type="text" placeholder="search..." />
<input type="submit" value="Search" />
</div>
</form>
<nav id="main-menu" className="collapse">
<ul>
<li className="d-lg-none">
<div className="po">
<a data-toggle="collapse" href="#home" aria-expanded="false">Home</a>
</div>
<div className="collapse" id="home">
<div className="card card-block">
<a className="dropdown-item" href="index.html">Home Map</a>
<a className="dropdown-item" href="index-2.html">Home Image</a>
<a className="dropdown-item" href="index-3.html">Home Video</a>
<a className="dropdown-item" href="index-4.html">Home Slider</a>
<a className="dropdown-item" href="index-5.html">Horizontal Search</a>
<a className="dropdown-item" href="index-6.html">Parallax Image</a>
<a className="dropdown-item" href="index-7.html">Home 3D Video</a>
<a className="dropdown-item" href="index-8.html">Home Full Slider</a>
<a className="dropdown-item" href="index-9.html">Home Map style 2</a>
<a className="dropdown-item" href="index-10.html">Presentation Slider</a>
<a className="dropdown-item" href="index-11.html">Presentation Slider 2</a>
<a className="dropdown-item" href="index-12.html">Home Map style 3</a>
</div>
</div>
</li>
<li className="dropdown d-none d-lg-flex">
<a className="active dropdown-toggle" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false" href="#">Home</a>
<div className="dropdown-menu">
<a className="dropdown-item" href="index.html">Home Map</a>
<a className="dropdown-item" href="index-2.html">Home Image</a>
<a className="dropdown-item" href="index-3.html">Home Video</a>
<a className="dropdown-item" href="index-4.html">Home Slider</a>
<a className="dropdown-item" href="index-5.html">Horizontal Search</a>
<a className="dropdown-item" href="index-6.html">Parallax Image</a>
<a className="dropdown-item" href="index-7.html">Home 3D Video</a>
<a className="dropdown-item" href="index-8.html">Home Full Slider</a>
<a className="dropdown-item" href="index-9.html">Home Map style 2</a>
<a className="dropdown-item" href="index-10.html">Presentation Slider</a>
<a className="dropdown-item" href="index-11.html">Presentation Slider 2</a>
<a className="dropdown-item" href="index-12.html">Home Map style 3</a>
</div>
</li>
<li><a href="contact-us.html">Contact</a></li>
</ul>
</nav>
</div>
</div>
</div>
);
}
}
export default Header;
|
const { Joi } = require('celebrate');
const envVarsSchema = Joi.object({
MYSQL_HOST: Joi.string()
.required(),
MYSQL_PORT: Joi.number()
.required(),
MYSQL_USER: Joi.string()
.required(),
MYSQL_PASSWORD: Joi.string()
.required(),
MYSQL_DATABASE: Joi.string()
.required(),
MYSQL_CONN_POOL_SIZE: Joi.number()
.required(),
}).unknown()
.required();
const { error, value: envVars } = Joi.validate(process.env, envVarsSchema);
if (error) {
throw new Error(`Common config validation error: ${error.message}`);
}
const config = {
mysql: {
host: envVars.MYSQL_HOST,
port: envVars.MYSQL_PORT,
user: envVars.MYSQL_USER,
password: envVars.MYSQL_PASSWORD,
database: envVars.MYSQL_DATABASE,
connectionLimit: envVars.MYSQL_CONN_POOL_SIZE,
},
};
module.exports = config;
|
angular
.module('RenderedField', [])
.factory('RenderedField', RenderedField);
function RenderedField(Field) {
class RenderedField extends Field {
constructor(number, edgePixelSize) {
super(number);
this.center = this._getCenterCoordinates(this);
}
_getCenterCoordinates(field) {
return {
x : field.columnNumber * 60 - 30,
y : field.rowNumber * 60 - 30
};
}
}
return RenderedField;
}
|
import React from 'react'
import { BrowserRouter, Route, Switch } from 'react-router-dom'
import Layout from './layouts'
import Dashboard from './routes/Dashboard'
import Orders from './routes/Orders/AddOrders'
import Login from './routes/Login'
import Companies from './routes/Companies/Add'
import OrdersByCompany from './routes/Companies/Orders'
import Users from './routes/Users/Add'
import MyAccount from './routes/Users/MyAccount'
const RoutesComponent = () => (
<Switch>
<BrowserRouter>
<Route exact path="/" component={Login} />
<Route
exact
path="/dashboard"
render={(props) => (
<Layout>
<Dashboard {...props} />
</Layout>
)}
/>
<Route
exact
path="/companies"
render={(props) => (
<Layout>
<Companies {...props} />
</Layout>
)}
/>
<Route
exact
path="/companies/:id/orders"
render={(props) => (
<Layout>
<OrdersByCompany {...props} />
</Layout>
)}
/>
<Route
exact
path="/users"
render={(props) => (
<Layout>
<MyAccount {...props} />
</Layout>
)}
/>
<Route
exact
path="/users/new"
render={(props) => (
<Layout>
<Users {...props} />
</Layout>
)}
/>
<Route
exact
path="/orders"
render={(props) => (
<Layout>
<Orders {...props} />
</Layout>
)}
/>
</BrowserRouter>
</Switch>
)
export default RoutesComponent
|
// ==UserScript==
// @name 贴吧广告
// @namespace http://tampermonkey.net/
// @version 1.0.0
// @description 干掉贴吧广告
// @author MO
// @create 2018-08-14
// @match *://tieba.baidu.com/*
// @run-at document-end
// @grant none
// ==/UserScript==
'use strict';
;(function() {
document.body.insertAdjacentHTML('beforeEnd','<style>.threadlist_bright li:not(.j_thread_list),.l_post_bright:not([data-field]){display:none}</style>')
})()
|
/* jshint node: true */
module.exports = function(environment) {
var ENV = {
modulePrefix: 'yith-library-mobile-client',
environment: environment,
baseURL: '/',
locationType: 'auto',
EmberENV: {
FEATURES: {
// Here you can enable experimental features on an ember canary build
// e.g. 'with-controller': true
}
},
defaults: {
clientId: 'd866fbc8-a367-44a2-9d6f-8ae2ffbd2748',
clientBaseUrl: 'http://mobileyith:4200',
serverBaseUrl: 'http://serveryith:6543'
},
APP: {
// Here you can pass flags/options to your application instance
// when it is created
version: '@@projectVersion'
}
};
if (environment === 'development') {
// ENV.APP.LOG_RESOLVER = true;
// ENV.APP.LOG_ACTIVE_GENERATION = true;
// ENV.APP.LOG_TRANSITIONS = true;
// ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
// ENV.APP.LOG_VIEW_LOOKUPS = true;
}
if (environment === 'test') {
// Testem prefers this...
ENV.baseURL = '/';
ENV.locationType = 'none';
// keep test console output quieter
ENV.APP.LOG_ACTIVE_GENERATION = false;
ENV.APP.LOG_VIEW_LOOKUPS = false;
ENV.APP.rootElement = '#ember-testing';
}
if (environment === 'production') {
ENV.defaults.clientId = '2c48642d-6113-4fa3-949d-5a5922ed1ff1';
ENV.defaults.clientBaseUrl = 'https://mobile.yithlibrary.com';
ENV.defaults.serverBaseUrl = 'https://www.yithlibrary.com';
}
return ENV;
};
|
/* eslint-disable jsx-a11y/anchor-has-content */
/* eslint-disable jsx-a11y/iframe-has-title */
import React from "react";
//import { Link } from "react-router-dom";
import './HomePage.css'
import About from '../about/About'
import Projects from '../projects/Projects'
import Contact from '../contact/Contact'
const HomePage = () => (
<div className="">
<About />
<Projects />
<Contact />
</div>
);
export default HomePage;
|
'use strict';
var accounts = [
{ 'client_name': 'Igor', 'account_number': 11234543, 'balance': 203004099.2 },
{ 'client_name': 'Vladimir', 'account_number': 43546731, 'balance': 5204100071.23 },
{ 'client_name': 'Sergei', 'account_number': 23456311, 'balance': 1353600.0 }
]
// Create function that returns the name and balance of cash on an account
// Create function that transfers an balance of cash from one account to another
// it should have three parameters:
// - from account_number
// - to account_number
// - balance
//
// Log "404 - account not found" if any of the account numbers don't exist to the console.
function detail() {
for (var i = 0; i < accounts.length; i++) {
return accounts[i].client_name + " " + accounts[i].balance;
}
}
function transfer(from, to, b) {
if (from === undefined || to === undefined) {
console.log("404 - account not found");
}
else {
for (var i = 0; i < accounts.length; i++) {
if (accounts[i].account_number == from) {
accounts[i].balance -= b;
}
else if (accounts[i].account_number == to) {
accounts[i].balance += b;
}
}
}
return accounts;
}
console.log(detail());
console.log(transfer(11234543, 23456311, 99.2));
console.log(accounts);
|
function noop(){}
$(document).ready(function(){
function xhr(method, url, data, callback){
jQuery.getJSON(url, function(){
callback.apply(this, arguments);
scope.updateView();
});
}
var resourceFactory = new ResourceFactory(xhr);
var Tweeter = resourceFactory.route("http://twitter.com/statuses/:service:username.json", {}, {
home: {method:'GET', params: {service:'home_timeline'}, isArray:true },
user: {method:'GET', params: {service:'user_timeline/'}, isArray:true }
});
var scope = window.scope = angular.compile(document, {
location:angular.startUrlWatcher()
});
function fetchTweets(username){
return username ? Tweeter.user({username: username}) : Tweeter.home();
}
scope.set('fetchTweets', fetchTweets);
scope.set('users', [
{screen_name:'mhevery', name:'Mi\u0161ko Hevery',
notes:'Author of <angular/> http://www.getangular.com.',
profile_image_url:'http://a3.twimg.com/profile_images/54360179/Me_-_Small_Banner_normal.jpg'},
{screen_name:'abrons', name:'Adam Abrons',
notes:'Author of <angular/> & Ruby guru see: http://www.angularjs.org.',
profile_image_url:'http://media.linkedin.com/mpr/mpr/shrink_80_80/p/2/000/005/0a8/044278d.jpg'}
]);
scope.init();
});
|
// this is our friends.js file located at /server/controllers/friends.js
// note the immediate function and the object that is returned
// First add the following two lines at the top of the friends controller so that we can access our model through var Friend
// need to require mongoose to be able to run mongoose.model()
var mongoose = require('mongoose');
var List = mongoose.model('List');
var User = mongoose.model('User');
module.exports = (function() {
return {
// notice how index in the factory(client side) is calling the index method(server side)
index: function(req, res) {
console.log(req.body);
List.find({_user:req.body.id}).sort('date').exec(function(err, results){
if(err){
console.log(err);
}else {
res.json(results);
}
})
},
create: function(req, res){
console.log(req.body);
List.create(req.body, function(err, results){
if(err){
console.log(err);
}else{
User.findOneAndUpdate({_id:req.body._user},{$push:{"tasks":results._id}}).exec(function(err, user){
if(err){
console.log(err);
}else{
res.json(results);
}
})
}
})
},
delete: function(req, res){
List.remove({_id: req.body._id}, function(err, results){
if(err){
console.log(err);
}else{
res.json(results);
}
})
},
toggle: function(req, res){
if(req.body.completed == "Incomplete"){
List.update({_id: req.body._id}, {completed: 'Completed'}, [], function(err, results){
if(err){
console.log(err);
}else{
res.json(results);
}
});
}else{
List.update({_id: req.body._id}, {completed: 'Incomplete'}, [], function(err, results){
if(err){
console.log(err);
}else{
res.json(results);
}
});
}
},
findOne: function(req,res){
console.log(req.body.id);
List.findOne({_id:req.body.id}, function(err, results){
if(err){
console.log(err);
}else{
res.json(results);
}
});
},
update: function(req, res){
console.log(req.body);
List.update({_id:req.body._id}, {$set: {name: req.body.name, desc: req.body.desc, category: req.body.category, date: req.body.date}}, [], function(err, results){
if(err){
console.log(err);
}else{
res.json(results);
}
})
},
indexCompleted: function(req, res) {
List.find({_user:req.body.id, completed:"Completed"}).sort('date').exec(function(err, results){
if(err){
console.log(err);
}else {
res.json(results);
}
})
},
indexIncomplete: function(req, res) {
List.find({_user:req.body.id, completed:"Incomplete"}).sort('date').exec(function(err, results){
if(err){
console.log(err);
}else {
res.json(results);
}
})
}
}
})();
|
import * as actionTypes from '../actions/actionsTypes';
import { updateObject } from '../utility';
const initialState = {
orders: [],
loading: false,
purchased: false
}
const purchasInit = (state, action) => {
return updateObject(state, { purchased: false });
}
const purchaseBurgerStart = (state, action) => {
return updateObject(state, { loading: true });
}
const purchaseBurgerSuccess = (state, action) => {
const newOrder = updateObject(action.orderData, { id: action.orderId });
return updateObject(state, {
loading: false,
orders: state.orders.concat(newOrder),
purchased: true
});
}
const purchaseBurgerFailure = (state, action) => {
return updateObject(state, { loading: false });
}
const fetchIngredientsFailed = (state, action) => {
return updateObject(state, { loading: false });
}
const loadOrdersStart = (state, action) => {
return updateObject(state, { loading: true });
}
const loadOrdersSuccess = (state, action) => {
return updateObject(state, { orders: action.orders, loading: false });
}
const loadOrdersFailure = (state, action) => {
return updateObject(state, { loading: false });
}
const reducer = (state = initialState, action) => {
switch (action.type) {
case actionTypes.PURCHASE_INIT: return purchasInit(state, action);
case actionTypes.PURCHASE_BURGER_START: return purchaseBurgerStart(state, action);
case actionTypes.PURCHASE_BURGER_SUCCESS: return purchaseBurgerSuccess(state, action);
case actionTypes.PURCHASE_BURGER_FAILURE: return purchaseBurgerFailure(state, action);
case actionTypes.FETCH_INGREDIENTS_FAILED: return fetchIngredientsFailed(state, action);
case actionTypes.LOAD_ORDERS_START: return loadOrdersStart(state, action);
case actionTypes.LOAD_ORDERS_SUCCESS: return loadOrdersSuccess(state, action);
case actionTypes.LOAD_ORDERS_FAILURE: return loadOrdersFailure(state, action);
default:
return state;
}
}
export default reducer;
|
const RolesAccessDataModel = require('../../dataModels/roleAccess');
class RoleAccess{
constructor(){
this.dataModel = RolesAccessDataModel;
this.caseRoles = [];
}
getAccessRolesByCaseId(mockRoles){
RolesAccessDataModel.getCaseRole();
const response = [];
response.push(RolesAccessDataModel.getCaseRole());
response.push(RolesAccessDataModel.getCaseRole());
return response;
}
}
module.exports = new RoleAccess();
|
import React from "react"
import PropTypes from "prop-types"
import Day from "./Day"
import ErrorBoundary from "./ErrorBoundary"
class TripMeals extends React.Component {
render () {
var days = this.props.days.map( (day) =>
<Day key={day.date} {...day} />
)
return (
<ErrorBoundary>
<div className='flex flex-wrap'>
{days}
</div>
</ErrorBoundary>
);
}
}
export default TripMeals
|
import React from "react"
class Index extends React.Component{
constructor(props){
super(props)
this.state = {
}
}
render(){
return (
<li className={!this.props.mobileMenu ? `nav-item dropdown main notclosesearch${this.state.style == "block" ? " active" : ""}` : `main dropdown MobDropdownNav notclosesearch${this.state.style == "block" ? " active" : ""}`} onClick={(e)=>this.props.openToggle('search',e)}>
<a className={!this.props.mobileMenu ? "nav-link markReadAll parent notclosesearch" : "parent"} >
<span className="material-icons parent" data-icon="search"></span>
</a>
</li>
)
}
}
export default Index
|
import React from 'react'
import { NavLink } from 'react-router-dom'
export default function Nav({ authenticated, user, handleLogOut }) {
let authenticatedOptions
if (user) {
authenticatedOptions = (
<nav>
<h3>Welcome {user.email}!</h3>
<NavLink to="/" className="navlinks">Home</NavLink>
<NavLink to="/myorders" className="navlinks">My Orders</NavLink>
<NavLink to="/aboutus" className="navlinks about-nav">About Us</NavLink>
<h3>|</h3>
<NavLink onClick={handleLogOut} to="/" className="navlinks">
Sign Out
</NavLink>
</nav>
)
}
const publicOptions = (
<nav>
<NavLink to="/" className="navlinks">Home</NavLink>
<NavLink to="/myorders" className="navlinks">My Orders</NavLink>
<NavLink to="/aboutus" className="navlinks">About Us</NavLink>
<h3>|</h3>
<NavLink to="/signin" className="navlinks">Sign In</NavLink>
</nav>
)
return (
<header>
<NavLink to="/" className="fake-logo">e</NavLink>
{authenticated && user ? authenticatedOptions : publicOptions}
</header>
)
}
|
import React from "react";
import Css from "./button.module.css";
const Button = ({ children, disabled, clickHandler }) => {
return (
<button onClick={clickHandler} className={Css.button} disabled={disabled}>
{children}
</button>
);
};
export default Button;
|
module.exports = Frame;
function Frame(destMac, srcMac, payload) {
this.destMac = destMac;
this.srcMac = srcMac;
this.payload = payload;
}
Frame.prototype.toString = function() {
var string = this.destMac + ",";
string += this.srcMac + ",";
string += '"' + this.payload + '"';
return string;
}
|
import request from 'superagent'
export const SHOW_ERROR = 'SHOW_ERROR'
export const RECEIVE_POSTS = 'RECEIVE_POSTS'
export const REQUEST_POSTS = 'REQUEST_POSTS'
export const requestPosts = () => {
return {
type: REQUEST_POSTS
}
}
export const receivePosts = (posts) => {
return {
type: RECEIVE_POSTS,
posts: posts.map(post => post.data)
}
}
export const showError = (errorMessage) => {
return {
type: SHOW_ERROR,
errorMessage: errorMessage
}
}
export function fetchPosts (subreddit) {
return (dispatch) => {
dispatch(requestPosts())
return request
.get(`/api/v1/reddit/subreddit/${subreddit}`)
.then(res => {
dispatch(receivePosts(res.body))
})
.catch(err => {
dispatch(showError(err.message))
})
}
}
|
// @flow strict
import * as React from 'react';
import { graphql, PublicApiRenderer } from '@kiwicom/mobile-relay';
import { type NavigationType, HeaderTitle } from '@kiwicom/mobile-navigation';
import { Translation } from '@kiwicom/mobile-localization';
import BookingDetailContext from '../../../../context/BookingDetailContext';
import type { InsuranceOverviewSceneQueryResponse } from './__generated__/InsuranceOverviewSceneContainerQuery.graphql';
import InsuranceOverviewScene from './InsuranceOverviewScene';
type ContainerProps = {|
+navigation: NavigationType,
|};
export default class InsuranceOverviewSceneContainer extends React.Component<ContainerProps> {
static navigationOptions = () => {
return {
headerTitle: function TripServicesHeaderTitle() {
return (
<HeaderTitle>
<Translation id="mmb.trip_services.insurance.title" />
</HeaderTitle>
);
},
};
};
renderInnerComponent = (response: InsuranceOverviewSceneQueryResponse) => {
return (
<InsuranceOverviewScene
data={response}
navigation={this.props.navigation}
/>
);
};
render() {
return (
<BookingDetailContext.Consumer>
{({ bookingId, authToken }) => (
<PublicApiRenderer
render={this.renderInnerComponent}
query={graphql`
query InsuranceOverviewSceneContainerQuery(
$bookingId: Int!
$authToken: String!
) {
singleBooking(id: $bookingId, authToken: $authToken) {
... on BookingInterface {
...DestinationImage
...TripInfo
}
}
}
`}
variables={{
bookingId,
authToken,
}}
/>
)}
</BookingDetailContext.Consumer>
);
}
}
|
'use strict';
module.exports = {
up: (queryInterface, Sequelize) => {
return queryInterface.bulkInsert('Items', [{
itemName: "Jaket",
itemDesc: "Jaket kulit kualitas KW Super",
price: 300000,
createdAt: new Date(),
updatedAt: new Date()
},{
itemName: "Sepatu",
itemDesc: "Sepatu Babibas",
price: 700000,
createdAt: new Date(),
updatedAt: new Date()
},{
itemName: "TV",
itemDesc: "LCD TV PanasBanget",
price: 2300000,
createdAt: new Date(),
updatedAt: new Date()
},{
itemName: "Payung",
itemDesc: "Payung super besar",
price: 75000,
createdAt: new Date(),
updatedAt: new Date()
},{
itemName: "Blender",
itemDesc: "Blender super",
price: 500000,
createdAt: new Date(),
updatedAt: new Date()
}], {});
},
down: (queryInterface, Sequelize) => {
return queryInterface.bulkDelete('Items', null, {});
}
};
|
var express = require('express');
var router = express.Router();
var rouletteModel = require('../models/roulettes.js');
var Roulette = rouletteModel.Roulette;
var userModel = require('../models/users.js');
var User = userModel.User;
//add login check function
var loginCheck = function(req, res, next){
if(req.isAuthenticated()){
return next();
}
res.redirect('/login');
}
/* GET home page. */
router.get('/', loginCheck,function(req, res){
console.log(req.user.name);
res.render('user',{
user: req.user.name,
name: req.user.name,
rouletteGroup: req.user.rouletteGroup
});
});
router.get('/userinfo', loginCheck, function(req, res){
res.render('userinfo',
{
user : req.user.name,
userName: req.user.name,
userEmail: req.user.email,
id: req.user._id
});
});
router.get('/create', loginCheck, function(req, res){
res.render('createRoulette',
{
user: req.user.name
});
})
module.exports = router;
|
$("#salir").click(function () {
$.ajax({
url: "/salir",
success: function (respuesta) {
window.location.href = "/login.html";
}
});
});
|
/*global chrome*/
const script = document.createElement("script");
script.textContent = `window.cljs_data_browser = message => {
window.postMessage({
id: "cljs-data-browser",
message: message
}, "*");
};
`;
script.onload = () => script.parentNode.removeChild(script);
(document.head || document.documentElement).appendChild(script);
window.addEventListener('message', event => {
if (event.data.id === "cljs-data-browser") {
browser.runtime.sendMessage(event.data);
}
});
browser.runtime.onMessage.addListener((msg) => {
window.postMessage({
id: "cljs-data-browser-action",
message: msg.message
}, "*");
});
console.log("Plugin gadget-browser initialized successfully")
|
var webpack = require('webpack');
var UglifyJsPlugin = require('uglifyjs-webpack-plugin');
var HtmlwebpackPlugin = require('html-webpack-plugin');
var OpenBrowserPlugin = require('open-browser-webpack-plugin');
module.exports = {
entry: './main.js',
output: {
filename: 'bundle.js'
},
module: {
rules: [
{
test: /\.js$/,
loader: 'babel-loader',
exclude: /node_modules/
},
{
test: /\.vue$/,
loader: 'vue-loader'
}
]
},
resolve: {
alias: {
'vue': 'vue/dist/vue.js'
}
},
plugins: [
new webpack.HotModuleReplacementPlugin(),
// new UglifyJsPlugin(),
// new HtmlwebpackPlugin({
// title: 'webpack-demos',
// filename: "index.html"
// }),
// new OpenBrowserPlugin({
// url: 'http://localhost:8080'
// })
],
devServer: {
noInfo: true,
hot: true,
inline: true,//实时刷新
stats:{
colors: true
}
}
}
|
// SEMANTIC UI library ----------------------------------------------------------------
// 1. In the index.html file, place a link to the library
<link rel="stylesheet" href ="https://cdnjs.cloudflare.com/ajax/libs/semantic-ui/2.4.1/semantic.min.css" />
// 2. Create a component and use the semantic UI classNames to automatically style the component elements. Copy the elements from the Semantic UI library website and paste them into your component and change class to className. Below is an example of the comment ui component. NOTE: the example below uses the faker api to create fake data.
//3. Faker api: npm install --save faker // this allows you to add fake data to your app to see what things will look like before you use real data. IMPORTANT: must import faker library (import faker from 'faker') into any react component that uses it. Then to use it, you reference it in curly braces in the jsx using object notation (look at faker API for structure: https://github.com/marak/Faker.js/) and INVOKE IT WITH (). Here's an example of an avatar usage <img src={faker.image.avatar()}/>
//IMPORTANT: Don't forget to invoke faker calls with ()
import React from "react";
import faker from "faker";
const CommentDetail = () => {
return (
<div className="comment">
<a className="avatar">
<img alt="avatar" src={faker.internet.avatar()} />
</a>
<div className="content">
<a className="author">{faker.name.firstName()} Feliciano</a>
<div className="metadata">
<div className="date">2 days ago</div>
<div className="rating">
<i className="star icon" />5 Faves
</div>
</div>
<div className="text">
Hey guys, I hope this example comment is helping you read this .
</div>
</div>
</div>
);
};
export default CommentDetail;
|
var gulp = require('gulp')
pug = require('gulp-pug')
livereload = require('gulp-livereload')
connect = require('gulp-connect')
compass = require('gulp-compass')
plumber = require('gulp-plumber')
babel = require("gulp-babel");
gulp.task('connect', function() {
connect.server({
livereload: true
});
});
gulp.task('pug', function() {
gulp.src('./src/**/*.pug')
.pipe(plumber({
errorHandler: function (error) {
console.log(error.message);
this.emit('end');
}}))
.pipe(pug({
pretty : true
}))
.pipe(plumber.stop())
.pipe(gulp.dest('./dist'))
.pipe(connect.reload());
});
gulp.task('compass', function() {
gulp.src('./assets/sass/*.sass')
.pipe(plumber({
errorHandler: function (error) {
console.log(error.message);
this.emit('end');
}}))
.pipe(compass({
config_file: './config.rb',
css: './assets/stylesheets',
sass: './assets/sass'
}))
.pipe(plumber.stop())
.pipe(gulp.dest('./assets/stylesheets'))
.pipe(connect.reload());
});
gulp.task("babel", function () {
return gulp.src("src/app.js")
.pipe(plumber({
errorHandler: function (error) {
console.log(error.message);
this.emit('end');
}}))
.pipe(babel())
.pipe(plumber.stop())
.pipe(gulp.dest("dist"));
});
gulp.task('watch', function() {
gulp.watch('./src/**/*.pug', ['pug','compass'])
gulp.watch('./assets/sass/**/*.{sass,scss}', ['compass','pug'])
});
gulp.task('default', ['connect', 'pug' , 'compass' , 'watch']);
|
import { createStyles, makeStyles } from "@material-ui/core/styles";
export default makeStyles((theme) =>
createStyles({
title: {
fontStyle: 'normal',
fontWeight: 'bold',
fontSize: '18px',
lineHeight: '25px',
letterSpacing: '-0.02em',
color: '#000000'
},
llevamosContainer: {
display: 'flex',
width:'100%',
alignItems: 'center'
},
tittleH3: {
fontStyle: 'normal',
fontWeight: 'bold',
fontSize: '10px',
lineHeight: '14px',
letterSpacing: '-0.02em'
},
divider: {
marginLeft: '40px',
width: '100%',
height: '0px',
left: '774px',
top: '213px',
border: '1px solid #C4C4C4'
},
selectContainer: {
display: 'flex',
width:'100%',
justifyContent: 'space-between',
},
dividerFull: {
width: '100%',
height: '0px',
border: '1px solid #C4C4C4'
},
radioContainer : {
display:'flex',
width:'100%',
}
})
);
|
/**
* Created by lerayne on 02.10.2017.
*/
import {tinngServerURL} from 'config'
export async function verifyUserAuth(token) {
try {
const response = await fetch(tinngServerURL + '/checkAuth', {
method: 'post',
mode: 'cors',
headers: {
// json type forces "OPTIONS" request first. todo - think what to do with it
'Content-Type': 'text/plain'
},
body: JSON.stringify({token})
})
const data = await response.text()
if (response.ok) {
return JSON.parse(data)
} else {
throw new Error(data)
}
} catch (err) {
throw err
}
}
|
var spine; //global so we can inspect it using devtools
window.addEventListener("load",function init()
{
var app = new PIXI.Application();
document.getElementById("canvas-container").appendChild(app.view);
document.getElementById("play-bone-anim").addEventListener("click",function(){
spine.state.setAnimation(0,"bone-anim",true);
});
document.getElementById("play-vert-anim").addEventListener("click",function(){
spine.state.setAnimation(0,"vert-anim",true);
});
var text = new PIXI.Text(document.title,{fill:0xffffff});
app.stage.addChild(text);
//loader location changed between pixi4 and 5
var loader = new (PIXI.Loader || PIXI.loaders.Loader)();
loader
.add("test","assets-dist/spine-test-anim.json")
.load(function(loader,resources){
spine = new PIXI.spine.Spine(resources.test.spineData);
spine.position.set(app.renderer.width/2,app.renderer.height/2);
app.stage.addChild(spine);
});
});
|
/* begin copyright text
*
* Copyright © 2016 PTC Inc., Its Subsidiary Companies, and /or its Partners. All Rights Reserved.
*
* end copyright text
*/
/* jshint node: true */
/* jshint strict: global */
/* jshint camelcase: false */
/* jshint proto: true */
/* jshint esnext: true */
'use strict';
var assert = require('assert');
var path = require('path');
var fs = require('fs');
var fse = require('fs-extra');
var Busboy = require('busboy');
var Q = require("q");
var debug = require('debug')('vxs:cds');
var root = path.normalize(path.join(__dirname,'../..'));
var utils = require(path.join(root,'utils.js'));
var uuidgen = require("uuid").v4;
var unzip = require('./unzip');
var Metadata = require('./metadata.js');
var performanceMetrics = require('../handlers/performanceMetrics.js');
var EventNotifier = require ('../../analytics/eventNotifier.js');
var EventEmitter = require('eventemitter-async');
var eventEmitter = new EventEmitter();
var LimitsHelper = require('./limitsHelper.js');
var zipFolder = require('./zipFolder');
var rename = Q.denodeify(fs.rename);
var renameRetryLimit = 10;
function renameWithRetryPromise(from, to, retryCount, deferredParam) {
var deferred = deferredParam || Q.defer();
retryCount = retryCount || 0;
fs.rename(from, to, function(err){
if (err) {
if (err.code === "EPERM" && retryCount < renameRetryLimit) {
retryCount++;
debug("Ignoring rename failure, retrying # " + retryCount, err);
setTimeout(function() { renameWithRetryPromise(from, to, retryCount, deferred); }, 10*retryCount);
} else {
err.message = "Rename error after " + retryCount + " retries. " + err.message;
deferred.reject(err);
}
} else {
deferred.resolve();
}
});
return deferred.promise;
}
/**
* Uploads, unzips and stores the archive file and its info in the DB.
*/
var doUpload = function(req, res, next) {
debug("In doUpload() " + req.method + " " + req.params.archive + (req.query.replace ? " replace=" + req.query.replace : ""));
var store = req.params.store ? req.params.store.trim() : req.params.store;
var storeRoot;
debug("Request store parameter: " + store );
var config = req.app.settings;
var displayName;
var tableName;
var preMapEventData;
renameRetryLimit = config.uploadRenameRetryLimit || 10;
switch (store) {
case "projects" : storeRoot = config.projects._store; displayName = config.projects.displayName; tableName = config.projects.tableName; break;
case "reps" : storeRoot = config.reps._store; displayName = config.reps.displayName; tableName = config.reps.tableName; break;
default: {
res.status(400).end();
return;
}
}
if (req.namespaceStoreDirectory === undefined) { throw new Error("'req.namespaceStoreDirectory' is undefined"); }
storeRoot = (storeRoot + req.namespaceStoreDirectory); //?? path.normalize
debug("Using storeRoot: " + storeRoot + ", Display Name: " + displayName);
// methodIsPostWihReplace only applies to POST on projects
// Post on reps doesn't update the reps with the replace=true query string
var methodIsPostWithReplace = (req.method === "POST" && store !== "reps" && req.query.replace && req.query.replace === "true");
var methodIsPut = (req.method === "PUT");
var contentNameFromPut;
var existingId;
var preexistanceCheckForPutPromise;
var projectType;
var oldProjectType;
if (methodIsPut) {
contentNameFromPut = req.params.archive && req.params.archive.trim();
if (!contentNameFromPut) {
res.status(400).send("*** The " + displayName + " name is missing in the PUT request");
return;
}
preexistanceCheckForPutPromise = lookupIdByNamePromise(config, contentNameFromPut.toLowerCase(), tableName, req.namespaceId)
.tap(function(lookupId) {
if (!lookupId) {
throw createErrorWithCode("No existing " + displayName + " found with name: " + contentNameFromPut, 404);
}
existingId = lookupId;
});
} else {
preexistanceCheckForPutPromise = Q.resolve();
}
//upload direcory
var uploadDirToBeDeleted;
//renamed old directory if update
var renamedOldDir;
//store directory for app/rep (storeRoot + app/rep name)
var storeDir;
// app name to be deleted from DB table in case of rollback
var contentNameForRollback;
var lookupAndValidateExistingContent = function(deferred, contentName, namespaceId) {
lookupIdByNamePromise(config, contentName, tableName, namespaceId)
.then(function(lookupId) {
existingId = lookupId;
if (lookupId) {
debug("A " + displayName + " with name " + contentName + " already exists. ID: " + lookupId);
if (methodIsPostWithReplace || methodIsPut) {
debug("The " + displayName + " " + contentName + " will be replaced");
deferred.resolve(uuidgen()); // temporary content directory name
} else {
// This is a POST request without replace and the archive already exists
deferred.reject(createErrorWithCode("A " + displayName + " with name already exists: " + contentName, 409));
}
} else {
deferred.resolve(contentName); // permanent content directory name
}
})
.fail(deferred.reject);
};
var validateUploadFileNamePromise = function(filename) {
var archiveFileExt = path.extname(filename).toLowerCase();
var contentName = methodIsPut ? contentNameFromPut.toLowerCase() : path.basename(filename.toLowerCase(), archiveFileExt);
var deferred = Q.defer();
if (methodIsPut) {
debug("Delay content name validation until metadata is avaialable");
deferred.resolve(uuidgen()); // temporary content directory name
} else {
lookupAndValidateExistingContent(deferred, contentName, req.namespaceId);
}
return deferred.promise
.then(function(contentDirectoryName) {
return {
contentDir: path.join(storeRoot, contentDirectoryName),
extension: archiveFileExt,
contentName: contentName};
});
};
var limitsCheckPromise = function(){
if (store === 'reps' && !methodIsPut){
return LimitsHelper.checkModelLimit(config._dbHandler, req.namespaceId);
} else {
return Q.resolve();
}
};
limitsCheckPromise()
.then(function() { return preexistanceCheckForPutPromise; })
.then(function() { return fileTransferPromise(req, res, displayName, validateUploadFileNamePromise); })
.tap(utils.debugCallback(debug,"Busboy transfer resolved"))
.then(function(context) { // file transfer context argument becomes context parameter here
uploadDirToBeDeleted = context.contentDir; //TODO check if name of uploadDirToBeDeleted is appropriate
var filePath = path.join(context.contentDir, context.compressedFileName + context.extension);
var startAt = process.hrtime();
return unzip.extractZipPromise(filePath, context.contentDir)
.then(function() {
req._uploadUnzipTime = millisecondsSince(startAt);
return context;
});
})
.tap(utils.debugCallback(debug,displayName + " unzip resolved"))
.tap(function(context) {
var deferred = Q.defer();
var newMetadata = new Metadata(context.contentDir);
newMetadata.readPromise()
.then(function(metadata) {
if (metadata && store === "reps") { Metadata.assertRepresentationMetadata(metadata); }
projectType = Metadata.getProjectType(metadata);
if (Metadata.designedForOffline(metadata)) {context.offline = true;}
return metadata && metadata.name; },
function(err) { debug("* Ignoring error reading metadata", err); })
.then(function(metadataName) {
if (metadataName) {
Metadata.assertProjectName(metadataName, 400);
context.contentName = metadataName.toLowerCase();
if (contentNameFromPut && contentNameFromPut.toLowerCase() !== context.contentName) {
deferred.reject(createErrorWithCode("Metadata name '"+ metadataName +
"' does not match PUT request content name '" + contentNameFromPut + "'.", 400));
return;
}
debug("Using metadata project name: " + metadataName);
}
if (!methodIsPut) {
lookupAndValidateExistingContent(deferred, context.contentName, req.namespaceId);
} else {
assert(existingId, "Existing ID should be available");
deferred.resolve(); // no lookup is necessary since content name is pre-checked
}
})
.fail(deferred.reject);
return deferred.promise;
})
.tap(utils.debugCallback(debug, "Name from metadata resolved"))
.tap(context => {
const newProjectDir = context.contentDir;
const existingProjectDir = existingId ? path.join(storeRoot, context.contentName) : null;
return eventEmitter.emit('post-unzip', {newProjectDir, store, existingProjectDir, req})
.then(feedbacks => {
if (feedbacks) {
context.rebuildCompressedFile = feedbacks.some(feedback => feedback && feedback.rebuildCompressedFile);
}
});
})
.then(function(context) {
return Q.promise(function(resolve, reject, notify) {
// If content with the same ID exists, its an update and the file has been unzipped
// to the new directory. Need to rename it to the permanent name
if (existingId) {
storeDir = path.join(storeRoot, context.contentName);
var uploadDir = context.contentDir;
var tempPath = storeDir + "_" + Date.now();
//rename old/existing directory to temporary name
renameWithRetryPromise(storeDir, tempPath)
.then(function() {
renamedOldDir = tempPath;
},
function(error) {
debug("Rename old directory failed" );
//if old directory does not exist, print warning and continue
if (error && error.code === 'ENOENT') {
debug("WARNING: cannot find old directory to update." );
resolve(context);
} else {
reject(error);
}
})
.then(function() {
//rename upload directory to permanent name
return rename(uploadDir, storeDir);
})
.then(function() {
uploadDirToBeDeleted = storeDir;
resolve(context);
}, reject);
} else {
storeDir = path.join(storeRoot, context.contentName);
renameWithRetryPromise(context.contentDir, storeDir)
.then(function() {
uploadDirToBeDeleted = storeDir;
resolve(context);
}, reject);
}
});
})
.tap(utils.debugCallback(debug, "Rename directory resolved"))
.tap(context => {
if (context.rebuildCompressedFile && context.offline) {
return zipFolder(path.join(storeDir, context.compressedFileName + context.extension),
storeDir, [context.compressedFileName + context.extension]);
}
})
.tap(utils.debugCallback(debug, "Rebuild of compressed file resolved"))
.then(function(context) {
var values = {};
// If content with the same ID exists, its an update. All pre-conditions should
// have been verified earlier
if (existingId) {
// Update the record for this archive
var set = 'extension = ?, compressedname = ?, modifiedby = ?, modifiedon = ?';
var params = [context.extension, context.compressedFileName, req.user, new Date(Date.now()).toUTCString()];
if (req.namespaceId) {
set += ', namespace = ?';
params.push(req.namespaceId);
}
var where = 'id = ?';
params.push(existingId);
return Q.promise(function(resolve,reject,notify) {
config._dbHandler.updateWithParams(tableName, set, where, params)
.then(function() {resolve(context);}, function(error) {reject(error);});
});
} else {
// Insert a record for this archive
var ts = new Date(Date.now()).toUTCString();
values = {
name: context.contentName,
extension: context.extension,
compressedname: context.compressedFileName,
createdby: req.user,
createdon: ts,
modifiedby: req.user,
modifiedon: ts
};
if (req.namespaceId) { values.namespace = req.namespaceId; }
return Q.promise(function(resolve,reject,notify) {
config._dbHandler.insertWithParams(values,tableName)
.then(
function() {
contentNameForRollback = context.contentName;
resolve(context);
},
function(error) {
reject(error);
});
});
}
})
.tap(utils.debugCallback(debug,"Insert/Update archive info to db resolved"))
.tap(function(context){
context.location = req.baseUrl + req.path;
if (!methodIsPut) {
context.location += (req.path.endsWith("/") ? "" : "/") + encodeURIComponent(context.contentName);
}
preMapEventData = {
store: store,
namespaceId: req.namespaceId,
username: req.user,
resourceName: context.contentName,
resourcePath: context.location,
isUpdate: existingId ? 1 : 0
};
return eventEmitter.emit('pre-map', preMapEventData);
})
.then(function(context) {
var deferred = Q.defer();
var startAt = process.hrtime();
var deleteOldIrsEntriesPromise = null;
if (existingId){
var oldMetadata = new Metadata(renamedOldDir || storeDir); // "|| storeDir" required when renameWithRetryPromise in line 193 fails with ENOENT error
deleteOldIrsEntriesPromise = oldMetadata.deleteIrsEntriesPromise(req, context.contentName)
.tap(utils.debugCallback(debug, "Old metadata remove from IRS resolved"))
.then(function() {
return oldMetadata.readPromise()
.then(function(metadata) {
oldProjectType = metadata && Metadata.getProjectType(metadata);
});
})
.catch(function(err) {
if (err.isMetadataReadError) {
debug("* Ignoring old metadata read error.", err.stack);
} else {
var message = "*** Error removing old metadata from IRS";
console.error(message, err);
throw err;
}
});
}
var newMetadata = new Metadata(uploadDirToBeDeleted);
(deleteOldIrsEntriesPromise || Q.resolve(true))
.then(function() {
return newMetadata.addIrsEntriesPromise(req, context.contentName); })
.then(function() {
req._uploadIrsTime = millisecondsSince(startAt);
deferred.resolve(context); })
.catch(deferred.reject);
return deferred.promise;
})
.tap(utils.debugCallback(debug,"Adding app key/app URL mappings into IRS resolved"))
.then(function(context) {
//Update successful, cleanup old app/rep directory
return Q.promise(function(resolve,reject,notify) {
removeDir(renamedOldDir)
.then(function() { resolve(context); },
function(error) {
debug("Continuing without cleanup");
resolve(context);
});
});
})
.tap(function(context){
// sending publish event in async mode
try {
var body = {
hostname: req.hostname,
userId: req.user,
projectName: context.contentName,
update: existingId ? 1 : 0,
date: Date.now()
};
if (projectType) { body.projectType = projectType; }
if (oldProjectType) { body.oldProjectType = oldProjectType; }
EventNotifier.notifyEvent(req.user, "ProjectPublished", req.namespaceInfo && req.namespaceInfo.eloquaid, body)
.tap(utils.debugCallback(debug,"Sending Publish Event resolved"))
.catch(function(err){console.error("Error sending Publish Event", err);})
.done();
} catch(err){console.error("Error sending Publish Event ", err);}
})
.then(function(context) {
if (!methodIsPut) {
res.location(context.location);
}
performanceMetrics.publish(store, context.contentName, existingId, req.namespaceId);
res.status(methodIsPut ? 204 : 201).end(); // succesful end of upload
})
.catch(function(error) {
// rollback the changes
var systemError = error.stack !== undefined;
var status = error.http_code || error.status || (systemError ? 500 : 400);
error.status = status;
console.error("*** Terminating upload " + req.method + " (" + status +").", (error.stack || error));
//remove uploaded app/rep from store
removeDir(uploadDirToBeDeleted)
.catch(function(err){ /* show log */
console.error("Unable to delete " + uploadDirToBeDeleted + " directory: ", err);
})
//restore old app/rep if exists
.then(function() {
return restoreOldStoreDir(renamedOldDir, storeDir);
})
.catch(function(err){ /* show */
console.error("Unable to restore " + storeRoot + " directory to the original state: ", err);
})
.then(function(){
return preMapEventData ? eventEmitter.emit('rollback', preMapEventData) : Q.resolve();
})
.catch(function(err){ /* show */
console.error("A listener to a rollback event failed with an error: ", err);
})
.then(rollbackStoreTableChanges(contentNameForRollback, config, tableName, req.namespaceId))
.catch(function(err){ /* show log */
console.error("Unable to remove " + contentNameForRollback + " from db: ", err);
})
.then(function() {
//should not clean up the old directory whether or not we were able to rename it back
renamedOldDir = null;
next(error);
});
})
.done();
};
function lookupIdByNamePromise(config, name, tableName, namespaceId) {
return config._dbHandler.selectWithParams(['id'],tableName,
"name = ?" + (namespaceId ? " and namespace = ?" : ""), (namespaceId ? [name, namespaceId] : [name]))
.then(function(existing) { return existing && existing.length > 0 && existing[0].id; })
.tap(utils.debugCallback(debug, "Lookup ID by name '" + name + "' resolved"));
}
function fileTransferPromise(req, res, displayName, validateUploadFileNamePromiseCallback) {
var busboyConfig = {
headers: req.headers,
};
var contentDirToBeDeleted;
var config = req.app.settings;
if (config.maxFileSize || config.maxFieldSize){
var limits = {};
if (config.maxFileSize){ // Defaults to infinity
limits.fileSize = config.maxFileSize;
}
if (config.maxFieldSize){ // Defaults to 1MB
limits.fieldSize = config.maxFieldSize;
}
busboyConfig.limits = limits;
}
return Q.promise(function(resolve, reject, notify) {
var busboy = new Busboy(busboyConfig);
var transferFilePromise;
var alreadyAccepted = false;
busboy.on('error', function(err) {
debug('busboy error', err);
reject(err);
});
busboy.on('field', function(fieldname) { debug({Ignoring_Fieldname: fieldname}); });
busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
var archiveFileSize = 0;
if (alreadyAccepted) {
debug("Ignoring file", "fieldname: ", fieldname, "; filename: ", filename);
file.resume(); // must so that the finish event is called
return;
}
alreadyAccepted = true;
debug("Accepted file field: " + fieldname + ", mimetype: " + mimetype);
if (!filename || filename.length===0) {
rejectWithNewError("The " + displayName + " archive file is missing in the request: " + filename,400, reject, file);
return;
}
var startAt = process.hrtime();
validateUploadFileNamePromiseCallback(filename)
.tap(utils.debugCallback(debug, "validateUploadFileNamePromise resolved"))
.tap(function(transferContext) { return promisedEnsureDirectory(transferContext.contentDir); })
.tap(utils.debugCallback(debug, "Archive " + displayName + " ensure content directory resolved"))
.then(function(transferContext) {
transferFilePromise = Q.defer();
return Q.promise(function(resolve, reject, notify) {
contentDirToBeDeleted = transferContext.contentDir;
// Start writing the file
transferContext.compressedFileName = uuidgen();
var archiveFileStagePath = path.join(transferContext.contentDir, transferContext.compressedFileName + transferContext.extension);
var limitReached = false;
var writeStream = fs.createWriteStream(archiveFileStagePath);
writeStream.on('open', function() {
file.pipe(writeStream);
file.on('data', function(chunk) {
archiveFileSize += chunk.length;
});
file.on('end', function() {
debug('Archive transfer complete. size: ', archiveFileSize,
'bytes; fieldname: ', fieldname, '; filename: ', filename,
'; limitReached: ', limitReached, '; file.truncated: ', file.truncated);
});
file.on('limit', function() {
limitReached = true;
rejectWithNewError("Upload file size limit of " + busboyConfig.limits.fileSize + " bytes was reached", 413, reject, file);
});
file.on('error', function(error) {
rejectWithError(error,null, reject, file);
});
});
writeStream.on('error', function(error) {
rejectWithError(error,null, reject, file);
});
writeStream.on('finish', function() {
transferContext.filesize = archiveFileSize;
resolve(transferContext);
});
});
})
.then(
function(transferContext) {
req._uploadFileTransferTime = millisecondsSince(startAt);
transferFilePromise.resolve(transferContext); },
function(error) {
rejectWithError(error, null, reject, file);
if (contentDirToBeDeleted) {
return removeDir(contentDirToBeDeleted)
.fail(function(err) { debug("Ignoring error deleting content directory", err); });
}
}
)
.done();
});
busboy.on('finish', function() {
if (!transferFilePromise) {
rejectWithNewError("The " + displayName + " archive file is missing in the request.",400,reject);
} else {
transferFilePromise.promise
.done(function(transferContext) {
resolve(transferContext);
});
}
});
req.pipe(busboy);
});
}
function removeDir(dirToBeDeleted){
return Q.promise(function(resolve, reject, notify) {
if (dirToBeDeleted) {
debug("Removing: " + dirToBeDeleted);
fse.remove(dirToBeDeleted, function(err) {
if (err) {
debug("Unable to delete directory: ", dirToBeDeleted);
reject(err);
} else {
debug("Deleted directory: ", dirToBeDeleted);
resolve();
}
});
} else {
resolve();
}
});
}
function restoreOldStoreDir(renamedOldDir, storeDir) {
return Q.promise(function(resolve, reject, notify) {
// Try to delete the uploadDir if it exists
if (renamedOldDir) {
debug("Restoring old version of directory ", storeDir);
fs.rename(renamedOldDir, storeDir, function(err) {
if (err) {
debug("Unable to restore old version of directory: ", storeDir);
reject(err);
} else {
resolve();
}
});
} else {
debug("No old version of directory to restore");
resolve();
}
});
}
function rollbackStoreTableChanges(contentNameForRollback, config, tableName, namespaceId){
return Q.promise(function(resolve,reject,notify) {
// remove uploaded app/rep mapping from DB if applicable
if (contentNameForRollback) {
debug("Purging: " + contentNameForRollback);
config._dbHandler.delete(tableName,"name=? and namespace = ?", [contentNameForRollback, namespaceId])
.then(function() {resolve();});
} else {
resolve();
}
});
}
function promisedEnsureDirectory(path) {
return new Promise((resolve, reject) =>
fse.ensureDir(String(path), err => {
if (err) {
if (err.code === "EINVAL") {
err.status = 400;
err.message = "Invalid path character";
}
reject(err);
} else { resolve(); }})
);
}
// create error with http response status code
function createErrorWithCode(errorMessage, http_code) {
var error = new Error(errorMessage);
error.http_code = http_code;
return error;
}
function rejectWithNewError(errorMessage, http_code, rejectionHandler, streamToResume) {
return rejectWithError(new Error(errorMessage),http_code, rejectionHandler, streamToResume);
}
function rejectWithError(error, http_code, rejectionHandler, streamToResume) {
if (http_code && error && !error.http_code){error.http_code = http_code;}
rejectionHandler(error);
if (streamToResume){
streamToResume.resume(); // must so that the finish event is called
}
return error;
}
function millisecondsSince(startAt) {
var endAt = process.hrtime();
var ms = (endAt[0] - startAt[0]) * 1e3 + (endAt[1] - startAt[1]) * 1e-6;
return ms.toFixed(0);
}
module.exports.upload = doUpload;
module.exports.eventEmitter = eventEmitter;
|
var MyPlugin = {};
MyPlugin.install = function(Vue, options){
// 给 Vue.prototype 添加一个 $testProperty 属性
// 并且这个属性不允许被替换成其他的对象
Object.defineProperty(Vue.prototype, "$testProperty", {
value: {msg: 'hello'},
configurable: false,
writeable: false,
enumerable: true
})
};
export default MyPlugin;
|
import Story from '../../db/models/Story'
import Content from '../../db/models/Content'
export default async function(src, args, ctx) {
try {
let contents = args.contentIds.slice()
let story = await Story.findOne({
where: {
id: args.storyId
},
include: [
{
model: Content,
as: 'contents'
}
]
})
story.contents.forEach(content => {
if (!contents.includes(content.id)) {
contents.push(content.id)
}
})
contents = contents.map((id, index) => {
return {
id,
index
}
})
for (let content of contents) {
await Content.update(
{
index: content.index
},
{
where: {
id: content.id
}
}
)
}
return await Story.findOne({
where: {
id: args.storyId
},
include: [
{
model: Content,
as: 'contents'
}
]
})
} catch (ex) {
console.error(ex)
}
}
|
const app = getApp()
//公共请求方法 仅支持post
function request(obj) {
if (app.globalData.netWorkType === 'none') {
wx.showToast({
title: '无网络连接',
icon: 'none'
})
return
}
checkLoginStatus(obj);
}
//检查登录状态
function checkLoginStatus(obj) {
app.getLoginStatus(function(res) {
console.log("获取token:" + res.data.token)
console.log("获取绑定状态:" + res.data.setUserInfo)
app.globalData.setUserInfo = res.data.setUserInfo
obj.token = res.data.token
doRequest(obj)
}, function(res) {
console.log("获取登录状态失败，重新登录")
relogin()
})
}
//发起服务器请求
function doRequest(obj) {
console.log("实际请求token:" + obj.token)
console.log("请求地址:" + obj.url)
console.log("请求参数:" + JSON.stringify(obj.data))
var header = obj.header || {}
header['content-type'] = 'application/json'
header['ms-token'] = obj.token
if (obj.message) {
wx.showLoading({
title: obj.message,
mask: true
})
}
wx.request({
url: obj.url,
data: obj.data || {},
method: 'post',
header: header,
success: function(res) {
if (obj.message) {
wx.hideLoading()
}
if (res.data.code === 403) {
console.log("token失效：" + JSON.stringify(res.data))
relogin()
} else if (res.data.code === 0) {
console.log("响应报文：" + JSON.stringify(res.data))
obj.success(res.data)
} else {
console.log("请求失败返回：" + JSON.stringify(res))
obj.fail(res.data.msg)
}
},
fail: function(res) {
if (obj.message != "") {
wx.hideLoading()
}
wx.showToast({
title: '糟糕,服务器开小差了~',
icon: 'none'
})
}
})
}
function relogin() {
wx.login({
success: function(res) {
if (res.code) {
console.log("登录成功：" + res.code);
wx.request({
url: `${app.globalData.API_URL}/api/wxa/v1/login/wxCode`,
method: 'post',
data: {
code: res.code
},
success: function(res) {
console.log("登录：" + JSON.stringify(res))
if (res.data.code === 0) {
wx.clearStorage();
wx.setStorage({
key: 'loginStatus',
data: res.data.data,
success: function(res) {
getCurrentPages()[getCurrentPages().length - 1].onLoad()
},
fail: function(res) {
console.log("保存登录状态失败：" + JSON.stringify(res))
}
})
}
},
fail: function(res) {
console.log("登录失败：" + JSON.stringify(res))
}
})
} else {
console.log('登录失败！' + res.errMsg)
}
}
})
}
/**
* 获取短信验证码
*/
export function getPassCode(mobile, resolve, reject) {
request({
message: "正在获取验证码",
url: `${app.globalData.API_URL}/api/wxa/v1/login/getSmsCode`,
data: {
mobile: mobile
},
success: resolve,
fail: reject
})
}
/**
* 验证短信验证
*/
export function vailPassCode(mobile, msgCode, resolve, reject) {
request({
message: "正在校验验证码",
url: `${app.globalData.API_URL}/api/wxa/v1/login/checkSmsCode`,
data: {
mobile: mobile,
code: msgCode
},
success: resolve,
fail: reject
})
}
/**
* 注册宝宝信息
*/
export function register(mobile, msgCode, nickName, birthDay, sex, resolve, reject) {
request({
message: "正在注册...",
url: `${app.globalData.API_URL}/api/wxa/v1/user/register`,
data: {
mobile: mobile,
code: msgCode,
nickName: nickName,
birthDay: birthDay,
sex: sex
},
success: resolve,
fail: reject
})
}
/**
* 获取宝宝信息
*/
export function getBabyInfo(resolve, reject) {
request({
message: "正在加载...",
url: `${app.globalData.API_URL}/api/wxa/v1/user/getBabyInfo`,
data: null,
success: resolve,
fail: reject
})
}
/**
* 获取首页bar
*/
export function getHomeBar(resolve, reject) {
request({
url: `${app.globalData.API_URL}/api/wxa/v1/video/indexBar`,
success: resolve,
fail: reject
})
}
/**
* 获取首页推荐等数据
*/
export function getHomeVedio(resolve, reject) {
request({
message: "正在加载...",
url: `${app.globalData.API_URL}/api/wxa/v1/video/index`,
success: resolve,
fail: reject
})
}
/**
* 获取视频列表
*/
export function getVedioList(st, mt, nextPage, pageSize, resolve, reject) {
var message = null
if (nextPage === 0) {
message = "正在加载..."
}
request({
message: message,
url: `${app.globalData.API_URL}/api/wxa/v1/video/list`,
data: {
st: st,
mt: mt,
lastTimeStamp: nextPage,
pageSize: pageSize
},
success: resolve,
fail: reject
})
}
/**
* 获取视频详情
*/
export function getVedioDetail(id, resolve, reject) {
request({
message: "正在加载...",
url: `${app.globalData.API_URL}/api/wxa/v1/video/detail`,
data: {
detailId: id
},
success: resolve,
fail: reject
})
}
/**
* 视频点赞
*/
export function like(id, resolve, reject) {
request({
message: "正在提交...",
url: `${app.globalData.API_URL}/api/wxa/v1/video/like`,
data: {
detailId: id
},
success: resolve,
fail: reject
})
}
export function getUserInfo(resolve, reject) {
request({
message: "正在加载",
url: `${app.globalData.API_URL}/api/wxa/v1/user/getUserInfo`,
success: resolve,
fail: reject
})
}
|
import gameEngine from '../src/index.js';
import { getRandomInt } from '../src/utils.js';
const settings = {
min: 0,
max: 100,
};
const getQuestionData = () => {
const questionValue = getRandomInt(settings.min, settings.max);
return {
questionValue,
correctAnswer: questionValue % 2 === 0 ? 'yes' : 'no',
};
};
const gameEven = () => {
gameEngine({
rules: 'Answer "yes" if the number is even, otherwise answer "no".',
getQuestionData,
});
};
export default gameEven;
|
// function bubble_sort(arr) {
// for (let i = 0; i < arr.length; i++) {
// for (let j = 0; j < arr.length; j++) {
// console.log(arr, arr[j], arr[j + 1])
// if (arr[j] > arr[j + 1]) {
// let temp = arr[j]
// arr[j] = arr[j + 1]
// arr[j + 1] = temp
// }
// }
// }
// return arr
// }
// console.log(bubble_sort([3, 6, 1, 3, 7]))
// [1,9,5,5,1,7]
// [1,5,9,5,1,7]
function bubble(arr) {
let swapped = false
do {
swapped = false
for (let i = 0; i < arr.length; i++) {
if (arr[i] > arr[i + 1]) {
;[arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]
swapped = true
}
}
} while (swapped)
return arr
}
console.log(bubble([2, 34, 1, 5, 32, 3, 72]))
|
//GetPlayerSummaries.json
$.ajax({
url: "https://raw.githubusercontent.com/MalikSteam/account_public/main/public/webapi/GetPlayerSummaries.json",
type:"get",
dataType: 'text',
error: function(data){
//debugger;
//alert('err');
},
success:function(data) {
var data = JSON.parse( data );
var gpsjson_personaname = data.response.players[0].personaname;
$( ".gpsjson_personaname" ).append( gpsjson_personaname );
$( "title" ).append( gpsjson_personaname );
var gpsjson_avatar = data.response.players[0].avatar;
$( ".gpsjson_avatar" ).attr("src", gpsjson_avatar);
var gpsjson_avatarmedium = data.response.players[0].avatarmedium;
$( ".gpsjson_avatarmedium" ).attr("src", gpsjson_avatarmedium);
var gpsjson_avatarfull = data.response.players[0].avatarfull;
$( ".gpsjson_avatarfull" ).attr("src", gpsjson_avatarfull);
var gpsjson_profileurl = data.response.players[0].profileurl;
$( ".gpsjson_profileurl" ).attr("href", gpsjson_profileurl);
var gpsjson_timecreated = data.response.players[0].timecreated;
gpsjson_timecreated = new Date(gpsjson_timecreated*1000);
$( ".gpsjson_timecreated" ).append("timecreated:<br>" + gpsjson_timecreated);
//var gpsjson_personaname = data.response.players[0].personaname;
//$( ".gpsjson_personaname" ).append( gpsjson_personaname );
//"communityvisibilitystate": 3,
//"profilestate": 1,
//"commentpermission": 1,
//"personastate": 1,
//"primaryclanid": "103582791429521408",
//"personastateflags": 0
}
});
|
'use strict';
(function (app) {
app.controller('Home.OrderController', [
'$scope',
'$state',
'$stateParams',
'$http',
function ($scope, $state, $stateParams, $http) {
}
]);
}(window.MTG.main));
|
var tiles = $('td');
var xAndOGame;
var xAndOAi;
var xAndORenderer;
var startButton = $('#xo-start-button');
var xAndOBoard = $('table');
var isComputerMoveOver = true;
var isGameOver = true;
//obiectul care se ocupa de afisare in dom
function constructRenderer() {
return{
//afiseaza x si o in dom
//Input: tabla(matrice / array de arrayuri)
//Output: none
drawBoard: function(board){
for(var i = 0; i < 3; i++){
for(var j = 0; j < 3; j++){
if(board[i][j] === 'x' && !tiles[i*3+j].classList.contains('x')){
tiles[i*3+j].className += ' x'
}else if(board[i][j] === 'o' && !tiles[i*3+j].classList.contains('o')){
tiles[i*3+j].className += ' o'
}else if(board[i][j] === '-'){
tiles[i*3+j].classList.remove('x');
tiles[i*3+j].classList.remove('o');
tiles[i*3+j].classList.remove('winning-path');
}
}
}
},
//face modificarile initiale ale jocului
//Input & Output: none
renderNewGame: function(){
xAndOBoard.toggleClass('invisible');// face sa apara tabla
startButton.css({'color': 'white', 'background': 'black'});// modifica butonul de start
startButton.html('Game in progress');
},
//face modificarile vizuale de sfarsit de jocului
//Input & Output: none
renderEndGame: function(){
setTimeout(function(){
xAndOBoard.toggleClass('invisible');
startButton.css({'color': 'black', 'background': 'white'});
startButton.html('Start');
$('.xo-message').html('');
},2000);
},
//Afiseaza numarul de victori in dom
//Input & Output: none
updateWins: function(){
var playerWinsString = '';
var aiWinsString = '';
var wins = xAndOGame.returnWins();
var pWins = wins[0];
var aiWins = wins[1];
for(var i = 0; i < pWins; i++){ playerWinsString += 'I ';}
for(var i = 0; i < aiWins; i++){ aiWinsString += 'I ';}
$('.xo-player-wins').html(playerWinsString);
$('.xo-ai-wins').html(aiWinsString);
},
//Coloreaza segmentul castigator
//Input: linia castigatoare(un array de 3 elemente)
//Output: none
drawWinningPath: function(winningLine){
for(var i = 0; i < winningLine.length; i++){
tiles[winningLine[i][0]*3+winningLine[i][1]].className += ' winning-path';
}
}
}
}
//construieste obiectul care se ocupa de mecanica jocului
function constructXandOGame(){
var gameBoard = [
['-', '-', '-'],
['-', '-', '-'],
['-', '-', '-']
];
var crtPiece = 'x';
var playerWins = 0;
var aiWins = 0;
return {
//functie care apeleaza functia care returneaza segmentul castigator si in functie de existenta/inexistenta acestuia returneaza true/false
//Input: none
//Output: boolean
isThereAWinner: function(){
if(this.returnWinningPath().length){
isGameOver = true;
if(crtPiece === 'x'){
playerWins++;
return true;
}else{
aiWins++;
return true;
}
}else{
return false;
}
},
//returneaza numarul de victorii a juctaorului si a AI-jocului pentru a le afisare
//Input: none
//Output: un array de 2 cu nr de victorii a fiecarui jucator
returnWins: function(){
return [playerWins, aiWins];
},
//goleste tabla pentru un joc nou
//Input & Output: none
clearGameBoard: function(){
gameBoard = [
['-', '-', '-'],
['-', '-', '-'],
['-', '-', '-']
];
},
//imi verifica care ar fi linia/coloana/diagonala castigatoare
//Input: none
//Output: un array gol daca nu a castigat nimeni si cu pozitiile daca este un castigator
returnWinningPath: function(){
if(gameBoard[0][0] === crtPiece && gameBoard[0][1] === crtPiece && gameBoard[0][2] === crtPiece){ return [[0, 0], [0, 1], [0, 2]]; }
if(gameBoard[0][0] === crtPiece && gameBoard[1][0] === crtPiece && gameBoard[2][0] === crtPiece){ return [[0, 0], [1, 0], [2, 0]]; }
if(gameBoard[0][0] === crtPiece && gameBoard[1][1] === crtPiece && gameBoard[2][2] === crtPiece){ return [[0, 0], [1, 1], [2, 2]]; }
if(gameBoard[0][1] === crtPiece && gameBoard[1][1] === crtPiece && gameBoard[2][1] === crtPiece){ return [[0, 1], [1, 1], [2, 1]]; }
if(gameBoard[0][2] === crtPiece && gameBoard[1][2] === crtPiece && gameBoard[2][2] === crtPiece){ return [[0, 2], [1, 2], [2, 2]]; }
if(gameBoard[0][2] === crtPiece && gameBoard[1][1] === crtPiece && gameBoard[2][0] === crtPiece){ return [[0, 2], [1, 1], [2, 0]]; }
if(gameBoard[1][0] === crtPiece && gameBoard[1][1] === crtPiece && gameBoard[1][2] === crtPiece){ return [[1, 0], [1, 1], [1, 2]]; }
if(gameBoard[2][0] === crtPiece && gameBoard[2][1] === crtPiece && gameBoard[2][2] === crtPiece){ return [[2, 0], [2, 1], [2, 2]]; }
else{
return [];
}
},
//verifca remiza in functie de existenta/inexistenta elementului '-' care semnifica pozitie goala
//Input: none
//Output: boolean
isThereARemach: function(){
for(var i = 0; i < 3; i++){
for(var j = 0; j < 3; j++){
if(gameBoard[i][j] === '-'){
return false;
}
}
}
return true;
},
//schimba jucatorul
//Input & Output: none
switchPlayer: function(){
if(crtPiece === 'x'){
crtPiece = 'o';
return;
}else{
crtPiece = 'x';
return;
}
},
//modifica tabla cu noua miscare executata
//Input: i, j parametrii
//Outpu: none
makeMove: function(i, j){
if(gameBoard[i][j] === '-'){
gameBoard[i][j] = crtPiece;
}
},
//returneaza tabla
//Input & Output: none
getBoard: function(){
return gameBoard;
}
}
}
//
function constructAI(){
return {
makeMove: function(i,j){
var gameBoard = xAndOGame.getBoard();
//nu merge da asta ii algoritumul http://neverstopbuilding.com/minimax
if(gameBoard[0][0] === 'o' && gameBoard[0][1] === 'o' && gameBoard[0][2] === '-'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[0][0] === 'o' && gameBoard[0][1] === '-' && gameBoard[0][2] === 'o'){ xAndOGame.makeMove(0,1); return;}
if(gameBoard[0][0] === '-' && gameBoard[0][1] === 'o' && gameBoard[0][2] === 'o'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][0] === 'o' && gameBoard[1][0] === 'o' && gameBoard[2][0] === '-'){ xAndOGame.makeMove(2,0); return;}
if(gameBoard[0][0] === 'o' && gameBoard[1][0] === '-' && gameBoard[2][0] === 'o'){ xAndOGame.makeMove(1,0); return;}
if(gameBoard[0][0] === '-' && gameBoard[1][0] === 'o' && gameBoard[2][0] === 'o'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][0] === 'o' && gameBoard[1][1] === 'o' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[0][0] === 'o' && gameBoard[1][1] === '-' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][0] === '-' && gameBoard[1][1] === 'o' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][1] === 'o' && gameBoard[1][1] === 'o' && gameBoard[2][1] === '-'){ xAndOGame.makeMove(2,1); return;}
if(gameBoard[0][1] === 'o' && gameBoard[1][1] === '-' && gameBoard[2][1] === 'o'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][1] === '-' && gameBoard[1][1] === 'o' && gameBoard[2][1] === 'o'){ xAndOGame.makeMove(0,1); return;}
if(gameBoard[0][2] === 'o' && gameBoard[1][2] === 'o' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[0][2] === 'o' && gameBoard[1][2] === '-' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(1,2); return;}
if(gameBoard[0][2] === '-' && gameBoard[1][2] === 'o' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[0][2] === 'o' && gameBoard[1][1] === 'o' && gameBoard[2][0] === '-'){ xAndOGame.makeMove(2,0); return;}
if(gameBoard[0][2] === 'o' && gameBoard[1][1] === '-' && gameBoard[2][0] === 'o'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][2] === '-' && gameBoard[1][1] === 'o' && gameBoard[2][0] === 'o'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[1][0] === 'o' && gameBoard[1][1] === 'o' && gameBoard[1][2] === '-'){ xAndOGame.makeMove(1,2); return;}
if(gameBoard[1][0] === 'o' && gameBoard[1][1] === '-' && gameBoard[1][2] === 'o'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[1][0] === '-' && gameBoard[1][1] === 'o' && gameBoard[1][2] === 'o'){ xAndOGame.makeMove(1,0); return;}
if(gameBoard[2][0] === 'o' && gameBoard[2][1] === 'o' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[2][0] === 'o' && gameBoard[2][1] === '-' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(2,1); return;}
if(gameBoard[2][0] === '-' && gameBoard[2][1] === 'o' && gameBoard[2][2] === 'o'){ xAndOGame.makeMove(2,0); return;}
if(gameBoard[0][0] === 'x' && gameBoard[0][1] === 'x' && gameBoard[0][2] === '-'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[0][0] === 'x' && gameBoard[0][1] === '-' && gameBoard[0][2] === 'x'){ xAndOGame.makeMove(0,1); return;}
if(gameBoard[0][0] === '-' && gameBoard[0][1] === 'x' && gameBoard[0][2] === 'x'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][0] === 'x' && gameBoard[1][0] === 'x' && gameBoard[2][0] === '-'){ xAndOGame.makeMove(2,0); return;}
if(gameBoard[0][0] === 'x' && gameBoard[1][0] === '-' && gameBoard[2][0] === 'x'){ xAndOGame.makeMove(1,0); return;}
if(gameBoard[0][0] === '-' && gameBoard[1][0] === 'x' && gameBoard[2][0] === 'x'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][0] === 'x' && gameBoard[1][1] === 'x' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[0][0] === 'x' && gameBoard[1][1] === '-' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][0] === '-' && gameBoard[1][1] === 'x' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(0,0); return;}
if(gameBoard[0][1] === 'x' && gameBoard[1][1] === 'x' && gameBoard[2][1] === '-'){ xAndOGame.makeMove(2,1); return;}
if(gameBoard[0][1] === 'x' && gameBoard[1][1] === '-' && gameBoard[2][1] === 'x'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][1] === '-' && gameBoard[1][1] === 'x' && gameBoard[2][1] === 'x'){ xAndOGame.makeMove(0,1); return;}
if(gameBoard[0][2] === 'x' && gameBoard[1][2] === 'x' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[0][2] === 'x' && gameBoard[1][2] === '-' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(1,2); return;}
if(gameBoard[0][2] === '-' && gameBoard[1][2] === 'x' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[0][2] === 'x' && gameBoard[1][1] === 'x' && gameBoard[2][0] === '-'){ xAndOGame.makeMove(2,0); return;}
if(gameBoard[0][2] === 'x' && gameBoard[1][1] === '-' && gameBoard[2][0] === 'x'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[0][2] === '-' && gameBoard[1][1] === 'x' && gameBoard[2][0] === 'x'){ xAndOGame.makeMove(0,2); return;}
if(gameBoard[1][0] === 'x' && gameBoard[1][1] === 'x' && gameBoard[1][2] === '-'){ xAndOGame.makeMove(1,2); return;}
if(gameBoard[1][0] === 'x' && gameBoard[1][1] === '-' && gameBoard[1][2] === 'x'){ xAndOGame.makeMove(1,1); return;}
if(gameBoard[1][0] === '-' && gameBoard[1][1] === 'x' && gameBoard[1][2] === 'x'){ xAndOGame.makeMove(1,0); return;}
if(gameBoard[2][0] === 'x' && gameBoard[2][1] === 'x' && gameBoard[2][2] === '-'){ xAndOGame.makeMove(2,2); return;}
if(gameBoard[2][0] === 'x' && gameBoard[2][1] === '-' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(2,1); return;}
if(gameBoard[2][0] === '-' && gameBoard[2][1] === 'x' && gameBoard[2][2] === 'x'){ xAndOGame.makeMove(2,0); return;}
else{ this.makeRandomMove();}
},
makeRandomMove: function(){
var gameBoard = xAndOGame.getBoard();
var isPositionEmpty = false;
while(!isPositionEmpty){
var randomI = Math.floor(Math.random()*3);
var randomJ = Math.floor(Math.random()*3);
if(gameBoard[randomI][randomJ] === '-'){
xAndOGame.makeMove(randomI, randomJ)
isPositionEmpty = true;
}
}
}
}
}
xAndOGame = constructXandOGame();
startButton.click(startGame);
function startGame(){
if(isGameOver){
isGameOver = false;
createTilesPositions();
xAndOAi = constructAI();
xAndORenderer = constructRenderer();
xAndORenderer.renderNewGame();
xAndOGame.clearGameBoard();
xAndORenderer.drawBoard(xAndOGame.getBoard());
}
}
function createTilesPositions(){
for(var i = 0; i < 3; i++){
for(var j = 0; j < 3; j++){
tiles[i*3+j].dataset.i = i;
tiles[i*3+j].dataset.j = j;
}
}
}
xAndOBoard.click(function(){
playTurn(xAndOGame, event.target.dataset.i, event.target.dataset.j);
setTimeout(function(){
isComputerMoveOver = true;
playTurn(xAndOAi, 0, 0);
xAndOGame.switchPlayer();
isComputerMoveOver = true;
},1000);
xAndOGame.switchPlayer();
});
function playTurn(player, i, j){
if(isComputerMoveOver && !isGameOver){
isComputerMoveOver = false;
player.makeMove(i,j);
if(xAndOGame.isThereARemach()){
$('.xo-message').html('rematch');
xAndORenderer.renderEndGame();
isGameOver = true;
}
if(xAndOGame.isThereAWinner()){
$('.xo-message').html('winner');
xAndORenderer.drawWinningPath(xAndOGame.returnWinningPath());
xAndORenderer.updateWins();
xAndORenderer.renderEndGame();
isGameOver = true;
}
xAndORenderer.drawBoard(xAndOGame.getBoard());
}
}
|
//
// positions = [12,13,14,1,4,5,2];
// var a = positions.sort();
// console.log(a);
// function myFunction(){
// positions.sort(function(a,b){return a-b})
// }
// var result = myFunction();
// console.log(result);
// console.log(positions);
// positions.splice(2,4);
// console.log(positions);
// positions.shift();
// console.log(positions);
// var matrix =[];
// for(var i=0;i<3;i++){
// matrix[i]=[];{
// for(var j=0;j<3;j++){
// matrix[i][j]=[];
// for(var k=0;k<3;k++)
// matrix[i][j][k]=i+j+k;
// }
// }
// }
// console.log(matrix);
// var str = 121;
// let result = number();
// console.log(result);
// var result = number();
// var result = number(121);
// console.log(result);
// function number(n){
// n=n+"";
// n= n.split("").reverse().join("");
// if(output==n){
// return true;
// }
// else{
// return false;
// }
// }
// console.log(number(3123));
// var numb = str.split("").reverse().join("");
// if(numb==str)
// {
// return true;
// }
// else{
// return false;
// }
//}
// function palindrome(){
// revers = str.split("").reverse().join("");
// if(str==revers){
// return true;
// }
// else
// return false;
// }
// var number = 1221;
var result = reverse();
console.log(result);
function reverse(){
var remender,temp, final = 0;
var number = 1121;
temp = number;
while(number>0){
remender = number%10;
number = parseInt(number/10);
final = final *10 +remender;
}
if(final==temp){
return ("It is a palindrome");
}
else {
return ("Not a palindrome");
}
}
|
const User = require("./user");
const Resume = require("./resume");
const Company = require("./company");
const JobPost = require("./jobPost");
const File = require("./file");
const Apply = require("./apply");
module.exports = {
User,
Resume,
Company,
JobPost,
File,
Apply,
};
|
// Video Example Expression
var yearBorn = 1975;
var age = 2015 - yearBorn - 1;
console.log(age);
|
import React, {useState, useEffect, createContext, useContext} from "react";
const defaultState = {
theme: "light",
toggleTheme: () => {}
}
export const ThemeContext = createContext(defaultState);
export function ThemeProvider({ children }){
const [theme, setTheme] = useState("light");
useEffect(function(){
const theme = localStorage.getItem("theme") ? JSON.parse(localStorage.getItem("theme")) : "light";
setTheme(theme);
if (theme == "dark") {
document.documentElement.classList.add("dark")
} else {
document.documentElement.classList.remove("dark");
}
}, [])
function toggleTheme(){
const newTheme = theme == "light" ? "dark" : "light";
setTheme(newTheme);
if (newTheme == "dark") {
document.documentElement.classList.add("dark")
} else {
document.documentElement.classList.remove("dark");
}
localStorage.setItem("theme", JSON.stringify(newTheme));
}
return (
<ThemeContext.Provider value={{theme, toggleTheme}}>
{children}
</ThemeContext.Provider>
)
}
export function useTheme() {
return useContext(ThemeContext);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.