text
stringlengths 7
3.69M
|
|---|
// The default code is a module class (inherited from xui.Module)
// Ensure that all the value of "key/value pair" does not refer to external variables
xui.Class('App', 'xui.Module',{
Instance:{
// Dependency classes
Dependencies:[],
// Required modules
Required:[],
// To initialize properties
properties : {},
// To initialize instance(e.g. properties)
initialize : function(){
},
// To initialize internal components (mostly UI controls)
// *** If you're not a skilled, dont modify this function manually ***
iniComponents : function(){
// [[Code created by CrossUI RAD Studio
var host=this, children=[], append=function(child){children.push(child.get(0));};
append(
xui.create("xui.UI.SVGPaper")
.setHost(host,"xui_ui_svgpaper1")
.setLeft("5.833333333333333em")
.setTop("1.6666666666666667em")
.setWidth("52.833333333333336em")
.setHeight("8.333333333333334em")
);
host.xui_ui_svgpaper1.append(
xui.create("xui.svg.text")
.setHost(host,"xui_svg_text1")
.setSvgTag("Shapes:Text")
.setAttr({
"x":321,
"y":58.5,
"text":"Welcome to B-Words",
"font-size":"50px",
"font-weight":"bold"
})
);
append(
xui.create("xui.UI.Button")
.setHost(host,"xui_ui_button8")
.setDirtyMark(false)
.setLeft("13em")
.setTop("9.5em")
.setWidth("12.083333333333334em")
.setHeight("5.416666666666667em")
.setCaption("Open B-Words")
.onClick([
{
"desc":"Action 1",
"type":"page",
"target":"App.Writer",
"args":[
{ }
],
"method":"open",
"event":1
},
"_xui_ui_button8_onclick"
])
.setCustomStyle({
"KEY":{
"font-size":"20px"
}
})
);
append(
xui.create("xui.UI.SVGPaper")
.setHost(host,"xui_ui_svgpaper7")
.setLeft("0em")
.setTop("47.5em")
.setWidth("67em")
.setHeight("2.5em")
);
host.xui_ui_svgpaper7.append(
xui.create("xui.UI.MenuBar")
.setHost(host,"xui_ui_menubar4")
.setItems([
{
"id":"menu1",
"sub":[
{
"id":"normal",
"caption":"normal"
},
{
"id":"disabled",
"caption":"disabled",
"disabled":true
},
{
"id":"image",
"caption":"image",
"imageClass":"xui-icon-xui"
},
{
"type":"split"
},
{
"id":"checkbox 1",
"caption":"checkbox 1",
"type":"checkbox"
},
{
"id":"checkbox 2",
"caption":"checkbox 2",
"type":"checkbox"
}
],
"caption":"Menu"
},
{
"id":"menu2",
"sub":[
{
"id":"sub menu 1",
"caption":"sub menu 1",
"add":"[Ctrl+F]",
"sub":[
{
"id":"sub 1",
"type":"radiobox"
},
{
"id":"sub 2",
"type":"radiobox"
},
{
"id":"sub 3"
}
]
},
{
"id":"sub menu 2",
"caption":"sub menu 2",
"add":"[Ctrl+T]",
"sub":[
"sub 3",
"sub 4"
]
}
],
"caption":""
}
])
.setTop("4.166666666666667em")
);
return children;
// ]]Code created by CrossUI RAD Studio
},
// Give a chance to determine which UI controls will be appended to parent container
customAppend : function(parent, subId, left, top){
// "return false" will cause all the internal UI controls will be added to the parent panel
return false;
},
/**
* Fired when user click it
* @method onClick [xui.UI.Button event]
* @param {xui.UIProfile.} profile The current control's profile object
* @param {Event} e , Dom event object
* @param {Element.xui} src id or Dom Element
* @param {} value Object
*/
_xui_ui_button8_onclick:function(profile, e, src, value){
var ns = this, uictrl = profile.boxing();
}
/*,
// To determine how properties affects this module
propSetAction : function(prop){
},
// To set all node's style in this modlue
customStyle:{}
},
//To customize the default properties and event handlers
Static:{
$DataModel:{
},
$EventHandlers:{
}
*/
}
});
|
import * as Reaflow from 'reaflow';
import React, { useRef, useState } from 'react';
import ReactDOM from 'react-dom';
import * as FramerMotion from 'framer-motion';
import * as RDK from 'rdk';
import ClassNames from 'classnames';
window.Reaflow = Reaflow;
window.React = React;
window.ReactDOM = ReactDOM;
window.RDK = RDK;
window.FramerMotion = FramerMotion;
window.ClassNames = ClassNames;
|
import Ember from 'ember';
import {
module,
test
} from 'qunit';
import startApp from 'wall-of-fame/tests/helpers/start-app';
var application;
var stubUsers = [
{id: 1, name: 'User A'},
{id: 2, name: '2nd user'},
{id: 3, name: 'Another user'},
];
module('Acceptance: User', {
beforeEach: function() {
application = startApp();
$.fauxjax.new({
request: {
type: "GET",
url: '/api/users',
},
response: {
content: {users: stubUsers}
}
});
},
afterEach: function() {
Ember.run(application, 'destroy');
}
});
test("it lists all users", function(assert) {
visit('/');
andThen(function() {
var users = find('.user-link');
assert.equal(users.length, 3);
var user = find('.user-link:eq(0)');
assert.equal(user.text().trim(), 'User A');
});
});
test("Clicking the user name will show their details", function(assert) {
visit('/');
click(".user-link:eq(1)");
andThen(function() {
assert.equal(currentURL(), "/user/2");
var details = find('.user-details');
assert.equal(details.text().trim(), '2nd user');
});
});
|
/*!
* Copyright 2015, All Rights Reserved.
*
* Code licensed under the MIT License:
* http://vitorbritto.mit-license.org/
*
* Author: Vitor Britto <code@vitorbritto.com.br>
*/
(function(window, document, undefined) {
'use strict';
var APP = (function() {
var obj = obj || {};
// -----------------------------------
// PRIVATE METHODS
// -----------------------------------
obj._foo = function() {
// code goes here
};
// -----------------------------------
// PUBLIC METHODS
// -----------------------------------
obj.bar = function() {
// code goes here
};
// -----------------------------------
// INITIALIZE MODULE
// -----------------------------------
return {
init: obj.bar
};
})();
// Global
window.APP = APP;
})(window, document);
|
const dnaSeqCheck = sequence => {
/*
This function will be used to proofread the entered sequence before
processing. The function qill return a sequence in lower-case format
*/
//create array of the allowed bases
const allowedChars = ['a', 'g', 'c', 't'];
//loop over every base in the sequence
for (var base = 0; base < sequence.length; base++) {
//if the character is not in the allowedChars array
if(allowedChars.indexOf(sequence[base]) === -1) {
//throw an error telling user that the sequence contains a character
//other than an 'a', 't', 'g', or 'c'. Breaks the loop
throw new Error('A base in your sequence is not a nucleotide');
}
}
//if no characters are wrong, return the sequence
return (sequence);
}
const gcContent = sequence => {
/*
This function will calculate the gc content for a given sequence. Returns
the percent gc.
*/
//find number of 'g': (sequence.match(/g/g) || []).length;
//find number of 'c': (sequence.match(/c/g) || []).length;
//add those togther and divide by length of sequence and multiply by 100
return ((((sequence.match(/g/g) || []).length +
(sequence.match(/c/g) || []).length) / sequence.length) * 100);
}
const reverseComp = sequence => {
/*
This function will allow for the reverse complement of an input sequence to
be determined. Returns a string that is reverse complement.
*/
let reverse = []; //creates empty array to add reverse base to
//loops over bases in sequence in reverse order
for (let i = sequence.length - 1; i >= 0; i--) {
//if the base is an 'a', push 't' to array
if (sequence[i] === 'a') {
reverse.push('t');
}
//if the base is an 'c', push 'g' to array
else if (sequence[i] === 'c') {
reverse.push('g');
}
//if the base is an 'g', push 'c' to array
else if (sequence[i] === 'g') {
reverse.push('c');
}
//if the base is an 't', push 'a' to array
else {
reverse.push('a');
}
}
//convert array to string, replace commas with '', and return value
return (reverse.toString().replace(/,/g, ''));
}
const transcription = sequence => {
/*
This funcion allows for the transcription of dna to rna for the input
sequence. Returns a string that is the rna transcript.
*/
let trasncript = []; //create empty array to add bases to
//loop over every base in sequence
for (let i = 0; i < sequence.length; i++) {
//if the base is a 't', push 'u' to array
if (sequence[i] === 't') {
trasncript.push('u');
}
//all other bases are pushed to array
else {
trasncript.push(sequence[i]);
}
}
//convert array to string, replace commas with '', return value
return (trasncript.toString().replace(/,/g, ''))
}
const translation = sequence => {
/*
This function will allow for the DNA sequence to be translated into the
corresponding protein sequence. It finds the first start codon (ATG) in the
sequence and all of the stop codons (TAA, TAG, TGA). The protein will be
translated using the start and first stop codon. The translated protein
is in the 1-letter code.
*/
//create dictionary for refernce of codons and corresponding amino acid
const codons = {
'ttt': 'F',
'ttc': 'F',
'tta': 'L',
'ttg': 'L',
'ctt': 'L',
'ctc': 'L',
'cta': 'L',
'ctg': 'L',
'att': 'I',
'atc': 'I',
'ata': 'I',
'atg': 'M',
'gtt': 'V',
'gtc': 'V',
'gta': 'V',
'gtg': 'V',
'tct': 'S',
'tcc': 'S',
'tca': 'S',
'tcg': 'S',
'cct': 'P',
'ccc': 'P',
'cca': 'P',
'ccg': 'P',
'act': 'T',
'acc': 'T',
'aca': 'T',
'acg': 'T',
'gct': 'A',
'gcc': 'A',
'gca': 'A',
'gcg': 'A',
'tat': 'Y',
'tac': 'Y',
'taa': '',
'tag': '',
'cat': 'H',
'cac': 'H',
'caa': 'Q',
'cag': 'Q',
'aat': 'N',
'aac': 'N',
'aaa': 'K',
'aag': 'K',
'gat': 'D',
'gac': 'D',
'gaa': 'E',
'gag': 'E',
'tgt': 'C',
'tgc': 'C',
'tga': '',
'tgg': 'W',
'cgt': 'R',
'cgc': 'R',
'cga': 'R',
'cgg': 'R',
'agt': 'S',
'agc': 'S',
'aga': 'R',
'agg': 'R',
'ggt': 'G',
'ggc': 'G',
'gga': 'G',
'ggg': 'G'
};
let startSite = sequence.indexOf('atg');//find index of first 'atg'
let protein = [];//create empy array to push amino acids to
//loop over entire sequence beginning at start site, increment index by
//3 to move to the first base of the next codon
for (let codon = startSite; codon < sequence.length; codon += 3) {
//if the codon matches a stop codon, break out of the loop
if (codons[sequence.slice(codon, codon + 3)] === 'taa'||
codons[sequence.slice(codon, codon + 3)] === 'tag'||
codons[sequence.slice(codon, codon + 3)] === 'tga') {
break;
}
//otherwise, push the corresponding amino acid for the codon
else {
protein.push(codons[sequence.slice(codon, codon + 3)])
}
}
//for some reason, a space is pushed to the end of the list, pop that
protein.pop();
//comert array to string, replaces commas with '', return value
return (protein.toString().replace(/,/g, ''));
}
|
// var co = require('co');
// var thunkify = require('thunkify');
// var mongoStock = require('../dal/mongoStock.js');
// mongoStock.stockItemModel.find = thunkify(mongoStock.stockItemModel.find);
// var search = decodeURIComponent('BABA');
// var searchReg = new RegExp(search, 'i'); // i,不区分大小写
// var result = [];
// var startTime = new Date().getTime();
// co(function*() {
// try {
// result = yield mongoStock.stockItemModel.find({
// $or: [{
// "Symbol": {
// $regex: searchReg
// }
// }, {
// "Name": {
// $regex: searchReg
// }
// }]
// }, null, {
// // skip: (page - 1) * 3, // start
// limit: 4
// });
// console.log(result)
// } catch (err) {
// console.log(err);
// }
// var endTime = new Date().getTime();
// console.log(`getStockListAsLike -> 模糊查询 [ ${decodeURIComponent(search)} ] 成功，用时： ${endTime-startTime}`)
// });
// var mongoose = require('./mongodb.js').mongoose;
// var StockItemSchema = new mongoose.Schema({ // 股票信息 - 数据结构
// Index: mongoose.Schema.Types.Mixed,
// Symbol: mongoose.Schema.Types.Mixed,
// Name: String,
// MarketCap: String,
// Sector: String,
// Industry: String
// });
// var stockItemModel = mongoose.model('StockItem', StockItemSchema, 'StockList');
// console.log()
/*var mongoose = require('mongoose'); //引用mongoose模块
var db = mongoose.createConnection('localhost', 'STOCK_US'); //创建一个数据库连接
db.on('error', console.error.bind(console, '连接错误:'));
db.once('open', function() {
//一次打开记录
console.log('一次打开记录')
});
var StockItemSchema = new mongoose.Schema({ // 股票信息 - 数据结构
Index: mongoose.Schema.Types.Mixed,
Symbol: mongoose.Schema.Types.Mixed,
Name: String,
MarketCap: String,
Sector: String,
Industry: String
});
var stockItemModel = db.model('StockItem', StockItemSchema, 'StockList');
var SM = db.model('StockItem');
SM.find({Symbol:'BABA'},function(err, persons) {
//查询到的所有person
console.log(persons)
});*/
var co = require('co');
var thunkify = require('thunkify');
var mongoose = require('../dal/mongodb/');
var fs = require('fs');
// var SheetUsNewsModel = mongoose.stock_db.model('SHEET_US_NEWS');
co(function*(){
/*var result = yield SheetUsNewsModel.findOne({symbol:'AMD'});
console.log('SHEET_US_NEWS')
console.log(result.data)
console.log(result.symbol)
console.log(typeof result)
fs.writeFileSync('./abc.json',result);*/
var search = '1st Constitution Bancorp (NJ)';
// var search = '1st\\ Constitution\\ Bancorp\\ \\(NJ\\)';
// search = search.split(' ').join('\\ ');
// search = search.split('(').join('\\(');
// search = search.split(')').join('\\)');
console.log(search)
var searchReg = new RegExp(search, 'i'); // i,不区分大小写
console.log(searchReg)
var result = yield mongoose.stock_db.model('SHEET_US_NEWS').findOne({});
fs.writeFileSync('./abc.json',result);
console.log(result)
});
// var stockItemModel = mongoose.stock_db.model('StockItem');
// co(function*(){
// var result = yield stockItemModel.find({Symbol:'BABA'});
// console.log('yangyue1')
// console.log(result)
// });
|
'use strict';
/**
* logic
* @param {} []
* @return {} []
*/
export default class extends think.logic.base {
/**
* index action logic
* @return {} []
*/
indexAction(){
}
/**
* 权限验证
*/
async checkAuth() {
let value = await this.session('userInfo');
return think.isEmpty(value);
}
/**
* 登录
*/
loginAction(){
this.allowMethods = 'post';
}
/**
* 注册
*/
registerAction() {
this.allowMethods = 'post';
this.rules = {
account: "required|mobile:zh-CN",
password: "required|length:6,20"
}
}
/**
* 更新
*/
async updateAction(){
let auth = await this.checkAuth();
if(auth) return this.fail('没有权限！');
this.allowMethods = 'post';
}
/**
* 点赞记录
*/
async thumbupAction() {
let auth = await this.checkAuth();
if(auth) return this.fail('没有权限！');
}
}
|
export const GOOGLE_MAPS_API_KEY = 'AIzaSyBW5D1IFR4q5PWD3j-MSIBy6dhd0VP4aPE';
export const GOOGLE_ANDROID_CLIENT_ID =
'338739180498-f9r6pacfhd7osnq81r4r3gs6j54v692f.apps.googleusercontent.com';
export const GOOGLE_IOS_CLIENT_ID = '';
|
import React, { Component } from 'react';
import { connect } from "react-redux";
import { func, array } from "prop-types";
import { ToastContainer } from 'react-toastify';
import { LoaderContainer } from "./components/Loader/Loader";
import Headers from "./components/Headers/Headers";
import UnderHeaderImage from "./components/UnderHeaderImage/UnderHeaderImage";
import Products from "./components/Products/Products";
import Video from "./components/Video/Video";
import AdvantageOfOurCompany from "./components/AdvantageOfOurCompany/AdvantageOfOurCompany";
import ConditionOfDelivery from "./components/ConditionOfDelivery/ConditionOfDelivery";
import UserReviews from "./components/UserReviews/UserReviews";
import UserReviewsForm from "./components/UserReviewsForm/UserReviewsForm";
import ConnectWithUs from "./components/ConnectWithUs/ConnectWithUs";
import Basket from "./components/Basket/Basket";
import * as producActions from "./modules/product/product.actions";
import * as commentsActions from "./modules/comment/comment.actions";
import 'react-toastify/dist/ReactToastify.css';
import classes from './App.less'
class App extends Component {
static propTypes = {
getAllProductSaga: func,
getAllCommentsSaga: func,
saveCommentSage: func,
comments: array,
}
state = {
contactRef: null
}
componentDidMount() {
this.props.getAllProductSaga();
this.props.getAllCommentsSaga();
}
handleScrollToElement = (event) => {
window.scrollTo({ top: this.state.contactRef.offsetTop, behavior: 'smooth' });
}
setRef = (element) => {
this.setState({
contactRef: element
})
}
render() {
const { products } = this.props;
return (
<div className={classes.app}>
<ToastContainer />
<LoaderContainer />
<Basket />
<Headers handleScrollToElement={this.handleScrollToElement} />
<UnderHeaderImage />
<Products products={products} />
<Video />
<AdvantageOfOurCompany />
<ConditionOfDelivery />
<UserReviews comments={this.props.comments} />
<UserReviewsForm saveComment={this.props.saveCommentSage} />
<ConnectWithUs setRef={this.setRef} />
</div>
);
}
}
function mapStateToProps({ product, comment }) {
return {
products: product.products,
comments: comment.comments,
};
}
export default connect(mapStateToProps, { ...producActions, ...commentsActions })(App);
|
const express = require('express');
const path = require('path');
const apiRouter = require('./api_router');
const app = express();
const staticPath = path.join(__dirname, 'static');
app.use(express.static(staticPath));
app.use('/api', apiRouter);
app.listen(3000, () => {
console.log('Listening on port 3000...');
});
|
import {List} from "@material-ui/core";
import styled from "styled-components";
const StyledMenu = styled(List)`
border-bottom: solid 1px #e5ecef;
margin-bottom: 42px;
position: relative;
.menu-button {
flex-direction: column;
padding: 8px;
box-sizing: border-box;
border-radius: 5px;
transition: color 0.15s ease;
white-space: nowrap;
text-align: center;
font-size: 1.05rem;
width: auto;
display: inline-block;
padding: 8px 16px;
.menu-icon {
margin-bottom: 8px;
}
&:hover {
color: #da4167;
background-color: transparent;
}
}
.creating-menu {
text-align: center;
color: red;
}
`;
export {StyledMenu};
|
const lottery = require("./lottery")
describe("Lottery", () => {
beforeEach(() => {
jest.restoreAllMocks()
})
it("Draw random ball is an integer", () => {
expect(Number.isInteger(lottery.drawRandomBall())).toBe(true)
})
it("Check Min and Max ball", () => {
const mathRandomSpy = jest.spyOn(Math, 'random')
mathRandomSpy.mockImplementation(() => 0)
expect(lottery.drawRandomBall()).toBe(lottery.MIN_NUMBER)
mathRandomSpy.mockImplementation(() => 1)
expect(lottery.drawRandomBall()).toBe(lottery.MAX_NUMBER)
})
it("Check is ascending order", () => {
const lotteryBalls = [38, 14, 26, 5, 48, 21]
expect(lottery.sortLotteryAscending(lotteryBalls)).toEqual([5, 14, 21, 26, 38, 48])
})
})
// // Write a function that will return random numbers for a lottery
// // The lottery will draw 6 balls from a pool labelled 1 to 49
// // Your function should idsplay the selected balls in ascending order
|
import React, { /* useState, useEffect, */ useCallback } from "react";
|
import BackToTop from './backtotop'
import Breadcrumbs from './breadcrumbs'
import Homepage from './homepage'
import NationalGoals from './national-goals'
import Navigation from './navigation'
import Pagination from './pagination'
import PostListing from './post-listing'
import ShareIcons from './share-icons'
import ShowMoreMeta from './show-more-meta'
import SmoothScroll from './smooth-scroll'
import StatesLanding from './state-landing'
import StickyMenu from './sticky-menu'
import { Search, SearchOverlay } from './searchpage'
window.addEventListener('DOMContentLoaded', () => {
BackToTop()
Breadcrumbs()
Homepage()
NationalGoals()
Navigation()
Pagination()
PostListing()
ShareIcons()
ShowMoreMeta()
SmoothScroll()
StatesLanding()
StickyMenu()
SearchOverlay()
Search()
})
|
var rExcerpt = /<!--\s*more\s*-->/;
function excerptFilter(data){
data.content = data.content.replace(rExcerpt, function(){
return '<a id="more"></a>';
});
}
module.exports = excerptFilter;
|
//所有关于数字处理
//1.常规基础数字处理
let numBaseHandle = {
parseInt (num) {//丢弃小数部分,保留整数部分
return parseInt(num)
},
ceil(num) {//向上取整
return Math.ceil(num)
},
round(num) {//四舍五入
return Math.round(num)
},
floor(num){//向下取整
return Math.floor(num)
},
random(num1,num2,pre){//num1-num2之间随机数,pre为精确度
let backNum;
if (num1&&num2) {
let add = num1<num2 ? num1 : num2;
backNum = Math.random() * Math.abs(num1-num2) + add
}else if(num1 || num2){
backNum = Math.random() * num1
}else{
backNum = 0
}
//取精确度
if(pre){
backNum = backNum.toString().slice(0,pre+2)
}else{
backNum = parseInt(backNum)
}
return backNum
}
};
//2.特殊数字处理
let numSpecialHandle = {
floatNumAdd(num1,num2) {//浮点数相加
return parseFloat((num1+num2).toFixed(10))
},
floatNumSub(num1,num2) {//浮点数相减
return parseFloat((num1-num2).toFixed(10))
},
floatNumMult(num1,num2) {//浮点数相乘
return parseFloat((num1*num2).toFixed(10))
},
floatNumDivision(num1,num2) {//浮点数相除
//浮点数相除预先处理如果出现1/3类似情况，四舍五入保留4位小数
let num = '';
num = Math.round(parseFloat((num1/num2).toFixed(10))*10000)/10000
return num;
},
floatDotTwo(num){//四舍五入保留两位小说
return Math.round(num*100)/100
},
moneyNum(num){//数字金额，从右到左每隔3位加.
//正则写法
return (num || 0).toString().replace(/(\d)(?=(?:\d{3})+$)/g,'$1,');
}
}
export {numBaseHandle,numSpecialHandle}
|
import React from 'react';
import Layout from '../components/Layout';
/*
import PageFooter from '../components/PageFooter';
import SideBar from '../components/Sidebar/index'
import pic2 from '../assets/images/pic02.jpg';
import pic3 from '../assets/images/pic03.jpg';
import pic4 from '../assets/images/pic04.jpg';
import pic5 from '../assets/images/pic05.jpg';
import pic6 from '../assets/images/pic06.jpg';
import pic7 from '../assets/images/pic07.jpg';
import pic8 from '../assets/images/pic08.jpg';
import Scroll from '../components/Scroll';
import ScrollToTop from 'react-router-scroll-top'
//import HomeHeader from '../components/HomeHeader'
import { Link } from 'gatsby';*/
import HomePage from '../components/PageComponents/Home/Page'
//import Rgallery from '../components/Rgallery'
//import { Link } from 'gatsby'
/*const sections = [
{ id: 'top', name: 'Intro', icon: 'fa-home' },
{ id: 'portfolio', name: 'Portfolio', icon: 'fa-th' },
{ id: 'about', name: 'About Me', icon: 'fa-user' },
{ id: 'contact', name: 'Contact', icon: 'fa-envelope' },
];*/
const IndexPage = () => (
<Layout>
<HomePage />
</Layout>
);
export default IndexPage;
|
'use strict'
/** @typedef {import('@adonisjs/framework/src/Request')} Request */
/** @typedef {import('@adonisjs/framework/src/Response')} Response */
/** @typedef {import('@adonisjs/framework/src/View')} View */
// /** @type {typeof import('@adonisjs/lucid/src/Lucid/Model')} */
const Task = use('App/Models/Task')
const moment = use('moment')
/**
* Resourceful controller for interacting with tasks
*/
class TaskController {
/**
* Show a list of all tasks.
* GET tasks
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
* @param {View} ctx.view
*/
async index({ request, response, view }) {
const tasks = (await Task.all()).toJSON()
tasks.forEach(task => {
task.started_at = moment(task.started_at).format('YYYY-MM-DD HH:mm')
});
return view.render('pages.admin.tasks.index', { tasks })
}
/**
* Render a form to be used for creating a new task.
* GET tasks/create
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
* @param {View} ctx.view
*/
async create({ request, response, view }) {
return view.render('pages.admin.tasks.create')
}
/**
* Create/save a new task.
* POST tasks
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
*/
async store({ request, response }) {
const task = await Task.findOrCreate(
{
name: request.input('name'),
slug: request.input('slug')
},
{
name: request.input('name'),
slug: request.input('slug'),
answer: request.input('answer'),
score: request.input('score'),
is_manual: !!request.input('is_manual'),
bonus_time: request.input('bonus_time'),
bonus_coef: request.input('bonus_coef')
}
)
return response.route('admin.tasks.index')
}
/**
* Display a single task.
* GET tasks/:id
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
* @param {View} ctx.view
*/
async show({ params, request, response, view }) {
}
/**
* Render a form to update an existing task.
* GET tasks/:id/edit
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
* @param {View} ctx.view
*/
async edit({ params, request, response, view }) {
}
/**
* Update task details.
* PUT or PATCH tasks/:id
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
*/
async update({ params, request, response }) {
}
/**
* Delete a task with id.
* DELETE tasks/:id
*
* @param {object} ctx
* @param {Request} ctx.request
* @param {Response} ctx.response
*/
async destroy({ params, request, response }) {
const { id } = params
const task = await Task.find(id)
await task.delete()
return response.route('admin.tasks.index')
}
}
module.exports = TaskController
|
var searchData=
[
['x_5fcomment_5fto',['x_comment_to',['../structEnvelope.html#a52153c6e4fdb551233e26d4fdb48fb78',1,'Envelope']]],
['x_5flabel',['x_label',['../structEnvelope.html#ac7bed8a507227756030c035a7aad198e',1,'Envelope']]],
['x_5foriginal_5fto',['x_original_to',['../structEnvelope.html#a525bd5213606067d5c2be2e17fbe956b',1,'Envelope']]],
['xcred',['xcred',['../structTlsSockData.html#a44b81a79c0f6cd2185054a494b9eb193',1,'TlsSockData']]],
['xdg_5fdefaults',['xdg_defaults',['../muttlib_8c.html#acc0475757fa09772b783f791f2c41a80',1,'muttlib.c']]],
['xdg_5fenv_5fvars',['xdg_env_vars',['../muttlib_8c.html#aa56f51d9542560ead857cd669e7081fe',1,'muttlib.c']]],
['xneomuttkeep',['xneomuttkeep',['../structMailcapEntry.html#af711c81e4798bf4790fb6dd58d739d68',1,'MailcapEntry']]],
['xref',['xref',['../structEnvelope.html#aafcabc33a66b5edfa91bbdc922515c2e',1,'Envelope']]],
['xtype',['xtype',['../structBody.html#a25c15115b34c11620fc995c13383fd9b',1,'Body']]]
];
|
// Evento de deixar opção ativada no menu da outra section
$('[data-grupo]').each(function(){
var tags_a = $(this).find('[data-item]');
var tags_conteudo = $(this).find('[data-conteudo]');
tags_a.eq(0).addClass('active');
tags_conteudo.eq(0).addClass('active');
var section_da_vez = $(this);
var section_da_vez_attr = section_da_vez.attr('data-grupo')
tags_a.on('click', function(e){
e.preventDefault();
if( section_da_vez_attr == 'animais'){
var conteudo_anterior_outra_section = $('[data-grupo="florestas"]').find('[data-conteudo].active');
var item_anterior = $('[data-grupo="florestas"]').find('[data-item].active');
} else {
var conteudo_anterior_outra_section = $('[data-grupo="animais"]').find('[data-conteudo].active');
var item_anterior = $('[data-grupo="animais"]').find('[data-item].active');
}
$('[data-conteudo]').removeClass('active')
var conteudo = $(this).data('item')
$('[data-conteudo="'+conteudo+'"]').addClass('active');
conteudo_anterior_outra_section.addClass('active')
$('[data-item]').removeClass('active');
$(this).addClass('active')
$(item_anterior).addClass('active')
})
})
// Adicionar div no botão ativar
$('.botao_ativar').wrap("<div class='acima' data-seila='a'></div>")
// Adicionar ou remover classe animar no botão ativar
$('.botao_ativar').on('click', function(){
if($(this).is('.animar') ){
$(this).removeClass('animar')
} else {
$(this).addClass('animar')
}
})
// Ao passar mouse por cima faz efeito de basquete
$('.botao_ativar').on('mouseenter', function(){
if( $(this).is('.animar_scale') ){
} else {
$(this).addClass('animar_scale')
}
})
// Media querie por JS não utilizada
document.body.onresize = function() {
if (document.body.clientWidth < 600) {
}
};
// Esconder Menu Mobile com a classe activee com media querie
$('.menu-cel').on('click', function(){
if($('.nav-cel').parent().hasClass('activee')) {
$('.nav-cel').parent().removeClass('activee')
} else {
$('.nav-cel').parent().addClass('activee')
}
})
// Animação no scroll para efeito de transform com opaciti da classe anime
$(window).on('scroll', function(){
// Elementos com data-anime
efeito_scroll();
})
function efeito_scroll(){
$('[data-anime="scroll"]').each(function(){
// Pegar posições da tela
var baixo_item = $(this).offset().top;
var altura_scroll_cima = $(window).scrollTop()+1000
if(altura_scroll_cima > baixo_item){
$(this).addClass('anime')
} else {
$(this).removeClass('anime')
}
})
}
efeito_scroll();
|
import React, { useState, useEffect } from "react";
import "./home.css";
import { Row, Col, Table, Button } from "reactstrap";
import axios from "../../defaults/axiosConf";
import Spinner from "./Spinner";
import { Link } from "react-router-dom";
import Swal from "sweetalert2";
export default function ViewStock() {
const [stockObj, setStockObj] = useState(null);
var rows;
useEffect(() => {
axios
.get("api/stock/getAllStocks")
.then((res) => {
setStockObj(res.data);
})
.catch((err) => {});
}, []);
if (stockObj == null) {
rows = <Spinner />;
} else {
console.log(`stockObj`, stockObj);
if (Object.keys(stockObj).length > 0) {
rows = stockObj.map((b, i) => (
<>
<tr>
<th scope="row">{i + 1}</th>
<td>{b.name}</td>
<td>{b.latest_price}</td>
<td>{b.previous_price}</td>
<td>{b.low}</td>
<td>{b.high}</td>
<td>{b.percentage}</td>
<td>{b.time}</td>
<td>{b.date}</td>
<td>
<Link to={"/stock/" + b._id} className="btn btn-primary">
View
</Link>
</td>
<td>
<Link to={"/updateStock/" + b._id} className="btn btn-primary">
Edit
</Link>
</td>
<td>
<Button
outline
color="danger"
onClick={() => {
Swal.fire({
title: "Are you sure?",
text: "You won't be able to revert this!",
icon: "warning",
showCancelButton: true,
confirmButtonColor: "#3085d6",
cancelButtonColor: "#d33",
confirmButtonText: "Yes, delete it!",
}).then((result) => {
if (result.isConfirmed) {
axios
.post("api/stock/deleteStock", { id: b._id })
.then((res) => {
console.log("data", res);
window.location.reload();
Swal.fire(
"Deleted!",
"Your record has been deleted.",
"success"
);
})
.catch((err) => {});
}
});
}}
>
Delete
</Button>
{/* <Link to={"/deleteStock/" + b._id} className="btn btn-primary">
Delete
</Link> */}
</td>
</tr>
</>
));
}
}
return (
<>
<Row className="pt-4 pb-4 pl-4 pr-4">
<div className="col-centered">
<h2
style={{
display: "table",
marginTop: "50px",
marginBottom: "25px",
margin: "0 auto",
}}
>
<b>S&P 500</b> STOCKS
</h2>
{/* <Col sm="12" md="6" lg="6" className="col-centered">
<div className="col-centered">
<Row className="pt-4">
<Col
sm="12"
md="6"
lg="6"
className="col-centered d-flex justify-content-center"
>
{<EncForm />}
</Col>
</Row>
</div>
</Col> */}
<Table striped>
<thead>
<tr>
<th>#</th>
<th>Name</th>
<th>Latest Price</th>
<th>Previous Price</th>
<th>Low</th>
<th>High</th>
<th>Percentage</th>
<th>Time</th>
<th>Date</th>
<th>View Stock</th>
<th>Edit Stock</th>
<th>Delete Stock</th>
</tr>
</thead>
<tbody>{rows}</tbody>
</Table>
<div class="row justify-content-center">
<Link
to={"/createStock"}
className="btn btn-primary"
style={{ width: "25%", float: "" }}
>
Create Stock
</Link>
</div>
</div>
</Row>
</>
);
}
|
window.onload = function(){
skill_show();
addAllNum();
tip_show();
}
function skill_show(){
var skill = document.getElementById("skill");
if(skill){
var skillList = skill.getElementsByTagName("li");
for(var i=0; i<skillList.length; i++){
skillList[i].addEventListener("mouseover",function(){
for(var j=0; j<skillList.length; j++){
skillList[j].className="";
};
this.className = "skill_show";
})
}
}
}
function addAllNum(){
var point = document.getElementById("point");
if(point){
var pointUls = point.getElementsByTagName("ul");
for(var i=0; i<pointUls.length; i++){
addNum(pointUls[i]);
};
}
}
function addNum(ul){
var lis = ul.getElementsByTagName("li");
var num = ul.getAttribute("addNum").split(",");
for(var i=0; i<lis.length; i++){
for(var j=0; j<num.length; j++){
if(i==num[j]-1){
lis[i].innerHTML=num[j];
lis[i].setAttribute("style","border: 1px solid #5a2626");
}
}
}
}
function tip_show(){
var tip = document.getElementById("tip");
if(tip){
var tipList = tip.getElementsByTagName("li");
for(var i=0; i<tipList.length; i++){
tipList[i].addEventListener("mouseover",function(){
for(var j=0; j<tipList.length; j++){
tipList[j].className="";
};
this.className="tip_show";
})
}
}
}
|
'use strict';
(function (){
angular
.module("BookApp")
.controller("ProfileController",ProfileController);
function ProfileController($rootScope, $scope ,UserService) {
function init() {
$rootScope.user.dateOfBirth = new Date($rootScope.user.dateOfBirth);
}
init();
$scope.update = update;
function update(newUser) {
UserService
.updateUserById(newUser._id, newUser)
.then(
function(doc){
var user = doc.data;
if(user){
user.dateOfBirth = new Date(user.dateOfBirth);
$scope.success = "Updated Successfully";
UserService.setUser(user);
}
}
);
}
}
})();
|
/**
* Eamil Search
*/
import React, { Component } from 'react';
import { FormGroup, Input } from 'reactstrap';
import { connect } from 'react-redux';
// actions
import { searchEmail, updateSearchEmail } from 'Actions';
class EmailSearch extends Component {
/**
* On Search Email
*/
onSearchEmail(e) {
this.props.updateSearchEmail(e.target.value);
this.props.searchEmail(e.target.value);
}
render() {
const { searchEmailText } = this.props;
return (
<FormGroup className="mb-0">
<Input
type="text"
name="search"
id="search-todo"
placeholder="Search Mail"
onChange={(e) => this.onSearchEmail(e)}
value={searchEmailText}
/>
</FormGroup>
);
}
}
// map state to props
const mapStateToProps = ({ emailApp }) => {
return emailApp;
}
export default connect(mapStateToProps, {
updateSearchEmail,
searchEmail
})(EmailSearch);
|
var express = require('express');
var router = express.Router();
//1. get the mongo node module
const mongodb = require('mongodb')
//2. create a mongodbclient
const mongoClient = mongodb.MongoClient;
// console.log(mongoClient)
//3. create a url to our mongo server
const mongoURL = `mongodb://localhost:27017`
const databaseName = 'electric';
let db; //make a global var so that all routes can use it.
//4. connect express to mongo db.
mongoClient.connect(mongoURL,{ useNewUrlParser: true },(err, database)=>{
if(err) throw err;
db = database.db(databaseName);
// console.log('db',db )
console.log('Connected to mongo!')
})
/* GET home page. */
router.get('/', function(req, res, next) {
db.collection('students').find().toArray((err,results)=>{
if(err) throw err;
console.log(results)
res.render('index', { title: 'Express', students: results });
})
});
router.post('/form_submit', (req,res,next)=>{
db.collection('students').insertOne({
name: req.body.student
})
res.redirect('/')
})
module.exports = router;
|
/* 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 esversion: 6 */
'use strict';
const debug = require('debug')('vxs:tg');
let os = require('os');
let fork = require('child_process').fork;
const _ = require('lodash');
const path = require('path');
let fs = require('fs-extra');
const Q = require('q');
const glob = Q.nfbind(require('glob'));
const eventEmitter = require('../../cds/uploadArchive.js').eventEmitter;
let gutils = require('./generatorUtils.js');
const MemoryManager = require('./MemoryManager.js');
let generatorInfo = null;
let tgConfig = {};
let forks = [];
module.exports.init = (appSettings) => {
if (os.platform() === 'win32' || os.platform() === 'linux') {
tgConfig = gutils.validateConfig(appSettings.targetGenerator);
if (!tgConfig.model.disable || !tgConfig.image.disable) {
generatorInfo = { guid: require('../guidHandler.js').load() };
generatorInfo.model = !tgConfig.model.disable;
generatorInfo.image = !tgConfig.image.disable;
(new MemoryManager(tgConfig.maxMemory, tgConfig.memoryManagerInterval)).monitor(forks);
eventEmitter.on('post-unzip', eventData => runGenerator(eventData));
debug('mtg enabled? %s itg enabled? %s', generatorInfo.model, generatorInfo.image);
return;
}
} else {
console.warn('target generation is not supported on the current platform');
}
generatorInfo = null;
tgConfig = {};
forks = [];
};
function runGenerator(eventData = {}) {
const eventDataNoReq = _.omit(eventData, ['req']);
debug("In runPackager()", eventDataNoReq);
if (generatorInfo === null || eventData.store !== 'projects') { return; }
const resourceCache = path.join(eventData.newProjectDir, 'WEB-INF/resource_cache/');
return glob('**/*.info.json', {cwd: resourceCache})
.then(files => getFileInfos(files, {cwd: resourceCache, root: eventData.newProjectDir}))
.then(fileInfos => {
if (fileInfos.model.length > 0 || fileInfos.image.length > 0) {
return forkPackager(eventDataNoReq, eventData.req, fileInfos)
.then(() => ({rebuildCompressedFile: true}));
}
});
}
function getFileInfos(files = [], options) {
return Promise.all(files.map(file => getFileInfo(file, options)))
.then(fileInfos => {
const fileInfosByType = { model: [], image: [] };
fileInfos.forEach(fileInfo => fileInfo && fileInfosByType[fileInfo.type].push(fileInfo));
return fileInfosByType;
});
}
function getFileInfo(file = '', options) {
if ((file.startsWith('mtg') && !tgConfig.model.disable) ||
(file.startsWith('itg') && !tgConfig.image.disable)) {
const type = file.startsWith('itg') ? 'image' : 'model';
return fs.readJson(path.join(options.cwd, file))
.then(json => getFileStats(json.filePath, options.root, path.basename(file)))
.then(stats => validateSizeAndGetInfo(stats, type));
}
}
function getFileStats(srcFilePath, root, infoFileName) {
const filePath = path.join(root, srcFilePath);
if (filePath === root || !filePath.startsWith(root)) {
throw gutils.newError('Invalid file path in ' + infoFileName);
}
const fileName = path.basename(filePath);
return fs.stat(filePath)
.then(stats => { stats.filename = fileName; return stats; }, err => {
console.error('An error occurred while calculating file stats for', fileName, err);
const maskedError = new Error('An error occurred while calculating file stats for ' + fileName);
maskedError.code = err.code;
throw maskedError;
});
}
function validateSizeAndGetInfo(stats, type) {
const size = type === 'image' ? tgConfig.image.maxImageSize : tgConfig.model.maxModelSize;
if (stats.size > size) {
throw gutils.newError(type + ' size exceeds max allowed for target generation', 413);
}
return {file: stats.filename, size: stats.size, type: type};
}
function forkPackager(eventData = {}, request, fileInfos) {
const startTime = process.hrtime();
const processMetadata = {requestUser: request.user, fileInfos, startTime, progress: [],
project: path.basename(eventData.existingProjectDir || eventData.newProjectDir)};
const genInfo = _.defaultsDeep({}, generatorInfo);
genInfo.model = genInfo.model && fileInfos.model.length > 0;
genInfo.image = genInfo.image && fileInfos.image.length > 0;
const deferred = Q.defer();
const defaultRequestTimeout = request.app.settings.defaultRequestTimeout;
debug('Request timeout %s ms', defaultRequestTimeout);
validateForkCount();
deferred.packager = fork(path.join(__dirname, './generator.js'));
deferred.packager.__tgMetadata__ = processMetadata;
const settle = settleFork(deferred);
deferred.packager.on('error', err => settle({code: 2, reason: err}));
deferred.packager.on('exit', (code, signal) => settle({code, signal}));
deferred.packager.on('message', message => (message && message.type === 'info') ?
processMetadata.progress.push(message.progress) : settle(message));
forks.push(deferred.packager);
debug('active target generation forks', forks.length);
deferred.packager.send({eventData, generatorInfo: genInfo});
adjustRequestTimeout(request, defaultRequestTimeout);
deferred.killSwitch = createKillSwitch(deferred.packager, defaultRequestTimeout, request._uploadUnzipTime);
return deferred.promise.finally(() => {
request._uploadTgTime = gutils.hrTimeToMs(process.hrtime(startTime)).toFixed(0);
debug('target generation time: %s ms', request._uploadTgTime);
});
}
function settleFork(deferred) {
return (message = {code:0}) => {
try {
if (deferred.killSwitch) {
clearTimeout(deferred.killSwitch);
deferred.killSwitch = null;
}
let whyKill = {};
if (deferred.packager) {
try {
if (!deferred.packager.killed) { deferred.packager.disconnect(); }
} finally {
const index = forks.indexOf(deferred.packager);
if (index > -1) { forks.splice(index, 1); }
whyKill = deferred.packager.whyKill || whyKill;
deferred.packager = null;
}
}
if (deferred.promise.isPending()) {
let error = null;
if (message.signal === 'SIGTERM') {
error = gutils.newError((whyKill.reason || '') +
' target generation process terminated', whyKill.statusCode || 413);
} else if (message.code > 0 || message.signal) {
error = errorFromReason(message.reason) ||
new Error('target generation error ' + JSON.stringify(message));
}
if (error) { deferred.reject(error); } else { deferred.resolve(); }
} else {
debug('promise settled. processing skipped for', message);
}
} catch (e) {
deferred.reject(e);
}
};
}
function errorFromReason(reason) {
if (reason) {
let error = new Error(reason.message);
if (reason.stack) { error.stack = reason. stack; }
if (reason.name) { error.name = reason.name; }
return error;
}
}
function validateForkCount() {
if (forks.length >= tgConfig.maxTasks) {
throw gutils.newError('Maximum target generation process forks exceeded. Retry later.', 429);
}
}
function adjustRequestTimeout(request, defaultRequestTimeout) {
if (tgConfig.timeout === 0 || tgConfig.timeout > defaultRequestTimeout) {
const timeout = tgConfig.timeout || Number.MAX_SAFE_INTEGER;
debug('changing request timeout to %s ms', timeout);
request.setTimeout(timeout);
}
}
function createKillSwitch(forProcess, defaultTimeout, unzipTime) {
let killSwitch = null;
if (tgConfig.timeout !== 0) {
let killInTime = tgConfig.timeout < 0 ? defaultTimeout : tgConfig.timeout;
killInTime = killInTime - unzipTime - tgConfig.timeoutDelta;
killSwitch = setTimeout(whyKill => gutils.killTree(forProcess, whyKill), killInTime, {reason: 'long running', statusCode: 413});
debug('kill switch will trigger in %s ms', killInTime);
}
return killSwitch;
}
module.exports.capabilitiesMdw = function capabilitiesMdw(req, res) {
if (generatorInfo) {
req.params.capability = (req.params.capability || '').toLowerCase();
if (!tgConfig.model.disable && req.params.capability === 'mtg') {
return res.json({
result: true,
maxModelSize: tgConfig.model.maxModelSize,
maxPolygons: tgConfig.model.maxPolygons
});
} else if (!tgConfig.image.disable && req.params.capability === 'itg') {
return res.json({
result: true,
maxImageSize: tgConfig.image.maxImageSize
});
}
}
return res.json({result: false});
};
|
import React, { Component } from 'react'
import { Text, View, StyleSheet } from 'react-native'
export default class DoorStatus extends Component {
render() {
return (
<View style={styles.textContent}>
<Text style={styles.alarmText}> { this.props.text } </Text>
{
this.props.status ?
<Text style={styles.locked}> Status: Locked </Text> :
<Text style={styles.unlocked}> Status: Unlocked </Text>
}
</View>
)
}
}
const styles = StyleSheet.create({
textContent: {
paddingVertical: 10
},
alarmText: {
fontSize: 24,
fontWeight: '300',
color: '#333333'
},
locked: {
fontSize: 16,
fontWeight: '300',
color: '#006ac6'
},
unlocked: {
fontSize: 16,
fontWeight: '300',
color: 'red'
}
})
|
/**
* localStorage Helper
* Helper class to create object store in localStorage and do basic create, read, update, delete operations
* @returns {{createDataStore: Function, set: Function, get: Function, remove: Function}}
* @author Suman Paul
*/
var lsd = (function () {
'use strict';
/**
*
* @param objectStore
* @param id
*/
function remove(objectStore, id) {
var os = getTable(objectStore);
var uid = os.map[id];
var collections = getTables();
localStorage.removeItem(uid);
delete os.map[id];
collections[objectStore] = os;
localStorage.tables = JSON.stringify(collections);
}
/**
*
* @param objectStore
* @param dataObj
* @returns {*}
*/
function store(objectStore, dataObj) {
var id = '';
var table = getTable(objectStore);
var data = {};
if (data.hasOwnProperty('id')) {
var dataId = data.id;
var storedData = read(objectStore, dataId);
id = table.map[dataId];
for (var key in data) {
if (data.hasOwnProperty(key)) {
storedData[key] = data[key];
}
}
data = storedData;
//data augmentation
data.modified = new Date();
} else {
var needle = table.needle;
id = randomUUID();
data.local = {};
data.db = {};
//data augmentation
data.local.created = new Date();
data.local.modified = new Date();
data.local.id = needle;
data.db = dataObj;
//table augmentation
table.needle = needle + 1;
table.map[needle] = id;
var tables = getTables();
tables[objectStore] = table;
localStorage.tables = JSON.stringify(tables);
}
var putDataInLS = putData(id, data);
if(putDataInLS){
return data;
} else {
return false;
}
}
/**
*
* @param objectStore
* @param id
* @returns {*}
*/
function read(objectStore, id) {
var os = getTable(objectStore);
if (id) {
var uid = os.map[id];
if (typeof uid !== 'undefine') {
if (localStorage[uid]) {
return JSON.parse(localStorage[uid]);
} else {
return false;
}
} else {
return false;
}
} else {
var data = [];
var mapList = os.map;
for (var key in mapList) {
data.push(JSON.parse(localStorage[mapList[key]]));
}
return data;
}
}
/**
* Initialize DB
* @returns {boolean}
*/
function initDB() {
if (!getTables()) {
localStorage.tables = '{}';
return true;
}
}
/**
* get all tables
* @returns {*}
*/
function getTables() {
if (localStorage.tables) {
return JSON.parse(localStorage.tables);
} else {
return false;
}
}
/**
* get a particular table
* @param name
* @returns {*}
*/
function getTable(name) {
var table = getTables()[name];
if (table) {
return table;
} else {
return false;
}
}
/**
* Create new table
* @param name
* @param schema
* @returns {boolean}
*/
function createTable(name, schema) {
if (!getTable(name)) {
initDB();
var tables = getTables();
var tableProps = {
needle: 1,
created: new Date(),
map: {}
};
tables[name] = tableProps;
putData('tables', tables);
}
return true;
}
/**
* write in localStorage
* @param key
* @param value
* @returns {boolean}
*/
function putData(key, value) {
localStorage[key] = JSON.stringify(value);
return true;
}
/**
*
* @param key
* @returns {*}
*/
function getData(key) {
return JSON.parse(localStorage[key]);
}
/**
* array exist
* @param val
* @returns {boolean}
*/
Array.prototype.exists = function (val) {
for (var i = 0; i < this.length; i++) {
if (this[i] === val) {
return true;
} else {
return false;
}
}
};
/**
* Create and return a "version 4" RFC-4122 UUID string.
*
* randomUUID.js
* This software is made available under the terms of the Open Software License
* v3.0 (available here: http://www.opensource.org/licenses/osl-3.0.php )
* The latest version of this file can be found at: http://www.broofa.com/Tools/randomUUID.js
* For more information, or to comment on this, please go to: http://www.broofa.com/blog/?p=151
*
* @author Robert Kieffer
* @copyright 2008
* @license This software is made available under the terms of the Open Software License v3.0 (available here: http://www.opensource.org/licenses/osl-3.0.php)
* @version 1.0
* @access private
* @api private
* @return {String} a "version 4" RFC-4122 UUID string
*/
function randomUUID() {
var s = [],
itoh = '0123456789ABCDEF';
// Make array of random hex digits. The UUID only has 32 digits in it, but we
// allocate an extra items to make room for the '-'s we'll be inserting.
var i, j;
for (i = 0; i < 36; i++) s[i] = Math.floor(Math.random() * 0x10);
// Conform to RFC-4122, section 4.4
s[14] = 4; // Set 4 high bits of time_high field to version
s[19] = (s[19] & 0x3) | 0x8; // Specify 2 high bits of clock sequence
// Convert to hex chars
for (j = 0; j < 36; j++) {
s[j] = itoh[s[j]];
}
// Insert '-'s
s[8] = s[13] = s[18] = s[23] = '-';
return s.join('');
}
return {
createDataStore: createTable,
set: store,
get: read,
remove: remove
};
}).call(this);
|
// Code for the main app page (locations list).
// This is sample code to demonstrate navigation.
// You need not use it for final app.
function viewLocation(locationName)
{
// Save the desired location to local storage
localStorage.setItem(APP_PREFIX + "-selectedLocation", locationName);
// And load the view location page.
location.href = 'viewlocation.html';
}
for (i=0;i <= LocationWeatherCache.length();i++){
//i ripped the example icons and I'm adding them to the list but with the values changing based on what entry it's for
//not really sure how the locationWeatherCache actually works but i think its this
var locationObject = LocationWeatherCache.locationAtIndex(i)
var addList = ""
//it should change the ids of the buttons as well so we can access them later
//also the whole entry has an id so it can be removed (not sure how well that will work)
//might be better to make this a function called update or something that first clears the list
//but the id is still good in case it needs an update or something (the original didnt include it)
addList +='<li class="mdl-list__item mdl-list__item--two-line" id="'+i+'" onclick="viewLocation(' + i + ');">\
<span class="mdl-list__item-primary-content">\
<img class="mdl-list__item-icon" id="icon' + i + '" src="images/loading.png" class="list-avatar" />+
//not sure how well this will work but ideally it accesses the location object from the cache
'<span>'+ locationObject.nickname +'</span>\
<span id="weather'+ i + '" class="mdl-list__item-sub-title">Weather summary</span>\
</span>\
</li>'
Document.getElementById('locationList').appendChild(addList)
}
|
function ResumenEvent(div){
this.div = div;
this.pathHtml = "html/resumen/resumen.html";
}
ResumenEvent.prototype.draw = function(){
//$.get(this.pathHtml,{},$.proxy(this.renderView,this));
//$("#viewContainer").get(this.pathHtml,{},$.proxy(this.renderView,this));
//$("#viewContainer").html(this.pathHtml);
$("#viewContainer").load(this.pathHtml);
};
ResumenEvent.prototype.renderView = function(){
};
ResumenEvent.init = function(){
var resumenEvent = new ResumenEvent("resumenEvent");
resumenEvent.draw();
}
|
const repository = require("./repository.js");
const userRepository = require("./user_repository");
const Activity = require("../classes/activity.js");
const ObjectID = require("mongodb").ObjectID;
function getAll(
activityCollection,
userCollection,
charityCollection,
rewardCollection
) {
return repository.getAll(activityCollection).then((activities) => {
const newActivities = activities.map((activity) => {
return fillInActivity(
activity,
userCollection,
charityCollection,
rewardCollection
);
});
return Promise.all(newActivities);
});
}
function getOne(
activityCollection,
userCollection,
charityCollection,
rewardCollection,
id
) {
return repository.getOne(activityCollection, id).then((activity) => {
return fillInActivity(
activity,
userCollection,
charityCollection,
rewardCollection
);
});
}
function save(activityCollection, activity) {
newActivity = new Activity(
activity.title,
activity.charity,
activity.description,
activity.duration,
activity.location,
activity.points,
activity.datetime
);
return repository.save(activityCollection, newActivity);
}
function update(
activityCollection,
userCollection,
charityCollection,
rewardCollection,
id,
updateData
) {
return activityCollection
.updateOne({ _id: ObjectID(id) }, { $set: updateData })
.then((data) => {
return getOne(
activityCollection,
userCollection,
charityCollection,
rewardCollection,
id
);
});
}
function destroy(
activityCollection,
userCollection,
charityCollection,
rewardCollection,
id
) {
return activityCollection.deleteOne({ _id: ObjectID(id) }).then(() => {
return getAll(
activityCollection,
userCollection,
charityCollection,
rewardCollection
);
});
}
// Helpers
function fillInActivity(
activity,
userCollection,
charityCollection,
rewardCollection
) {
const charityPromise = getCharityfromId(activity.charity, charityCollection);
const usersPromises = getAllUsersApplied(
activity,
userCollection,
rewardCollection
);
const promises = [charityPromise, ...usersPromises];
return Promise.all(promises).then((data) => {
const charity = data.shift();
const applicants = data;
const newActivity = new Activity(
activity.title,
charity,
activity.description,
activity.duration,
activity.location,
activity.points,
activity.datetime,
activity.applications
);
newActivity._id = activity._id;
newActivity.applications.forEach((application, index) => {
application.user = applicants[index];
});
return newActivity;
});
}
function getCharityfromId(id, charityCollection) {
return repository.getOne(charityCollection, id);
}
const getAllUsersApplied = (activity, userCollection, rewardCollection) => {
return activity.applications.map((application) => {
return createNewUser(userCollection, rewardCollection, application.user);
});
};
function createNewUser(userCollection, rewardCollection, applicationId) {
return userRepository.getOne(userCollection, rewardCollection, applicationId);
}
module.exports = { getAll, getOne, save, update, destroy };
|
import React from 'react';
import * as Sentry from '@sentry/browser';
import './App.css';
function methodDoesNotExist(){
// eslint-disable-next-line no-throw-literal
try{
var err = 'Sentry test';
throw err;
}catch{
//nothing
Sentry.captureException(err);
console.log("DONE!!");
}
};
// function App() {
// return (
// <div className="App">
// {/* <header className="App-header">
// <img src={logo} className="App-logo" alt="logo" />
// <p>
// Edit <code>src/App.js</code> and save to reload.
// </p>
// <a
// className="App-link"
// href="https://reactjs.org"
// target="_blank"
// rel="noopener noreferrer"
// >
// Learn React
// </a>
// </header> */}
// <button onClick={methodDoesNotExist}>Break the world</button>;
// <p>Form below</p>
// <form>
// NAME: <input type="text" id="name" placeholder="NAME" /> <br/>
// Email: <input type="email" id="email" placeholder="EMAIL" /><br/>
// COMMENT: <input type="text" id="comments" placeholder="COMMENT"/><br/>
// <button id="submit" onClick={s}>Send-TO-Sentry</button>
// </form>
// </div>
// );
// }
function sendToSentry(){
// create a new XMLHttpRequest
var xhr = new XMLHttpRequest()
// get a callback when the server responds
// xhr.addEventListener('load', () => {
// // update the state of the component with the result here
// console.log(xhr.responseText)
// })
// open the request with the verb and the url
xhr.open('POST', 'https://sentry.io/api/0/projects/imi_org_slug/imi_proj_slug/user-feedback/');
xhr.setRequestHeader('Authorization','Bearer 1c0932a0af29448fb969324713fac8a7e09901c042e54c1f90a6475017e9cda8');
xhr.setRequestHeader('Content-Type', 'application/json');
xhr.setRequestHeader('Access-Control-Allow-Headers','*');
xhr.setRequestHeader('Access-Control-Allow-Origin', '*');
// send the request
xhr.send(JSON.stringify({
"comments": "CORS-ISSUSE'S",
"email":"abhinav@abhinav.com",
"event_id":"213cb4911fb5461191e1b97dac6aa306",
"name":"singh"
}))
console.log(xhr.responseText);
console.log("done");
};
class App extends React.Component{
render(){
return(
<div className="App">
<button onClick={methodDoesNotExist}>Break the world</button>;
<p>Form below</p>
<form>
NAME: <input type="text" id="name" placeholder="NAME" /> <br/>
Email: <input type="email" id="email" placeholder="EMAIL" /><br/>
COMMENT: <input type="text" id="comments" placeholder="COMMENT"/><br/>
<button type="button" id="submit" onClick={sendToSentry}>Send-TO-Sentry</button>
</form>
</div>
)
}
}
export default App;
|
'use strict';
let UserListItem = Reach.component('User.UserListItem');
let { Table } = require('reactabular');
let { MenuItem, LeftNav, Styles } = require('material-ui');
let { Colors, Spacing, Typography } = Styles;
let columns = [
{
property : 'id',
header : 'Id'
},
{
property : 'role',
header : 'Role'
},
{
property : 'firstName',
header : 'First Name'
},
{
property : 'lastName',
header : 'Last Name'
},
{
property : 'email',
header : 'Email'
},
{
property : 'facebook',
header : 'Facebook'
},
{
property : 'twitter',
header : 'Twitter'
},
{
property : 'linkedin',
header : 'LinkedIn'
},
{
property : 'stripeId',
header : 'Stripe'
},
{
property : 'createdAt',
header : 'Created At'
},
{
property : 'updatedAt',
header : 'Updated At'
}
];
export default class UsersList extends React.Component {
getStyles() {
return {
fontSize : '14px',
color : Typography.textFullBlack,
lineHeight : Spacing.desktopKeylineIncrement + 'px',
fontWeight : Typography.fontWeightLight,
backgroundColor : Colors.white,
paddingLeft : Spacing.desktopGutter,
paddingTop : '0px',
marginBottom : '0px'
};
}
render() {
// let users = this.props.users.map(function (user) {
// if (user._key) {
// return (<UserListItem key={user._key} user={user} />);
// }
// return (<UserListItem key={user.id} user={user} />);
// });
return (
<Table columns={ columns } data={ this.props.users } />
);
}
}
|
import Vue from 'vue'
const v = new Vue()
v.loadData = 'e_load_data'
v.showCreateDialog = 'e_show_create_dialog'
v.showEditDialog = 'e_show_edit_dialog'
v.loadDataset = 'e_load_dataset'
Vue.prototype.$bus = v
|
import React, { useState,useEffect } from "react";
import { getPractitioners } from "../services";
import PractitionerCard from "./PractitionerCard";
import ErrorBoundary from "./ErrorBoundary";
import './Practitioner.css'
export const flattenPractitionerObj = (response) => {
return (response.data.entry || []).map((item) => {
const name = item.resource.name || [];
return {
id: item.resource.id,
name: `${((name[0] || {}).given || []).join(" ")} ${
(name[0] || {}).family
}`,
gender: item.resource.gender,
dob: item.resource.birthDate,
photo:
"https://cdn.pixabay.com/photo/2016/08/08/09/17/avatar-1577909_1280.png",
};
});
};
function Practitioner(){
const [practitioners,setPractioners] = useState([])
const [loading, setLoading] = useState(true)
useEffect(()=>{
setLoading(true)
getPractitioners().then((res) => {
setPractioners(flattenPractitionerObj(res));
setLoading(false)
});
},[])
let deletePractitioner = (practitioners,id) =>{
let filtered = practitioners.filter((value)=>{
return value.id!==id
})
setPractioners(filtered)
}
if(!loading){
return (
<main>
<div className="slider">
{practitioners.map((practitioner,i)=>{
return (
<a href={"#"+practitioner.id}>{i+1}</a>
)
})}
<div className={"slides"}>
{practitioners.map((practitioner)=>{
practitioner.del = (id)=>{
deletePractitioner(practitioners,id)
}
return <PractitionerCard
id={practitioner.id}
name={practitioner.name}
gender={practitioner.hender}
dob={practitioner.dob}
del={practitioner.del}
photo={practitioner.photo}
key={practitioner.id}
/>
})}
</div>
</div>
</main>
);
}
else{
return (
<main>
<h1>Loading...</h1>
</main>
)
}
}
export default Practitioner;
|
var express = require('express');
var router = express.Router();
var books = require('../resources/books');
let Books = require('../models/books');
router.get('/add', function (req, res, next) {
res.render('addBooks', {
title: 'Add book',
});
});
router.post('/save', function(req, res, next) {
//console.log('save function,,,,,',req.body)
const book = new Books(req.body);
let promise = book.save();
promise.then(() => {
console.log('Book added')
res.redirect('/');
})
//books.push({...req.body, id: `00${books.length + 1}`})
});
router.get('/remove/:_id', function (req, res) {
Books.remove({ _id: req.params._id }, function() {
res.redirect('/');
})
//console.log(req.params.id);
// books.splice(req.params.index, 1);
//res.redirect('/');
});
router.get('/edit/:_id', function (req, res) {
Books.findOne({_id: req.params._id}, function(err, book){
res.render('editBooks',{title: 'Edit book', book: book});
})
// const book = books.find((book) => book._id === req.params._id);
// res.render('editBooks', {
// title: 'Edit book',
// book
// });
});
//findOneandUpdate
router.post('/saveEdit/:_id', function(req,res){
Books.findOneAndUpdate({ _id: req.params._id }, { $set: req.body }, function(err, book) {
console.log(book);
res.redirect('/');
})
// books.splice(books.findIndex(book => book._id === req.params._id), 1, {...req.body, _id: req.params._id});
//{} .splice ma {} chai replace garna use gareko, splice add/remove garna use huncha hai
//books.splice(req.params._id, 1, {...req.body, _id: req.params._id});
//you can do also do // let updatebook = books.findIndex(book => book._id === req.params._id
});
// if separate object banayera garney ho vaney
// var currentbBoks suppose garera gara ho
// var currentBookindex = -1;
// books.some(function(books, i) {
// if (book._id == req.params._id) {
// currentBookindex = i;
// return true;
// }
module.exports = router;
|
const express = require('express');
const postController = require('../controllers/post.controller');
const postRouter = express.Router();
const activeController = require('../controllers/active.controller');
postRouter.post('/', (req,res) => {
const { name, title, image, content , author} = req.body;
activeController.create({})
.then(activeCreated => {
postController.create({ name, title, image, content , author, active : activeCreated._id })
.then(postCreated => {
res.json({
success: true,
data: postCreated
})
})
.catch(error => {
res.json({
success: false,
data: error
})
})
})
.catch(err => {
console.log(err);
})
})
// read all
postRouter.get('/', (req,res) => {
postController.getList()
.then(listPost => {
res.json({
success: true,
data: listPost
});
})
.catch(error => {
res.json({
success: false,
data: error
});
})
})
// read one
postRouter.get('/:_id', (req,res) => {
const { _id } = req.params;
postController.getById({ _id })
.then(postDetail => {
res.json({
success: true,
data: postDetail
});
})
.catch(error => {
res.json({
success: false,
data: error
});
})
})
//update
postRouter.put('/:_id', (req,res) => {
const {_id} = req.params;
const { name, title, imaga, content} = req.body;
postController.update({_id}, { name, title, imaga, content})
.then(postUpdated => {
res.json({
success: true,
data: postUpdated
});
})
.catch(error => {
res.json({
success: false,
data: error
})
})
})
// deletes
postRouter.delete('/:_id', (req,res) => {
const _id = req.params;
postController.remove({_id})
.then(() => {
res.json({
success: true
});
})
.catch(() => {
res.json({
success: false
})
})
})
module.exports = postRouter;
|
function _textureParameter(name, channel = true, vertexColor = true) {
const result = {};
result[`${name}Map`] = 'texture';
result[`${name}MapTiling`] = 'vec2';
result[`${name}MapOffset`] = 'vec2';
result[`${name}MapRotation`] = 'number';
result[`${name}MapUv`] = 'number';
if (channel) {
result[`${name}MapChannel`] = 'string';
if (vertexColor) {
result[`${name}VertexColor`] = 'boolean';
result[`${name}VertexColorChannel`] = 'string';
}
}
return result;
}
const standardMaterialParameterTypes = {
name: 'string',
chunks: 'chunks',
mappingFormat: 'string',
_engine: 'boolean', // internal param for engine-only loading
ambient: 'rgb',
ambientTint: 'boolean',
..._textureParameter('ao'),
..._textureParameter('aoDetail', true, false),
aoDetailMode: 'string',
diffuse: 'rgb',
diffuseTint: 'boolean',
..._textureParameter('diffuse'),
..._textureParameter('diffuseDetail', true, false),
diffuseDetailMode: 'string',
specular: 'rgb',
specularTint: 'boolean',
..._textureParameter('specular'),
occludeSpecular: 'enum:occludeSpecular',
specularityFactor: 'number',
specularityFactorTint: 'boolean',
..._textureParameter('specularityFactor'),
useMetalness: 'boolean',
metalness: 'number',
enableGGXSpecular: 'boolean',
anisotropy: 'number',
metalnessTint: 'boolean',
..._textureParameter('metalness'),
useMetalnessSpecularColor: 'boolean',
conserveEnergy: 'boolean',
shininess: 'number',
gloss: 'number',
glossInvert: 'boolean',
..._textureParameter('gloss'),
clearCoat: 'number',
..._textureParameter('clearCoat'),
clearCoatGloss: 'number',
clearCoatGlossInvert: 'boolean',
..._textureParameter('clearCoatGloss'),
clearCoatBumpiness: 'number',
..._textureParameter('clearCoatNormal', false),
useSheen: 'boolean',
sheen: 'rgb',
sheenTint: 'boolean',
..._textureParameter('sheen'),
sheenGloss: 'number',
sheenGlossTint: 'boolean',
sheenGlossInvert: 'boolean',
..._textureParameter('sheenGloss'),
fresnelModel: 'number',
emissive: 'rgb',
emissiveTint: 'boolean',
..._textureParameter('emissive'),
emissiveIntensity: 'number',
..._textureParameter('normal', false),
bumpiness: 'number',
// normalMapFactor: 'number', // TODO rename bumpiness to normalMapFactor
..._textureParameter('normalDetail', false),
normalDetailMapBumpiness: 'number',
..._textureParameter('height', true, false),
heightMapFactor: 'number',
alphaToCoverage: 'boolean',
alphaTest: 'number',
alphaFade: 'number',
opacity: 'number',
..._textureParameter('opacity'),
opacityFadesSpecular: 'boolean',
reflectivity: 'number',
refraction: 'number',
refractionTint: 'boolean',
..._textureParameter('refraction'),
refractionIndex: 'number',
thickness: 'number',
thicknessTint: 'boolean',
..._textureParameter('thickness'),
attenuation: 'rgb',
attenuationDistance: 'number',
useDynamicRefraction: 'boolean',
sphereMap: 'texture',
cubeMap: 'cubemap',
cubeMapProjection: 'number',
cubeMapProjectionBox: 'boundingbox',
useIridescence: 'boolean',
iridescence: 'number',
iridescenceTint: 'boolean',
..._textureParameter('iridescence'),
iridescenceThicknessTint: 'boolean',
iridescenceThicknessMin: 'number',
iridescenceThicknessMax: 'number',
iridescenceRefractionIndex: 'number',
..._textureParameter('iridescenceThickness'),
..._textureParameter('light'),
depthTest: 'boolean',
depthFunc: 'enum:depthFunc',
depthWrite: 'boolean',
depthBias: 'number',
slopeDepthBias: 'number',
cull: 'enum:cull',
blendType: 'enum:blendType',
shadingModel: 'enum:shadingModel',
useFog: 'boolean',
useLighting: 'boolean',
useSkybox: 'boolean',
useGammaTonemap: 'boolean',
envAtlas: 'texture',
twoSidedLighting: 'boolean'
// nineSlicedMode
// pixelSnap
// forceUv1
// occludeDirect
// occludeSpecularIntensity
// fastTbn
// normalizeNormalMap
// msdfMap
// msdfMapChannel
// msdfMapUv
// msdfMapTiling
// msdfMapOffset
// msdfTextAttribute
// msdfVertexColor
// msdfVertexColorChannel
};
const standardMaterialTextureParameters = [];
for (const key in standardMaterialParameterTypes) {
const type = standardMaterialParameterTypes[key];
if (type === 'texture') {
standardMaterialTextureParameters.push(key);
}
}
const standardMaterialCubemapParameters = [];
for (const key in standardMaterialParameterTypes) {
const type = standardMaterialParameterTypes[key];
if (type === 'cubemap') {
standardMaterialCubemapParameters.push(key);
}
}
const standardMaterialRemovedParameters = {
aoMapVertexColor: 'boolean',
diffuseMapTint: 'boolean',
diffuseMapVertexColor: 'boolean',
emissiveMapTint: 'boolean',
emissiveMapVertexColor: 'boolean',
glossMapVertexColor: 'boolean',
metalnessMapVertexColor: 'boolean',
opacityMapVertexColor: 'boolean',
specularAntialias: 'boolean',
specularMapTint: 'boolean',
specularMapVertexColor: 'boolean'
};
export {
standardMaterialParameterTypes,
standardMaterialCubemapParameters,
standardMaterialTextureParameters,
standardMaterialRemovedParameters
};
|
const data = [
{
osname: "Ubuntu",
sum: 60, "__typename": "SessionsByOs"
},
{
osname: "Mac",
sum: 20,
__typename: "SessionsByOs"
},
{
osname: "Windows",
sum: 80,
__typename: "SessionsByOs"
}
]
export default data
|
//Purpose: Survey Engine Design
//Author: Nergui Badarch
//Date: 06/21/2014
function Question(question) {
this.question = question;
}
Question.prototype.putQuestion = function(counter){
return "<span name='ans"+counter+"' id='ans"+counter+"'>"+this.question+"</span>";
};
Question.prototype.generate = function(counter){
return "<input type='text' name='ans"+counter+"' id='ans"+counter+"'>";
//alert("blank");
};
function QuestionRadioButton(question,value) {
Question.call(this, question);
this.value = value;
};
QuestionRadioButton.prototype = Object.create(Question.prototype);
QuestionRadioButton.prototype.constructor = QuestionRadioButton;
QuestionRadioButton.prototype.generate = function(counter){
// alert(this.value+"Radio");
var sb = new StringBuilder();
var valueArray=splitByComma(this.value);
for(var i = 0; i < valueArray.length; i++)
{
sb.append("<input type='radio' name='ans"+counter+"' id='ans"+counter+"' value='"+valueArray[i]+"'>"+valueArray[i]);
}
return sb.toString();
};
function QuestionCheckboxButton(question,value) {
Question.call(this, question);
this.value = value;
};
QuestionCheckboxButton.prototype = Object.create(Question.prototype);
QuestionCheckboxButton.prototype.constructor = QuestionCheckboxButton;
QuestionCheckboxButton.prototype.generate = function(counter){
var sb = new StringBuilder();
var valueArray=splitByComma(this.value);
for(var i = 0; i < valueArray.length; i++)
{
sb.append("<input type='checkbox' name='ans"+counter+"' id='ans"+counter+"' value='"+valueArray[i]+"'>"+valueArray[i]);
}
return sb.toString();
};
function QuestionDropdown(question,value) {
Question.call(this,question);
this.value = value;
};
QuestionDropdown.prototype = Object.create(Question.prototype);
QuestionDropdown.prototype.constructor = QuestionDropdown;
QuestionDropdown.prototype.generate = function(counter){
var valueArray=splitByComma(this.value);
var sb = new StringBuilder();
sb.append("<select name='ans"+counter+"' id='ans"+counter+"' >");
for(var i = 0; i < valueArray.length; i++)
{
sb.append("<option value='"+valueArray[i]+"'>"+valueArray[i]+"</option>");
}
return sb.toString();
};
function splitByComma(str) {
var values = str.split(',');
for(var i = values.length; i--;) {
if(values[i] == "") {
values.splice(i, 1);
}
}
return values;
};
function StringBuilder()
{
var strings = [];
this.append = function (string)
{
string = verify(string);
if (string.length > 0) strings[strings.length] = string;
};
this.appendLine = function (string)
{
string = verify(string);
if (this.isEmpty())
{
if (string.length > 0) strings[strings.length] = string;
else return;
}
else strings[strings.length] = string.length > 0 ? "\r\n" + string : "\r\n";
};
this.clear = function () { strings = []; };
this.isEmpty = function () { return strings.length == 0; };
this.toString = function () { return strings.join(""); };
var verify = function (string)
{
if (!defined(string)) return "";
if (getType(string) != getType(new String())) return String(string);
return string;
};
var defined = function (el)
{
return el != null && typeof(el) != "undefined" && String(el) != "NaN";
};
var getType = function (instance)
{
if (!defined(instance.constructor)) throw Error("Unexpected object type");
var type = String(instance.constructor).match(/function\s+(\w+)/);
return defined(type) ? type[1] : "undefined";
};
};
|
import typescript from '@rollup/plugin-typescript'
import { terser } from 'rollup-plugin-terser'
/**
* @type {import('rollup').RollupOptions}
*/
const config = {
input: './ts/index.ts',
output: [
{
format: 'iife',
file: 'dist/global-store.js',
name: 'GlobalStore',
exports: 'named',
sourcemap: true
}
],
plugins: [typescript({
tsconfig: './tsconfig.rollup.json'
}), terser({
format: { comments: false }
})
]
}
export default config
|
export const SET_STATE = "SET_STATE";
export const ADD_BOARD = "ADD_BOARD";
export const ADD_LIST = "ADD_LIST";
export const ADD_ITEM = "ADD_ITEM";
export const DELETE_BOARD = "DELETE_BOARD";
export const DELETE_LIST = "DELETE_LIST";
export const DELETE_ITEM = "DELETE_ITEM";
export const SET_DROP_ZONE = "SET_DROP_ZONE";
export const SET_DROP_DEPTH = "SET_DROP_DEPTH";
|
/**
* PedidoController
*
* @description :: Server-side logic for managing pedidoes
* @help :: See http://sailsjs.org/#!/documentation/concepts/Controllers
*/
// ESTADOS
module.exports = {
realizarPedido:function(req,res){
Restaurante.find({where:{id:req.param('restaurante')}},{select:['horarioAtencion','horaInicio','horaFin','dias']}).then(function(restaurante){
var R=restaurante[0];
var D=new Date();
var Da=new Date("01/01/2000 "+D.getHours()+":"+D.getMinutes());
var Di=new Date("01/01/2000 "+R.horaInicio);
var Df=new Date("01/01/2000 "+R.horaFin);
if(!R.horarioAtencion || (R.dias[D.getDay()]=="true" && Da>Di && Da<Df)){
var restaurante=req.allParams();
delete restaurante.id;
if(req.param('restaurante')!=null && req.param('cliente')!=null && req.param('plato')!=null &&
req.param('cantidad')){
Pedido.create(restaurante)
.exec(function(e,o){
if(e){
res.send({success:false,titulo:"Error",contenido:"No se pudo completar la transaccion"});
}else{
Pedido.publishCreate(req.param('restaurante'),req);
res.send({success:true,titulo:"Correcto",contenido:"Pedido solicitado!",id:o.id});
}
});
}else{
res.send({success:false,titulo:"Error",contenido:"Faltan datos!"});
}
}else{
res.send({success:false,titulo:"Que lastima",contenido:"El horario no cumple para hacer pedidos!"});
}
});
},
comentar:function(req,res){
if(req.isSocket && req.method ==='POST'){
Pedido.findOne({where:{id:req.param('pedido')}}).populate(req.param('tipo')?'cliente':'restaurante').then(function(pedido){
var mensaje={tipo:req.param('tipo'),fecha:new Date(),msg:req.param('msg')};
pedido.mensajes.push(mensaje);
mensaje.id=pedido.id;
mensaje.nombre=req.param('tipo')?pedido.cliente.nombre:pedido.restaurante.nombre;
pedido.save(function(e){
Pedido.publishUpdate(req.param('pedido'),mensaje);
});
});
}else if(req.isSocket){
Pedido.watch(req.socket);
}
},
suscripcion:function(req,res){
if(req.isSocket){
Pedido.find({where:{restaurante:req.param('id')}}).exec(function(e,r){
Pedido.subscribe(req,_.pluck(r,'id'));
return res.ok();
});
}
},
suscripcionRestaurante:function(req,res){
if(req.isSocket){
Pedido.find({where:{cliente:req.param('id')}}).exec(function(e,r){
Pedido.subscribe(req,_.pluck(r,'id'));
return res.ok();
});
}
},
cancelar:function(req,res){
if(req.isSocket && req.method ==='POST'){
Pedido.findOne({where:{id:req.param('pedido')}}).then(function(pedido){
if(pedido.estado=="Pendiente" || pedido.estado=="Aprobado"){
var mensaje={tipo:req.param('tipo'),fecha:new Date(),msg:req.param('nombre')+", cancelo este pedido y dejó esta nota: "+req.param('msg')};
pedido.mensajes.push(mensaje);
pedido.estado="Cancelado";
pedido.save(function(e){
Pedido.publishUpdate(req.param('pedido'),mensaje);
return res.send({titulo:"Pedido cancelado",contenido:"Se a cancelado el pedido actual"});
});
}else{
return res.send({titulo:"Error",contenido:"El pedido no se puede cancelar"});
}
});
}else if(req.isSocket){
Pedido.watch(req.socket);
}
},
RealizadosHoy:function(req,res){
var where=req.allParams();
var D=new Date();
D=new Date(D.getFullYear(),D.getMonth(),D.getDate());
delete where.id;
where.createdAt={'>':D};
Pedido.find(where).populate('plato').then(function(pedidos){
res.send(pedidos);
});
},
RealizadosMes:function(req,res){
var where=req.allParams();
var fecha=new Date(req.param("fecha"));
var Di=new Date(fecha.getFullYear(),fecha.getMonth(),1);
var Df=new Date(fecha.getFullYear(),fecha.getMonth()+1,0);
var estado=['Enviado'];
if(req.param('sinPagar')=="false"){
estado.push('Pagado');
}
delete where.id;
delete where.fecha;
delete where.sinPagar;
where.createdAt={'>':Di,'<=':Df};
where.estado=estado;
Pedido.find(where).populate('plato').then(function(pedidos){
res.send(pedidos);
});
},
pedidoDetalle:function(req,res){
Pedido.findOne({where:{id:req.param('id')}}).populate('plato').populate('restaurante').then(function(pedido){
res.send(pedido);
});
},
aceptar:function(req,res){
modificarEstado(req,res,"Aprobado");
},
estado:function(req,res){
modificarEstado(req,res,req.param('estado'));
},
estadoMultiple:function(req,res){
modificarEstadoMultiple(req,res,req.param('estado'));
},
pendientePorPagar:function(req,res){
Pedido.find({where:{restaurante:req.param('id'),estado:"Enviado"}}).populate("cliente").populate("plato").then(function(pedidos){
var usuarios=[];
var UA;
if(pedidos.length>0){
UA=pedidos[0].cliente.id;
var usuario={nombre:pedidos[0].cliente.nombre,id:UA,deuda:0};
for (var i = 0; i < pedidos.length; i++) {
var pedido=pedidos[i];
if(pedido.cliente.id==UA){
usuario.deuda+=pedido.plato.precio*pedido.cantidad;
}else if(pedido.cliente.id!=UA){
sails.log("Termino");
usuarios.push(usuario);
UA=pedido.cliente.id
usuario={nombre:pedido.cliente.nombre,id:UA,deuda:0};
}
if(i+1==pedidos.length){
usuarios.push(usuario);
}
}
}
res.send(usuarios);
});
},
pagarPedidos:function(req,res){
Pedido.find({where:{restaurante:req.param('restaurante'),estado:"Enviado",cliente:req.param('cliente')}}).then(function(pedidos){
pagarMultiple(pedidos,function(){
res.send({success:true,titulo:"Cuenta saldada",contenido:"Se realizo el pago de todos los pedidos"});
})
});
},
detalleDeuda:function(req,res){
Pedido.find({where:{restaurante:req.param('restaurante'),estado:"Enviado",cliente:req.param('cliente')}}).populate('plato').then(function(pedidos){
res.send(pedidos);
});
},
pagarPedidosSeleccionados:function(req,res){
Pedido.find({where:{id:req.param('ids')}}).then(function(pedidos){
pagarMultiple(pedidos,function(){
res.send({success:true,titulo:"Pago realizado",contenido:"Se realizo el pago de los pedidos"});
});
});
}
};
function modificarEstado(req,res,estado){
var params=req.allParams();
delete params.estado;
Pedido.findOne(params).then(function(pedido){
pedido.estado=estado;
pedido.save().then(function(e){
if(e==null){
res.send({success:false,titulo:"Error",contenido:"Error al intentar aprobar el pedido"});
}else{
res.send({success:true});
}
});
});
}
function modificarEstadoMultiple(req,res,estado){
var params=req.allParams();
delete params.estado;
Pedido.find(params).then(function(pedidos){
for (var i = 0; i < pedidos.length; i++) {
pedidos[i].estado=estado;
pedidos[i].save();
}
res.send({success:true,titulo:"Enviados",contenido:"Pedidos enviados"});
});
}
function pagarMultiple(pedidos,callback){
for (var i = 0; i < pedidos.length; i++) {
pedidos[i].estado="Pagado";
pedidos[i].save();
}
callback();
}
|
// This is a test harness for your module
// You should do something interesting in this harness
// to test out the module and to provide instructions
// to users on how to use it by example.
var startX, startY, startLeft, startTop;
// open a single window
var window = Ti.UI.createWindow({
backgroundColor:'black'
});
// TODO: write your module tests here
var multitouch = require('ti.pinchview');
var pinchView = multitouch.createPinchView({
top:0,
left:0,
width:Ti.Platform.displayCaps.platformWidth,
height:Ti.Platform.displayCaps.platformHeight,
backgroundColor:'transparent',
minZoomValue:0.5,
maxZoomValue:1
});
var view = Ti.UI.createView({
top:0,
left:0,
width:Ti.Platform.displayCaps.platformWidth / 2,
height:Ti.Platform.displayCaps.platformHeight / 2,
backgroundColor:'white',
touchEnabled:false
});
window.add(view);
window.add(pinchView);
window.open();
pinchView.addEventListener('pinch',function(e) {
var oldWidth = view.width;
var oldHeight = view.height;
view.width = Ti.Platform.displayCaps.platformWidth / 2 * e.scale;
view.height = Ti.Platform.displayCaps.platformHeight / 2 * e.scale;
var deltaWidth = view.width - oldWidth;
var deltaHeight = view.height - oldHeight;
view.left -= deltaWidth / 2;
view.top -= deltaHeight / 2;
});
pinchView.addEventListener('multiStart', function(e) {
startX = view.left;
startY = view.top;
});
pinchView.addEventListener('multiMove',function(e) {
view.left += e.x;
view.top += e.y;
startLeft = view.left;
startTop = view.top;
});
pinchView.addEventListener('doubletap', function(e) {
Ti.API.debug("DOUBLE TAP");
});
|
const keys = require('./configs/keys')
const cors = require('cors');
const express = require('express');
const bodyParser = require('body-parser');
const rp = require('request-promise');
const passport = require('passport');
const FacebookStrategy = require('passport-facebook').Strategy;
const webpack = require('webpack');
const webpackConfig = require('./webpack.config');
const compiler = webpack(webpackConfig);
// Firebase App (the core Firebase SDK) is always required and
// must be listed before other Firebase SDKs
const firebase = require("firebase/app");
// Add the Firebase products that you want to use
// require("firebase/auth");
require("firebase/firestore");
// const admin = require('firebase-admin');
// const functions = require('firebase-functions');
var Amadeus = require('amadeus');
/* Testing Calls To REST API */
// -------------- Express Server -------------- //
/* Order */
// cookieParser
// session
// passport.initialize
// passport.session
// app.router
const app = express()
app.use(cors());
app.use(bodyParser.json()); // support json encoded bodies
app.use(bodyParser.urlencoded({ extended: true })); // support encoded bodies
app.use(passport.initialize());
app.use(passport.session());
var jsonParser = bodyParser.json();
const port = process.env.PORT || 3000
/* Firebase Setup */
const firebaseConfig = {
apiKey: keys.firebaseConfig.apiKey,
authDomain: keys.firebaseConfig.authDomain,
databaseURL: keys.firebaseConfig.databaseURL,
projectId: keys.firebaseConfig.projectId,
storageBucket: keys.firebaseConfig.storageBucket,
messagingSenderId: keys.firebaseConfig.messagingSenderId,
appId: keys.firebaseConfig.appId,
measurementId: keys.firebaseConfig.measurementId
};
// Initialize Firebase
firebase.initializeApp(firebaseConfig);
// admin.initializeApp(functions.config().firebase);
// admin.initializeApp(firebaseConfig);
let db = firebase.firestore();
// let docRef = db.collection('users').doc('alovelace');
// let setAda = docRef.set({
// first: 'Ada',
// last: 'Lovelace',
// born: 1815
// });
// let aTuringRef = db.collection('users').doc('aturing');
// let setAlan = aTuringRef.set({
// 'first': 'Alan',
// 'middle': 'Mathison',
// 'last': 'Turing',
// 'born': 1912
// });
// db.collection('users').get()
// .then((snapshot) => {
// snapshot.forEach((doc) => {
// console.log(doc.id, '=>', doc.data());
// });
// })
// .catch((err) => {
// console.log('Error getting documents', err);
// });
/* ----------------------------------------------------- */
/* Amadeus Setup */
const amadeus = new Amadeus({
clientId: keys.amadeus_key,
clientSecret: keys.amadeus_secret
});
console.log(process.env.NODE_ENV); // Debug Line
if (process.env.NODE_ENV === 'development') {
console.log('Using Hod Middleware!');
app.use(require('webpack-dev-middleware')(compiler, {
publicPath: webpackConfig.output.publicPath
}));
app.use(require('webpack-hot-middleware')(compiler));
}
app.use('/',express.static('./build'));
// -------------- Passport Serialization -------------- //
passport.serializeUser(function(user, done) {
console.log('Serializing User!');
done(null, user);
});
passport.deserializeUser(function(user, done) {
console.log('Deserializing User!');
done(null, user);
});
// -------------- API Routes -------------- //
app.get('/test',(req, res) => {
res.status(200).send({'Test': 'test data'})
})
// NOTE: //
/* When you fetch you MUST have `headers: { 'Content-Type': 'application/json' }` in order for jsonParser to do it's job */
app.post('/amadeus/lowfare',jsonParser,(req, res) => {
let options = req.body;
amadeus.shopping.flightOffers.get({
origin : options.origin,
destination : options.destination,
departureDate : options.departureDate
}).then(response => {
res.status(200).send(response)
}).catch(function (err) {
// API call failed...
console.error(err)
console.error(`Unable to reach the website: ${options.uri}`)
res.status(500).send(err)
})
})
app.post('/yelp/businesses/search',jsonParser,(req, res) => {
let body = req.body;
let options = {
method: 'GET',
uri: body.uri,
qs: {
// access_token: 'xxxxx xxxxx' // -> uri + '?access_token=xxxxx%20xxxxx'
location: body.location
},
headers: {
'User-Agent': 'Request-Promise',
'cache-control': 'no-cache',
'Authorization': ('Bearer ' + keys.yelp.APIKey)
},
json: true // Automatically parses the JSON string in the response
}
console.log('Options:',options)
// console.log('\n\n');
rp(options).then((response) => {
// console.log('Succeeded')
console.log('Data:',response)
res.status(200).send(response)
}).catch((err) => {
// console.log('Failed')
console.log('ERROR:',err)
res.status(500).send(err)
});
})
app.post('/firebase/add',jsonParser,(req,res) => {
let body = req.body;
let response = body.response
// console.log('Body:',body)
console.log('Response:',response)
console.log('User ID:',response.userID)
console.log('Adding to firebase...')
let docRef = db.collection('users').doc(response.userID);
let [first,last] = response.name.split(' ', 2);
console.log('First:',first,', Last:',last)
let setAda = docRef.set({
first: first,
last: last,
email: response.email
});
})
// -------------- OAuth Routes -------------- //
/* Configuration */
passport.use(new FacebookStrategy({
clientID: keys.facebook.app_id,
clientSecret: keys.facebook.app_secret,
callbackURL: keys.facebook.callback_url,
redirect_uri: keys.facebook.callback_url,
enableProof: true,
profileFields: ['id', 'displayName', 'photos', 'email']
},
function(accessToken, refreshToken, profile, done) {
// console.log('accessToken:',accessToken);
// console.log('refreshToken:',refreshToken);
// console.log('profile:',profile);
// console.log('done',done)
// console.log('Passport callback function reached!');
done(null, profile);
}
));
/* Facebook Auth */
app.get('/auth/facebook', passport.authenticate('facebook'), (req, res) => {
console.log('Authenticating...');
});
app.get('/auth/facebook/callback', passport.authenticate('facebook', { failureRedirect: '/login' }), (req, res) => {
console.log('Successfully Logged In! Redirecting to main route...')
res.redirect('/');
});
// -------------- Other Routes -------------- //
// app.get('/login:provider', cors(), (req, res) => {
// console.log('Request:',req.params.provider) // includes the ':'
// res.redirect('/auth/' + req.params.provider.substring(1))
// })
app.get('/login', (req, res) => {
res.render('Login!');
});
app.get('/logout', (req, res) => {
res.render('Logout!');
})
app.all('/*', function(req, res, next) {
res.header("Access-Control-Allow-Origin", "*");
next();
});
// -------------- Listening -------------- //
app.listen(port, () => {
console.log(`Example app listening on port ${port}!`)
});
|
var router = require("express").Router()
router.use(require("./account_info"))
router.use(require("./address_info"))
// api 추가 후 npm 재시작 필요!
module.exports = router
|
/* globals define, Promise */
'use strict';
define([
'lodash',
'immutable',
'dataloader',
'request',
'-/logger/index.js'
], (_, { Map, List }, DataLoader, request, logger) => function getLoader({ uri }) {
return new DataLoader(keys => {
const initial = Map({
objects: Map({}),
contexts: Map({}),
batch: List([])
});
const json = _.reduce(keys, (result, key) => {
const { prevPath, obj, ctxt, trxId, args, config } = key || {};
return result
.mergeDeep(Map({ objects: Map({}).set(`${trxId}/${prevPath}`, obj) }))
.mergeDeep(Map({ contexts: Map({}).set(trxId, ctxt) }))
.mergeDeep(Map({ batch: result.get('batch').push({ prevPath, trxId, args, config }) }));
}, initial).toJS();
return new Promise((resolve, reject) => {
request({
url: uri,
method: 'POST',
json
}, (httpError, res, body) => {
if (httpError) {
logger.error('api unable to resolve', { httpError, body, uri });
return reject(new Error('Unexpected error while resolving'));
}
const { error, data } = body || {};
if (error) {
return reject(error);
}
return resolve(data);
});
});
}, {
maxBatchSize: 128, // TODO: remove hardcoding
cache: false
});
});
|
/*
Copyright (c) 2010 Mike Desjardins
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
var EXPORTED_SYMBOLS = ["Ctx","Global","strings"];
// Current Context
var Ctx = {
user:"",
password:"",
service:"",
token:"",
tokenSecret:"",
list:"",
profile:null,
followers:[],
friendScreenNames:null,
setAccount : function(account) {
Ctx.user = account.username;
Ctx.password = account.password;
Ctx.list = null;
Ctx.service = account.service;
Ctx.token = account.token;
Ctx.tokenSecret = account.tokenSecret;
Ctx.profile = null;
}
};
// Other Global junk
var Global = {
updateTimer:null,
unread:0,
unreadDirectFrom:0,
unreadMentions:0,
mostRecentDirect:null,
mostRecentUpdate:null,
mostRecentMention:null,
previousMostRecentUpdate:null,
supportedServices: ['twitter','identi.ca'],
rawTweets: {},
resetCounters : function() {
Global.updateTimer = null;
Global.unread = 0;
Global.unreadDirectFrom = 0;
Global.unreadMentions = 0;
Global.previousMostRecentMention = null;
Global.mostRecentDirect = null;
Global.mostRecentUpdate = null;
Global.mostRecentMention = null;
Global.rawTweets = {};
}
}
function Strings() {
var stringBundleService =
Components.classes["@mozilla.org/intl/stringbundle;1"]
.getService(Components.interfaces.nsIStringBundleService);
var stringProps = stringBundleService.createBundle("chrome://buzzbird/locale/strings.properties");
this.get = function(name) {
var result = name.replace(/_/g," ");
try {
x = stringProps.GetStringFromName(name);
if (x != null && x != "") {
result = x;
}
} catch (e) { }
return result;
}
}
var strings = new Strings();
|
import React, { Component } from 'react';
import './CurrentForecast.css';
import axios from 'axios';
class CurrentForecast extends Component {
constructor (props) {
super(props);
this.state = {
currently: {},
// icons: "",
isLoading: true
};
}
componentDidMount() {
// static location for Starke, FL
const lat = '29.9441';
const lon = '-82.1098';
const url = `/forecast/location/${lat},${lon}`;
axios.get(url).then(response => {
this.setState({
currently: response.data.currently,
isLoading: false,
});
}).catch((error) => {
this.setState({
isLoading: true,
error: error,
});
});
}
// skycons() {
// const icons = new skycons({
// 'color': '#F8C471',
// 'resizeClear': true
// }),
// list = [
// 'clear-day',
// 'clear-night',
// 'partly-cloudy-day',
// 'partly-cloudy-night',
// 'cloudy',
// 'rain',
// 'sleet',
// 'snow',
// 'wind',
// 'fog'
// ];
// icons.play();
// }
render() {
const {isLoading, error, currently} = this.state;
if(error) {
return (
<p>
Today's information is not available at this time.
Please check again later.
</p>
);
}
if(isLoading) {
return (
<h1>
Retrieving the current conditions...
{/* <i class="far fa-sun fa-spin"></i> */}
</h1>
);
}
const temp = Math.round(currently.temperature);
const apparent = Math.round(currently.apparentTemperature);
const wind = Math.round(currently.windSpeed);
return(
<div className='CurrentForecast-container' >
<div className='CurrentForecast-weather' >
<section className='CurrentForecast-local' >
<h2 className='CurrentForecast-city' >
Starke, FL
</h2>
<p className='CurrrentForecast-summary' >
{currently.icon}
</p>
</section>
<section className='CurrentForecast-icon' >
{/* <canvas id='{this.skycons}' width='128' height='128' /> */}
</section>
<section className='CurrentForecast-temp' >
<h1 className='CurrentForecast-actual' >
{temp}°F
</h1>
<p className='CurrentForecast-apparent' >
Feels Like: {apparent}°F
</p>
</section>
<section className='CurrentForecast-other' >
Chance of Rain: {currently.precipProbability * 100}% <br/>
Wind Speed: {wind} mph <br/>
Humidity: {currently.humidity * 100}% <br/>
UV: {currently.uvIndex}
</section>
</div>
</div>
);
}
}
export default CurrentForecast;
|
export default function ({ ctx, text, setup }) {
const {
font,
box,
debugRect,
minSize,
maxSize,
lineHeight,
fillStyle,
blur,
} = setup;
const words = text.trim().split(" ");
if (debugRect) {
ctx.lineWidth = 4;
ctx.strokeStyle = "white";
ctx.strokeRect(box.x, box.y, box.width, box.height);
}
let validLines = [];
for (let fontSize = minSize; fontSize <= maxSize; fontSize++) {
const currentLineHeight = fontSize * lineHeight;
let { x, y, width, height } = box;
let fy = y + fontSize;
ctx.font = `${fontSize}px ${font}`;
validLines = [];
let line = "";
for (var word of words) {
let biggerLine = line + word + " ";
if (ctx.measureText(biggerLine).width > width) {
validLines.push({ text: line, x: x + width / 2, y: fy });
line = word + " ";
fy += currentLineHeight;
} else {
line = biggerLine;
}
}
validLines.push({ text: line, x: x + width / 2, y: fy });
if (fy > y + height - fontSize) break;
}
for (var line of validLines) {
const { x, y, text } = line;
ctx.fillStyle = fillStyle;
ctx.textAlign = "center";
ctx.shadowColor = fillStyle;
ctx.shadowBlur = blur || 0;
ctx.fillText(text.trim(), x, y);
}
}
|
/* your code should go here */
// Three main classes of cards:
// done: when the user has discovered the pair of cards
// hidden: when the card has not been discovered yet
tmpl = "<li id='0' class='hidden'>" + "<h3>1</h3>";
$(document).ready(function(){
for (var i =0; i<data.length; i++){
item = tmpl.replace(/1/g, data[i]);
item = item.replace('hidden', 'done');
$(".cards").append(item);
}
$(".opt-start").click(function(){
$(".cards").children().removeClass('done');
$(".cards").children().addClass('hidden');
$('h3').hide();
});
});
var previous = 0;
$(document).on("click", "li", function(event){
previous++;
var number = $(event.currentTarget).find("h3").html();
if(parseInt(number)!==previous){
alert("you lost");
} else{
$(event.currentTarget).removeClass("hidden");
$(event.currentTarget).addClass("done");
$(event.currentTarget).find("h3").show();
if(parseInt(number)===9){
alert("cooool you're almost done");
}
if(parseInt(number)===10){
alert("you won!");
}
}
});
|
import React from 'react';
import {Grid as GridSemantic} from 'semantic-ui-react';
import styled from 'styled-components';
const Grid = styled(GridSemantic)`
margin: 0px!important;
`;
export default props => (
<Grid {...props}/>
);
export const GridColumn = props => (
<GridSemantic.Column {...props}/>
);
|
const assert = require('assert');
const arrays = [
["1", "2", "3"],
[true],
[4, 5, 6]
];
function flatten() {
let array = ((arrays.reduce((result, iten) => result.concat(iten))));
return array;
/* Utilizei HOF reduce junto com a função concat para concatenar os arrays. */
}
assert.deepEqual(flatten(), ["1", "2", "3", true, 4, 5, 6]);
|
import kNN from './lib/kNN';
import kMeans from './lib/kMeans';
import ANN from './lib/ANN';
export class Learn {
constructor(fn) {
this._algorithm= fn;
this.trainingDataset= [];
this._preparedFn= () => {};
}
/**
* Train the algorithm
*
* @param {Array} Training dataset
*/
train(dataset) {
// Dataset has to be an array
if(dataset.constructor !== Array)
throw new Error('Training dataset has to be an array');
// Concat the training dataset to the old one
this.trainingDataset= this.trainingDataset.concat(dataset);
// Train the algorithm
this._preparedFn= this._algorithm(this.trainingDataset);
}
/**
* Classify a point with the help of the training dataset
*
* @param {Array} point Point to classify
*
* @return {String} Classified label
*/
classify(point) {
// Dataset has to be an array
if(point.constructor !== Array)
throw new Error('The point to classify has to be an array');
return this._preparedFn(point);
}
predict(point) {
return this._preparedFn(point);
}
cluster(point) {
if(point.constructor !== Array)
throw new Error('The point to classify has to be an array');
return this._preparedFn(point);
}
}
Learn.kNN= kNN;
Learn.kMeans= kMeans;
Learn.ANN= ANN;
|
/*-------------------------------------------
collision4.js
多数剛体の衝突
-------------------------------------------*/
var canvas; //canvas要素
var gl; //WebGL描画用コンテキスト
var camera; //カメラ
var light; //光源
var numRigid = 300;//3の倍数
var rigid = [];
var dummy;
var floor0;
var coord = [];//座標軸表示用
var plane = [0.0, 0.0, 1.0, 0.0];//床平面(z = 0)
var shadow_value = 0.2;
var flagShadow = true;
var flagWorld = false;
var dt;
var kind0No = 0;
var kind1No = 0;
//animation
var fps = 0;
var lastTime = new Date().getTime();
var elapseTime = 0.0;//全経過時間
var elapseTime0 = 0.0;
var elapseTime1 = 0.0;
var flagStart = false;
var flagStep = false;
var flagReset = false;
var flagDebug = false;
function webMain()
{
// Canvas要素を取得する
canvas = document.getElementById('WebGL');
// WebGL描画用のコンテキストを取得する
gl = WebGLUtils.setupWebGL(canvas);
if (!gl)
{
alert('WebGLコンテキストの取得に失敗');
return;
}
var VS_SOURCE = document.getElementById("vs").textContent;
var FS_SOURCE = document.getElementById("fs").textContent;
if(!initGlsl(gl, VS_SOURCE, FS_SOURCE))
{
alert("GLSL初期化に失敗");
return;
}
//Canvasをクリアする色を設定し、隠面消去機能を有効にする
gl.clearColor(0.1, 0.1, 0.1, 1.0);
gl.enable(gl.DEPTH_TEST);
initCamera();
initObject();
readyTexture();
var animate = function()
{
//繰り返し呼び出す関数を登録
requestAnimationFrame(animate, canvas); //webgl-utilsで定義
//時間計測
var currentTime = new Date().getTime();
var frameTime = (currentTime - lastTime) / 1000.0;//時間刻み[sec]
elapseTime += frameTime;
elapseTime1 += frameTime;
fps ++;
if(elapseTime1 >= 0.5)
{
form1.fps.value = 2*fps.toString(); //1秒間隔で表示
var timestep = 0.5 / fps;
form1.step.value = timestep.toString();
fps = 0;
elapseTime1 = 0.0;
}
lastTime = currentTime;
if(flagStart)
{
var vPos = new Vector3();
for(var i = 0; i < numRigid; i++)
{
rigid[i].state = "FREE";
vPos.copy(rigid[i].vPos); vPos.z = 0;
var rad = mag(vPos);//ワールド座標中心からの距離
//外へ向かう方向
var vDirOut = normXY(vPos);
//中心に向かう方向
var vDirIn = reverse(vDirOut);
if(rigid[i].vPos.z < 8)
{
if(rad > 5) rigid[i].vForce0 = mul(getRandom(50, 100), vDirIn);
if(rad < 4) rigid[i].vForce0 = mul(getRandom(40, 60), vDirOut);
if(rad < 6) rigid[i].vForce0.z = getRandom(200, 500);
}
else
{
rigid[i].vForce0 = mul(getRandom(70,100), vDirOut);
if(rad > 5) rigid[i].vForce0.z = -getRandom(150, 300);
}
var speed = mag(rigid[i].vVel);
if(speed > 30)
{
var vDir = norm(rigid[i].vVel);
rigid[i].vVel = mul(30, vDir);
}
}
collision(dt);
elapseTime0 = elapseTime;//現在の経過時間を保存
form1.time.value = elapseTime.toString();
if(flagStep) { flagStart = false; }
display();
}
}
animate();
}
//------------------------------------------------------------------------
function readyTexture()
{
//テクスチャオブジェクトを作成する
var tex = [];
tex[0] = gl.createTexture();
tex[1] = gl.createTexture();
tex[2] = gl.createTexture();
//Imageオブジェクトを作成する
var image = [];
for(var i = 0; i < 3; i++) image[i] = new Image();
image[0].src = '../imageJPEG/check3.jpg';
image[1].src = '../imageJPEG/check2.jpg';
image[2].src = '../imageJPEG/check4.jpg';
var flagLoaded = [];//画像読み込み終了フラグ
flagLoaded[0] = false;
flagLoaded[1] = false;
flagLoaded[2] = false;
// 画像の読み込み完了時のイベントハンドラを設定する
image[0].onload = function(){ setTexture(0); }
image[1].onload = function(){ setTexture(1); }
image[2].onload = function(){ setTexture(2); }
function setTexture(no)
{
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);// 画像のY軸を反転する
// テクスチャユニット0を有効にする
if(no == 0) gl.activeTexture(gl.TEXTURE0);
else if(no == 1) gl.activeTexture(gl.TEXTURE1);
else gl.activeTexture(gl.TEXTURE2);
// テクスチャオブジェクトをターゲットにバインドする
gl.bindTexture(gl.TEXTURE_2D, tex[no]);
// テクスチャ画像を設定する
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, image[no]);
//ミップマップ自動生成
gl.generateMipmap(gl.TEXTURE_2D);
// テクスチャパラメータを設定する
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
flagLoaded[no] = true;
//2つの画像の読み込み終了後描画
if(flagLoaded[0] && flagLoaded[1] && flagLoaded[2]) display();
}
}
//--------------------------------------------
function initCamera()
{
//カメラと光源の初期設定
//光源インスタンスを作成
light = new Light();
light.pos = [50, 50, 100, 1];
//初期設定値をHTMLのフォームに表示
form2.lightX.value = light.pos[0];
form2.lightY.value = light.pos[1];
form2.lightZ.value = light.pos[2];
//カメラ・インスタンスを作成
camera = new Camera();
camera.dist = 40;
camera.cnt[2] = 5.0;
camera.getPos();//カメラ位置を計算
mouseOperation(canvas, camera);//swgSupport.js
}
function initObject()
{
flagStart = false;
dt = parseFloat(form1.dt.value);//計算時のタイムステップ[s]
restitution = parseFloat(form2.restitution.value);
muK = parseFloat(form2.muK.value);
numRigid = parseFloat(form2.num.value);
for(var i = 0; i < numRigid; i++) rigid[i] = new Rigid();
//オブジェクト0
rigid[0].kind = "CUBE";
rigid[0].vVel = new Vector3(0, 0, 0);
rigid[0].vSize = new Vector3(1.5, 1.5, 1.5);
rigid[0].flagTexture = true;
rigid[0].flagDebug = flagDebug;
rigid[0].mass = 1.0;//kg
rigid[0].ready();
//オブジェクト1
var n1 = numRigid / 3;
rigid[n1].kind = "SPHERE";
rigid[n1].vSize = new Vector3(1.5, 1.5, 1.5);
rigid[n1].nSlice = 8;//12;
rigid[n1].nStack = 8;//12;
rigid[n1].flagTexture = true;
rigid[n1].flagDebug = flagDebug;
rigid[n1].mass = 1.0;//kg
rigid[n1].ready();
//オブジェクト2
var n2 = 2 * numRigid / 3;
rigid[n2].kind = "CYLINDER";
rigid[n2].flagTexture = true;
rigid[n2].flagDebug = flagDebug;
rigid[n2].vSize = new Vector3(1.5, 1.5, 1.5);
rigid[n2].nSlice = 8;//12;
rigid[n2].radiusRatio = 1.0;
rigid[n2].flagTexture = true;
rigid[n2].mass = 1.0;//kg
rigid[n2].ready();
for(var i = 1; i < n1; i++)
{
rigid[i].kind = "CUBE";
rigid[i].diffuse = [0.9, 0.6, 0.0, 1.0];
rigid[i].ambient = [0.5, 0.3, 0.0, 1.0];
rigid[i].ready();
}
for(var i = n1+1; i < n2; i++)
{
rigid[i].kind = "SPHERE";
rigid[i].diffuse = [0.0, 0.6, 0.9, 1.0];
rigid[i].ambient = [0.0, 0.3, 0.5, 1.0];
rigid[i].nSlice = 8;//12;
rigid[i].nStack = 8;//12;
rigid[i].ready();
}
for(var i = n2+1; i < numRigid; i++)
{
rigid[i].kind = "CYLINDER";
rigid[i].diffuse = [0.4, 0.6, 0.4, 1.0];
rigid[i].ambient = [0.2, 0.3, 0.2, 1.0];
rigid[i].radiusRatio = 1.0;
rigid[i].nSlice = 8;//12;
//rigid[i].nStack = 8;//12;
rigid[i].ready();
}
for(var i = 0; i < numRigid; i++)
{
rigid[i].vPos = getRandomVector(8);
if(rigid[i].vPos.z <= 0.5) rigid[i].vPos.z = 0.5;
}
//座標軸
var lenCoord = 2.0;
var widCoord = 0.05;
for(var i = 0; i < 9; i++)
{
coord[i] = new Rigid();
coord[i].specular = [0.0, 0.0, 0.0, 1.0];
coord[i].shininess = 10.0;
coord[i].nSllice = 8;
}
coord[0].diffuse = [0.5, 0.0, 0.0, 1.0];
coord[0].ambient = [0.5, 0.0, 0.0, 1.0];
coord[1].diffuse = [0.0, 0.5, 0.0, 1.0];
coord[1].ambient = [0.0, 0.5, 0.0, 1.0];
coord[2].diffuse = [0.0, 0.0, 0.5, 1.0];
coord[2].ambient = [0.0, 0.0, 0.5, 1.0];
//ワールド座標
coord[0].kind = "CYLINDER_X";
coord[0].vPos = new Vector3(0.0, 0.0, 0.0);
coord[0].vSize = new Vector3(lenCoord, widCoord, widCoord);
coord[1].kind = "CYLINDER_Y";
coord[1].vSize = new Vector3(widCoord, lenCoord, widCoord);
coord[1].vPos = new Vector3(0.0, 0.0, 0.0);
coord[2].kind = "CYLINDER_Z";
coord[2].vSize = new Vector3(widCoord, widCoord, lenCoord);
coord[2].vPos = new Vector3(0.0, 0.0, 0.0);
for(var i = 0; i < 3; i++) coord[i].q = getQFromEulerXYZ(coord[i].vEuler);
//フロア
floor0 = new Rigid();
floor0.kind = "CHECK_PLATE";
floor0.vPos = new Vector3(0.0, 0.0, -plane[3]-0.01);
floor0.vSize = new Vector3(40, 40, 1);
floor0.nSlice = 20;//x方向分割数
floor0.nStack = 20;//y方向分割数
floor0.specular = [0.5, 0.5, 0.5, 1.0];
floor0.shininess = 50;
floor0.flagCheck = true;
display();
}
//---------------------------------------------
function display()
{
//光源
var lightPosLoc = gl.getUniformLocation(gl.program, 'u_lightPos');
gl.uniform4fv(lightPosLoc, light.pos);
var lightColLoc = gl.getUniformLocation(gl.program, 'u_lightColor');
gl.uniform4fv(lightColLoc, light.color);
var cameraLoc = gl.getUniformLocation(gl.program, 'u_cameraPos');
gl.uniform3fv(cameraLoc, camera.pos);
//ビュー投影行列を計算する
var vpMatrix = new Matrix4();// 初期化
vpMatrix.perspective(camera.fovy, canvas.width/canvas.height, camera.near, camera.far);
//vpMatrix.lookAt(camera.pos[0], camera.pos[1], v, 0, 0, 0, 0, 0, 1);
if(Math.cos(Math.PI * camera.theta /180.0) >= 0.0)//カメラ仰角90度でﾋﾞｭｰｱｯﾌﾟﾍﾞｸﾄﾙ切替
vpMatrix.lookAt(camera.pos[0], camera.pos[1], camera.pos[2], camera.cnt[0], camera.cnt[1], camera.cnt[2], 0.0, 0.0, 1.0);
else
vpMatrix.lookAt(camera.pos[0], camera.pos[1], camera.pos[2], camera.cnt[0], camera.cnt[1], camera.cnt[2], 0.0, 0.0, -1.0);
var vpMatrixLoc = gl.getUniformLocation(gl.program, 'u_vpMatrix');
gl.uniformMatrix4fv(vpMatrixLoc, false, vpMatrix.elements);
// カラーバッファとデプスバッファをクリアする
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.viewport(0, 0, canvas.width, canvas.height);
var samplerLoc = gl.getUniformLocation(gl.program, 'u_sampler');
var n = rigid[0].initVertexBuffers(gl);//CUBE
for(var k = 0; k < numRigid/3; k++)
{
rigid[k].draw(gl, n);
gl.activeTexture(gl.TEXTURE0);
gl.uniform1i(samplerLoc, 0);
}
n = rigid[numRigid/3].initVertexBuffers(gl);//SPHERE
for(var k = numRigid/3; k < 2*numRigid/3; k++)
{
rigid[k].draw(gl, n);
gl.activeTexture(gl.TEXTURE1);
gl.uniform1i(samplerLoc, 1);
}
n = rigid[2*numRigid/3].initVertexBuffers(gl);//CYLINDER
for(var k = 2*numRigid/3; k < numRigid; k++)
{
rigid[k].draw(gl, n);
gl.activeTexture(gl.TEXTURE2);
gl.uniform1i(samplerLoc, 2);
}
if(flagWorld)
{
for(var i = 0; i < 3; i++)
{
var n = coord[i].initVertexBuffers(gl);
coord[i].draw(gl, n);
}
}
n = floor0.initVertexBuffers(gl);
floor0.draw(gl, n);
//影
if(flagShadow) drawShadow();
function drawShadow()
{
gl.depthMask(false);
gl.blendFunc(gl.SRC_ALPHA_SATURATE,gl.ONE_MINUS_SRC_ALPHA);
gl.enable(gl.BLEND);
for(var k = 0; k < numRigid; k++) rigid[k].shadow = shadow_value;
var n = rigid[0].initVertexBuffers(gl);//CUBE
for(var k = 0; k < numRigid/3; k++) rigid[k].draw(gl, n);
n = rigid[numRigid/3].initVertexBuffers(gl);//SPHERE
for(var k = numRigid/3; k < 2*numRigid/3; k++) rigid[k].draw(gl, n);
n = rigid[2*numRigid/3].initVertexBuffers(gl);//CYLINDER
for(var k = 2*numRigid/3; k < numRigid; k++) rigid[k].draw(gl, n);
for(var k = 0; k < numRigid; k++) rigid[k].shadow = 0;
gl.disable(gl.BLEND);
gl.depthMask(true);
}
}
//---------------------------------------------------
//イベント処理
function onClickC_Size()
{
canvas.width = form1.c_sizeX.value;
canvas.height = form1.c_sizeY.value;
display();
}
function onChangeData()
{
initObject();
}
function onClickCollision()
{
flagCollision = form2.collision.checked;
}
function onClickSeparate()
{
flagSeparate = form2.separate.checked;
}
function onClickDrag()
{
flagDrag = form2.drag.checked;
}
function onClickLight()
{
light.pos[0] = parseFloat(form2.lightX.value);
light.pos[1] = parseFloat(form2.lightY.value);
light.pos[2] = parseFloat(form2.lightZ.value);
display();
}
function onClickCoord()
{
if(form2.world.checked) flagWorld = true;
else flagWorld = false;
display();
}
function onClickDebug()
{
if(form2.debug.checked) flagDebug = true;
else flagDebug = false;
for(var i = 0; i < numRigid; i++) rigid[i].flagDebug = flagDebug;
display();
}
function onClickStart()
{
fps = 0;
elapseTime = elapseTime0;
elapseTime = 0.0;
elapseTime1 = 0.0;
countTrace = 0;
timeTrace = 0;
flagStart = true;
flagStep = false;
lastTime = new Date().getTime();
if(rigid[0].kind == "SPHERE")
{ if(rigid[0].vSize.x != rigid[0].vSize.y || rigid[0].vSize.y != rigid[0].vSize.z || rigid[0].vSize.x != rigid[0].vSize.z)
alert("球のサイズはすべて同じ値にすること!");
}
else if(rigid[0].kind == "CYLINDER")
{ if(rigid[0].vSize.x != rigid[0].vSize.y)
alert("円柱のサイズx,yは同じ値にすること!");
}
if(rigid[1].kind == "SPHERE")
{ if(rigid[1].vSize.x != rigid[1].vSize.y || rigid[1].vSize.y != rigid[1].vSize.z || rigid[1].vSize.x != rigid[1].vSize.z)
alert("球のサイズはすべて同じ値にすること!");
}
else if(rigid[1].kind == "CYLINDER")
{ if(rigid[1].vSize.x != rigid[1].vSize.y)
alert("円柱のサイズx,yは同じ値にすること!");
}
}
function onClickFreeze()
{
if(flagStart) { flagStart = false; }
else { flagStart = true; elapseTime = elapseTime0; }
flagStep = false;
}
function onClickStep()
{
flagStep = true;
flagStart = true;
elapseTime = elapseTime0;
}
function onClickReset()
{
elapseTime0 = 0;
flagStart = false;
flagStep = false;
initObject();
form1.time.value = "0";
display();
}
function onClickCameraReset()
{
initCamera();
display();
}
function onClickShadow()
{
shadow_value = parseFloat(form2.shadow.value);
//display();
}
function onClickFlagShadow()
{
flagShadow = form2.flagShadow.checked;
}
function onClickPeriod()
{
periodTrace = parseFloat(form2.period.value);
}
//-----------------------------------------------------------------------------
|
import React, { useState } from "react";
import config from '../../Services/Config';
import axios from 'axios';
import LikeReplyButton from "./LikeReplyButton";
import BestReplyButton from "./BestReplyButton";
const Reply = ({ thread, reply, auth, onDelete, onEdit, onLike, onMark, onRemoveAsBest }) => {
const [editing, setEditing] = useState(false);
const [content, setContent] = useState('');
const deleteReply = function (event) {
event.preventDefault();
onDelete(reply);
const endpoint = `${config.remoteBaseUrl}/replies/${reply.id}?token=${auth.token}`;
axios.delete(endpoint);
};
function saveEditingReply() {
onEdit(content, reply);
setEditing(false);
const endpoint = `${config.remoteBaseUrl}/replies/${reply.id}?token=${auth.token}`;
axios.put(endpoint, {content});
}
function handleEditingChange() {
setEditing(true);
setContent(reply.content);
}
function handleContentEditing(event) {
setContent(event.target.value)
}
function showEditingButton() {
if(editing) {
return (
<button className="mr-2 btn btn-warning text-white" style={{ cursor: 'pointer' }}
onClick={ () => setEditing(false) }
>
<i className="fa fa-ban"/> Cancel
</button>
)
}
return (
<button className="mr-2 btn btn-info text-white" style={{cursor: 'pointer'}} onClick={ handleEditingChange }>
<i className="fa fa-pencil"/>
</button>
)
}
function showContent() {
if(editing) {
return (
<>
<textarea className="form-control " rows="5" value={ content } onChange={handleContentEditing} />
<button className="mr-2 mt-2 btn btn-success text-white" style={{cursor: 'pointer'}} onClick={saveEditingReply}>
Edit <i className="fa fa-check"/>
</button>
</>
)
}
return (
<>
<p className="card-text">
{reply.content}
</p>
<i className="fa fa-clock-o"/>
<small className="text-muted text-right">{reply.ago}</small>
</>
)
}
function isBestReply() {
return parseInt(thread.best_reply_id) === parseInt(reply.id);
}
return (
<div className={`${isBestReply() ? `best_reply`: ''} card mb-3`}>
<div className="card-body">
<div className="d-flex justify-content-between align-items-center">
<h5 className="d-flex justify-content-center align-items-center">
<img src={ reply.creator.avatar_link } alt="" width="20" height="20" className="mr-1"/>
<span>{reply.creator.name}</span>
</h5>
<div>
{
parseInt(auth.id) === parseInt(thread.creator.id) &&
<BestReplyButton auth={auth} thread={thread} reply={reply}
onPress={ () => onMark(reply)} active={ isBestReply() }
onRemove={ () => onRemoveAsBest() }
/>
}
<LikeReplyButton
reply={reply}
auth={auth}
onLike={onLike}
/>
</div>
</div>
<hr/>
{ showContent() }
</div>
{
parseInt(auth.id) === parseInt(reply.user_id) &&
<div className="card-footer d-flex justify-content-between">
{ showEditingButton() }
<button className="btn btn-danger" onClick={deleteReply} style={{ cursor: 'pointer'}} >
<i className="fa fa-trash-o"/>
</button>
</div>
}
</div>
)
};
export default Reply;
|
import React from 'react';
import {
Container,
Wrapper,
TabsContainer,
TabName,
TabWrapper,
TabContainer,
LogoImage,
TabContent,
} from './Tab.style';
const Tab = ({ ...props }) => {
const { links } = props;
const tabs = [];
if (links && links.length) {
links.forEach(tab => {
tabs.push(
<TabContainer href={tab.link} key={tab.index} target="_blank">
<TabWrapper>
<TabContent>
<LogoImage src={tab.image} alt={tab.name} />
<TabName>
{tab.name}
</TabName>
</TabContent>
</TabWrapper>
</TabContainer>);
});
}
return (
<Container>
<Wrapper>
<TabsContainer>
{tabs}
</TabsContainer>
</Wrapper>
</Container>
)
}
export default Tab;
|
import React, { useState, useEffect } from 'react';
import { Link, useParams } from 'react-router-dom';
import './Ingredients.css';
const Ingredients = () => {
const APP_ID = `3a8d5f7e`;
const APP_KEY = `4f9d16cc15ec1acf30530217c75ee197`;
const { item,label } = useParams();
const [recipe,setRecipe] = useState([]);
const [image,setImage] = useState('');
useEffect(() => {
async function loadRecipe() {
console.log(item)
const url = `https://api.edamam.com/search?q=${item}&app_id=${APP_ID}&app_key=${APP_KEY}`;
const response = await fetch(url);
const data = await response.json();
const newRecipe = data.hits.find( recipe => recipe.recipe.label === label);
setRecipe(newRecipe.recipe.ingredientLines)
setImage(newRecipe.recipe.image)
}
if(!recipe.length){
loadRecipe()
}
// eslint-disable-next-line react-hooks/exhaustive-deps
},[recipe]);
return (
<div className="ingredient">
<div className="ingredient-card">
<img className="ingredient-image" src={image} alt=""/>
<div className="ingredient-list">
<h3>{label}</h3>
<ul>
{recipe.map(e => <li>{e}</li>)}
</ul>
<Link to={`/${item}`}><button>Home</button></Link>
</div>
</div>
</div>
);
};
export default Ingredients;
|
let users1=[
{
name:'Vinay',
age:22,
city:'Bangalore',
salary:22000
},
{
name:'Naveen',
age:24,
city:'Chennai',
salary:25000
},
{
name:'Madhu',
age:33,
city:'Mumbai',
salary:35000
},
{
name:'Kiran',
age:38,
city:'Pune',
salary:30000
},
{
name:'Jeeven',
age:44,
city:'Vizag',
salary:55000
}
];
/*let userNames = users.map(user=> user.name);
//console.log(userNames);
let peopleMoreThan30 = users.filter(user => user.age > 30);
let peopleLessThan30 = users.filter(user => user.age < 30);
let userNamesLessThan30 = users.filter(user => user.age > 30)
.map(user => user.name);
console.log(userNamesLessThan30);
*/
let totalUsersSalary = users1.map(user => user.salary).reduce((p, c)=> {
return p * c;
}, 1);
//console.log(`The total salary is ${totalUsersSalary}`)
//users1.map(user => user.name).forEach(name => console.log(name));
users1.sort((user1, user2)=> {
if (user1.age > user2.age){
return 1;
} else if (user1.age < user2.age ){
return -1;
}
return 0;
}).map(user => user.name).forEach(name => console.log(name))
|
import axios from 'axios';
const API_KEY = 'F6802FA00954F880AB63D61DD7E5A9BC604A1BCB049C9D54B3D2B3EF14504E81';
export const bestSellerApi = () => axios.get(`/api/bestSeller.api?key=${API_KEY}&categoryId=100&output=json`);
export const newBookApi = () => axios.get(`/api/newBook.api?key=${API_KEY}&categoryId=100&output=json`);
export const recommendApi = () => axios.get(`/api/recommend.api?key=${API_KEY}&categoryId=100&output=json`);
export const searchApi = term => axios.get(`/api/search.api?key=${API_KEY}&output=json&query=${term}`);
|
import React from 'react';
import { Button, View, Text, TextInput } from 'react-native';
export default class Tela2 extends React.Component {
constructor(props) {
super(props);
this.state = {
numero: 0,
resultado: '',
};
}
static navigationOptions = {
title: 'Segunda Tela',
};
onCalcular() {
const { numero } = this.state;
var dobro = parseInt(numero) * 2;
var res = (
<View>
<Text>Dobro: {dobro}</Text>
<Text>Metade: {numero / 2}</Text>
<Text>Triplo: {numero * 3}</Text>
</View>
);
this.setState({ resultado: res });
}
render() {
return (
<View>
<Button
title="abrir primeira tela"
onPress={() => this.props.navigation.navigate('Tela1')}
/>
<TextInput
value={this.state.numero}
onChangeText={numero => this.setState({ numero })}
placeholder={'numero'}
/>
<Button title={'Calcular'} onPress={this.onCalcular.bind(this)} />
<View>{this.state.resultado}</View>
</View>
);
}
}
|
$(function(){
var arrays = [];
$("#submit").click(function(){
var groceries = $("input#groceries").val();
arrays.push(groceries);
$("#items").prepend('<li>' + groceries + '</li>');
});
$("#submit1").click(function(){
var sortedGroceries = arrays.sort();
var upperCase=sortedGroceries.map(function(grocery) {
return grocery.toUpperCase();
});
upperCase.forEach(function(grocery){
$("#final").append('<li>' + grocery + '</li>');
$("#formOne").hide();
$("#items").hide();
$("#final").show();
});
});
});
// $(function(){
// var flavors = ["vanilla", "choco", "mint", "cookie", "strawberry"]
// flavors.forEach(function(flavor) {
// $("#fav-flavor").prepend('<li>' + flavor + '</li>');
// });
// });
|
const { version } = require("discord.js");
const moment = require("moment");
require("moment-duration-format");
const Discord = require('discord.js')
exports.run = async (client, message, args) => {
const duration = moment
.duration(client.uptime)
.format(" D [days], H [hrs], m [mins], s [secs]");
const elapsed = moment
.duration(moment().diff(moment(client.user.createdAt)))
.format(
"Y [years], D [days], H [hours], m [minutes] [and] s [seconds] [ago]"
);
let embed = new Discord.MessageEmbed()
.setColor("RANDOM")
.setTitle("STATISTICS")
.setDescription(`${client.user.username} v88`)
.setFooter("Stole by a Samplasion code")
.addFields(
{
name: "⚙️ Memory Usage",
value: `${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)} MB`,
inline: true
},
{ name: "⏱️ Uptime", value: duration, inline: true },
{ name: "\u200b", value: "\u200b", inline: true },
{
name: "🔢 Versions",
value: `**• Discord.js**: v${version}
**• Node.js**: ${process.version}`,
inline: true
},
{ name: "🎂 Creation date", value: elapsed, inline: false }
);
message.channel.send(embed);
};
exports.help = {
name: ":bar_chart:stats",
info: "See some fancy bot statistics",
usage: "",
};
exports.config = {
aliases: ["status","state"], // Array of aliases
cooldown: 3, // Command cooldown
};
|
var Applicant = require('../models/applicants.js')
var indexController = {
index: function(req, res) {
res.render('index');
},
createApplicant : function(req, res){
// Access form data from the body
// req.body
var app = {
name : req.body.name,
bio : req.body.bio,
skills : req.body.skills.split(', '),
years : req.body.years,
why : req.body.why,
}
// Create a new applicant
var newApp = new Applicant(app);
// Save that applicant
newApp.save(function(err, doc){
console.log('Save Err : ', err);
if (err) {
res.send("There was a problem with your application - " + err.message);
}
res.redirect('/success');
});
},
showApplicants : function(req, res){
Applicant.find({}, function(err, docs){
res.render('applicants', { people : docs})
})
},
deleteApplicant : function(req, res){
Applicant.find({}, function(err, docs){
})
}
};
module.exports = indexController;
|
/**
* 拿梦想做赌注，我怎么舍得输
*/
//fs file system
let fs = require('fs');
let EventEmitter = require('events');
// fs里的方法
//1.读取的文件必须存在
//2.读取内容默认都是buffer类型
//error-first模式
let school = {};
let e = new EventEmitter();
e.on('输出',out);
fs.readFile('name.txt','utf8',function (err,data) {
if(err)console.log(err);
school.name = data;
e.emit('输出');
});
fs.readFile('age.txt','utf8',function (err,data) {
if(err)console.log(err);
school.age = data;
e.emit('输出');
});
function out() { //将对象转化为数组
if(Object.keys(school).length==2)console.log(school);
}
/*
let name = fs.readFileSync('name.txt','utf-8');
let age = fs.readFileSync('age.txt','utf-8');
let school = {name,age}
console.log(school);*/
|
/*
* @Descripttion:购物车状态模块
*/
export default {
state: {
shoppingCart: [],
},
getters: {
getShoppingCart(state) {
// 获取购物车状态
return state.shoppingCart
},
getNum(state) {
// 购物车商品总数量
let totalNum = 0
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
totalNum += temp.Num
}
return totalNum
},
getIsAllCheck(state) {
// 判断是否全选
let isAllCheck = true
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
// 只要有一个商品没有勾选立即return false;
if (!temp.check) {
isAllCheck = false
return isAllCheck
}
}
return isAllCheck
},
getCheckGoods(state) {
// 获取勾选的商品信息
// 用于确认订单页面
let checkGoods = []
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
if (temp.check) {
checkGoods.push(temp)
}
}
return checkGoods
},
getCheckNum(state) {
// 获取购物车勾选的商品数量
let totalNum = 0
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
if (temp.check) {
totalNum += temp.Num
}
}
return totalNum
},
getTotalPrice(state) {
// 购物车勾选的商品总价格
let totalPrice = 0
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
if (temp.check) {
totalPrice += temp.Price * temp.Num
}
}
return totalPrice
}
},
mutations: {
setShoppingCart(state, data) {
// 设置购物车状态
data.map(item => {
item['check'] = false
})
state.shoppingCart = data
},
addShoppingCart(state, data) {
// 添加购物车
// 用于在商品详情页点击添加购物车,后台添加成功后，更新vuex状态
if (state.shoppingCart==[]||state.shoppingCart.length < 1) {
return state.shoppingCart.push(data)
}
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
if (temp.GoodsId === data.GoodsId) {
if (data.Num < data.MaxNum) {
state.shoppingCart[i].Num++
return
} else {
this.$baseMessage('该商品数量已经达到上限', 'warning')
return
}
}
}
state.shoppingCart.push(data)
console.log(state.shoppingCart)
},
updateShoppingCart(state, payload) {
// 更新购物车
// 可更新商品数量和是否勾选
// 用于购物车点击勾选及加减商品数量
console.log(payload.key)
if (payload.prop === 'Num') {
if (payload.val < state.shoppingCart[payload.key].MaxNum && payload.val > 1) {
state.shoppingCart[payload.key][payload.prop] = payload.val
console.log(state.shoppingCart[payload.key])
return
}
}
if (payload.prop === 'check') {
state.shoppingCart.forEach((item, i) => {
let bool=payload.key.some((val, j) => {
return item.GoodsId === val.GoodsId
})
if(bool==true){
item.check=true
}else {
item.check=false
}
console.log(item)
})
return
}
},
deleteShoppingCart(state, id) {
// 根据购物车id删除购物车商品
for (let i = 0; i < state.shoppingCart.length; i++) {
const temp = state.shoppingCart[i]
if (temp.GoodsId == id) {
state.shoppingCart.splice(i, 1)
}
}
console.log(state.shoppingCart)
},
checkAll(state, data) {
// 点击全选按钮，更改每个商品的勾选状态
for (let i = 0; i < state.shoppingCart.length; i++) {
state.shoppingCart[i].check = data
}
}
},
actions: {
setShoppingCart({commit}, data) {
commit('setShoppingCart', data)
},
addShoppingCart({commit}, data) {
commit('addShoppingCart', data)
},
updateShoppingCart({commit}, payload) {
commit('updateShoppingCart', payload)
},
deleteShoppingCart({commit}, id) {
commit('deleteShoppingCart', id)
},
checkAll({commit}, data) {
commit('checkAll', data)
}
}
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import { shallow } from 'enzyme';
import RangeSlider from './RangeSlider';
describe('RangeSlider', () => {
let wrapper;
let mockProps;
beforeEach(() => {
mockProps = {
originalRange: [],
handleRangeChange: () => {},
range: [],
};
});
describe('originalRange is defined', () => {
beforeEach(() => { mockProps.originalRange = [1, 5]; });
it('should render correclty', () => {
expect(wrapper).toMatchSnapshot();
});
});
describe('range is defined', () => {
beforeEach(() => { mockProps.range = [0, 5]; });
it('should render correclty', () => {
expect(wrapper).toMatchSnapshot();
});
});
});
|
import * as React from 'react';
import {useEffect} from 'react';
import {FlatList, Text, TouchableOpacity, View} from 'react-native';
import {connect} from 'react-redux';
import {bindActionCreators} from 'redux';
import {ErrorPage} from '../../components/errorPage';
import {LoadingFullscreen} from '../../components/loadingFullScreen';
import {TransactionActions} from '../../redux/action';
import {styles} from '../../styles';
import {ROUTE_NAMES} from '../../utils';
import {strings} from '../../utils/localization';
import Item from './item';
import SearchInput from './search';
const Skeleton = () => {
return (
<View>
<Text>Skeleton</Text>
</View>
);
};
function TransactionScreen({
navigation,
transactionList,
loading,
transactionActions,
isErrorPage,
}) {
const [refreshing, setRefreshing] = React.useState(false);
React.useEffect(() => {
transactionActions.getTransaction();
}, []);
useEffect(() => {
if (refreshing) {
transactionActions.getTransaction();
setRefreshing(false);
}
}, [refreshing, transactionActions]);
const renderItem = ({item, index}) => {
return (
<TouchableOpacity
key={index.toString()}
onPress={() =>
navigation.navigate(ROUTE_NAMES.TRANSACTION_DETAIL, {detail: item})
}>
<Item data={item} />
</TouchableOpacity>
);
};
return (
<View style={styles.containers}>
<SearchInput />
{isErrorPage ? (
<ErrorPage
onPress={() => {
setRefreshing(true);
}}
/>
) : (
<FlatList
data={transactionList}
renderItem={renderItem}
keyExtractor={item => item.id}
refreshing={refreshing}
onRefresh={() => setRefreshing(true)}
ListFooterComponent={() =>
!loading && transactionList.length === 0 ? (
<ErrorPage type={'empty'} />
) : null
}
/>
)}
{loading && <LoadingFullscreen />}
</View>
);
}
const mapStateToProps = state => ({
transactionList: state.transaction,
loading: state.loading,
isErrorPage: state.transactionListErr,
});
const mapDispatchToProps = dispatch => {
return {
transactionActions: bindActionCreators(TransactionActions, dispatch),
};
};
export default connect(mapStateToProps, mapDispatchToProps)(TransactionScreen);
|
module.exports= async function(db,{proffyValue, classesValue, classScheduleValues}){
const insetedProffy=await db.run(`
INSERT INTO proffys(
name,
avatar,
whatsapp,
bio
) VALUES(
"${proffyValue.name}",
"${proffyValue.avatar}",
"${proffyValue.whatsapp}",
"${proffyValue.bio}"
);
`)
const proffy_id=insetedProffy.lastID
const insertedClass=await db.run(`
INSERT INTO classes(
subject,
cost,
proffy_id
)VALUES(
"${classesValue.subject}",
"${classesValue.cost}",
"${proffy_id}"
);
`)
const class_id=insertedClass.lastID
const insertdAllClassSchedulesValues = classScheduleValues.map((classScheduleValue)=> {
return db.run(`
INSERT INTO class_schedule(
class_id,
weekday,
time_from,
time_to
)VALUES(
"${class_id}",
"${classScheduleValue.weekday}",
"${classScheduleValue.time_from}",
"${classScheduleValue.time_to}"
);
`)
})
await Promise.all(insertdAllClassSchedulesValues)
}
|
// --== CS400 File Header Information ==--
// Name: Neil Bhutada
// Email: nbhutada@wisc.edu
// Team: MG
// Role: Front end developer 1
// TA: Harit
// Lecturer: Florian
// Notes to Grader: Used Autoformat as adviced per TA. The size of scene is 600 x 600.
function updateBossMeter(meter) //Updates boss's meter
{
document.getElementById("boss").value = meter;
}
function updateUserMeter(meterValue) //Updates user's meter
{
document.getElementById("user").value = meterValue;
}
function updateUserMeterDelay(meterValue) //Update user's meter with delay so that player can see boss's attack
{
setTimeout(function() {updateUserMeter(meterValue);}, 1000);
}
function updateImage(image = "Choose Player.png",name = "",value = 0.0) //Loads the images at the begininng of the game
{
document.getElementById("Image_3").src = image;
document.getElementById("User").innerHTML = name;
document.getElementById("user").value = value;
}
function lost() //Will print on screen that the person lost the game
{
document.getElementById("Status").innerHTML = "YOU'VE LOST THE GAME";
}
function won() //Will print on screen the user won the game
{
document.getElementById("Status").innerHTML = "YOU'VE WON THE GAME";
}
function updateHeader(text) //Updates the header to display the boss's move/user's status
{
document.getElementById("Head").innerHTML = text;
setTimeout(function() {document.getElementById("Head").innerHTML = "GARY'S REVENGE";}, 1000);
}
function updateHeaderDelay(text) //Updates header with delay so that player can see what move the boss made
{
setTimeout(function() {document.getElementById("Head").innerHTML = text},1000);
setTimeout(function() {document.getElementById("Head").innerHTML = "GARY'S REVENGE";}, 2000);
}
|
function LikeButton() {
// like 버튼에 상태값을 false 로 셋팅
const [liked, setLiked] = React.useState(false); // 상태에 따라서 텍스트 변경
const text = liked ? '좋아요 취소' : '좋아요';
return /*#__PURE__*/React.createElement("button", {
onClick: () => {
setLiked(!liked);
}
}, text); // react 를 반환
//return React.createElement(
// 'button', // html 에 해당하는 tag가 만들어 진다
// { onClick: () => setLiked(!liked)},
// text,
//);
}
const domContainer = document.getElementById('root');
ReactDOM.render(React.createElement(LikeButton), domContainer);
const testContainer = document.getElementById('test');
function TestList() {
return React.createElement('div', null, React.createElement('p', null, 'hello'), React.createElement('p', null, 'world'));
}
ReactDOM.render(React.createElement(TestList), testContainer);
|
import Ember from 'ember';
export default Ember.View.extend({
tagName: 'section',
layoutName: 'main-layout',
didInsertElement: function(e) {
this.get('controller').send('onLoad', e);
}
});
|
let express = require('express');
let bodyParser = require('body-parser');
let app = express();
let swaggerJSDoc = require('swagger-jsdoc');
let path = require('path');
var childProcess = require('child_process');
global.config = {
STORAGE: process.env.STORAGE || 'cache',
PORT: process.env.PORT || '3000',
DBTYPE: process.env.DBTYPE || 'mongodb'
};
if(global.config.STORAGE == "db"){
//move this later to a seperate connection file.
switch(global.config.DBTYPE){
case "mongodb":
var mongoose = require('mongoose');
var dbconfig = require('./config/db_config');
mongoose.Promise = global.Promise;
mongoose.connect(`${dbconfig.url}:${dbconfig.port}/${dbconfig.dbname}`, {
user: dbconfig.user,
pass: dbconfig.password,
auth: {authdb: dbconfig.authdb},
server: {
socketOptions: {keepAlive: 300000, connectTimeoutMS: 30000},
replset: {socketOptions: {keepAlive: 300000, connectTimeoutMS: 30000}}
}
});
var conn = mongoose.connection;
conn.on('error', console.error.bind(console, 'connection error: UMS'));
break;
case "postgres":
//postgres connection here
var pg = require("pg");
var dbconfig = require('./config/pg_db_config');
var conString = `${dbconfig.url}${dbconfig.user}:${dbconfig.password}@${dbconfig.servername}:${dbconfig.port}/${dbconfig.dbname}`;
var conn = new pg.Client(conString);
conn.on('error', console.error.bind(console, 'connection error: UMS'));
break;
default:
console.log("Unexpected error occured");
process.exit(1);
break;
}
}
// swagger definition
var swaggerDefinition = {
info: {
title: 'Approval workflow as a service',
version: '1.0.0',
description: '',
},
host: `localhost:${global.config.PORT}`,
basePath: '/',
};
// options for the swagger docs
var options = {
// import swaggerDefinitions
swaggerDefinition: swaggerDefinition,
// path to the API docs
apis: ['./*.js']
};
// initialize swagger-jsdoc
var swaggerSpec = swaggerJSDoc(options);
app.use('/apidoc', express.static(path.join(__dirname, '/api-doc')));
app.get('/swagger.json', function(req, res){
res.setHeader('Content-Type', 'application/json');
res.send(swaggerSpec);
});
app.use(bodyParser.json({limit: '20mb'}));
app.use('/api', require('./routes'));
app.use(function (err, req, res, next) {
return res.status(500).json({responseCode:1, responseMessage: 'an error occured', errorData: err});
})
app.listen(global.config.PORT, ()=>{
console.log(`app is running on ${global.config.PORT}`);
});
childProcess.exec(`node ${__dirname}/test/test.js`);
|
module.exports = (sequelize, DataTypes) => {
const SeriesTags = sequelize.define(
'series_tags',
{
series_id: {
type: DataTypes.INTEGER,
allowNull: false,
primaryKey: true,
onDelete: 'CASCADE',
},
tag_id: {
type: DataTypes.INTEGER,
allowNull: false,
primaryKey: true,
onDelete: 'CASCADE',
},
},
{ underscored: true, timestamps: false }
);
return SeriesTags;
};
|
import bip39 from 'bip39';
import REWToken from './contracts/rew-token';
import getWeb3 from './web3';
import Config from '../config';
import EthCrypto from 'eth-crypto';
class WalletApi {
constructor() {
this.address = null;
}
async getTotalTokenAmount(tokensInput) {
const web3 = await getWeb3();
const rew = await REWToken.contract;
const BN = web3.utils.BN;
let tokens = new BN(tokensInput, 10);
let ten = new BN(10, 10);
let decimals = new BN(await rew.methods.decimals().call())
return tokens.mul(ten.pow(decimals));
}
async getTokenAmountFormatted(tokensInput) {
const web3 = await getWeb3();
const rew = await REWToken.contract;
const BN = web3.utils.BN;
let tokens = new BN(tokensInput, 10);
let ten = new BN(10, 10);
let decimals = new BN(await rew.methods.decimals().call())
console.log(tokensInput, tokens.div(ten.pow(decimals)).toNumber())
return tokens.div(ten.pow(decimals)).toNumber();
}
async getMyBalance() {
const rew = await REWToken.contract;
const decimals = Number(await rew.methods.decimals().call())
let balance = Number(await rew.methods.balanceOf(this.getMyAddress()).call())
return balance / 10**decimals
}
getPublicKey(wallet) {
return EthCrypto.publicKeyByPrivateKey(wallet[0].privateKey);
}
getMyAddress() {
return this.address;
}
setMyAddress(address) {
this.address = address;
}
setPrivateKey(key) {
this.privateKey = key;
}
getMyPrivateKey() {
return this.privateKey;
}
getMnemonic() {
return bip39.generateMnemonic();
}
async approveREWs(amount) {
const config = await Config.config;
const address = config.REVIEW_NETWORK_ADDRESS;
const rew = await REWToken.contract;
let totalAmount = await this.getTotalTokenAmount(amount);
return REWToken.sendSigned(rew.methods.approve(address, totalAmount));
}
// clearing on logout
async clear() {
const web3 = await getWeb3();
this.setPrivateKey('');
this.setMyAddress('');
sessionStorage.removeItem(`wallet`);
await web3.eth.accounts.wallet.clear();
}
// reload from sessionStorage
reload() {
const wallet = JSON.parse(sessionStorage.getItem('wallet'));
if (wallet) {
this.setMyAddress(wallet.address);
this.setPrivateKey(wallet.privateKey);
}
return wallet;
}
// load wallet on login
async load(email, password) {
try {
const web3 = await getWeb3();
const wallet = web3.eth.accounts.wallet.load(password, email)[0];
this.setMyAddress(wallet.address);
this.setPrivateKey(wallet.privateKey);
sessionStorage.setItem(`wallet`, JSON.stringify(wallet));
return wallet;
} catch (err) {
alert('Wrong Credentials!');
}
}
// create wallet on register
async create(mnemonic, email, password) {
const web3 = await getWeb3();
const wallet = web3.eth.accounts.wallet.create(
1,
bip39.mnemonicToSeedHex(mnemonic),
)[0];
this.setMyAddress(wallet.address);
this.setPrivateKey(wallet.privateKey);
web3.eth.accounts.wallet.save(password, email);
sessionStorage.setItem(`wallet`, JSON.stringify(wallet));
return wallet;
}
}
export default new WalletApi();
|
/**
* main.js
* Checkout that submits orders to ecommerce store
*/
(async () => {
'use strict';
/**
* Reference the main form
*/
// Create references to the main form and its submit button.
const form = document.getElementById('payment-form');
const submitButton = form.querySelector('button[type=submit]');
/**
* Display product information on the form
*/
// Option One Card Display Text
form.querySelector("#op-one > .left").innerHTML = `${op.one.displayBest} ${op.one.displayName} ${op.one.displayPromo}`;
form.querySelector("#op-one > .right").innerHTML = `${op.one.displayPrice} ${op.one.displayShipping}`;
// Option Two Card Display Text
form.querySelector("#op-two > .left").innerHTML = `${op.two.displayBest} ${op.two.displayName} ${op.two.displayPromo}`;
form.querySelector("#op-two > .right").innerHTML = `${op.two.displayPrice} ${op.two.displayShipping}`;
// Option Three Card Display Text
form.querySelector("#op-three > .left").innerHTML = `${op.three.displayBest} ${op.three.displayName} ${op.three.displayPromo}`;
form.querySelector("#op-three > .right").innerHTML = `${op.three.displayPrice} ${op.three.displayShipping}`;
// Option Four Card Display Text
form.querySelector("#op-four > .left").innerHTML = `${op.four.displayBest} ${op.four.displayName} ${op.four.displayPromo}`;
form.querySelector("#op-four > .right").innerHTML = `${op.four.displayPrice} ${op.four.displayShipping}`;
// Option Five Card Display Text
form.querySelector("#op-five > .left").innerHTML = `${op.five.displayBest} ${op.five.displayName} ${op.five.displayPromo}`;
form.querySelector("#op-five > .right").innerHTML = `${op.five.displayPrice} ${op.five.displayShipping}`;
/**
* Setup Stripe Elements.
*/
// Create an instance of Elements.
const elements = stripe.elements();
// Prepare the styles for Elements.
const style = {
base: {
iconColor: '#666ee8',
color: '#31325f',
fontWeight: 400,
fontFamily:
'-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif',
fontSmoothing: 'antialiased',
fontSize: '15px',
'::placeholder': {
color: '#aab7c4',
},
':-webkit-autofill': {
color: '#666ee8',
},
},
};
/**
* Implement a Stripe Card Element that matches the look-and-feel of the app.
*/
// Create a Card Element and pass some custom styles to it.
const card = elements.create('card', {hidePostalCode: true, style});
// Mount the Card Element on the page.
card.mount('#card-element');
// Monitor change events on the Card Element to display any errors.
card.on('change', ({error}) => {
const cardErrors = document.getElementById('card-errors');
if (error) {
cardErrors.textContent = error.message;
cardErrors.classList.add('visible');
} else {
cardErrors.classList.remove('visible');
}
// Re-enable the Pay button.
submitButton.disabled = false;
});
/**
* Handle the form submission.
*/
// Listen to changes to the user-selected country.
form
.querySelector('select[name=country]')
.addEventListener('change', event => {
event.preventDefault();
selectCountry(event.target.value);
});
// Submit handler for our payment form.
form.addEventListener('submit', async event => {
event.preventDefault();
// setTimeout("location.href = 'thank-you.html';",5000);
// window.location.replace("thank-you.html");
// Retrieve the selected product options from the form.
let selection = form.querySelector('input[name=option]:checked').value;
// Update product choice based on the users selection
switch (selection) {
case 'one':
selection = op.one;
console.log("Option one");
break;
case 'two':
selection = op.two;
console.log("Option two");
break;
case 'three':
selection = op.three;
console.log("Option three");
break;
case 'four':
selection = op.four;
console.log("Option four");
break;
case 'five':
selection = op.five;
console.log("Option five");
break;
};
// Retrieve the user information from the form.
const payment = form.querySelector('input[name=payment]:checked').value;
const country = form.querySelector('select[name=country] option:checked')
.value;
const email = form.querySelector('input[name=email]').value;
// Build a data Object to pass with the order to the Store
let data = {
payment_method: '',
payment_method_title: '',
status: 'pending',
billing: {
first_name: form.querySelector('input[name=first_name]').value,
last_name: form.querySelector('input[name=last_name]').value,
address_1: form.querySelector('input[name=address_1]').value,
address_2: form.querySelector('input[name=address_2]').value,
city: form.querySelector('input[name=city]').value,
postcode: form.querySelector('input[name=postcode]').value,
country: country,
email: email,
phone: form.querySelector('input[name=phone]').value
},
shipping: {
first_name: form.querySelector('input[name=first_name]').value,
last_name: form.querySelector('input[name=last_name]').value,
address_1: form.querySelector('input[name=address_1]').value,
address_2: form.querySelector('input[name=address_2]').value,
city: form.querySelector('input[name=city]').value,
postcode: form.querySelector('input[name=postcode]').value,
country: country
},
line_items: [
{
product_id: selection.product_id,
quantity: selection.quantity,
total: selection.total
}
]
};
// Update Payment Method and Payment Method Title based on User Selection
let sourceId = "";
switch (payment) {
case 'card':
data.payment_method = 'stripe';
data.payment_method_title = 'Cartão de Débito ou Crédito';
// Create Stripe Source, IF Success, submitOrder
stripe
.createSource(card, {
type: 'card',
owner: {
email: data.email
},
})
.then( result => {
if (result.error) {
// Inform the user if there was an error
let errorElement = document.getElementById('card-errors');
errorElement.textContent = result.error.message;
console.log("Error: ", result.error.message);
} else {
// Send the source to the server
sourceId = result.source.id;
console.log("Success: New source ", sourceId);
submitOrder(data, sourceId);
}
});
break;
case 'multibanco':
data.payment_method = 'multibanco_gateway';
data.payment_method_title = 'Referência Multibanco';
// Call the submitOrder function with an null source
submitOrder(data, sourceId);
break;
case 'cod':
data.payment_method = 'cod';
data.payment_method_title = 'Pagamento na Entrega';
data.status = 'processing';
// aqui posso meter o status em Em Processamento!!!
// Call the submitOrder function with an null source
submitOrder(data, sourceId);
break;
};
// Disable the Pay button to prevent multiple click events.
submitButton.disabled = true;
submitButton.textContent = 'Processing…';
});
/**
* Process the order.
*/
// Send order to the server
const submitOrder = (orderData, sourceId) => {
// Prepare the request url
let url = baseUrl + 'orders';
let myHeaders = new Headers();
myHeaders.append("Authorization", myAuth);
myHeaders.append("Content-Type", "application/json");
let requestOptions = {
method: 'POST',
headers: myHeaders,
body: JSON.stringify(orderData),
redirect: 'follow'
};
fetch(url, requestOptions)
.then(response => {
return response.json();
})
.then((data) => {
console.log('New order created: ', data.id);
// Prepare request urls for the next function call
if (data.payment_method === 'multibanco_gateway') {
url = baseUrl + 'multibanco_gateway';
console.log("Enviado para:", url);
// call the processPayment function
processPayment(data.id, data.payment_method, sourceId, url)
} else if (data.payment_method === 'stripe') {
url = baseUrl + 'stripe_payment';
console.log("Enviado para:", url)
// call the processPayment function
processPayment(data.id, data.payment_method, sourceId, url)
} else {
console.log("Processo concluído! (outros métodos de pagamento)")
redirectPost(data.id);
}
})
.catch((error) => {
console.log('Error', error);
});
};
// Instruct the store to process the payment
const processPayment = (orderId, paymentMethod, sourceId, url) => {
let myHeaders = new Headers();
myHeaders.append("Authorization", myAuth);
myHeaders.append("Content-Type", "application/json");
let raw = JSON.stringify({"order_id":orderId,"payment_method":paymentMethod,"payment_token":sourceId});
let requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};
fetch(url, requestOptions)
.then(response => response.json())
.then(result => {
console.log('Payment status: ', result.message);
redirectPost(orderId);
})
.catch(error => {
console.log('Error', error);
redirectPost(orderId);
})
};
// Redirect to thank you page after completed submission
const redirectPost = (data) => {
window.location.replace("thank-you.html?id=" + btoa(data));
};
/**
* Display the relevant payment methods for a selected country.
*/
// List of relevant countries for the payment methods supported in this demo.
// Read the Stripe guide: https://stripe.com/payments/payment-methods-guide
const paymentMethods = {
card: {
name: 'Card',
flow: 'none',
},
multibanco: {
name: 'Multibanco',
flow: 'receiver',
countries: ['PT'],
currencies: ['eur'],
},
cod: {
name: 'Envio à Cobrança',
flow: 'none',
countries: ['PT'],
currencies: ['eur'],
},
};
const selectCountry = country => {
const selector = document.getElementById('country');
selector.querySelector(`option[value=${country}]`).selected = 'selected';
selector.className = `field ${country}`;
// Trigger the methods to show relevant fields and payment methods on page load.
showRelevantFormFields();
showRelevantPaymentMethods();
};
// Show only form fields that are relevant to the selected country.
const showRelevantFormFields = country => {
if (!country) {
country = form.querySelector('select[name=country] option:checked').value;
}
const zipLabel = form.querySelector('label.zip');
// Only show the state input for the United States.
zipLabel.parentElement.classList.toggle('with-state', country === 'US');
// Update the ZIP label to make it more relevant for each country.
form.querySelector('label.zip span').innerText =
country === 'US' ? 'ZIP' : country === 'PT' ? 'Código Postal' : 'Postal Code';
};
// Show only the payment methods that are relevant to the selected country.
const showRelevantPaymentMethods = country => {
if (!country) {
country = form.querySelector('select[name=country] option:checked').value;
}
const paymentInputs = form.querySelectorAll('input[name=payment]');
for (let i = 0; i < paymentInputs.length; i++) {
let input = paymentInputs[i];
input.parentElement.classList.toggle(
'visible',
input.value === 'card' ||
(suportedPaymentMethods.includes(input.value) &&
paymentMethods[input.value].countries.includes(country) &&
paymentMethods[input.value].currencies.includes(defaultCurrency))
);
}
// Hide the tabs if card is the only available option.
const paymentMethodsTabs = document.getElementById('payment-methods');
paymentMethodsTabs.classList.toggle(
'visible',
paymentMethodsTabs.querySelectorAll('li.visible').length > 1
);
// Check the first payment option again.
paymentInputs[0].checked = 'checked';
form.querySelector('.payment-info.card').classList.add('visible');
form.querySelector('.payment-info.cod').classList.remove('visible');
form.querySelector('.payment-info.multibanco').classList.remove('visible');
//updateButtonLabel(paymentInputs[0].value);
};
// Listen to changes to the payment method selector.
for (let input of document.querySelectorAll('input[name=payment]')) {
input.addEventListener('change', event => {
event.preventDefault();
const payment = form.querySelector('input[name=payment]:checked').value;
const flow = paymentMethods[payment].flow;
// Show the relevant details, whether it's an extra element or extra information for the user.
form
.querySelector('.payment-info.card')
.classList.toggle('visible', payment === 'card');
form
.querySelector('.payment-info.cod')
.classList.toggle('visible', payment === 'cod');
form
.querySelector('.payment-info.multibanco')
.classList.toggle('visible', payment === 'multibanco');
document
.getElementById('card-errors')
.classList.remove('visible', payment !== 'card');
});
}
// Select the default country from the config on page load.
let country = defaultCountry;
// Override it if a valid country is passed as a URL parameter.
// Example comming from the landing page with http://localhost:8000/?country=ES
const urlParams = new URLSearchParams(window.location.search);
let countryParam = urlParams.get('country')
? urlParams.get('country').toUpperCase()
: country;
if (form.querySelector(`option[value="${countryParam}"]`)) {
country = countryParam;
}
selectCountry(country);
})();
|
'use strict';
const request = require('request-promise-native')
const Botkit = require('botkit')
const parseXml = require('xml2js').parseString
const momentjs = require('moment')
const momentrange = require('moment-range')
const find = require('lodash.find')
const controller = Botkit.slackbot({})
const moment = momentrange.extendMoment(momentjs);
const bot = controller.spawn({
incoming_webhook: {
url: process.env.SLACK_WEBHOOK
}
})
function whosOut() {
const date = new Date()
console.log('Whos out running\nCurrent time is: ' + date.getHours() + ':' + date.getMinutes())
const startQuery = moment(date).format("YYYY-MM-DD");
const endQuery = moment(date).add('7','days').format("YYYY-MM-DD");
const options = {
url: 'https://' + process.env.BAMBOOHR_TOKEN + ':x@api.bamboohr.com/api/gateway.php/' + process.env.BAMBOOHR_SUBDOMAIN + '/v1/time_off/whos_out/?start='+startQuery+'&end='+endQuery
}
console.log(options);
var data;
request(options).then(function(xml) {
parseXml(xml, function(err, result) {
if (err) {
console.log('XML PARSE ERROR:', err)
return
}
const responseArray = []
responseArray.push('*Who is out this week*');
// Process Today
if(result.calendar == null || result.calendar.length == 0 ){
responseArray.push("All Hands OnBoard!")
}else{
result.calendar.item.forEach(item => {
console.log("Item"+JSON.stringify(item))
if(item.$.type == "holiday"){
var name = item.holiday[0]._
const startDate = moment(item.start[0])
//const endDate = moment(item.end[0])
responseArray.push("🎉"+name+"🎉 "+startDate.format("MMM DD"))
}else{
const startDate = moment(item.start[0])
const endDate = moment(item.end[0])
const entryRange = moment.range(startDate, endDate)
var start = moment().startOf('day'); // set to 12:00 am today
var end = moment().endOf('day'); // set to 23:59 pm today
const today = moment.range(start,end)
//Setting week start to Monday
const weekStart = moment().startOf('isoweek')
//Setting week end to Friday
const weekEnd = moment().endOf('isoweek').subtract('2', 'days')
const thisWeek = moment.range(weekStart,weekEnd)
const eventDetails = {
name : item.employee[0]._,
start : startDate.isSame(start) ? " today" : startDate.format("MMM DD"),
end: startDate.isSame(endDate)?"": " to "+endDate.format("MMM DD")
}
if(item.$.type == "timeOff"){
const name = item.employee[0]._;
responseArray.push(eventDetails.name+" is off "+eventDetails.start+eventDetails.end)
}
}
});
}
console.log(responseArray.join('\n'))
bot.sendWebhook({
text: responseArray.join('\n'),
username: 'Bueller, Bueller Bot',
icon_emoji: ':date:'
}, function(err) {
if (err) {
console.log(err)
} else console.log('message sent!');
});
})
})
}
function formatArrayToString(array) {
if (array.length < 1) {
console.log('formatArray needs an array with a length greater than 0!')
return
}
let resultArr = []
for (let i = 0; i < array.length; i += 1) {
let newArr = []
newArr.push('>' + '*' + array[i].name + '*')
newArr.push('_' + array[i].days.join(', ') + '_')
newArr = newArr.join(': ')
resultArr.push(newArr)
}
return resultArr.join('\n')
}
module.exports = whosOut
|
/**
* Created by wen on 2016/8/16.
*/
import React, { PropTypes,Component } from 'react';
import ClassName from 'classnames';
import {TextArea,LocalButton,Toast} from "../../../components";
import s from './BMmodifyPwd.css';
import history from '../../../core/history';
import {clientFetch} from "../../../utils/clientFetch"
class BMmodifyPwd extends Component {
constructor(props) {
super(props);
this.state = {
code: "",
isToast: false,
ToastMsg: "",
isBtn: true,
mobileCode: "",
};
this.data = {
localBtn: {
btnText1: "取消",
btnText2: "提交",
btnCB1: ()=> {
history.go(-1);
},
btnCB2: ()=> {
let oldPWD = this.refs.nickname.getValue().state ? this.refs.nickname.getValue() : this.matchValue(this.refs.nickname.getValue()),
newPWD = this.refs.nickname2.getValue().state ? this.refs.nickname2.getValue() : this.matchValue(this.refs.nickname2.getValue());
if (oldPWD.val == newPWD.val) {
return this.showToast({msg: "新密码和旧密码不能相同"});
}
if (oldPWD.state && newPWD.state) {
this.compare("/member/login", oldPWD.val).then(res=> {
return true ? this.compare("/member/resizepassword", newPWD.val) : this.showToast({msg: "密码修改失败,请重试！"});
}).then(res=> {
return res.code === 200 ? this.showToast({msg: "密码修改成功"}) : this.showToast({msg: "密码修改失败,请重试！"});
})
setTimeout(()=>{
history.go(-1);
},2000)
}
},
btnStyle: ["bg1", "fz2", "color2"],
border: true,
},
}
}
static contextTypes = {
insertCss: PropTypes.func.isRequired,
setTitle: PropTypes.func.isRequired,
setState: PropTypes.func,
showLoad: PropTypes.func,
clearLoad: PropTypes.func,
};
componentWillMount() {
const { insertCss,setTitle } = this.context;
this.removeCss = insertCss(s);
setTitle("修改密码");
}
componentDidMount() {
this.context.clearLoad();
}
componentWillUnmount() {
this.removeCss()
}
compare(url, pwd) {
let param = {account_name: this.GetQueryString("account_name"), password: pwd};
console.log(param);
return clientFetch(url, param);
}
GetQueryString(name) {
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
var r = window.location.search.substr(1).match(reg);
if (r != null)return unescape(r[2]);
return null;
}
showToast(opt) {
console.log(opt);
this.setState({
isToast: false,
})
setTimeout(()=> {
this.setState({
isToast: true,
ToastMsg: opt.msg
})
}, 100)
return opt;
}
matchValue(opt) {
for (var o in opt) {
if (!opt[o].state) {
return this.showToast(opt);
}
}
return true;
}
btnCB() {
console.log("nickname")
}
render() {
return (
<div className={s.modifyNickname}>
{this.state.isToast && <Toast showText={this.state.ToastMsg}/>}
<LocalButton {...this.data.localBtn} />
<TextArea ref="nickname" type="password" validaType={['required',"pwd"]} placeholder="请输入原密码"/>
<TextArea ref="nickname2" type="password" validaType={['required',"pwd"]} placeholder="请输入新密码"/>
</div>
);
}
}
export default BMmodifyPwd;
|
/**
* 拿梦想做赌注，我怎么舍得输
*/
let fs = require('fs');
//1.如果文件不存在会自动创建
//2.写默认都是utf8格式
//3.每次写最大是16k，读64写16 就占用了内存
let ws = fs.createWriteStream('./4.txt');
var flag = ws.write('1'); //flag 只是一个条件，可以告诉当前是否还需要继续读写，限制读的速率 读是疯狂的读 如果返回false 让读取暂停
ws.end('吃的好多'); //强制将没写入的全部写入 然后关闭 在end后不能再调用write方法
|
const pinPointsOnMap = locations => {
let map = L.map('mapContainer').setView([-37.81, 144.96], 8);
L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
}).addTo(map);
locations.forEach(location => {
marker = new L.marker([location[1],location[2]])
.bindPopup(location[0])
.addTo(map);
})
console.log('locations', locations)
//const group = new L.featureGroup();
const latLongPoints = location => location.slice(1);
const boundingBox = L.latLngBounds(locations.map(latLongPoints));
map.fitBounds(boundingBox);
}
const getData = url => {
fetch(url)
.then(res => res.json)
.then(json => console.log(json[data]))
}
if (/\/found_animals\/?$/.test(window.location.pathname)) {
const foundLocations = [];
let foundData = document.querySelector('#found-animal-data').dataset.animals;
foundData = JSON.parse(foundData);
//foundData = getData('/api/found_animals')
console.log('foundData', foundData)
for(let i = 0; i < foundData.location.length; i++) {
foundLocations.push([foundData.location[i], foundData.lat[i], foundData.long[i]]);
}
console.log(foundLocations)
pinPointsOnMap(foundLocations);
}
if (/\/lost_animals\/?$/.test(window.location.pathname)) {
const lostLocations = [];
let lostData = document.querySelector('#lost-animal-data').dataset.animals;
lostData = JSON.parse(lostData);
//console.log(lostData)
for(let i = 0; i < lostData.location.length; i++) {
lostLocations.push([lostData.location[i], lostData.lat[i], lostData.long[i]]);
}
//console.log(lostLocations)
pinPointsOnMap(lostLocations);
}
|
/**
* Created by lusiwei on 2016/9/22.
*/
'use strcit';
import requests from '../requests'
import config from '../config/base'
export const SET_TICKETS = 'SET_TICKETS';
export const SET_COUNT = 'SET_COUNT';
export const SET_ACTIVE_ITEM = 'SET_ACTIVE_ITEM';
export function setTickets(tickets) {
return {
type: SET_TICKETS,
tickets
}
}
export function setCount(count) {
return {
type: SET_COUNT,
count
}
}
export function setActiveItem(item) {
return {
type: SET_ACTIVE_ITEM,
item
}
}
export function fetchTickets(date) {
return function () {
// return requests.get(config.route.tickets, {date});
return new Promise((resolve, reject) => {
resolve({
"date": "2016-9-16",
"result": "00",
"ticketList": [{
"ticketCode": "005001000000",
"ticketName": "展馆门票 全票",
"price": 40,
"origPrice": 0
}, {"ticketCode": "005002000000", "ticketName": "展馆门票 半票", "price": 20, "origPrice": 0}]
});
})
}
}
|
import React, { Component } from 'react';
class RaceTab extends Component {
render(){
return (
<div onClick={this.props.onClick}>
<p>
{this.props.race.race_id}
</p>
</div>
)
}
}
export default RaceTab
|
const test = require('tape');
const toKebabCase = require('./toKebabCase.js');
test('Testing toKebabCase', (t) => {
//For more information on all the methods supported by tape
//Please go to https://github.com/substack/tape
t.true(typeof toKebabCase === 'function', 'toKebabCase is a Function');
t.equal(toKebabCase('camelCase'), 'camel-case', "toKebabCase('camelCase') returns camel-case");
t.equal(toKebabCase('some text'), 'some-text', "toKebabCase('some text') returns some-text");
t.equal(toKebabCase('some-mixed-string With spaces-underscores-and-hyphens'), 'some-mixed-string-with-spaces-underscores-and-hyphens', "toKebabCase('some-mixed-string With spaces-underscores-and-hyphens') returns some-mixed-string-with-spaces-underscores-and-hyphens");
t.equal(toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML'), 'i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html', "toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html");
t.equal(toKebabCase(), undefined, 'toKebabCase() return undefined');
t.throws(() => toKebabCase([]), 'toKebabCase([]) throws an error');
t.throws(() => toKebabCase({}), 'toKebabCase({}) throws an error');
t.throws(() => toKebabCase(123), 'toKebabCase(123) throws an error');
let start = new Date().getTime();
toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML');
let end = new Date().getTime();
t.true((end - start) < 2000, 'toKebabCase(IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML) takes less than 2s to run');
t.end();
});
|
$( ".button" ).click(function() {
console.log('stop geen logica direct in een listener functie');
console.log('maar roep de desgewenste business logic aan');
showInformation();
});
function showInformation()
{
console.log("de logica in deze functie is vanuit verschillende plekken aan te roepen");
}
|
var Filter = require('broccoli-filter');
AnalyticsFilter.prototype = Object.create(Filter.prototype);
AnalyticsFilter.prototype.constructor = AnalyticsFilter;
function AnalyticsFilter(inputNode, options) {
Filter.call(this, inputNode, {
annotation: 'AnalyticsFilter'
});
this.trackingId = options.trackingId;
this.fields = options.defaultFields || {};
this.debug = options.debug || false;
this.protocol = options.protocol || 'https://';
this.trackingFile = this.debug ? 'analytics_debug.js' : 'analytics.js';
}
AnalyticsFilter.prototype.extensions = ['js'];
AnalyticsFilter.prototype.targetExtension = 'js';
AnalyticsFilter.prototype.processString = function(content, relativePath) {
return content
.replace(/###PROTOCOL###/g, this.protocol)
.replace(/###FILE###/g, this.trackingFile)
.replace(/###TRACKINGID###/g, "'" + this.trackingId + "'")
.replace(/###FIELDS###/g, JSON.stringify(this.fields));
};
module.exports = AnalyticsFilter;
|
var XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;
var service = require("./servicesRep");
exports.processRes = function(sessionid,value,id,cb){
switch(id){
case '221': url="https://localhost:3000/Account_Enquery/CHQREQ/"+sessionid+"/"+value;
var xhttp = new XMLHttpRequest();
xhttp.open("GET",url , false);
xhttp.send(null);
var response = xhttp.responseText;
console.log(response);
return cb('CHAT| '+response);
break;
default: return cb("CHAT| Incorrect input.");
}
}
|
import './home.html';
import '../../components/recipe_form/recipe_form.js';
import '../../components/ingredient_form/ingredient_form.js';
import '../../components/ingredient_list/ingredient_list.js';
import '../../components/recipe_add_ingredient/recipe_add_ingredient.js';
import '../../components/recipe_list/recipe_list.js';
import '../../components/recipe_show/recipe_show.js';
import '../../components/recipe_search/recipe_search.js';
import '../../components/ingredient_search/ingredient_search.js';
import '../../components/ingredient_search_list/ingredient_search_list.js';
import '../../components/recipe_search_list/recipe_search_list.js';
import '../../components/ingredient_show/ingredient_show.js';
import '../../components/side_nav/side_nav.js';
import '../../components/header/header.html';
import { Meteor } from 'meteor/meteor';
import { ReactiveDict } from 'meteor/reactive-dict'
import { Template } from 'meteor/templating';
Template.App_home.onCreated(function () {
this.state = new ReactiveDict;
this.state.set('selected', 'recipe');
});
Template.App_home.helpers({
selected() {
return Template.instance().state.get('selected');
}
});
Template.App_home.events({
'click .recipe': function (event) {
Template.instance().state.set('selected', 'recipe');
},
'click .ingredient': function (event) {
Template.instance().state.set('selected', 'ingredient');
},
});
|
var client = require('./client')
var gql = require('graphql-tag')
var values = require('lodash/values')
function fetchItems() {
return client.query({
query: gql`
query {
todos: allTodoes {
id
text
done
}
}
`
})
.then(({ data }) => data.todos)
.catch(error => console.error(error));
}
function addItem(item) {
return client.mutate({
mutation: gql`
mutation ($text: String!) {
createTodo(text: $text, done: false) { id text done }
}
`,
variables: item
})
.then(({ data }) => data.createTodo)
.catch(error => console.error(error));
}
function deleteItems(items) {
return client.mutate({
mutation: gql`
mutation {
${items.map((item, i) => `
${item.id}: deleteTodo(id: "${item.id}") {
id
text
}
`)}
}
`
})
.then(({ data }) => values(data))
}
function updateItem(item) {
var params = `id: "${item.id}"`
// support dynamic params
if (item.text !== undefined)
params += `, text: "${item.text}"`
if (item.done !== undefined)
params += `, done: ${item.done}`
return client.mutate({
mutation: gql`
mutation {
updateTodo(${params}) {
id
text
done
}
}
`
})
.then(({ data }) => data.updateTodo)
}
module.exports = {
fetchItems, addItem, deleteItems, updateItem
}
|
let promise = new Promise((resolve, reject) => {
// reject(new TypeError('error'));
reject('error');
}).then((result, error) => {
console.log(result);
console.log('222');
console.error(error);
});
// Promise.resolve(true).then(result => {
// console.log(result);
// })
|
var app;
var store = false;
var server = 'https://cloud.sobhe.ir/zolal/';
var chrome_app = 'chrome' in window && 'app' in chrome && chrome.app.isInstalled;
var android_app = 'cordova' in window;
var searchResultChars = android_app ? 25 : 50;
var partialRendering = false;
// apps
if (chrome_app || android_app)
store = true;
// device events
document.addEventListener('deviceready', function() {
navigator.splashscreen.hide();
window.plugins.insomnia.keepAwake();
$('a[target]').click(function(){
window.open($(this).attr('href'), '_system');
return false;
});
}, false);
document.addEventListener('menubutton', function() {
app.address.trigger('menu');
}, false);
document.addEventListener('backbutton', function(e) {
// back on input
focused = $(':focus');
if (focused.length && focused[0].tagName == 'INPUT') {
focused.blur().typeahead('close');
app.address.render();
e.preventDefault();
return;
}
// back on modal
if ($('.modal').is(':visible')) {
$('.modal').modal('hide');
return;
}
// up button
if (app.position.mode == 'quran')
navigator.app.exitApp();
else {
history.back();
// back without history
var last_position = $.extend({}, app.position);
setTimeout(function() {
if (JSON.stringify(last_position) == JSON.stringify(app.position))
app.showQuran();
}, 25);
}
}, false);
if (chrome_app)
$('#installation #chrome').hide()
if (android_app)
$('#installation').hide()
$('[rel=menu]').show();
if (android_app)
$('.quran [rel=menu]').hide();
// app initialization
var initApp = function() {
$('#wrap').removeClass('loading');
app = new AppView();
app.router = new AddressRouter();
Backbone.history.start();
// navigate to previous location
if (Backbone.history.getFragment() == '') {
address = '';
position = app.position;
if (position.mode == 'quran') {
if (position.quran.aya != '')
address = 'quran/'+ position.quran.sura +'_'+ position.quran.aya;
else
address = 'quran/p'+ position.quran.page;
} else if (position.mode == 'detail') {
address = 'detail/'+ position.detail.sura +'_'+ position.detail.aya;
} else if (position.mode == 'tafsir') {
address = 'almizan_' + position.tafsir.lang +'/';
if (position.tafsir.aya)
address += position.tafsir.aya;
else
address += position.tafsir.section +'/i'+ position.tafsir.part;
}
app.router.navigate(address, {trigger: true});
}
download_quran(server +'quran/');
if (store) {
$('.storage').show();
$('#download-tafsir').click(download_tafsir);
}
$(window).resize();
track('Zolal');
}
// window
$(window).resize(function() {
$('.twitter-typeahead .tt-dropdown-menu').css('max-height', $('#views').height());
});
// settings dialog
$('select#language').val(variables.lang).change(function() {
$('#pages').html('');
variables.lang = $(this).val();
app.position.tafsir.lang = variables.lang;
app.render();
show_tafsir_stats();
});
// gestures
$("#views").swipe({
tap: function(e) {
if (e.type != 'mouseup') {
$(e.target).click();
if (e.target.id == 'page')
$(e.target).toggleClass('active');
}
},
swipeLeft: function() {
app.$el.find('.front').find('.glyphicon-chevron-right').click();
},
swipeRight: function() {
app.$el.find('.front').find('.glyphicon-chevron-left').click();
}
});
// track
var trackedData;
var track = function(title, data) {
if ('amplitude' in window && data != trackedData && navigator.onLine)
amplitude.getInstance().logEvent(title, data);
trackedData = data;
}
// download
var requestUrls = function(urls, index, isStored, storeData, progress) {
if (index >= urls.length && progress)
progress(100);
isStored(urls[index], function() {
if (progress) progress(100*index/urls.length);
requestUrls(urls, index+1, isStored, storeData, progress);
}, function() {
settings = {
context: {url: urls[index]},
url: server + urls[index],
success: function(data) {
storeData(this.url, data);
if (progress) progress(100*index/urls.length);
requestUrls(urls, index+1, isStored, storeData, progress);
},
error : function(xhr, textStatus) {
setTimeout(function() { $.ajax(this.settings); }, 1000);
console.log('retry in 1 second ...');
}
};
settings.context.settings = settings;
$.ajax(settings);
});
};
var tafsir_progress = function(percent) {
if (percent == 100) {
$('#download-state').hide();
$('#complete-state').show();
$('#download-progress').removeClass('active');
}
else {
$('#download-state').show();
$('#complete-state').hide();
}
$('#download-progress .progress-bar').width(Math.round(percent) +'%');
};
var download_tafsir = function() {
$('#download-tafsir').attr('disabled', 'disabled');
$('#download-progress').addClass('active');
track('Almizan Download', {'lang': variables.lang});
var storeData = function(url, data) {
bayan = new Bayan({id: url.substr(8), content: data});
bayan.save();
}
var isStored = function(url, success, error) {
bayan = new Bayan({id: url.substr(8)});
bayan.fetch({success: success, error: error});
}
urls = _.map(almizan_sections, function(section) { return 'almizan_'+ variables.lang +'/'+ section; });
requestUrls(urls, 0, isStored, storeData, tafsir_progress);
};
var show_tafsir_stats = function() {
almizan = new Almizan();
almizan.fetch({
success: function() {
sections = almizan.models.filter(function(item) {
return item.id.substr(0,2) == variables.lang;
});
tafsir_progress(100 * sections.length / almizan_sections.length);
}
});
}
var download_quran = function(origin) {
if (!localStorage.Quran || localStorage.Quran.split(',').length < 6230) {
request = $.when($.get(origin +'all'), $.getJSON(origin +'fa')).done(function(all, fa) {
parse_quran(all[0], fa[0]);
});
if (!android_app) {
$('#search').parent().addClass('loading');
request.then(function() { $('#search').parent().removeClass('loading'); });
}
return request;
}
return $.Deferred().resolve();
}
var parse_quran = function(data, trans) {
var ids = [], raws = '';
data.split('\n').forEach(function(aya) {
if (!aya) return;
i = aya.indexOf('id'); r = aya.indexOf('raw');
id = aya.substr(i + 6).slice(0, -2);
raws += id + aya.substr(r+3, i-r-3);
if (id in trans)
aya = aya.substr(0, aya.length-1) +', "fa": "'+ trans[id] +'"}';
localStorage['Quran-'+ id] = aya;
ids.push(id);
});
localStorage.Quran = ids.join(',');
localStorage.QuranTokens = normalize('{"'+ raws.slice(0, -3) +'}');
};
// main
if (!android_app || localStorage.Quran)
initApp();
else {
download_quran('').then(function() {
initApp();
});
}
|
import React from 'react'
import CopyRight from './CopyRight'
const Footer = () => {
return (
<div className="fluid-container py-2 text-center" style={{ backgroundColor: 'black', color: 'white' }}>
{/* <div className="row ">
<div className="col-md-3 col-sm-6">
The href attribute requires a valid value to be accessible. Provide a valid, navigable address as the href value. If you cannot provide a valid href, but
still need the element to resemble a link, use a button and change it with appropriate styles.
</div>
<div className="col-md-3 col-sm-6">
The href attribute requires a valid value to be accessible. Provide a valid, navigable address as the href value. If you cannot provide a valid href, but
still need the element to resemble a link, use a button and change it with appropriate styles.
</div>
<div className="col-md-3 col-sm-6">
The href attribute requires a valid value to be accessible. Provide a valid, navigable address as the href value. If you cannot provide a valid href, but
still need the element to resemble a link, use a button and change it with appropriate styles.
</div>
<div className="col-md-3 col-sm-6">
The href attribute requires a valid value to be accessible. Provide a valid, navigable address as the href value. If you cannot provide a valid href, but
still need the element to resemble a link, use a button and change it with appropriate styles.
</div>
</div> */}
<CopyRight></CopyRight>
</div>
)
}
export default Footer
|
const Eventgamehandler = require('../../modules/IMPmodules/eventgamehandler')
const eventgamehandler = new Eventgamehandler()
const utils1 = require("../../modules/IMPmodules/util")
const util = new utils1()
const deathhandle = require('../../handler/deathhandle')
const pterodactylgrab = require('../objects/abilitys/pterodactylgrab')
function godown(entities, player, which) {
entities[player].fallvelocity = 1
let startgodown = Date.now() + 2000;
let newgodown = setInterval(() => {
if (!entities[player]) { clearInterval(newgodown); return };
if (startgodown <= Date.now()) {
if (entities[player].z > 0) {
entities[player].goingsky = false
} else {
clearInterval(newgodown)
entities[player].abilitys.button_w.abil_active = false
entities[player].z = 0
entities[player].specType = 0
entities[player].isabletoboost = true
entities[player].specType2 = 0
entities[player].isgliding = false
entities[player].usingability = false
entities[player].isflying = false
entities[player].zoomwidth /= 1.5
entities[player].zoomheight /= 1.5
entities[player].playcamera *= 1.5;
eventgamehandler.sendabilityrechage(entities[player], which)
}
}
}, 10);
}
function pterodactylability(entities, player, which) {
if (entities[player].abilitys.button_w.abil_currentclick == 1 && !entities[player].abilitys.button_w.abil_active && entities[player].z == 0
) {
entities[player].abilitys.button_w.abil_active = true
entities[player].usingability = true
let wheninsky = Date.now() + 2000
let enteredinsky = false
entities[player].isabletoboost = false
entities[player].specType = 1
entities[player].specType2 = 0
let flycheck = setInterval(() => {
if (!entities[player]) { clearInterval(flycheck); return }
if (!entities[player].isflying && enteredinsky) { clearInterval(flycheck); return }
if (enteredinsky) {//when bar is low
// console.log(entities[player].bar.normalbarpercentage, entities[player].bar.maxbarnormalpercentage / 7.5, entities[player].z, !entities[player].isgliding)
if (entities[player].bar.normalbarpercentage <= entities[player].bar.maxbarnormalpercentage / 4 &&
!entities[player].isgliding && entities[player].z == 50) {
if (entities[player].flags.includes(21)) {
var delO = 21
var tmp = entities[player].flags.indexOf(delO); //remove from game arrays
if (-1 != tmp) {
entities[player].flags.splice(tmp, 1);
}
}
entities[player].isgliding = true
godown(entities, player, which)
}
}
if (!enteredinsky) {
if (wheninsky <= Date.now()) {
enteredinsky = true
whenglide = Date.now() + 2000
entities[player].isflying = true
entities[player].specType = 2
entities[player].zoomwidth *= 1.5
entities[player].zoomheight *= 1.5
entities[player].playcamera /= 1.5;
let autofly = setInterval(() => {
if (!entities[player]) { clearInterval(autofly); return };
if (entities[player].specType != 2) { clearInterval(autofly); entities[player].z = 50; return }
if (entities[player].z <= 50) {
entities[player].goingsky = true
entities[player].fallvelocity = 1.3
} else {
if (!entities[player]) { clearInterval(flycheck); return };
clearInterval(autofly)
entities[player].z = 50
entities[player].fallvelocity = 1
}
}, 10);
}
}
}, 10);
}
//start grab
if (entities[player].abilitys.button_w.abil_currentclick == 1 && entities[player].abilitys.button_w.abil_active
&& entities[player].z == 50 && entities[player].specType == 2 && entities[player].specType2 == 0) {
entities[player].specType = 3
entities[player].isgliding = true
entities[player].fallvelocity = 1.5
let de = setInterval(() => {
if (!entities[player]) { clearInterval(de); return };
if (entities[player].z > 0) {
entities[player].goingsky = false
} else {
clearInterval(de)
let newposition = util.rotate(entities[player].pos.x, entities[player].pos.y, entities[player].pos.x + (entities[player].radius), entities[player].pos.y, entities[player].angle);
let tempentitygrab = new pterodactylgrab(newposition.x, newposition.y, entities[player].radius)
for (var grabbedwho in entities) {
if (entities[grabbedwho].type == 2 && !entities[grabbedwho].isdiving && !entities[grabbedwho].isflying &&
!entities[grabbedwho].usingability && !entities[grabbedwho].flags.includes(35) && !entities[grabbedwho].isgrabbed
&& entities[grabbedwho].tier <= entities[player].tier
) {
if (util.getDistance2D(tempentitygrab.x, tempentitygrab.y, entities[grabbedwho].x, entities[grabbedwho].y) <= entities[grabbedwho].radius + tempentitygrab.radius) {
entities[grabbedwho].isflying = true
entities[grabbedwho].isgrabbed = true
entities[grabbedwho].fallvelocity = 1.15
entities[grabbedwho].goingsky = true
entities[grabbedwho].z = 50
entities[grabbedwho].canmove = false
entities[player].flags.push(21)
let declaredfall = false
let currgrab = setInterval(() => {
if (!entities[grabbedwho]) { clearInterval(currgrab); return }
if (entities[player]) {
if (entities[player].flags.includes(21)) {
let correctpos = util.rotate(entities[player].pos.x, entities[player].pos.y, entities[player].pos.x + entities[player].radius * 1.4, entities[player].pos.y, entities[player].angle);
entities[grabbedwho].pos.x = correctpos.x
entities[grabbedwho].pos.y = correctpos.y
} else {
clearInterval(currgrab);
if (!declaredfall) {
declaredfall = true
let speed = entities[player].lastdistance
let angle = entities[player].angle
let newfall = setInterval(() => {
if (!entities[grabbedwho]) { clearInterval(newfall); return };
entities[grabbedwho].goingsky = false
if (entities[grabbedwho].z > 0) {
let newpos = util.rotate(0, 0, 0 - speed * 5, 0, angle);
entities[grabbedwho].veloX = newpos.x
entities[grabbedwho].veloY = newpos.y
} else {
clearInterval(newfall)
entities[grabbedwho].isgrabbed = false
entities[grabbedwho].isflying = false
entities[grabbedwho].canmove = true
entities[grabbedwho].fallvelocity = 1
entities[grabbedwho].veloX = 0
entities[grabbedwho].veloY = 0
entities[grabbedwho].hp -= 30
entities[grabbedwho].timerstunned = Date.now() + 2000
new deathhandle(entities, entities[grabbedwho].id, entities[player].id)
}
}, 10);
}
}
} else {
clearInterval(currgrab);
entities[grabbedwho].isgrabbed = false
entities[grabbedwho].isflying = false
entities[grabbedwho].canmove = true
entities[grabbedwho].fallvelocity = 1
entities[grabbedwho].goingsky = false
entities[grabbedwho].veloX = 0
entities[grabbedwho].veloY = 0
}
}, 10);
break
}
}
}
entities[player].fallvelocity = 1
entities[player].z = 50
entities[player].isgliding = false
entities[player].goingsky = true
entities[player].specType = 2
entities[player].specType2 = 1
}
}, 10);
} else if (entities[player].abilitys.button_w.abil_currentclick == 1 && entities[player].abilitys.button_w.abil_active
&& entities[player].z == 50 && entities[player].specType == 2 && entities[player].isgliding == false && entities[player].specType2 == 1) {
//end ability
if (entities[player].flags.includes(21)) {
var delO = 21
var tmp = entities[player].flags.indexOf(delO); //remove from game arrays
if (-1 != tmp) {
entities[player].flags.splice(tmp, 1);
}
} else {
entities[player].isgliding = true
godown(entities, player, which)
}
}
}
pterodactylability.prototype = {}
module.exports = pterodactylability
|
import React,{Component} from 'react';
import {View, Text, TouchableOpacity, Dimensions,TextInput} from 'react-native';
import { createStackNavigator } from 'react-navigation-stack';
import { createBottomTabNavigator } from 'react-navigation-tabs';
import Icon from 'react-native-vector-icons/Ionicons';
import HomeScreen from './screens/HomeScreen';
import CartScreen from './screens/CartScreen';
import SearchScreen from './screens/SearchScreen';
import ContactScreen from './screens/ContactScreen';
import DetailsScreen from './screens/DetailsScreen';
const color = {
ACTIVE: '#147efb',
INACTIVE: '#ccc'
}
var {height, width} = Dimensions.get('window');
class NavigationDrawerStructure extends Component {
toggleDrawer = () => {
this.props.navigationProps.toggleDrawer();
};
render() {
return (
<View style={{ flexDirection: 'row', justifyContent:'center', alignItems:'center' }}>
<TouchableOpacity style={{ marginLeft:10}} onPress={this.toggleDrawer.bind(this)}>
<Icon name="ios-menu" size={36} color={'#fff'} />
</TouchableOpacity>
<View style={{textAlign:'center', marginLeft:106, marginRight:106}}>
<Text style={{color:'green',fontWeight:'bold', fontSize:20}} >Thế Thiêm</Text>
</View>
<TouchableOpacity onPress={()=>{alert("ok day");}}>
<Icon name="ios-contact" size={36} color={'#fff'} />
</TouchableOpacity>
</View>
);
}
}
class HeaderContact extends Component {
render() {
return (
<View style={{ width, justifyContent:'center' }}>
<Text style={{color:'#fff',fontWeight:'500', fontSize:22, textAlign:'center'}}>Thông tin</Text>
</View>
);
}
}
const HomeStack = createStackNavigator({
Home: {
screen:HomeScreen,
navigationOptions: ({ navigation }) => ({
headerLeft: <NavigationDrawerStructure navigationProps={navigation} />,
headerStyle: {
backgroundColor: '#FF9800',
},
headerTintColor: '#fff',
}),
},
Details: {
screen:DetailsScreen,
navigationOptions: ({ navigation }) => ({
headerStyle: {
backgroundColor: '#FF9800',
},
headerTintColor: '#fff',
}),
}
});
HomeStack.navigationOptions = {
tabBarLabel: 'Home',
tabBarIcon: ({ focused}) =>{
return <Icon name="ios-planet" size={36} color={focused ? color.ACTIVE: color.INACTIVE} />
}
}
const CartStack = createStackNavigator({
Second: {
screen: CartScreen,
navigationOptions: ({ navigation }) => ({
title: 'Cart',
headerStyle: {
backgroundColor: '#FF9800',
},
headerTintColor: '#fff',
}),
},
});
CartStack.navigationOptions = {
tabBarLabel: 'Cart',
tabBarIcon: ({ focused}) =>{
return <Icon name="ios-cart" size={36} color={focused ? color.ACTIVE: color.INACTIVE} />
}
}
const SearchStack = createStackNavigator({
Second: {
screen: SearchScreen,
navigationOptions: ({ navigation }) => ({
title:'Tìm kiếm',
headerStyle: {
backgroundColor: '#FF9800',
},
headerTintColor: '#fff',
}),
},
});
SearchStack.navigationOptions = {
tabBarLabel: 'Search',
tabBarIcon: ({ focused}) =>{
return <Icon name="ios-search" size={36} color={focused ? color.ACTIVE: color.INACTIVE} />
}
}
const ContactStack = createStackNavigator({
Second: {
screen: ContactScreen,
navigationOptions: ({ navigation }) => ({
headerLeft: <HeaderContact/>,
headerStyle: {
backgroundColor: '#FF9800',
},
headerTintColor: '#fff',
}),
},
});
ContactStack.navigationOptions = {
tabBarLabel: 'Contact',
tabBarIcon: ({ focused}) =>{
return <Icon name="ios-contact" size={36} color={focused ? color.ACTIVE: color.INACTIVE} />
}
}
const AppNavigator = createBottomTabNavigator({
HomeStack,
CartStack,
SearchStack,
ContactStack
});
export default AppNavigator;
|
var obj;
var logger = {
info: function () {},
debug: function () {},
error: function () {},
log: function () {},
warn: function () {}
};
if (typeof window === 'object') {
window.isClient = false;
window.isServer = false;
obj = window;
}
if (typeof global === 'object') {
global.isClient = false;
global.isServer = false;
obj = global;
global._ = require('lodash');
global.jQuery = global.$ = require('jquery')(require('jsdom').jsdom().defaultView);
}
obj.logger = logger;
jasmine.clientOnly = function (method) {
obj.isClient = true;
obj.isServer = false;
method();
obj.isClient = false;
};
jasmine.serverOnly = function (method) {
obj.isServer = true;
obj.isClient = false;
method();
obj.isServer = false;
};
|
var expect = require('chai').expect;
var sinon = require('sinon');
var proxyquire = require('proxyquire');
var mockRequest = require('supertest');
describe('smartcar tests', function() {
var request;
var server;
before(function() {
request = {};
request.post = sinon.stub();
server = proxyquire('./server.js', {
'request': request
});
});
it('Vehicle Info', function(done) {
var carId = '1234';
var gmEndpoint = 'http://gmapi.azurewebsites.net/getVehicleInfoService/' + carId;
var gmBody = {
'service': 'getVehicleInfo',
'status': '200',
'data': {
'vin': {
'type': 'String',
'value': '123123412412'
},
'color': {
'type': 'String',
'value': 'Metallic Silver'
},
'fourDoorSedan': {
'type': 'Boolean',
'value': 'True'
},
'twoDoorCoupe': {
'type': 'Boolean',
'value': 'False'
},
'driveTrain': {
'type': 'String',
'value': 'v8'
}
}
};
var smartCarResponse = {
vin: '123123412412',
color: 'Metallic Silver',
doorCount: 4,
driveTrain: 'v8'
};
request.post.yields(null, {
statusCode: 200
}, gmBody);
mockRequest(server).get('/vehicles/' + carId)
.expect(200)
.end(function(err, res) {
expect(err).to.be.null;
expect(JSON.stringify(res.body)).to.equal(JSON.stringify(smartCarResponse));
done();
});
});
it('Security', function(done) {
var carId = '1235';
var gmEndpoint = 'http://gmapi.azurewebsites.net/getSecurityStatusService/' + carId;
var gmBody = {
'service': 'getSecurityStatus',
'status': '200',
'data': {
'doors': {
'type': 'Array',
'values': [{
'location': {
'type': 'String',
'value': 'frontLeft'
},
'locked': {
'type': 'Boolean',
'value': 'False'
}
}, {
'location': {
'type': 'String',
'value': 'frontRight'
},
'locked': {
'type': 'Boolean',
'value': 'True'
}
}]
}
}
};
var smartCarResponse = [{
location: 'frontLeft',
locked: false
}, {
location: 'frontRight',
locked: true
}];
request.post.yields(null, {
statusCode: 200
}, gmBody);
mockRequest(server).get('/vehicles/' + carId + '/doors')
.expect(200)
.end(function(err, res) {
expect(err).to.be.null;
expect(JSON.stringify(res.body)).to.equal(JSON.stringify(smartCarResponse));
done();
});
});
it('Battery Level', function(done) {
var carId = '1235';
var gmEndpoint = 'http://gmapi.azurewebsites.net/getEnergyService/' + carId;
var gmBody = {
'service': 'getEnergyService',
'status': '200',
'data': {
'tankLevel': {
'type': 'Number',
'value': '30'
},
'batteryLevel': {
'type': 'Null',
'value': 'null'
}
}
};
var smartCarResponse = {
percent: 0
};
request.post.yields(null, {
statusCode: 200
}, gmBody);
mockRequest(server).get('/vehicles/' + carId + '/battery')
.expect(200)
.end(function(err, res) {
expect(err).to.be.null;
expect(JSON.stringify(res.body)).to.equal(JSON.stringify(smartCarResponse));
done();
});
});
it('Fuel Level', function(done) {
var carId = '1235';
var gmEndpoint = 'http://gmapi.azurewebsites.net/getEnergyService/' + carId;
var gmBody = {
'service': 'getEnergyService',
'status': '200',
'data': {
'tankLevel': {
'type': 'Number',
'value': '30'
},
'batteryLevel': {
'type': 'Null',
'value': 'null'
}
}
};
var smartCarResponse = {
percent: 30
};
request.post.yields(null, {
statusCode: 200
}, gmBody);
mockRequest(server).get('/vehicles/' + carId + '/fuel')
.expect(200)
.end(function(err, res) {
expect(err).to.be.null;
expect(JSON.stringify(res.body)).to.equal(JSON.stringify(smartCarResponse));
done();
});
});
it('Start/Stop Engine', function(done) {
var carId = '1235';
var gmEndpoint = 'http://gmapi.azurewebsites.net/actionEngineService/' + carId;
var gmBody = {
'service': 'actionEngine',
'status': '200',
'actionResult': {
'status': 'EXECUTED'
}
};
var smartCarResponse = {
status: 'success'
};
request.post.yields(null, {
statusCode: 200
}, gmBody);
mockRequest(server).post('/vehicles/' + carId + '/engine')
.set('Content-Type', 'application/json')
.send({'action': 'START'})
.expect(200)
.end(function(err, res) {
expect(err).to.be.null;
expect(JSON.stringify(res.body)).to.equal(JSON.stringify(smartCarResponse));
done();
});
});
});
|
'use strict';
var Bot = require('../models/bot.model.js');
function buildBot(req, res) {
var clientName = req.params.botName;
var bot = new Bot();
bot.name = clientName;
bot.model = 3009;
bot.save(function (err, botSaved) {
if(err){
res.status(500).send({
message: 'Error request on save in Mongo',
error: err
});
}else {
res.status(200).send({
message: 'Success request',
bot: botSaved
});
}
});
}
function buildBots(req, res) {
var totalBots = req.params.totalBots;
var bots = [];
for(var i=0; i<totalBots; i++){
console.log('BotCreated=' + i );
var bot = new Bot();
bot.name = 'Bot 00' + i;
bot.model = 3009;
bots.push(bot);
if(bots.length == totalBots){
Bot.create(bots, function (err, botsSaved) {
if(err){
res.status(500).send({
message: 'Error request on save in Mongo',
error: err
});
}else {
if(bots.length < 100){
res.status(200).send({
message: 'Success request',
bots: botsSaved
});
}else {
res.status(200).send({
message: 'Success request',
bots: bots.length
});
}
}
});
}
}
}
function getBots(req, res) {
var params = req.body;
var find = {};
console.log("Hello World on NodeJs");
console.log(params);
console.log(req.body);
if(params._id){
find._id = params._id;
}
if(params.name){
find.name = params.name;
}
Bot.find(find).limit(50).sort({name:1}).exec(function (err, bots) {
if (err) {
res.status(500).send({ message:'Error request', date: new Date() });
}
else {
if(bots.length > 0){
res.status(200).send({ message:'Success request', date: new Date(), bots:bots });
}
else {
res.status(404).send({ message:'No bots found', date: new Date() });
}
}
});
}
module.exports.buildBot = buildBot;
module.exports.buildBots = buildBots;
module.exports.getBots = getBots;
|
function ShowDate() {
document.getElementById('date').innerHTML = new Date().toDateString();
}
function PlayEggcat() {
document.getElementById("Eggcat").play();
}
|
/**
* Created by Happy Life on 2017/2/11.
*/
angular.module("movieApp.laterCtr",[])
.controller("laterCtr",["$scope",function ($scope) {
}])
|
let count = 1;
while (count <= 10) {
document.write(count);
document.write("<br>");
count++;
}
|
// chrome.runtime.onMessage.addListener(
// function(request, sender, sendResponse) {
// if( request.url) {
// console.log(request.url);
// $.ajax({
// type: "POST",
// url: request.url,
// position: data,
// success: success,
// dataType: dataType
// });
// }
// }
// );
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.