text
stringlengths 7
3.69M
|
|---|
angular.module('app.services', [])
.directive('loggedin', [function(){
return {
restrict: 'AE',
replace: true,
templateUrl: 'nav/loggedinnav.html'
};
}])
.directive('loggedout', [function(){
return {
restrict: 'AE',
replace: true,
templateUrl: 'nav/loggedoutnav.html'
};
}])
.factory('HttpRequests', ['$http', '$location', function($http, $location){
var signupUser = function(userObject){
// send to firebase
// var uid = UID from firebase
console.log('user http request sent', userObject);
return $http({
method: 'POST',
url: 'http://requestb.in/1h0kipc1',
data: userObject,
headers: {
'Content-Type': 'text/json'
}
}); // route will be '/api/users'
};
var loginUser = function(){
// do authentication login here, promisified
// then redirect
$location.path('/user');
};
var getUser = function(uid) {
return $http({
method: 'GET',
url: 'http://requestb.in/1h0kipc1', // route will be '/api/users' + uid
});
// .then( set username in localstorage?);
};
var getRequests = function(uid) { // optional filter by username
var url;
if (!username) {
url = 'api/requests/' + uid;
} else {
url = 'api/requests/';
}
return $http({
method: 'GET',
url: url // route will be '/api/users' + uid
});
};
var postRequest = function(request){
console.log('post request http request sent', request);
return $http({
method: 'POST',
url: 'http://requestb.in/1h0kipc1',
data: userObject,
headers: {
'Content-Type': 'text/json'
}
});
};
return {
loginUser: loginUser,
signupUser: signupUser,
getUser: getUser,
getRequests: getRequests,
postRequest: postRequest
};
}]);
|
import Component from '@ember/component';
import { computed } from '@ember/object';
import layout from './template';
import CurrencyDataLoaderMixin from '@upfluence/ember-upf-utils/mixins/currency-data-loader';
import { formatPrice } from '@upfluence/ember-upf-utils/helpers/format-price';
export default Component.extend(CurrencyDataLoaderMixin, {
layout,
tagName: '',
useFormatter: false,
roundPrecision: 2,
formattedPrice: computed('price', 'currencyData.{currency,rate}', 'useFormatter', 'roundPrecision', function () {
return formatPrice([this.price], {
rate: this.get('currencyData.rate'),
currency: this.get('currencyData.currency'),
useFormatter: this.useFormatter,
roundPrecision: this.roundPrecision
});
})
});
|
import React from 'react'
const Login = (props) => {
return (
<div className="login">
<h1>Login</h1>
<form>
<input type="text" name="username" placeholder="username" />
<input type="password" name="password" placeholder="password" />
<button type="submit">Login</button>
</form>
</div>
)
}
export default Login
|
Glagol.events.once('changed', reload);
module.exports = function (state) {
console.warn('reocnnect', state)
Object.keys(state).forEach(function (input) {
var connections = state[input];
input = input.split('/')
var mixer = _.model.Mixers()[input[0]];
if (!mixer) return console.error('no mixer', input[0]);
var channel = mixer.channels[input[1]];
Object.keys(connections).forEach(function (output) {
var player = _.model.Players[output];
if (!player) return;
player = player();
console.log('connecting output of', player, 'into', input);
player.output.connect(channel.gain);
});
})
}
function reload () {
_.reconnect(_.model().Connections);
}
|
//Destructuring
//*array
//*object
// const person ={
// name:"ali",
// age:12,
// lastname:"rezaei"
// }
// const name = person.name;
// const lastname = person.lastname;
// const { name : firstName,lastname } = person;
// person.name = "jafar";
// console.log(firstName,lastname);
// const arr = ["Apple","Orange","dasdas","aasda"];
// // const frute1 = arr[0];
// // const frute2 = arr[1];
// const [frute1,,frute2] = arr;
// console.log(frute1,frute2);
// function sample(){
// const x = function(){
// }
// const y = function(){
// }
// return [x,y]
// }
// //const myarr = sample();
// // const first =myarr[0];
// const [first,second] = sample();
//spread operator
// const student={
// avg:20,
// lastname:'hasani'
// }
// const person={
// height:180
// }
// const student2={
// // avg:student.avg,
// // lastname:student.lastname,
// fathername : 'reza',
// avg:33,
// ...student,
// ...person
// }
// console.log(student2);
// function sum(...numbers){
// let s =0;
// numbers.forEach(i=>{
// s+=i;
// });
// return s;
// }
// console.log(sum(3,4,5,6));
// const arr1 = [32,4,5,6];
// const arr2 = [32,23,43];
// const arr3 = [...arr2,...arr1,424];
// console.log(arr3);
//Arrow Function
// const ss = function (firstname,lastname){
// return firstname + " " + lastname;
// }
// const ss = (firstname,lastname) => {
// return firstname + " " + lastname;
// }
// const ss = (firstname,lastname) => firstname + " " + lastname;
// const square = input => input * input;
// const noinput = () => "no input";
// console.log(noinput());
// const arr1 = [32,4,5,6];
// arr1.map(item=> "This is :" + item);
// console.log(arr1.map(item=> "This is :" + item));
// const a = a=>b=>c=>d=>a*b+c*d;
// console.log(a(3)(4)(3)(2));
class Person{
constructor(name){
this.name = name;
}
sayHello1(){
console.log('sayHello1 called');
}
}
class Student extends Person {
constructor(name,age){
super(name);
this.age = age;
}
sayHello2=()=>{
this.sayHello1();
}
}
const std1 = new Student("ALI",23);
std1.sayHello2();
console.log(std1);
|
const path = require('path')
let extension
process.platform === 'win32' ?
extension = 'ico' // .ico on Win32
:
extension = 'png' // .png on Darwin
module.exports = {
png: path.join(__dirname, 'static', `logo.png`),
ico: path.join(__dirname, 'static', 'logo.ico')
}
|
const { Router } = require('express');
const Tweet = require('../models/Tweet');
module.exports = Router()
.post('/', (req, res) => {
const { handle, text } = req.body;
Tweet.create({
handle,
text
}, (err, createdTweet) => {
res.send(createdTweet);
});
})
.get('/', (req, res) => {
Tweet.find((err, listOfTweets) => {
res.send(listOfTweets);
});
})
.get('/:id', (req, res) => {
Tweet.findById(req.params.id, (err, tweet) => {
res.send(tweet);
});
});
|
import {reducer, ActionType, ActionCreator} from './data.js';
const questionGenre = {
genre: `metall`,
tracks: [
{
id: 0,
genre: `metall`,
src: `https://upload.wikimedia.org/wikipedia/commons/4/4e/BWV_543-fugue.ogg`,
},
{
id: 1,
genre: `rap`,
src: `https://upload.wikimedia.org/wikipedia/commons/4/4e/BWV_543-fugue.ogg`,
},
{
id: 2,
genre: `rock`,
src: `https://upload.wikimedia.org/wikipedia/commons/4/4e/BWV_543-fugue.ogg`,
},
{
id: 3,
genre: `jazz`,
src: `https://upload.wikimedia.org/wikipedia/commons/4/4e/BWV_543-fugue.ogg`,
},
]
};
const questionArtist = {
artist: `Пелагея`,
src: `https://upload.wikimedia.org/wikipedia/commons/4/4e/BWV_543-fugue.ogg`,
options: [
{
artist: `Пелагея`,
id: 0,
},
{
artist: `Меладзе`,
id: 1,
},
{
artist: `Шнуров`,
id: 2,
},
]
};
const questions = [questionArtist, questionGenre];
const initialState = {
questions: [],
};
it(`Reducer without params should return initial state`, () => {
expect(reducer(undefined, {})).toMatchObject(initialState);
});
it(`Reducer should load questions`, () => {
expect(reducer(initialState, ActionCreator.loadQuestions(questions))).toMatchObject({
questions,
});
});
describe(`Action creator work correctly`, () => {
it(`Action creator load questions get questions`, () => {
expect(ActionCreator.loadQuestions([questionGenre, questionArtist])).toEqual({
type: ActionType.LOAD_QUESTIONS,
payload: [questionGenre, questionArtist]
});
});
});
|
var baseWebStorage = require("./baseWebStorage");
var webLocalStorage = function ls(wsKey) {
this.wsKey = wsKey;
};
webLocalStorage.prototype.setData = function(param,value,isDelete) {
if(typeof localStorage != 'undefined') {
var found,
ls = JSON.parse(localStorage.getItem(this.wsKey) || '{}'),
objProperties = param.split("."),
lsClone = ls,
endPoint = objProperties[objProperties.length-1];
for(var i=0;i<(objProperties.length-1);i++) {
if(lsClone[objProperties[i]]) {
lsClone = lsClone[objProperties[i]];
}
else {
return false;
}
}
if(this.isArray(lsClone[endPoint])) {
if(isDelete) {
lsClone[endPoint].indexOf(value) > -1 ? lsClone[endPoint].splice(lsClone[endPoint].indexOf(value),lsClone[endPoint].indexOf(value)) : false;
}
else {
lsClone[endPoint].push(value);
}
}
else {
lsClone[endPoint] = value;
}
localStorage.setItem(this.wsKey,JSON.stringify(ls));
}
};
webLocalStorage.prototype = new baseWebStorage();
webLocalStorage.prototype.constructor = webLocalStorage;
module.exports = webLocalStorage;
|
/* eslint no-console: off */
// custom console
console.log('Hello world!')
const asciiArtM = `%c
........ ........
@MMMMMMM. .MMMMMM@
MMMMMMM. .MMMMMM.
@MMMMMMM. .MMMMMMM.
@M @MMMMM. .M.@MMMMM.
@M @MMMMM@ .M. @MMMMM.
@M @MMMMM@M@ @MMMMM.
@M .MMMMM@ @MMMMM.
.MM@ .MMM@ @MMMMM.
.@MMMMM@ .M@ .@MMMMMMM@
........ . ..........\n`
const logMSG = "You're visiting: "
const currentURL =
window.location.protocol +
'//' +
window.location.host +
window.location.pathname
console.log(asciiArtM, 'font-family:monospace')
console.log(logMSG + currentURL)
|
import { getOwner } from '@ember/application';
import Controller from '@ember/controller';
import { inject as service } from '@ember/service';
import { action } from '@ember/object';
export default class HttpErrors402Controller extends Controller {
@service intl;
@action
openSupportChannel() {
const csChat = getOwner(this).lookup('service:cs-chat');
if (csChat) {
csChat.openTicket(this.intl.t('errors.402.limit_exceeded.email_data.body'));
this.goBack();
}
}
@action
goBack() {
this.transitionToRoute('lists');
}
}
|
/*
You are having a BBQ, after the BBQ you are left with the rubbish.
You have 3 recycling boxes:
Red: Plastics, Green: Glass, Blue: Card.
You will need to sort the rubbish according to the material and return the number of items in each box in the form of an array i.e [2,3,4] where 2 is the number of plastic items, 3 is the number of glass items and 4 is the number of card items.
assume:
Plastics > 0, Glass < 0, Card = 0
*/
function recycleMe(recycle) {
let plastics = 0;
let glass = 0;
let cards = 0;
for (let i = 0; i < recycle.length; i++) {
let num = recycle[i];
if (num > 0) plastics++;
if (num < 0) glass++;
if (num === 0) cards++;
}
return [plastics, glass, cards];
}
|
(function() {
'use strict';
angular
.module('app')
.controller('RegisterController', RegisterController);
// RegisterController.$inject = [];
/* @ngInject */
function RegisterController($state, $auth) {
var vm = this;
vm.user = {};
vm.register = __register;
console.log('RegisterController()');
function __register() {
console.log(vm.user);
$auth.signup({
email: vm.user.email,
password: vm.user.password,
name: vm.user.name
}).then(function (response) {
$state.go('dashboard');
}).catch(function (response) {
console.log(response);
});
}
}
})();
|
Ext.define('cfa.controller.help.HelpController',{
extend: 'Ext.app.Controller',
requires: ['cfa.view.help.HelpView', 'cfa.view.help.HTMLPanel'],
config: {
routes: {
'help': 'showHelpPage',
'help/:path' : 'showHelpById'
},
refs: {
main: 'main'
}
},
showHelpPage: function(){
var helpView = Ext.create('cfa.view.help.HTMLPanel');
helpView.setUrl('data/HelpPages/HomeHelp.html');
Ext.Viewport.add(helpView);
helpView.show();
},
showHelpById: function(path){
var helpView = Ext.create('cfa.view.help.HTMLPanel');
helpView.setUrl('data/HelpPages/' + path + '.html');
Ext.Viewport.add(helpView);
helpView.show();
}
})
|
_.parseInt = function(val,radix) {
if(typeof val === 'string'){
val = val.replace(/^0+/g,'');
}
return parseInt(val,radix);
}
|
//51 53 55 59 60 63 64 71
const skirtsImageLinks = {
51: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/51_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/51_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/51_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/51_multi_4.jpeg'
],
52: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/52_blue_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/52_blue_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/52_blue_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/52_blue_4.jpeg'
],
53: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_black_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_black_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_5.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/53_blue_6.jpeg'
],
54: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/54_green_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/54_green_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/54_green_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/54_green_4.jpeg'
],
55: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_5.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/55_multi_6.jpeg'
],
56: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/56_pink_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/56_pink_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/56_pink_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/56_pink_4.jpeg'
],
57: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/57_yellow_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/57_yellow_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/57_yellow_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/57_yellow_4.jpeg'
],
58: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/58_purple_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/58_purple_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/58_purple_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/58_purple_4.jpeg'
],
59: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/59_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/59_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/59_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/59_multi_4.jpeg'
],
60: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_5.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_6.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/60_multi_7.jpeg'
],
61: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_5.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_6.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_7.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/61_black_8.jpeg'
],
62: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/62_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/62_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/62_black_3.jpeg'
],
63: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/63_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/63_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/63_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/63_multi_4.jpeg'
],
64: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/64_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/64_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/64_multi_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/64_multi_4.jpeg'
],
65: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/65_orange_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/65_orange_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/65_orange_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/65_orange_4.jpeg'
],
66: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/66_red_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/66_red_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/66_red_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/66_red_4.jpeg'
],
67: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/67_orange_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/67_orange_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/67_orange_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/67_orange_4.jpeg'
],
68: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/68_green_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/68_green_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/68_green_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/68_green_4.jpeg'
],
69: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/69_green_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/69_green_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/69_green_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/69_green_4.jpeg'
],
70: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/70_blue_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/70_blue_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/70_blue_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/70_blue_4.jpeg'
],
71: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/71_multi_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/71_multi_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/71_multi_3.jpeg'
],
72: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_4.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_5.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/72_black_6.jpeg'
],
73: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/73_red_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/73_red_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/73_red_3.jpeg'
],
74: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/74_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/74_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/74_black_3.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/74_black_4.jpeg'
],
75: [
'https://404-images-fec.s3-us-west-1.amazonaws.com/75_black_1.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/75_black_2.jpeg',
'https://404-images-fec.s3-us-west-1.amazonaws.com/75_black_3.jpeg'
]
}
module.exports = { skirtsImageLinks }
|
// JavaScript source code
var express = require('express');
var path = require('path');
var app = express(); //our server
app.set('view engine', 'pug'); // allows to set varialbes for express
app.use(express.static(path.join(__dirname, 'public')));
//app.use(express.static('node_modules'));
//app.use(express.static('assets'));
app.get('/', function (req, res) { //references the root route. '/' refers to that.
res.render('index'); //regular JS object. Can be data from JSON file
});
app.get('/about', function (req, res) {
res.render('about');
});
app.get('/woman', function (req, res) {
res.render('woman');
});
app.get('/activewear', function (req, res) {
res.render('activewear');
});
app.get('/UALeggings', function (req, res) {
res.render('UALeggings');
});
app.get('*', function (req, res) { //must be at the end, but the * tells it that if you get something else to do this.
res.send('Bad Route');
});
var server = app.listen(3000, function () {
console.log('Listening on port 3000');
});
|
import React, {useEffect, useState} from 'react'
import {
Text,
View,
StyleSheet,
Image
} from 'react-native'
import Axios from 'axios'
const key = 'faf981d79c94b75d3c34a1b45c9330b9'
const MovieDetail = (props)=>{
const getMovieURL = `https://api.themoviedb.org/3/movie/${props.movieid}?api_key=${key}&language=en-US`
const [movieDetail, setMovieDetail] = useState(null);
const fetchDetails = async()=>{
try {
const {data} = await Axios.get(getMovieURL)
const movieDetail = data;
setMovieDetail(movieDetail);
} catch (error) {
console.log(error);
}
}
useEffect(() => {
fetchDetails();
}, [])
// console.log(movieDetail.adult)
if(!movieDetail){
return(
<View>
<Text>LOADING..</Text>
</View>
);
}else{
return(
<View style={styles.container}>
<View style={styles.header}>
<Image
source={movieDetail.poster_path
? {uri: `https://image.tmdb.org/t/p/w185${movieDetail.poster_path}`}
: {uri: 'https://images.unsplash.com/photo-1594322436404-5a0526db4d13?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=1430&q=80'}
}
style={styles.imageStyle}
/>
<Text
style={styles.titleStyle}
>{movieDetail.original_title}</Text>
</View>
<View style={styles.body}>
<Text style={styles.bodyTitleStyle}>Status: <Text style={styles.bodyInfoStyle}>{movieDetail.status}</Text></Text>
<Text style={styles.bodyTitleStyle}>Adult: <Text style={styles.bodyInfoStyle}>{movieDetail.adult ? 'yes, it is a adult movie' : 'Not a Adult Movie'}</Text></Text>
<Text style={styles.bodyTitleStyle}>Release Date: <Text style={styles.bodyInfoStyle}>{movieDetail.release_date ? movieDetail.release_date : 'Not avialable'}</Text></Text>
</View>
</View>
);
}
}
const styles = StyleSheet.create({
container: {
width: '100%',
height: '100%',
backgroundColor: '#121212'
},
header: {
alignItems: 'center',
justifyContent: 'center'
},
imageStyle: {
width: 180,
height: 250,
marginTop: 150
},
titleStyle: {
fontSize: 22,
fontWeight: "bold",
color: 'white',
marginTop: 15,
textAlign: 'center'
},
body: {
marginLeft: 50,
marginTop: 60
},
bodyTitleStyle: {
fontSize: 20,
color: '#b3b3b3'
},
bodyInfoStyle: {
color: '#535353'
}
})
export default MovieDetail;
|
console.log('Bucles - Ejercicio 3');
|
import Vue from "vue";
import './style/index.scss';
import {
getmaxAndminObj,
hasOwn,
isFunction,
isObject,
mergeOptions,
isHasValue
} from "@utils/index.js"
import FilterPanel from "./filterPanel/index.js"
import defaultC from "./editCell/default.vue"
import selection from "./editCell/selection.vue"
const editComponents = {
default: defaultC,
selection: selection
}
export default {
name: 'ETable',
inheritAttrs: false,
render(h) {
const _this = this;
const columnRender = function (col, h) {
if (!hasOwn(col, 'childrens')) {
if (col.hidden === true) return;
return h('el-table-column', {
props: {
...col
},
key: col['column-key'] || col.prop,
scopedSlots: {
header: col.defaultHeader ? null : function (props) {
let {
column,
$index
} = props;
let colKey = column.columnKey || column.property || column.id;
return h('span', {
class: {
'e-custom-header': true
}
}, [(col.label || col.prop),
(function () {
if (_this.tableConfig.filter === false || col.filter !== true) return;
return h('transition', {
attrs: {
name: 'el-fade-in-linear',
appear: true
}
}, [h('span', { // filter button
class: {
'e-filter-btn': true
}
}, [h('i', { // icon
class: {
'e-filter-tag': true,
'active': _this.headFCNs.some(hn => hn === colKey),
'el-icon-loading': _this.filterLoads.some(fl => fl === colKey),
'el-icon-arrow-down': !_this.filterLoads.some(fl => fl === colKey),
'filted': hasOwn(_this.filtedList, colKey) && _this.filtedList[colKey].value,
},
on: {
click: e => {
e.stopPropagation();
_this.headFilterBtnClick(col, column, e)
}
},
})])])
})()
])
},
default: function (props) { //custom table cell
let {
row,
column
} = props;
let funControl = isFunction(col.editControl) ? col.editControl.call(null, row[col.prop], row, column) : true,
isCan = (_this.tableConfig.cellEdit !== false && col.edit && funControl) ? true : false;
isCan ? _this.setEditMap({
x: row.rowIndex,
y: column.property
}) : null;
if (isCan && _this.editX === row.rowIndex && _this.editY === column.property) {
let options = {
attrs: {
...col.editAttrs
},
props: {
value_: row[col.prop],
column: column,
columnObj: col,
row: row
},
on: {
...col.editListeners,
change: (v) => {
row[col.prop] = v
_this.$emit('cell-value-change', v, row, column, col)
}
},
nativeOn: {
click: (e) => {
e.stopPropagation()
}
},
directives: [{
name: 'focus'
}]
};
if (col.editComponent && typeof col.editComponent === 'object') {
return h(col.editComponent, options)
} else {
return h(editComponents[col.editType || 'default'], options)
}
} else {
if (col.renderCell && typeof col.renderCell === 'function') { //custom cell render
return col.renderCell.call(_this._renderProxy, h, {
value: row[col.prop],
row: row,
column: column,
})
} else { //default cell render
return h('span', {
domProps: {
innerHTML: (col.formatter && typeof col.formatter === 'function') ?
col.formatter(row[col.prop]) : row[col.prop]
}
})
}
}
}
}
})
} else {
if (Array.isArray(col.childrens) && col.childrens.length > 0) {
return h('el-table-column', {
attrs: {
label: col.label || col.prop
}
}, [...col.childrens.map(function (column) {
return columnRender(column, h)
})])
}
console.error(`[ETable warn] childrens need Array and can't be empty`)
return null;
}
}
const indAndSel = function () {
let indSel = [],
config = _this.tableConfig;
const indSelTemp = function (name) {
let indSelattrs = {
type: name,
fixed: _this.hasLeftFixed || config[name].fixed || false
}
if (isObject(config[name])) {
indSelattrs = {
...config[name],
...indSelattrs
}
}
return h('el-table-column', {
attrs: {
...indSelattrs
},
// scopedSlots: {
// head: name === 'index' ? function (props) {
// return h('span', '1')
// } : null
// }
})
}
if (config.index !== false) {
indSel.push(indSelTemp('index', config))
}
if (config.selection !== false) {
indSel.push(indSelTemp('selection', config))
}
return indSel
}
return h('el-table', {
ref: 'elTable',
props: {
...this.$attrs,
rowStyle: this.rowStyle_,
cellClassName: this.cellClassName_,
rowClassName: this.rowClassName_,
},
class: {
'e-table': true,
},
on: {
...this.$listeners,
...this.eListeners
},
directives: this.tableConfig.scroll === true ? [{
name: 'autoScroll'
}] : null,
scopedSlots: {
empty: function () {
return _this.$slots.empty
},
append: function () {
return _this.$slots.append
}
},
}, [...indAndSel(), // index and selection
this.columns.map(function (col) { // render column
return columnRender(col, h)
}),
this.$slots.default // slot columns
])
},
computed: {
eListeners() {
return {
'cell-click': this.cellClick,
'row-click': this.rowClick,
'selection-change': this.selectionChange,
'sort-change': this.sortChange
}
},
hasLeftFixed() {
return this.columns.some(
c => hasOwn(c, 'fixed') && (c.fixed === "left" || c.fixed === true)
);
},
maxSelectionRow() {
if (this.selectionRow.length == 0) return null;
return this.selectionRow.reduce((start, end) => {
return start.rowIndex > end.rowIndex ? start : end;
});
},
minSelectionRow() {
if (this.selectionRow.length == 0) return null;
return this.selectionRow.reduce((start, end) => {
return start.rowIndex < end.rowIndex ? start : end;
});
},
},
directives: {
focus: {
inserted(el) {
let Element = el.querySelector('input')
if (Element) {
Element.focus()
}
}
},
autoScroll: {
componentUpdated(el) {
let warp = el.querySelector('.el-table__body-wrapper'),
body = warp.querySelector('.el-table__body'),
timer = null;
warp.addEventListener("DOMMouseScroll", wheel, false);
warp.onmousewheel = wheel
function wheel(event) {
let e = event || window.event,
H = warp.clientHeight,
bH = body.clientHeight,
W = warp.clientWidth,
bW = body.clientWidth,
delta = 0;
if (W >= bW) return;
if (e.wheelDelta) {
delta = e.wheelDelta / 120;
} else if (e.detail) {
delta = -e.detail / 3;
}
if (delta > 0) { // up
if (warp.scrollLeft > 0) {
e.preventDefault();
let t = 0;
timer ? clearInterval(timer) : null;
timer = setInterval(() => {
warp.scrollLeft -= 5;
t += 1;
if (t >= 150) {
clearInterval(timer);
}
}, 1)
}
} else { // down
if (H >= bH || H + warp.scrollTop == bH) {
e.preventDefault();
let t = 0;
timer ? clearInterval(timer) : null;
timer = setInterval(() => {
warp.scrollLeft += 5;
t += 1;
if (t >= 150) {
clearInterval(timer);
}
}, 1)
}
}
}
}
}
},
methods: {
sortChange({
column,
prop,
order
}) {
let colKey = column.columnKey || column.property || column.id
this.closeFilterPanel(colKey);
this.editMap = [];
this.$emit('sort-change', {
column,
prop,
order
})
},
rowClick(row, column, event) {
this.$emit('row-click', row, column, event)
if (hasOwn(this.$attrs, 'highlight-current-row') ||
!this.tableConfig.selection ||
this.isEditCell(row, column))
return;
let refsElTable = this.$refs.elTable;
if (this.CtrlDown) {
refsElTable.toggleRowSelection(row);
return;
}
let findRow = this.selectionRow.find(c => c.rowIndex === row.rowIndex);
if (
this.shiftOrAltDown &&
this.selectionRow.length > 0
) {
let maxAndmin = getmaxAndminObj(
row,
this.maxSelectionRow,
this.minSelectionRow
);
refsElTable.clearSelection();
for (let index = maxAndmin.min; index <= maxAndmin.max; index++) {
refsElTable.toggleRowSelection(this.$attrs.data[index], true);
}
} else {
if (findRow && this.selectionRow.length === 1) {
refsElTable.toggleRowSelection(row, false);
return;
}
refsElTable.clearSelection();
refsElTable.toggleRowSelection(row);
}
},
rowStyle_({
row,
rowIndex
}) {
Object.defineProperty(row, "rowIndex", {
value: rowIndex,
writable: true,
enumerable: false
});
return this.rowStyle ? this.rowStyle.call(null, {
row,
rowIndex
}) : null
},
rowClassName_({
row,
rowIndex
}) {
let rowName = this.rowClassName ? this.rowClassName.call(null, {
row,
column,
rowIndex,
columnIndex
}) : ""
var findRow = this.selectionRow.find(c => c.rowIndex == row.rowIndex);
if (findRow) {
rowName = "current-row " + rowName;
}
return rowName;
},
cellClick(row, column, cell, event) {
this.$emit('cell-click', row, column, event)
if (!this.isEditCell(row, column)) {
// this.cancelEdit();
return
}
event.stopPropagation();
this.editX = row.rowIndex;
this.editY = column.property;
},
selectionChange(arr) {
this.selectionRow = arr;
this.$emit("selection-change", arr);
},
cancelEdit() {
this.editX = null;
this.editY = null;
},
cellClassName_({
row,
column,
rowIndex,
columnIndex
}) {
let cellName = this.cellClassName ? this.cellClassName.call(null, {
row,
column,
rowIndex,
columnIndex
}) : ""
if (this.isEditCell(row, column)) {
cellName += " edit-cell"
if (this.editX === row.rowIndex && this.editY === column.property) {
cellName += " edit-active"
}
}
return cellName
},
setEditMap(obj) {
if (this.editMap.some(e => e.x === obj.x && e.y === obj.y)) return;
this.editMap.push(obj)
},
isEditCell(row, column) {
return this.editMap.some(e => e.x === row.rowIndex && e.y === column.property)
},
async headFilterBtnClick(columnObj, column, event) {
let colKey = column.columnKey || column.property || column.id;
if (this.filterLoads.some(fd => fd === colKey)) return; //已在loading状态点击无效
const target = event.target;
let cell = target.tagName === 'I' ? target : target.parentNode,
filterPanel = this.filterPanels[colKey],
filtersData = [];
cell = cell.querySelector('.e-filter-tag') || cell;
if (filterPanel && this.headFCNs.some(f => f === colKey)) { // 已经存在过滤面板且已打开面板
filterPanel.doClose()
return
}
this.filterLoads.push(colKey) //显示loading
try { //await异步获取过滤数据时 捕获异常
if (columnObj.getFilters && typeof columnObj.getFilters === 'function') {
filtersData = (await columnObj.getFilters(columnObj, column)) || []
} else if (this.getFilters) {
filtersData = (await this.getFilters(columnObj, column)) || []
}
} catch (error) {
this.filterLoads.splice(this.filterLoads.findIndex(fd => fd === colKey), 1)
console.error(`[ETable warn]${error}`)
return
}
if (filterPanel) { //存在但当前未打开
this.filters = filtersData;
filterPanel.filtedList = this.filtedList;
filterPanel.filters = filtersData;
this.filterLoads.splice(this.filterLoads.findIndex(fd => fd === colKey), 1);
filterPanel.doShow();
return
}
if (!filterPanel) { //不存在过滤面板
filterPanel = new Vue(FilterPanel)
this.filterPanels[colKey] = filterPanel
filterPanel.reference = cell
filterPanel.columnId = colKey
filterPanel.column = column
filterPanel.columnObj = columnObj
filterPanel.table = this._self
filterPanel.filters = filtersData,
filterPanel.filtedList = this.filtedList,
filterPanel.$mount(document.createElement('div'));
this.filterLoads.splice(this.filterLoads.findIndex(fd => fd === colKey), 1)
filterPanel.doShow()
}
},
setHeadFCN(id) {
if (this.headFCNs.length === 1) {
this.filterPanels[this.headFCNs[0]].doClose()
}
this.headFCNs.push(id);
},
closeHeadFCN(id) {
let index = this.headFCNs.findIndex(h => h === id)
if (index >= 0) {
this.headFCNs.splice(index, 1)
}
},
filterChange(value, columnObj, column) {
let colKey = column.columnKey || column.property || column.id;
if (!isHasValue(value)) {
hasOwn(this.filtedList, colKey) ?
this.$delete(this.filtedList, colKey) :
null;
} else {
this.$set(this.filtedList, colKey, {
columnObj: columnObj,
value: Array.isArray(value) ? value : [value],
key: colKey
});
}
this.$emit("e-filter-change", value, column, this.filtedList);
},
keyDown(event) {
let key = event.keyCode;
if (key == 17) this.CtrlDown = true;
if (key == 16 || key == 18) this.shiftOrAltDown = true;
},
keyUp(event) {
let key = event.keyCode;
if (key == 17) this.CtrlDown = false;
if (key == 16 || key == 18) this.shiftOrAltDown = false;
},
attrsFilter() {
for (let c = 0; c < this.columns.length; c++) {
this.traversalCol(this.columns[c]);
}
},
traversalCol(c) {
if (!hasOwn(c, "childrens") || !Array.isArray(c["childrens"])) {
//filter header init
if (!c.defaultHeader) {
let filName = ["filters"];
filName.forEach(f => {
if (hasOwn(c, f)) {
delete c[f];
}
});
}
} else {
if (Array.isArray(c["childrens"]) && c["childrens"].length > 0) {
for (let cc = 0; cc < c.childrens.length; cc++) {
this.traversalCol(c.childrens[cc]);
}
}
}
},
/**Methods */
closeFilterPanel(key) {
if (hasOwn(this.filterPanels, key)) {
this.filterPanels[key].doClose()
return
}
console.error(`${key} is not exit`)
},
clearFiltedColumn(key, callback = function () {}) {
if (hasOwn(this.filtedList, key)) {
this.$delete(this.filtedList, key);
callback(true)
return
}
callback(false)
},
clearAllFiltedColumn() {
this.filtedList = {};
}
},
created() {
this.tableConfig = mergeOptions(this.tableConfig, this.config);
this.attrsFilter();
},
mounted() {
window.addEventListener("keydown", this.keyDown, false);
window.addEventListener("keyup", this.keyUp, false);
},
updated() {
if (this.reLayoutTimer) clearTimeout(this.reLayoutTimer);
this.reLayoutTimer = setTimeout(() => {
this.$refs.elTable ? this.$refs.elTable.doLayout() : null;
}, 300);
},
beforeDestroy() {
window.removeEventListener("keydown", this.keyDown);
window.removeEventListener("keyup", this.keyUp);
},
props: {
columns: {
type: Array,
default: function () {
return []
}
},
config: Object,
rowStyle: Function,
rowClassName: Function,
cellClassName: Function,
getFilters: Function
},
data() {
return {
reLayoutTimer: null,
filterLoads: [],
filtedList: {},
filterPanels: {},
headFCNs: [],
selectionRow: [],
editX: null,
editY: null,
editMap: [],
tableConfig: {
index: true,
selection: true,
}
}
},
watch: {
editX(n) {
if (n !== null) {
window.addEventListener('click', this.cancelEdit)
} else {
window.removeEventListener('click', this.cancelEdit)
}
},
"$attrs.data": function (n) {
this.editMap = []
}
}
}
|
/**
* Created by Liu.Jun on 2020/11/5 15:24.
*/
export function isString(str) {
return String(str) === str;
}
function genIdFn() {
let preKey = `${+new Date()}`;
let key = 0;
return () => {
const curTimestamp = `${+new Date()}`;
if (curTimestamp === preKey) {
key += 1;
} else {
// 重置 key
key = 0;
}
preKey = curTimestamp;
return `lj${preKey}x${key}`;
};
}
// 只保证同时生成不重复
export const genId = genIdFn();
// 委托事件判断target
export function getRealCurrentTarget(currentTarget, target, validFn) {
while (target) {
if (validFn(target)) {
return target;
}
if (target === currentTarget || target.parentNode === currentTarget) {
break;
} else {
target = target.parentNode;
}
}
return null;
}
// 返回普通数组
export function querySelectorList(selector, parent = document) {
if (selector instanceof NodeList) {
return Array.from(selector);
}
if (selector instanceof HTMLElement) {
return [selector];
}
if (isString(selector)) {
return Array.from(parent.querySelectorAll(selector));
}
throw new Error('请传入一个正确的选择器');
}
// 通过首字母对数据分组 数据分组
export function groupByLetter(data, searchVal) {
const tempCache = Object.create(null);
return data.reduce((preVal, curVal) => {
// 过滤搜索数据
if (searchVal !== '' && !(~curVal.label.toLocaleUpperCase().indexOf(searchVal.toLocaleUpperCase()))) return preVal;
const letter = String((curVal.groupKey || curVal.label)[0]).toLocaleUpperCase();
if (tempCache[letter] !== undefined) {
preVal[tempCache[letter]].value.push(curVal);
} else {
tempCache[letter] = preVal.length;
preVal.push({
name: letter,
letter,
value: [curVal],
anchorPoint: genId()
});
}
return preVal;
}, []);
}
export function throttle(func, wait, ops) {
let context;
let args;
let result;
let timeout = null;
let previous = 0;
const options = Object.assign({}, ops);
const later = () => {
previous = options.leading === false ? 0 : Date.now();
timeout = null;
result = func.apply(context, args);
if (!timeout) {
context = null;
args = null;
}
};
return function fn(...reArgs) {
const now = Date.now();
if (!previous && options.leading === false) previous = now;
const remaining = wait - (now - previous);
context = this;
args = reArgs;
if (remaining <= 0 || remaining > wait) {
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
previous = now;
result = func.apply(context, args);
if (!timeout) {
context = null;
args = null;
}
} else if (!timeout) {
timeout = setTimeout(later, remaining);
}
return result;
};
}
export function handleEvents(events, type = 'addEventListener') {
// 注册事件
events.forEach(({
target, eventName, handler, useCapture = false
} = {}) => {
if (Array.isArray(eventName)) {
eventName.forEach((eName) => {
target[type](eName, handler, useCapture);
});
} else {
target[type](eventName, handler, useCapture);
}
});
}
|
import React from "react";
import { Link } from "react-router-dom";
const NavBar = () => {
return (
<div>
<ul>
<li>
<Link to="/">Home</Link>
</li>
<li>
<Link to="/map">View Map</Link>
</li>
<li>
<Link to="/quiz/flags">Flags Quiz</Link>
</li>
<li>
<Link to="/quiz/capitals">Capitals Quiz</Link>
</li>
<li>
<Link to="/quiz/national-animals">National Animals Quiz</Link>
</li>
<li>
<Link to="/quiz/flags/scores" >Flags Scores</Link>
</li>
<li>
<Link to="/quiz/capitals/scores" >Capitals Scores</Link>
</li>
{/* <img className="bbc_logo" height="30" src={`${process.env.PUBLIC_URL}/bbc.jpeg`} /> */}
<li>
<Link to="/quiz/national-animals/scores" >National Animals Scores</Link>
</li>
</ul>
</div>
);
};
export default NavBar;
|
const members = [
{
id: 1,
name: 'John Doe',
email: 'johndoe@gmail.com',
status: 'inactive'
},
{
id: 2,
name: 'Susan Ibach',
email: 'ibachsusan@gmail.com',
status: 'active'
},
{
id: 1,
name: 'Bill Gate',
email: 'gatebill@gmail.com',
status: 'active'
}
];
module.exports = members;
|
Template.articleEdit.onCreated(function() {
Session.set('articleEditErrors', {});
});
Template.articleEdit.helpers({
errorMessage: function(field) {
return Session.get('articleEditErrors')[field];
},
errorClass: function (field) {
return !!Session.get('articleEditErrors')[field] ? 'has-error' : '';
}
});
Template.articleEdit.events({
'submit form': function(e) {
e.preventDefault();
var currentArticleId = this._id;
var article = {
title: $(e.target).find('[name=title]').val(),
text: $(e.target).find('[name=text]').val(),
status: $(e.target).find('[name=status]').val(),
tags: $(e.target).find('.js-input').val()
};
var errors = validateArticle(article);
if (errors.title || errors.text)
return Session.set('articleEditErrors', errors);
Articles.update(currentArticleId, {$set: article}, function(error) {
if (error) {
return throwError(error.reason);
}
throwConfirmation("Article has been updated successfully!");
Router.go('articlePage', {_id: currentArticleId});
});
}
});
|
console.log('pagy-e2e');
|
const tsRoute = require('express').Router();
const data = require('./../db/data') || [];
tsRoute.get('/', (request, response) => {
response.json(data);
});
tsRoute.post('/', (request, response) => {
const {id, name, phone} = request.body;
const newTs = {id, name, phone};
data.push(newTs);
response.json(newTs);
});
tsRoute.put('/', (request, response) => {
const {id, name, phone} = request.body;
const newTs = {id, name, phone};
const targetTs = data.find(ts => ts.id === newTs.id);
if (id && targetTs) {
targetTs.name = name;
targetTs.phone = phone;
response.json(targetTs);
} else {
response.status(400).end();
}
});
tsRoute.delete('/', (request, response) => {
const targetTsIndex = data.findIndex(ts => ts.id === request.query.id);
if (request.query.id && targetTsIndex !== -1) {
response.json(data.find(ts => ts.id === request.query.id));
data.splice(targetTsIndex);
} else {
response.status(400).end();
}
});
module.exports = tsRoute;
|
import React from 'react'
import './index.styl'
import Header from '~/main/components/Header'
class Home extends React.Component {
render () {
let { store } = this.props.route
return <div className='Home'>
<Header store={store} />
Home Page
</div>
}
}
export default Home
|
import React, { useContext } from "react";
import { TestContext } from "./ContextExample";
const CompB = () => {
const [msg, setMsg] = useContext(TestContext);
console.log("CompB.js");
return (
<div>
<hr />
<div>CompB: {msg}</div>
<input type="text" value={msg} onChange={e => setMsg(e.target.value)} />
</div>
);
};
export default CompB;
|
/*
Author: Jacob Williams
Purpose: server.js contains the connection to the server and DB
Useage: node server.js
*/
//creating constant variables
const express =require('express');
const mongoose = require('mongoose');
const app = express();
//digital ocean -> 143.198.105.222
const hostname = 'localhost';
const port = 300;
// degine mongoose and DBURL
const db = mongoose.connection;
const mongoDBURL = 'mongodb://localhost/ostaa';
// get Schema object
var Schema = mongoose.Schema;
// define item
var itemSchema = new Schema({
title: String,
description: String,
image: String,
price: Number,
stat: String
});
// create noew model
var Item = mongoose.model('Item', itemSchema);
// do same for user
var userSchema = new Schema({
username: String,
password: String,
listings: [{ type : mongoose.Types.ObjectId, ref: 'Item' }],
purchases: [{ type : mongoose.Types.ObjectId, ref: 'Item' }],
})
var User = mongoose.model('User', userSchema);
// connect mongoose with mongoDB
mongoose.connect(mongoDBURL, { useNewUrlParser: true});
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
// define folder with static files
app.use(express.static('public_html'));
// formating json
app.set('json spaces', 2);
// allowing res.json()
app.use(express.urlencoded({extended: true}));
app.use(express.json());
// gets all the users in a json format
app.get('/get/users', function(req, res){
if(req.url != '/favicon.ico'){
User.find({}).exec((err, results) =>{
res.json(results);
})
}
});
// gets all the items in json format
app.get('/get/items', function(req, res){
if(req.url != '/favicon.ico'){
Item.find({}).exec((err, results) =>{
res.json(results);
})
}
});
// given a username, this returns the listings under said username
app.get('/get/listings/:username',(req, res) =>{
User.findOne({username: req.params.username }).exec((err, result) =>{
if (err) return res.end('FAIL');
if (!result) return res.end('FAIL');
Item.find({_id: result.listings}).exec((err,listingResults) => {
res.json(listingResults);
});
});
});
// given a username. this returns the purchases of said username
app.get('/get/purchases/:username',(req, res) =>{
User.findOne({username: req.params.username }).exec((err, result) =>{
if (err) return res.end('FAIL');
if (!result) return res.end('FAIL');
Item.find({_id: result.purchases}).exec((err,purchasesResults) => {
res.json(purchasesResults);
});
});
});
// shows all users given a keyword substring
app.get('/search/users/:keyword', (req,res) =>{
User.find({username: {$regex: req.params.keyword }}).exec((err,results) =>{
res.json(results);
});
});
// shows all items with a keyword substring in the description
app.get('/search/items/:keyword', (req,res) =>{
Item.find({description: {$regex: req.params.keyword }}).exec((err,results) =>{
res.json(results);
});
});
// post addes a new user to the db
app.post('/add/user/', (req,res) => {
requestData = req.body;
var newUser = new User({
username: requestData.username,
password: requestData.password,
listings: [],
purchases: []
});
newUser.save(function(err) {if (err) res.send("FAILED TO ADD USER");});
res.send('SAVED USER');
});
// given a username this adds an item to the db
app.post('/add/item/:username', (req,res) => {
requestData = req.body;
User.findOne({username: req.params.username})
.exec(function(err,result){
if (err) return res.end('FAIL');
if (!result) return res.end('FAIL');
var newItem = new Item({
title: requestData.title,
description: requestData.description,
image: requestData.image,
price: requestData.price,
stat: requestData.status
});
// adds item id to username's listings array
result.listings.push(newItem._id);
result.save();
newItem.save(function(err) {if (err) res.send('FAILED TO ADD ITEM')});
res.send('SAVED ITEM');
})
});
// displays url for webpage in startup
app.listen(port,function () {
console.log(`App listening at http://${hostname}:${port}`);
});
|
import React, {PureComponent} from 'react';
import {ActivityIndicator, FlatList, StyleSheet, Text, View, InteractionManager} from "react-native";
import * as Request from "../../common/request";
import * as Config from "../../common/config";
import ComicListCell from "./ComicListCell";
export default class ComicListPage extends PureComponent {
constructor(props) {
super(props);
this.state = {
comicBookList: props.defaultList !== null ? props.defaultList : [],
refreshing: false,
pageIndex: 1,
};
this.renderFooter = this.renderFooter.bind(this);
this.renderSeparator = this.renderSeparator.bind(this);
}
onItemPress(comicId) {
}
render() {
return (
<View style={{flex: 1}}>
<FlatList
data={this.state.comicBookList}
renderItem={({item}) => <ComicListCell book={item}
onPress={(comicId) => this.onItemPress(comicId)}/>}
refreshing={this.state.refreshing}
onRefresh={() => {
this.loadListData();
}}
onEndReached={() => {
this.loadMoreListData();
}}
onEndThreshold={0}
keyExtractor={item => item.bid}
ListFooterComponent={this.renderFooter}
ItemSeparatorComponent={this.renderSeparator}
/>
</View>
);
}
loadListData() {
console.log("start refresh");
this.setState({
refreshing: true,
});
let url = Config.api.comicColumnListUrl + 'actionId=' + this.props.actionId + '&pagestamp=1';
if (this.props.actionTag) {
url = url + '&actionTag=' + this.props.actionTag;
}
Request.get(url,
(response) => {
let data = response.data;
console.log("get data:");
let bookList = data.bookList;
this.setState({
comicBookList: bookList,
refreshing: false,
pageIndex: data.pagestamp
});
if (this.state.comicBookList && this.props.getTagList) {
this.props.getTagList(data.info.actionIdList, data.info.actionTagList, this.state.comicBookList);
}
}, (error) => {
console.log(error);
this.setState({
refreshing: false
});
});
}
loadMoreListData() {
console.log("start load more");
if (this.state.pageIndex === 0) {
return;
}
let url = Config.api.comicColumnListUrl + 'actionId=' + this.props.actionId + '&pagestamp=' + this.state.pageIndex;
if (this.props.actionTag) {
url = url + '&actionTag=' + this.props.actionTag;
}
this.setState({}, () => {
Request.get(url,
(response) => {
let data = response.data;
let bookList = data.bookList;
this.setState({
comicBookList: this.state.comicBookList.concat(bookList),
pageIndex: data.pagestamp
});
if (this.state.comicBookList && this.props.getTagList) {
this.props.getTagList(data.info.actionIdList, data.info.actionTagList, this.state.comicBookList);
}
}, (error) => {
console.log(error);
});
}
);
}
renderFooter = () => {
if (this.state.refreshing) {
return null;
}
if (this.state.pageIndex === 0) {
return (
<View
style={{
paddingVertical: 20,
borderTopWidth: 1,
borderColor: "#CED0CE",
alignItems: 'center'
}}>
<Text>已加载全部</Text>
</View>
);
} else {
return (
<View style={{
paddingVertical: 20,
borderTopWidth: 1,
borderColor: "#CED0CE"
}}>
<ActivityIndicator animating size="large"/>
</View>
);
}
}
renderSeparator = () => {
return (
<View
style={{
height: 0.5,
width: "100%",
backgroundColor: "#f2f2f2"
}}
/>
);
}
}
const styles = StyleSheet.create({
container: {
flex: 1,
}
});
|
const express = require('express');
const app = express();
const http = require('http').Server(app);
const io = require('socket.io')(http);
const PythonShell = require('python-shell');
const router = require('./app/routes');
app.use('/', router);
app.use(express.static(__dirname + '/public'));
var request = require('request');
// Not required anymore.
//io.on('connection', function(socket) {
// socket.broadcast.emit('draw',{x: 0, y : 0}); // The starting point is always 0,0 for the trajectory plot.
//})
var coord_url = "http://localhost:666"
PythonShell.run('./scripts/data.py', (err) => {
if (err) throw err;
console.log('Started server.');
});
var position = {x : 0, y : 0};
var totalAngle = 0;
PythonShell.run('./scripts/stop.py', (err) => {
if (err) throw err;
console.log('Closed Rooomba.');
});
// Connect to Roomba (through python)
PythonShell.run('./scripts/start.py', (err) => {
if (err) throw err;
console.log('Connected to Rooomba.');
});
function randNum(min, max) {
return Math.random() * (max - min) + min;
}
io.on('connection', (socket) => {
socket.on('change direction', (msg) => {
let velocity = 0;
let radius = 0;
if (typeof msg.direction !== 'undefined') {
console.log(msg.direction.angle);
switch (msg.direction.angle) {
case 'up':
velocity = 2 * msg.distance;
break;
case 'down':
velocity = -2 * msg.distance;
break;
default:
break;
}
switch (msg.direction.angle) {
case 'right':
radius = -1;
break;
case 'left':
radius = 1;
break;
default:
break;
}
}
if (radius !== 0 && velocity === 0) {
velocity = 75;
}
//console.log('Direction changed: ' + msg.direction.angle);
PythonShell.run('./scripts/move.py', {args: [velocity, radius]}, (err) => {
if (err) throw err;
console.log('Changed direction of to velocity:' + velocity + ', radius: ' + radius);
});
});
setInterval(() => {
}, 1000);
// draw takes e.beg_x,e.beg_y, e.end_x, e.end_y
//We must transform the directions given into an x y coord to display as a line
function parse(body)
{
var x_coord = Math.cos(body.angle) * 180/Math.PI * body.distance
var y_coord = Math.sin(body.angle) * 180/Math.PI * body.distance
return {x : x_coord, y : y_coord}
//return {x : num, y : num}
}
/*
* Get the coordinates at regular interval to trigger a draw event
*/
setInterval(() => {
request({
url: coord_url,
json: true
}, function (error, response, body) {
if (!error && response.statusCode === 200) {
//console.log(body) // Print the json response
//coords = JSON.parse(body)
body.angle = totalAngle + body.angle;
totalAngle = body.angle;
var next = parse(body)
socket.emit('sensor data', {
distance: body.distance,
angle: body.angle,
cliffFrontRightSignal: body['cliff front right signal'],
cliffFrontLeftSignal: body['cliff front right signal'],
cliffRightSignal: body['cliff right signal'],
cliffLeftSignal: body['cliff left signal'],
cliffFrontRight: body['cliff front right'],
cliffFrontLeft: body['cliff front left'],
cliffLeft: body['cliff left'],
cliffRight: body['cliff right'],
bumpCenterLeftSignal: body['light bump center left signal'],
bumpLeftSignal: body['light bump center left signal'],
bumpFrontLeftSignal: body['light bump front left signal'],
bumpCenterRightSignal: body['light bump center right signal'],
bumpRightSignal: body['light bump right signal'],
bumpFrontRightSignal: body['light bump front right signal'],
dropLeft: body['wheel drop and bumps']['drop left'],
dropRight: body['wheel drop and bumps']['drop right'],
velocity: body['requested velocity'],
leftVelocity: body['requested left velocity'],
rightVelocity: body['requested right velocity'],
leftEncoderCount: body['left encoder counts'],
rightEncoderCount: body['right encoder counts'],
wallSignal: body['wall signal'],
wallSeen: body['wall seen'],
});
if(next.distance != 0 && next.angle != 0)
{
socket.emit('draw', {beg_x: position.x + 500, beg_y : position.y + 500, end_x : next.x + position.x + 500 , end_y : next.y + position.y + 500});
}
position.x = next.x;
position.y = next.y;
}
});
}, 1000);
});
http.listen(3000, () => {
console.log('listening on *:3000');
});
process.stdin.resume();//so the program will not close instantly
|
// document.getElementById('jsButton').onclick = function () {
// JSON.parse(a)
// }
document.getElementById('jsButton').addEventListener('click', function(){
console.log(aa)
})
|
const Koa = require('koa');
const app = new Koa();
const jsonData = require('./person_train.json')
// response
app.use(ctx => {
ctx.body = JSON.stringify(jsonData,undefined,1);
});
app.listen(3000);
|
module.exports = {
Landing: {
api: 'landing',
interval: 1,
params: {
cpid: '',
user_id: '',
user_agent: '',
user_device: '',
current_url: '',
product_code: ''
}
},
Login: {
api: 'login',
interval: 1,
params: {
cpid: '',
user_id: '',
user_device: '',
user_agent: '',
mail: '',
password: '',
product_code: '499',
current_url: '',
}
},
FillInfo: {
api: 'fillInfo',
interval: 5,
params: {
product_code: '495',
first_name: 'テスト',
last_name: 'テスト',
zipcode: '1500002',
pref: '東京都',
address1: '渋谷区渋谷',
address2: '1-11-8',
phone_number: '0357668877',
mail: 'botchan_test+235_0010@wevnal.co.jp',
user_id: '1575448333079hh61rDiYLKDCQH2',
cpid: '5dc53641a24a61078e73d5ef',
birthday: '1941-08-07',
password: '1111',
shipping_address_type: 'new',
shipping_first_name: 'ウェブナル',
shipping_last_name: 'テスト',
shipping_furigana_first: 'ウェブナル',
shipping_furigana_last: 'テスト',
shipping_zipcode: '5300002',
shipping_pref: '大阪府',
shipping_address1: '大阪市北区曽根崎新地',
shipping_address2: '1-13-22',
shipping_phone_number: '0357668878',
current_url: '',
furigana_first: 'テスト',
furigana_last: 'テスト',
login_type: '2',
address3: '渋谷パークプラザ 5F',
shipping_address3: 'WeWork御堂筋フロンティア',
gender: '1',
payment_type: '11',
card_token: 'tok_GxR3nL6vkc1VDrlE52VIwZeHB4',
user_device: '',
user_agent: '',
coupon: 'NWMVUKR8',
deliv_time: '指定なし',
order_quantity: '3',
quick_deliv_flg: '1',
card_number: '8016' ,
login_flg: '1',
deliv_select: '0',
}
},
GetPrice: {
api: 'getPrice',
interval: 1,
params: {
product_code: '',
payment_type: '',
coupon: '',
quantity: '',
}
},
Order: {
api: 'order',
params: {
user_id: '',
cpid: '',
product_code: '495',
user_device: '',
user_agent: ''
}
}
}
|
// JScript 文件
function ValidateInput()
{
var txtSupplierName = $.trim($("#txtSupplierName").val()); //供应商名称
var ddlContacter = $.trim($("#ddlContacter").val()); //联系人
var txtContactPhone = $.trim($("#txtContactPhone").val()); //联 系 电 话
var txtContacterRole = $.trim($("#txtContacterRole").val()); //联系人职位
var txtPostCode = $.trim($("#txtPostCode").val()); //邮 政 编 码
var txtPostAddress = $.trim($("#txtPostAddress").val()); //邮 政 地 址
var txtStaffNum = $.trim($("#txtStaffNum ").val()); //员 工 数 量
function FocusSupplierName(){$("#txtSupplierName").focus();}
function FocusContacter(){$("#ddlContacter").focus();}
function FocusContactPhone(){$("#txtContactPhone").focus();}
function FocusContacterRole(){$("#txtContacterRole").focus();}
function FocusPostCode(){$("#txtPostCode").focus();}
function FocusPostAddress(){$("#txtPostAddress").focus();}
function FocusStaffNum(){$("#txtStaffNum").focus();}
if(txtSupplierName == "")
{
$.prompt('请输入供应商名称！！', {callback:FocusSupplierName});
return false;
}
if(ddlContacter == "0")
{
$.prompt('请选择负责人！！', {callback:FocusContacter});
return false;
}
if(txtContactPhone == "")
{
$.prompt('请输入移动电话！！', {callback:FocusContactPhone});
return false;
}
else
{
if(!isMob(txtContactPhone))
{
$.prompt('您输入的移动电话格式不正确！！', {callback:FocusContactPhone});
return false;
}
}
if(txtContacterRole == "")
{
$.prompt('请输入联系人职位！！', {callback:FocusContacterRole});
return false;
}
if(txtPostCode == "")
{
$.prompt('请输入邮政编码！！', {callback:FocusPostCode});
return false;
}
else
{
if(!ispostcode(txtPostCode))
{
$.prompt('您输入的邮政编码格式不正确！！', {callback:FocusPostCode});
return false;
}
}
if(txtPostAddress == "")
{
$.prompt('请输入邮政地址！！', {callback:FocusPostAddress});
return false;
}
if(txtStaffNum == "")
{
$.prompt('请输入员工数量！！', {callback:FocusStaffNum});
return false;
}
else if(!isint(txtStaffNum))
{
$.prompt('员工数量必须输入整数！！', {callback:FocusStaffNum});
return false;
}
return true;
}
|
import isPresent from './isPresent'
/**
* Returns first not blank object.
*/
export default function notBlank() {
for (let i = 0; i < arguments.length; i++) {
const value = arguments[i]
if (isPresent(value)) {
return value
}
}
}
|
export default function bankConfig($stateProvider) {
//$urlRouterProvider.when('', '/authentication');
// Now set up the states
$stateProvider
.state('app.bank', {
url: 'bank',
views: {
'bankInformation@app': {
templateUrl: 'components/bankInformation/bankInformation.html',
controller: 'bankCtrl',
controllerAs: 'vm'
}
},
resolve: {
translatePartialLoader: ['$translate', '$translatePartialLoader', function ($translate, $translatePartialLoader) {
$translatePartialLoader.addPart('bank');
return $translate.refresh();
}]
}
});
}
|
const genomicRangeQuery = (s, p, q) => {
s = s.split('');
let Amap = s.map(c => c == 'A' ? 1 : 0);
let Cmap = s.map(c => c == 'C' ? 1 : 0);
let Gmap = s.map(c => c == 'G' ? 1 : 0);
let Tmap = s.map(c => c == 'T' ? 1 : 0);
Amap = Amap.reduceRight((s, n, i) => { s[i] = s[i+1] + n || n; return s; }, [0]);
Cmap = Cmap.reduceRight((s, n, i) => { s[i] = s[i+1] + n || n; return s; }, [0]);
Gmap = Gmap.reduceRight((s, n, i) => { s[i] = s[i+1] + n || n; return s; }, [0]);
Tmap = Tmap.reduceRight((s, n, i) => { s[i] = s[i+1] + n || n; return s; }, [0]);
let result = p.map(i => 0);
for(let i = 0; i < p.length; i++) {
if(Tmap[p[i]] - Tmap[q[i]] > 0 || s[q[i]] == 'T') { result[i] = 4 }
if(Gmap[p[i]] - Gmap[q[i]] > 0 || s[q[i]] == 'G') { result[i] = 3 }
if(Cmap[p[i]] - Cmap[q[i]] > 0 || s[q[i]] == 'C') { result[i] = 2 }
if(Amap[p[i]] - Amap[q[i]] > 0 || s[q[i]] == 'A') { result[i] = 1 }
}
return result;
};
module.exports = genomicRangeQuery;
|
/* becode/javascript
*
* /02-maths/04-sort-numbers/script.js - 2.4: classer des nombres
*
* coded by leny@BeCode
* started at 26/10/2018
*/
// NOTE: don't focus on the existing code structure for now.
// You will have time to focus on it later.
(() => {
// to get the value of an input: document.getElementById("element-id").value
document.getElementById("run").addEventListener("click", () => {
var nombres = document.getElementById("numbers").value;
var tab = nombres.split(", ").map(Number); //création du tableau via input et map pour traduire en nombres//
tab.sort((a, b) => {
return a - b;
});
alert(tab);
});
})();
|
import React, { useState, useEffect } from "react";
import styled from "styled-components";
import axios from "axios";
import {
Button,
Paper,
FormControl as MuiFormControl,
Grid,
Input,
InputLabel,
TextField,
Typography,
Tooltip,
Box,
Tab,
Tabs,
Card,
Link
} from "@mui/material";
import { Alert } from '@mui/material';
import { spacing } from "@mui/system";
import { Redirect } from "react-router-dom";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { green } from "@mui/material/colors";
import ReactMarkdown from "react-markdown";
const FloatIcon = styled(FontAwesomeIcon)({
cursor: "pointer",
color: green[400]
});
const FormControl = styled(MuiFormControl)(spacing);
const Wrapper = styled(Paper)`
padding: ${props => props.theme.spacing(6)};
margin-top:20px;
margin-bottom:20px;
${props => props.theme.breakpoints.up("md")} {
padding: ${props => props.theme.spacing(10)};
}
`;
function DataEdit() {
const [description, setDescription] = useState("");
const [name, setName] = useState("");
const [creator, setCreator] = useState("");
const [date, setDate] = useState("");
const [citation, setCitation] = useState("");
const [language, setLanguage] = useState("");
const [def_tar_att, setDefTatt] = useState("");
const [row_id_att, setRowIdatt] = useState("");
const [ignore_att, setIgnoreatt] = useState("");
const [error, setError] = useState(false);
const [errormessage, setErrorMessage] = useState(false);
const [success, setSuccess] = useState(false);
//const [user_id, setUserId] = useState("");
const [owner, setOwner] = useState(false);
const [original_data_url, setODUrl] = useState("");
const [paper_url, setPaperUrl] = useState("");
const [tabValue, setTabValue] = useState(0);
const yourConfig = {
headers: {
Authorization: "Bearer " + localStorage.getItem("token")
},
params: {
url: window.location.href,
},
};
const handleTabChange = (event, newValue) => {
setTabValue(newValue);
};
const handleChange = (event) => {
setDescription(event.target.value);
event.preventDefault();
}
useEffect(() => {
async function fetchData() {
// You can await here
const yourConfig = {
headers: {
Authorization: "Bearer " + localStorage.getItem("token")
},
params: {
url: window.location.href,
},
};
const response = await axios(process.env.REACT_APP_SERVER_URL + "data-edit", yourConfig);
//setUserId(response.data.user_id);
setName(response.data.name);
setDescription(response.data.description);
setCreator(response.data.creator);
setDate(response.data.date);
setLanguage(response.data.language);
setCitation(response.data.citation);
setDefTatt(response.data.default_target_attribute);
setRowIdatt(response.data.row_id_attribute);
setIgnoreatt(response.data.ignore_attribute);
setODUrl(response.data.original_data_url);
setPaperUrl(response.data.paper_url);
if (response.data.owner === 'true') {
setOwner(true);
}
}
fetchData();
}, []); // Or [] if effect doesn't need props or state
function datatoflask(event) {
event.preventDefault();
if (owner === true) {
axios
.post(
process.env.REACT_APP_SERVER_URL + "data-edit",
{
owner: "true",
description: event.target.description.value,
creator: event.target.creator.value,
date: event.target.collection_date.value,
citation: event.target.citation.value,
language: event.target.language.value,
default_target_attribute: event.target.default_target_attribute.value,
ignore_attribute: event.target.ignore_attribute.value,
row_id_attribute: event.target.row_id_attribute.value,
original_data_url: event.target.original_data_url.value,
paper_url: event.target.paper_url.value
},
yourConfig
)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
setError(true);
setErrorMessage("Cannot edit");
console.log(error)
});
} else if (owner === false) {
axios
.post(
process.env.REACT_APP_SERVER_URL + "data-edit",
{
owner: "false",
description: event.target.description.value,
creator: event.target.creator.value,
date: event.target.collection_date.value,
citation: event.target.citation.value,
language: event.target.language.value,
original_data_url: event.target.original_data_url.value,
paper_url: event.target.paper_url.value
},
yourConfig
)
.then(function (response) {
console.log(response.data);
setSuccess(true);
})
.catch(function (error) {
setError(true);
setErrorMessage("Cannot edit");
console.log(error.data);
});
}
return false;
}
return (
<Grid container spacing={3} justifyContent="center">
<Grid item md={7} xs={10}>
<Wrapper>
<form onSubmit={datatoflask}>
<Typography variant="h1" gutterBottom>
{"Edit " + name}
</Typography>
{error && (
<Alert severity="error">{errormessage}</Alert>
)}
<Grid container spacing={10}>
<Grid item xs={12}>
<Tabs
value={tabValue}
onChange={handleTabChange}
indicatorColor="primary"
textColor="primary"
>
<Tab
label="Description"
key="markdown"
/>
<Tab
label="Preview"
key="preview"
/>
</Tabs>
{tabValue === 0 ? (
<FormControl fullWidth>
<TextField
onChange={handleChange}
variant="outlined"
label=""
id="description"
rows={15}
multiline={true}
value={description}
/>
</FormControl>) : (
<Card variant="outlined">
<ReactMarkdown children={description} />
</Card>)}
<div style={{ float: "right" }}>
<Tooltip title="Styling with Markdown is supported" placement="left">
<Link target="_blank" rel="noopener" color="inherit" href="https://guides.github.com/features/mastering-markdown/">
<FloatIcon icon={["fab", "markdown"]} size="lg" />
</Link>
</Tooltip>
</div>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="citation">Citation</InputLabel>
<Input id="citation" placeholder="citation" defaultValue={citation}
multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<TextField label="Creator" id="creator" maxRows={4} defaultValue={creator}
multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="Collection Date">
Collection date
</InputLabel>
<Input id="collection_date" placeholder="Collection date" defaultValue={date}
multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="language">Language</InputLabel>
<Input id="language" placeholder="Language" defaultValue={language}
multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="original_data_url">
Original data URL
</InputLabel>
<Input id="original_data_url" placeholder="original_data_url"
defaultValue={original_data_url} multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="paper_url">
Paper Url
</InputLabel>
<Input id="paper_url" placeholder="paper_url"
defaultValue={paper_url} multiline={true} />
</FormControl>
{owner && (
<Box p={1} border="3px solid red" borderRadius="5px" padding={5} marginTop={10}
marginBottom={10}>
<b>Danger Zone (can only be edited by author)</b>
<FormControl fullWidth mb={3}>
<InputLabel
htmlFor="default_target_attribute">default_target_attribute</InputLabel>
<Input id="default_target_attribute" placeholder="default_target_attribute"
defaultValue={def_tar_att} multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="ignore_attribute">ignore_attribute</InputLabel>
<Input id="ignore_attribute" placeholder="ignore_attribute"
defaultValue={ignore_att} multiline={true} />
</FormControl>
<FormControl fullWidth mb={3}>
<InputLabel htmlFor="row_id_attribute">
row_id_attribute
</InputLabel>
<Input id="row_id_attribute" placeholder="row_id_attribute"
defaultValue={row_id_att} multiline={true} />
</FormControl>
</Box>
)}
</Grid>
</Grid>
<Button variant="contained" color="primary" type="Submit">
Edit Dataset
</Button>
{success && <Redirect to="/" />}
</form>
</Wrapper>
</Grid>
</Grid >
);
}
export default DataEdit;
|
// ────────────────────────────────────────────────────────────────────────────────
// MODULES
const path = require('path');
const webpack = require('webpack');
const CleanWebpackPlugin = require('clean-webpack-plugin');
const autoprefixer = require('autoprefixer');
// ────────────────────────────────────────────────────────────────────────────────
const outputDir = path.resolve(__dirname, '..', 'dist');
module.exports = {
target: 'electron-renderer',
entry: {
app: [ path.resolve(__dirname, '..', 'app', 'index.ts') ],
},
output: {
path: outputDir,
filename: '[name].bundle.js',
sourceMapFilename: '[name].map'
},
resolve: {
extensions: ['.js', '.ts', '.vue'],
modules: [ 'node_modules' ]
},
module: {
rules: [
{
test: /\.vue$/,
use: [
{
loader: 'vue-loader',
options: {
esModule: true,
postcss: [autoprefixer]
}
}
],
exclude: /node_modules/,
},
{
test: /\.ts$/,
exclude: /node_modules|vue\/src/,
use: [
{
loader: 'ts-loader',
options: {
appendTsSuffixTo: [/\.vue$/]
}
}
],
exclude: /node_modules/,
},
{
test: /\.js$/,
use: [
'babel-loader',
],
exclude: /(node_modules)/,
},
{
test: /\.styl$/,
use: [
'style-loader',
'css-loader',
'stylus-loader'
]
}
],
},
plugins: [
new CleanWebpackPlugin([ outputDir ], { verbose: false }),
new webpack.DefinePlugin({
'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
}),
new webpack.NamedModulesPlugin(),
new webpack.NoEmitOnErrorsPlugin(),
]
};
|
import { shallowMount } from "@vue/test-utils";
import Hero from "@/components/Hero.vue";
describe("Hero", () => {
describe("hero image", () => {
it("renders the hero image", () => {
const wrapper = shallowMount(Hero);
expect(wrapper.find(".hero__image img").exists()).toBe(true);
});
it("includes alt text", () => {
const wrapper = shallowMount(Hero);
expect(wrapper.find(".hero__image img").element.alt).toEqual(
"Joseph Banass Logo"
);
});
it("includes title", () => {
const wrapper = shallowMount(Hero);
expect(wrapper.find(".hero__image img").element.title).toEqual(
"Joseph Banass Hero Logo"
);
});
});
describe("subtitle", () => {
it("Includes the correct subtitle", () => {
const wrapper = shallowMount(Hero);
expect(wrapper.find(".hero__text").element.textContent.trim()).toEqual(
"FULL STACK DEVELOPER BASED IN CHICAGO."
);
});
});
});
|
const { checkToken } = require("../middlewares/auth");
const { Playlist, Track } = require("../models/index");
const {
Op: { like },
QueryTypes,
} = require("sequelize");
const { sequelize } = require("../sequelize");
const { recommendations } = require("../utils/recommendations");
function getSearchQuery(queryParams) {
const searchQuery = {};
Object.keys(queryParams).forEach((key) => {
searchQuery[key] = { [like]: queryParams[key] + "%" };
});
return searchQuery;
}
function playlistsRoute(app) {
app.get("/api/playlists/:id", checkToken, async (req, res) => {
const { id } = req.params;
const { id: UserId } = req.decoded;
let playlist;
if (!id) {
res.json({ error: "'id' field is not provided" });
}
if (id === "liked") {
const tracks = await sequelize.query(
`
select
t.*
from
"Track" t
inner join "Like" l on
t.id = l."TrackId"
where
l."UserId" = ? and
l.rating > 0
`,
{
replacements: [UserId],
type: QueryTypes.SELECT,
}
);
playlist = { ...recommendations.likes, tracks };
} else {
let [tracks, singlePlaylist] = await Promise.all([
sequelize.query(
`
select
distinct t.*,
l.rating
from
"Playlist" p
inner join "Playlist_Tracks" pt on
p.id = pt."PlaylistId"
inner join "Track" t on
pt."TrackId" = t.id
and p.id = ?
left outer join "Like" l on
t.id = l."TrackId"
and l."UserId" = ?
`,
{
replacements: [id, UserId],
type: QueryTypes.SELECT,
}
),
Playlist.findByPk(id, {
raw: true,
}),
]);
playlist = { ...singlePlaylist, tracks };
if (playlist.poster) {
playlist.poster = `${process.env["BACKEND_URL"]}:${process.env["BACKEND_PORT"]}${playlist.poster}`;
}
}
playlist.tracks.forEach(
(track) =>
track.poster &&
(track.poster = `${process.env["BACKEND_URL"]}:${process.env["BACKEND_PORT"]}${track.poster}`)
);
res.json(playlist);
});
app.get("/playlist-recommendations", async (req, res) => {
const { UserId } = req.decoded;
});
app.get("/api/playlists", async (req, res) => {
const searchQuery = getSearchQuery(req.query);
const playlist = await Playlist.findOne({
where: {
...searchQuery,
},
});
res.json(playlist);
});
app.post("/api/playlists", checkToken, async (req, res) => {
const { name, tracks } = req.body;
if (name) {
const playlist = await Playlist.create({
UserId: req.decoded.id,
name,
});
if (tracks) {
playlist.setTracks(tracks);
}
res.json({
message: "Playlist created succesfully",
id: playlist.id,
});
} else {
res.json({ error: "Wrong fields provided" });
}
});
app.post("/api/playlists/:id", checkToken, async (req, res) => {
const { method } = req.query;
const { newName } = req.body;
const { id } = req.params;
if (method && method === "duplicate") {
const playlist = await Playlist.findByPk(id, {
include: [
{
model: Track,
as: "tracks",
},
],
});
const newPlaylist = await Playlist.create({
UserId: req.decoded.id,
name: newName,
});
newPlaylist.setTracks(playlist.tracks);
res.json({
message: "Playlist successfully duplicated",
id: newPlaylist.id,
});
}
});
app.delete("/api/playlists/:id", checkToken, async (req, res) => {
const { id } = req.params;
if (id) {
const playlist = await Playlist.findByPk(id);
if (playlist.UserId === req.decoded.id) {
await playlist.destroy();
res.json({ message: "Playlist deleted succesfully" });
} else {
res.json({ error: "Insufficient privilleges" });
}
} else {
res.json({ error: "Wrong fields provided" });
}
});
app.patch("/api/playlists/:id", checkToken, async (req, res) => {
const { id } = req.params;
if (id) {
const playlist = await Playlist.findByPk(id);
if (playlist.UserId === req.decoded.id) {
await playlist.update({
...req.body,
});
res.json({ message: "Playlist updated succesfully" });
} else {
res.json({ error: "Insufficient privilleges" });
}
} else {
res.json({ error: "Wrong fields provided" });
}
});
}
module.exports = playlistsRoute;
|
import React from 'react';
import { Link } from 'react-router';
const Navigation = () => (
<ul className='Navigation'>
<li className='Navigation-item'>
<Link to='/projects' className='Navigation-link'>projects</Link>
</li>
<li className='Navigation-item'>
<Link to='/contacts' className='Navigation-link'>contacts</Link>
</li>
</ul>
);
export default Navigation;
|
/**
* 中间图片是为了演示，所以需要利用 js，将其“锁定”的动画解除
*/
$(".hover").mouseleave(
function () {
$(this).removeClass("hover");
}
);
|
let n1 = document.getElementById('num1');
let sum1 = 0;
function plus1() {
sum1 += 1;
n1.innerHTML = sum1;
}
function minus1() {
sum1 -= 1;
n1.innerHTML = sum1;
}
let n2 = document.getElementById('num2');
let sum2 = 0;
function plus2() {
sum2 += 1;
n2.innerHTML = sum2;
}
function minus2() {
sum2 -= 1;
n2.innerHTML = sum2;
}
let n11 = document.getElementById('num11');
let sum11 = 0;
function plus11() {
sum11 += 1;
n11.innerHTML = sum11;
}
function minus11() {
sum11 -= 1;
n11.innerHTML = sum11;
}
let n21 = document.getElementById('num21');
let sum21 = 0;
function plus21() {
sum21 += 1;
n21.innerHTML = sum21;
}
function minus21() {
sum21 -= 1;
n21.innerHTML = sum21;
}
let n12 = document.getElementById('num12');
let sum12 = 0;
function plus12() {
sum12 += 1;
n12.innerHTML = sum12;
}
function minus12() {
sum12 -= 1;
n12.innerHTML = sum12;
}
let n22 = document.getElementById('num22');
let sum22 = 0;
function plus22() {
sum22 += 1;
n22.innerHTML = sum22;
}
function minus22() {
sum22 -= 1;
n22.innerHTML = sum22;
}
let tabledata = 0;
let n = 1;
function displayDetails(event) {
event.preventDefault();
var match = document.getElementById("match-points")
var num1 = sum1;
var num2 = sum2;
var table = document.getElementById("myrow");
var row = table.insertRow(n);
var cell1 = row.insertCell(0);
cell1.innerHTML = num1;
var cell2 = row.insertCell(1);
cell2.innerHTML = num2;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
n++;
match.reset();
}
function resett() {
document.getElementById("num1").innerHTML = "0";
document.getElementById("num2").innerHTML = "0";
sum1 = 0;
sum2 = 0;
}
function displayDetails1(event) {
event.preventDefault();
var match = document.getElementById("match-points1")
var num11 = sum11;
var num21 = sum21;
var table = document.getElementById("myrow1");
var row = table.insertRow(n);
var cell1 = row.insertCell(0);
cell1.innerHTML = num11;
var cell2 = row.insertCell(1);
cell2.innerHTML = num21;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
n++;
match.reset();
}
function resett1() {
document.getElementById("num11").innerHTML = "0";
document.getElementById("num21").innerHTML = "0";
sum11 = 0;
sum21 = 0;
}
function displayDetails2(event) {
event.preventDefault();
var match = document.getElementById("match-points2")
var num12 = sum12;
var num22 = sum22;
var table = document.getElementById("myrow2");
var row = table.insertRow(n);
var cell1 = row.insertCell(0);
cell1.innerHTML = num12;
var cell2 = row.insertCell(1);
cell2.innerHTML = num22;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
n++;
match.reset();
}
function resett2() {
document.getElementById("num12").innerHTML = "0";
document.getElementById("num22").innerHTML = "0";
sum12 = 0;
sum22 = 0;
}
function junction() {
var randomNumber = Math.floor(Math.random() * 2) + 1;
if (randomNumber == 1) {
document.getElementById("submitt").src = "odd.png";
} else {
document.getElementById("submitt").src = "even.png";
}
}
function junction1() {
document.getElementById("submitt").src = "toss.jpg";
}
function displayDetails3(event) {
var teama = sum1 + sum22;
var teamb = sum2 + sum11;
var teamc = sum21 + sum12;
if (teama > teamb && teama > teamc) {
event.preventDefault();
var match = document.getElementById("match-points3")
var a = "Team A";
var table = document.getElementById("myrow3");
var row = table.insertRow(1);
var cell1 = row.insertCell(0);
cell1.innerHTML = a;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
match.reset();
} else if (teamb > teamc && teamb > teama) {
event.preventDefault();
var match = document.getElementById("match-points3")
var b = "Team B";
var table = document.getElementById("myrow3");
var row = table.insertRow(1);
var cell1 = row.insertCell(0);
cell1.innerHTML = b;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
match.reset();
} else if (teamc > teama && teamc > teamb) {
event.preventDefault();
var match = document.getElementById("match-points3")
var c = "Team C";
var table = document.getElementById("myrow3");
var row = table.insertRow(1);
var cell1 = row.insertCell(0);
cell1.innerHTML = c;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
tableData++;
match.reset();
}
else {
event.preventDefault();
var match = document.getElementById("match-points3")
var q = " ";
var table = document.getElementById("myrow3");
var row = table.insertRow(1);
var cell1 = row.insertCell(0);
cell1.innerHTML = q;
cell1.style.textAlign = "center";
cell2.style.textAlign = "center";
}
}
|
import { createStore } from 'redux';
import reducer from './reducer';
import { addComment } from './actions';
const store = createStore(reducer);
store.dispatch(addComment('pierwszy komentarz'));
store.dispatch(addComment('drugi komentarz'));
export default store;
|
/**
* Creates global functions that serve to facilitate the creation and manipulation of 2-3 trees.
*/
(function () {
"use strict";
/**
* Creates a new array tree. The values are hard coded, this method only work for this instance.
* @param jsav The JSAV that will draw the array nodes.
* @returns {Array} A list of all the array nodes that were created.
*/
function getArrayNodes(jsav) {
var arrays = [];
arrays.push(jsav.ds.array([18, 32]));
arrays.push(jsav.ds.array([12, ""]));
arrays.push(jsav.ds.array([23, 30]));
arrays.push(jsav.ds.array([48, ""]));
arrays.push(jsav.ds.array([10, ""]));
arrays.push(jsav.ds.array([15, ""]));
arrays.push(jsav.ds.array([20, 21]));
arrays.push(jsav.ds.array([24, ""]));
arrays.push(jsav.ds.array([31, ""]));
arrays.push(jsav.ds.array([45, 47]));
arrays.push(jsav.ds.array([50, 52]));
return arrays;
}
/**
* Draws the edges between array nodes. The edges are hard coded, this function only works for this instance.
* @param jsav The JSAV that will draw the edges.
* @param array_nodes The array nodes where the edges will be drawn from and to.
* @param array_node_length The length of each array node.
* @param edge_properties The properties of each edge.
* @returns {Array} A list of all the lines that were created.
*/
function getArrayNodesEdges(jsav, array_nodes, array_node_length, edge_properties) {
var lines = [];
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[0], array_nodes[1], 0, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[0], array_nodes[2], 1, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[0], array_nodes[3], 2, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[1], array_nodes[4], 0, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[1], array_nodes[5], 1, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[2], array_nodes[6], 0, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[2], array_nodes[7], 1, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[2], array_nodes[8], 2, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[3], array_nodes[9], 0, array_node_length));
lines.push(window.twothreetree.drawEdge(jsav, edge_properties, array_nodes[3], array_nodes[10], 1, array_node_length));
return lines;
}
/**
* This function positions a row of arrays.
* @param array_nodes The array of nodes to be positioned.
* @param top The top value for all noes.
* @param container_width The width of the container that the array nodes are in.
* @param row_width The desired width that all the nodes will take up.
* @param left_offset Optional left offset for all nodes.
*/
function positionRow(array_nodes, top, container_width, row_width, left_offset) {
var total_width, node_width, offset, left, i;
node_width = extractNumber(array_nodes[0].css("width"));
total_width = node_width * array_nodes.length;
offset = (row_width - total_width) / (array_nodes.length - 1);
if (typeof(left_offset) === "undefined") {
left_offset = 0;
}
left = (container_width - row_width) / 2 + left_offset;
for (i = 0; i < array_nodes.length; i += 1) {
array_nodes[i].css({"left": left + "px", "top": top + "px", "position": "absolute"});
left += node_width + offset;
}
}
/**
* Draws a lines from one array node to another.
* @param jsav The JSAV object where the line will be drawn.
* @param properties The properties of the line.
* @param arrayFrom The array node where the line is coming from.
* @param arrayTo The array node where the line is going to.
* @param edgeIndex The index of the arrayFrom where the line starts.
* @param length The length of each array node (list size).
* @returns {*} A JSAV line object.
*/
function drawEdge(jsav, properties, arrayFrom, arrayTo, edgeIndex, length) {
var top, left, height, width, step, x1, y1, x2, y2;
// Get coordinates for the x1 and y1 of the edge.
height = extractNumber(arrayFrom.css("height"));
width = extractNumber(arrayFrom.css("width"));
top = extractNumber(arrayFrom.css("top"));
left = extractNumber(arrayFrom.css("left"));
step = width / length;
x1 = left + (step * edgeIndex);
y1 = top + height;
// Get coordinates for the x2 and y2 of the edge.
height = extractNumber(arrayTo.css("height"));
width = extractNumber(arrayTo.css("width"));
top = extractNumber(arrayTo.css("top"));
left = extractNumber(arrayTo.css("left"));
x2 = left + (width / 2);
y2 = top + 1;
// Create line and return object.
return jsav.g.line(x1, y1, x2, y2, properties);
}
/**
* Turns a string to a float number.
* @param pixels The string to convert to string. This string has to end in "px".
* @returns {Number} The float number equivalent of the pixel value.
*/
function extractNumber(pixels) {
return parseFloat(pixels.substring(0, pixels.length - 2));
}
function toggleArrayHighlight(array_node) {
if (array_node.css(array_highlight_property) === "none") {
array_node.css(array_highlight_add);
} else {
array_node.css(array_highlight_remove);
}
}
function toggleEdgeHighlight(line) {
if (line.css(edge_highlight_property) === "#000") {
line.css(edge_highlight_add);
} else {
line.css(edge_highlight_remove);
}
}
// Highlight properties for arrays.
var array_highlight_property = "box-shadow";
var array_highlight_add = {"box-shadow": "0 0 15px 5px #2B92FF"};
var array_highlight_remove = {"box-shadow": "none"};
// Highlight properties for line edges.
var edge_highlight_property = "stroke";
var edge_highlight_add = {"stroke": "#2B92FF", "stroke-width": 3.0};
var edge_highlight_remove = {"stroke": "black", "stroke-width": 1.0};
var twothreetree = {};
twothreetree.drawEdge = drawEdge;
twothreetree.positionRow = positionRow;
twothreetree.getArrayNodes = getArrayNodes;
twothreetree.getArrayNodesEdges = getArrayNodesEdges;
twothreetree.toggleArrayHiglight = toggleArrayHighlight;
twothreetree.toggleEdgeHiglight = toggleEdgeHighlight;
window.twothreetree = twothreetree;
}());
|
var expect = require('expect.js')
, path = require('path')
, fun = require(path.resolve(__dirname, '..', 'src', 'chapter-1-2'))
describe('chapter-1-2', function() {
([
['\0', '\0'],
['abc\0', 'cba\0'],
['a\0', 'a\0'],
['abcdefg\0', 'gfedcba\0']
]).forEach(function(args) {
it('reverses ' + args[0] + ' to ' + args[1], function() {
expect(fun(args[0])).to.eql(args[1])
})
})
})
|
'use strict';
(function () {
var PIN_STEP = 20;
var uploadPopup = document.querySelector('.img-upload__overlay');
var effectPin = uploadPopup.querySelector('.effect-level__pin');
var effectLevelLine = uploadPopup.querySelector('.effect-level__line');
var convertCoordInPercent = function (coord, fullWidth) {
return (coord * 100) / fullWidth + '%';
};
var sliderArrowControl = function (callback) {
var onPinArrowsPress = function (evt) {
var startPinCoord = effectPin.offsetLeft;
var effectLevelLineWidth = effectLevelLine.offsetWidth;
var newPinCoord;
switch (evt.keyCode) {
case (window.util.KeyCode.ARROW_LEFT):
newPinCoord = startPinCoord - PIN_STEP;
if (newPinCoord < 0) {
newPinCoord = 0;
}
break;
case (window.util.KeyCode.ARROW_RIGHT):
newPinCoord = startPinCoord + PIN_STEP;
if (newPinCoord > effectLevelLineWidth) {
newPinCoord = effectLevelLineWidth;
}
break;
}
effectPin.style.left = newPinCoord + 'px';
var pinPositionPercent = convertCoordInPercent(newPinCoord, effectLevelLineWidth);
callback(pinPositionPercent);
};
effectPin.addEventListener('keydown', onPinArrowsPress);
};
var onSliderDrag = function (callback) {
effectPin.addEventListener('mousedown', function (evt) {
evt.preventDefault();
var startCoord = evt.clientX;
var effectLevelLineWidth = effectLevelLine.offsetWidth;
var coordSliderLine = effectLevelLine.getBoundingClientRect();
var coordSliderLineRight = coordSliderLine.left + effectLevelLineWidth;
var onMouseMove = function (moveEvt) {
moveEvt.preventDefault();
var shift = startCoord - moveEvt.clientX;
startCoord = moveEvt.clientX;
var effectPinCoord = effectPin.offsetLeft - shift;
if (moveEvt.clientX < coordSliderLine.left) {
effectPinCoord = 0;
}
if (moveEvt.clientX > coordSliderLineRight) {
effectPinCoord = effectLevelLineWidth;
}
effectPin.style.left = effectPinCoord + 'px';
var pinPositionPercent = convertCoordInPercent(effectPinCoord, effectLevelLineWidth);
callback(pinPositionPercent);
};
var onMouseUp = function (upEvt) {
upEvt.preventDefault();
document.removeEventListener('mousemove', onMouseMove);
document.removeEventListener('mouseup', onMouseUp);
};
document.addEventListener('mousemove', onMouseMove);
document.addEventListener('mouseup', onMouseUp);
});
};
var onSliderClick = function (callback) {
effectLevelLine.addEventListener('click', function (evt) {
if (evt.target !== effectPin) {
var coordClickLine = evt.offsetX;
var effectLevelLineWidth = effectLevelLine.offsetWidth;
var pinPosition = convertCoordInPercent(coordClickLine, effectLevelLineWidth);
effectPin.style.left = pinPosition;
callback(pinPosition);
}
});
};
var initSlider = function (callback) {
sliderArrowControl(callback);
onSliderDrag(callback);
onSliderClick(callback);
};
window.initSlider = initSlider;
})();
|
K = require('kefir');
_ = require('lodash');
const add = (a, b) => a + b;
const countTen = K.sequentially(100, _.times(10));
countTen.scan(add, 0)
.log('scan');
countTen.toProperty(() => 100)
.scan(add, 0)
.log('propertyScan');
|
/* See license.txt for terms of usage */
define([
"firebug/lib/object",
"firebug/lib/trace",
],
function(Obj, FBTrace) {
// ********************************************************************************************* //
// Constants
var Cc = Components.classes;
var Ci = Components.interfaces;
var Cu = Components.utils;
Cu["import"]("resource://gre/modules/devtools/dbg-server.jsm");
// ********************************************************************************************* //
// Implementation
function ElementActor(aObj, aThreadActor)
{
this.obj = aObj;
this.threadActor = aThreadActor;
}
ElementActor.prototype = Object.create(DebuggerServer.ObjectActor.prototype);
ElementActor.prototype = Obj.extend(ElementActor.prototype,
{
constructor: ElementActor,
actorPrefix: "element",
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
grip: function()
{
var obj = this.obj.unsafeDereference();
// Collect all information that are needed for FirebugReps.Element template.
// This is the basic set that needs to be immediatelly available so, an element
// can be properly displayed in Firebug UI.
// Consequent asynchronous queries should be done mostly for children or parents
// (which will be needed for the HTML panel).
var classList = [];
if (obj.classList.length > 0)
classList = obj.classList.toString().split(" ");
var attrs = [];
var attributes = obj.attributes;
for (var i=0; i<attributes.length; i++)
{
var attr = attributes[i];
attrs.push({
localName: attr.localName,
value: attr.value,
});
}
var localName = obj.tagName.toLowerCase();
var grip = {
"type": "object",
"class": "HTMLElement",
"actor": this.actorID
};
grip.ownProperties = {
"localName": localName,
"nodeName": localName,
"id": obj.id,
"classList": classList,
"attributes": attrs,
};
return grip;
},
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// API
onAttributes: function(request)
{
FBTrace.sysout("remoteSelector;ElementActor.onAttributes " +
this.obj.tagName, this.obj);
var attrs = {};
var attributes = this.obj.attributes;
for (var i=0; i<attributes.length; i++)
{
var attr = attributes[i];
attrs[attr.nodeName] = this.attributeDescriptor(attr);
}
// The "from" attribute is not provided, the protocol handler will
// add that for us.
return {"attributes": attrs};
},
attributeDescriptor: function(attr)
{
var descriptor = {};
descriptor.value = this.threadActor.createValueGrip(attr.nodeValue);
return descriptor;
},
});
ElementActor.prototype.requestTypes["attributes"] = ElementActor.prototype.onAttributes;
// ********************************************************************************************* //
// Registration
return ElementActor;
// ********************************************************************************************* //
});
|
/*!
* JavaScript Core Object v0.53
*
* Licensed under the new BSD License.
* Copyright 2008-2009, Bram Stein
* All rights reserved.
*/
(function () {
function getInternalType(value) {
return Object.prototype.toString.apply(value);
}
function Clone() {}
Object.extend = function (obj) {
var i = 1, key, len = arguments.length;
for (; i < len; i += 1) {
for (key in arguments[i]) {
// make sure we do not override built-in methods but toString and valueOf
if (arguments[i].hasOwnProperty(key) &&
(!obj[key] || obj.propertyIsEnumerable(key) || key === 'toString' || key === 'valueOf')) {
obj[key] = arguments[i][key];
}
}
}
return obj;
};
Object.extend(Object, {
isAtom: function (value) {
return ((typeof value !== 'object' || value === null) &&
typeof value !== 'function') ||
Object.isBoolean(value) || Object.isNumber(value) || Object.isString(value);
},
isNumber: function (value) {
return (typeof value === 'number' || value instanceof Number) && !isNaN(value);
},
isString: function (value) {
return typeof value === 'string' || value instanceof String;
},
isBoolean: function (value) {
return value !== null &&
(typeof value === 'boolean' || value instanceof Boolean);
},
isArray: function (value) {
return getInternalType(value) === '[object Array]';
},
isObject: function (value) {
return getInternalType(value) === '[object Object]';
},
isFunction: function (value) {
return typeof value === 'function';
},
isDefined: function (value) {
return typeof value !== 'undefined';
},
filter: function (obj, fun, thisObj) {
var key, r = {}, val;
thisObj = thisObj || obj;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
val = obj[key];
if (fun.call(thisObj, val, key, obj)) {
r[key] = val;
}
}
}
return r;
},
map: function (obj, fun, thisObj) {
var key, r = {};
thisObj = thisObj || obj;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
r[key] = fun.call(thisObj, obj[key], key, obj);
}
}
return r;
},
forEach: function (obj, fun, thisObj) {
var key;
thisObj = thisObj || obj;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
fun.call(thisObj, obj[key], key, obj);
}
}
},
every: function (obj, fun, thisObj) {
var key;
thisObj = thisObj || obj;
for (key in obj) {
if (obj.hasOwnProperty(key) && !fun.call(thisObj, obj[key], key, obj)) {
return false;
}
}
return true;
},
some: function (obj, fun, thisObj) {
var key;
thisObj = thisObj || obj;
for (key in obj) {
if (obj.hasOwnProperty(key) && fun.call(thisObj, obj[key], key, obj)) {
return true;
}
}
return false;
},
isEmpty: function (obj) {
return Object.every(obj, function (value, key) {
return !obj.hasOwnProperty(key);
});
},
values: function (obj) {
var r = [];
Object.forEach(obj, function (value) {
r.push(value);
});
return r;
},
keys: function (obj) {
var r = [];
Object.forEach(obj, function (value, key) {
r.push(key);
});
return r;
},
// Shallow or deep copy of an object. Code inspired by:
// * Oran Looney - http://oranlooney.com/static/functional_javascript/owl_util.js
// * Object-Oriented JavaScript, by Stoyan Stefanov
copy: function (obj, deep) {
var c, p, r;
if (typeof obj !== 'object') {
return obj;
} else {
c = obj.valueOf();
// Test for strict identity: if they are not equal we
// can be sure this not a native type wrapper.
if (obj !== c) {
return new obj.constructor(c);
}
// We clone the prototype if possible, otherwise construct a clean object or array
if (obj instanceof obj.constructor && obj.constructor !== Object && !Object.isArray(obj)) {
r = Object.clone(obj.constructor.prototype);
} else {
r = Object.isArray(obj) ? [] : {};
}
for (p in obj) {
if (obj.hasOwnProperty(p)) {
r[p] = deep ? Object.copy(obj[p], deep) : obj[p];
}
}
return r;
}
},
clone: function (obj) {
Clone.prototype = obj;
return new Clone();
},
reduce: function (obj, fun, initial) {
var key, initialKey;
if (Object.isEmpty(obj) && initial === undefined) {
throw new TypeError();
}
if (initial === undefined) {
for (key in obj) {
if (obj.hasOwnProperty(key)) {
initial = obj[key];
initialKey = key;
break;
}
}
}
for (key in obj) {
if (obj.hasOwnProperty(key) && key !== initialKey) {
initial = fun.call(null, initial, obj[key], key, obj);
}
}
return initial;
}
});
})();
|
const PannierReducer = (state = [], action) => {
if(action.type==="AJOUT"){
return [...state,action.payload]
}else if (action.type==="REMOVE_FROM_CART"){
return state.filter(el=>el._id!==action.payload)
}else {
return state
}
}
export default PannierReducer;
|
import * as mutations from "./mutations";
export default class Player{
inventory = new Set();
static pieceName = "Player";
static sprite = "Player_South_1.png";
static description = "The player character. You can only have one of these.";
sprite = "Player_South_1.png";
constructor(){
}
stateList = Object.freeze({
up : "Player_North_1.png",
down : "Player_South_1.png",
left : "Player_West_1.png",
right : "Player_East_1.png"
});
update(board, ownPos, dt){
//Does nothing, the sprite update happens at move()
return [];
}
//Function that attemptes to move the player piece
//May collide into other piece
move(board, ownPos, dir){
let mutation = [];
let newPos;
console.log(dir);
//First check if the direction moving is empty
if(dir === "UP"){
this.sprite = this.stateList.up;
//Check if it is edge piece to prevent out of bound error
if(ownPos[0] === 0){
return [];
}
//Check if space moving into is empty
//Else, call collide() onto that object
//Add to mutation list
if(board[ownPos[0]-1][ownPos[1]] === null){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]-1, ownPos[1]]));
newPos = [ownPos[0]-1, ownPos[1]];
}else{
//Get the mutation from calling collide
//If it is not null, add to the list of mutation
//AND if it is moved, set new position for use in checking tullip
const muta = board[ownPos[0]-1][ownPos[1]].collide(board, [ownPos[0], ownPos[1]],
[ownPos[0]-1, ownPos[1]], dir);
if(muta){
mutation = mutation.concat(muta);
if(muta.type === "MOVE"){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]-1, ownPos[1]]));
}
}
}
}else if(dir === "DOWN"){
this.sprite = this.stateList.down;
if(ownPos[0] === board.length - 1){
return [];
}
if(board[ownPos[0]+1][ownPos[1]] === null){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]+1, ownPos[1]]));
newPos = [ownPos[0]+1, ownPos[1]];
}else{
const muta = board[ownPos[0]+1][ownPos[1]].collide(board, [ownPos[0], ownPos[1]],
[ownPos[0]+1, ownPos[1]], dir);
if(muta){
mutation = mutation.concat(muta);
if(muta.type === "MOVE"){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]-1, ownPos[1]]));
}
}
}
}else if(dir === "LEFT"){
this.sprite = this.stateList.left;
if(ownPos[1] === 0){
return [];
}
if(board[ownPos[0]][ownPos[1]-1] === null){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0], ownPos[1]-1]));
newPos = [ownPos[0], ownPos[1]-1];
}else{
const muta = board[ownPos[0]][ownPos[1]-1].collide(board, [ownPos[0], ownPos[1]],
[ownPos[0], ownPos[1]-1], dir);
if(muta){
mutation = mutation.concat(muta);
if(muta.type === "MOVE"){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]-1, ownPos[1]]));
}
}
}
}else if(dir === "RIGHT"){
this.sprite = this.stateList.right;
if(ownPos[1] === board.width - 1){
return [];
}
if(board[ownPos[0]][ownPos[1]+1] === null){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0], ownPos[1]+1]));
newPos = [ownPos[0], ownPos[1]+1];
}else{
const muta = board[ownPos[0]][ownPos[1]+1].collide(board, [ownPos[0], ownPos[1]],
[ownPos[0], ownPos[1]+1], dir);
if(muta){
mutation = mutation.concat(muta);
if(muta.type === "MOVE"){
mutation.push(mutations.move([ownPos[0], ownPos[1]], [ownPos[0]-1, ownPos[1]]));
}
}
}
}//End direction check
return mutation;
}
}
|
var electron = require('electron');
const {remote} = require('electron')
const ipc = electron.ipcRenderer
var myApp = angular.module('myApp',[]);
myApp.controller('MyCtrl', function ($window) {
var vm = this;
vm.openWindow = function(){
//$window.open('html/search_song.html',
//'Search Song',
//'nodeIntegration=true,contextIsolation=false,enableRemoteModule=true,toolbar=yes,scrollbars=no,resizable=yes,top=100,left=500,width=600,height=400');
ipc.send('open-search-window', "result[0]")
}
});
|
$(document).ready(
function()
{
var controller = frontController();
controller.initialize_onload();
$("#tracks").tabs();
$("#charts").tabs();
$('#track-list input:checkbox').live('click', function() { $(this).change(controller.tracklist_checkbox_change)});
$('#track-list a.del').live('click', controller.tracklist_item_delete);
$('#track-list a.edit').live('click', controller.tracklist_item_edit);
$('#track-list a.vt').live('click', controller.show_vt_chart);
$('#track-list a.ht').live('click', controller.show_ht_chart);
$('.highslide-html-content .point').live('click', controller.route_point_edit);
$('.highslide-html-content .add-new-point').live('click', controller.show_form_for_new_point);
$('.highslide-html-content .delete-point').live('click', controller.route_point_delete);
$('.highslide-html-content .edit-time').live('click', controller.show_points_time_editor);
$('.highslide-html-content form.edit').live('submit', controller.route_point_update);
$('.highslide-html-content form.add').live('submit', controller.route_point_save_new);
$('#list-displayer').click(controller.reload_tracklist);
}
);
var frontController = function()
{
var URL = 'http://yarpo.republika.pl/studia/wdp/kml/';
var oMap = null,
oView = null,
oDataSrc = null;
function fTrackListCheckboxChanged()
{
if (this.checked)
{
fShowTrack(this);
}
else
{
fHideTrack(this);
}
}
function fGetIdFromAttr(attr)
{
var arr = attr.toString().split('_');
var n = arr.length;
return arr[n-1];
}
function fHideTrack(self)
{
var id = fGetIdFromAttr(self.id);
var url = fCreateUrlFromId(id);
oMap.removeRoute(url);
}
function fCreateUrlFromId(id)
{
var url = URL + 'file_' + id + '.kml';
return url;
}
function fShowTrack(self)
{
var id = fGetIdFromAttr(self.id);
var url = oDataSrc.getKMLRouteById(id, oMap.setCenterOnPoint);
oMap.addRoute(url);
}
function fInitializeOnload()
{
oMap = WDP.map('map3d');
window.onunload = GUnload
oView = WDP.view();
oDataSrc = WDP.dataSrc();
fReloadTracks();
}
function fReloadTracks()
{
oView.clearListOfRoutes();
oDataSrc.getAllRoutes(oView.insertListOfRoutes);
}
function fTrackListItemDelete()
{
var id = fGetIdFromAttr(this);
var url = fCreateUrlFromId(id);
oMap.removeRoute(url)
oDataSrc.deleteRoute(id);
oView.clearListOfRoutes();
oDataSrc.getAllRoutes(oView.insertListOfRoutes);//oDataSrc.getAllRoutes(oView.insertListOfRoutes);
}
function fSetData(id, data)
{
var numberOfPages = data[0];
var pageNum = 1;
if (numberOfPages > 1) {
do
{
pageNum = prompt("Którą stronę chcesz wyświetlić? Liczba stron to: " + numberOfPages);
pageNum = parseInt(pageNum);
} while(isNaN(pageNum) || ( pageNum > numberOfPages || pageNum < 1 ))
}
oDataSrc.getJSONRoutePageById(id, pageNum, oView.editRoute);
}
function fTrackListItemEdit(self)
{
var id = fGetIdFromAttr(this);
oDataSrc.getJSONNumberOfPagesById(id, fSetData);
return hs.htmlExpand(this, { headingText: 'Edytuj trasę ' + id, maincontentId: 'edit_' + id });
}
function fRoutePointEdit(event, self)
{
oView.startEditing(this);
}
function fGetTimeValues(form)
{
var id = fGetIdFromAttr(form.attr('id'));
time = form.find('.time-settings');
var dateStr = time.find('input:eq(0)').val();
var timer = WDP.time();
date = dateStr.split("/");
timer.day(parseInt(date[0]*1))
.month(parseInt(date[1]*1))
.year(parseInt(date[2]*1))
.hours(parseInt(time.find('select:eq(0)').val()))
.minutes(parseInt(time.find('select:eq(1)').val()))
.seconds(parseInt(time.find('select:eq(2)').val()));
return timer;
}
function fRouteSaveEditedPoint(event)
{
fPreccessPoint(this, oDataSrc.updatePoint);
return false;
}
function fGetInputValue(element)
{
var value = element.val();
var title = element.attr('title');
if (value == Math.decimal(title, 3))
{
return title; // wartosc nie zostala zmieniona
}
return value;
}
function fGenerateIdForNewPoint(id)
{
id = fGetIdFromAttr(id);
return (id * 1) + 1;
}
function fRouteAddFormForNewPoint(event)
{
var id = fGenerateIdForNewPoint(this.name);
oView.addNewPoint(id, $(this).parent().parent().parent().parent());
}
function fShowPointsTimeEditor()
{
oView.showTimeEditor($(this).parent().next());
}
function fGetAncestor(obj, n)
{
for(var i = 0; i < n; i++)
{
obj = obj.parent();
}
return obj;
}
function fPreccessPoint(self, func)
{
var obj = $(self);
var routeId = fGetIdFromAttr(self.id);
var pointId = fGetIdFromAttr(obj.find('input:eq(0)"').attr('id'));
var oPoint = WDP.point();
oPoint
.altitude(fGetInputValue(obj.find('input:eq(0)"')))
.latitude(fGetInputValue(obj.find('input:eq(1)"')))
.longitude(fGetInputValue(obj.find('input:eq(2)"')))
.time(fGetTimeValues(obj));
func(routeId, pointId, oPoint.getJSON());
obj.find('ul.point-item').pointEditor('close');
}
function fRouteSaveNewPoint(event)
{
fPreccessPoint(this, oDataSrc.addPoint);
var routeId = fGetIdFromAttr(this.id);
oDataSrc.getJSONRouteById(routeId, oView.editRoute);
return false;
}
function fRouteDeletePoint(o)
{
if (oView.confirm("Czy na pewno chcesz usunąć ten punkt?"))
{
var pointId = fGetIdFromAttr(this.name);
var routeId = fGetIdFromAttr(fGetAncestor($(this), 6).attr('id'));
var res = oDataSrc.deletePoint(routeId, pointId);
if (res)
{
var pageNum = Math.ceil((1.0 + pointId * 1.0) / 100.0);
oDataSrc.getJSONRoutePageById(routeId, pageNum, oView.editRoute);
}
else
{
oView.alert("Wystąpił błąd podczas usuwania punktu");
}
}
}
function fShowHtChart()
{
var id = fGetIdFromAttr(this.href);
var oChart = WDP.chart().line().useNode('graph');
oDataSrc.getChart(id, 'altitude', oChart.display);
return false;
}
function fShowVtChart()
{
var id = fGetIdFromAttr(this.href);
var oChart = WDP.chart().line().useNode('graph');
oDataSrc.getChart(id, 'speed', oChart.display);
return false;
}
return {
tracklist_checkbox_change : fTrackListCheckboxChanged,
initialize_onload : fInitializeOnload,
tracklist_item_delete : fTrackListItemDelete,
tracklist_item_edit : fTrackListItemEdit,
route_point_edit : fRoutePointEdit,
route_point_update : fRouteSaveEditedPoint,
route_point_delete : fRouteDeletePoint,
route_point_save_new : fRouteSaveNewPoint,
show_form_for_new_point : fRouteAddFormForNewPoint,
show_points_time_editor : fShowPointsTimeEditor,
show_ht_chart : fShowHtChart,
show_vt_chart : fShowVtChart,
reload_tracklist : fReloadTracks
};
};
Math.decimal = function(n, k) {
var factor = Math.pow(10, k+1);
n = Math.round(Math.round(n*factor)/10);
return n/(factor/10);
}
|
import { Node } from '../helpers/Node'
const BoardEmpty = props => {
return (
Node('div', { class: 'board empty' },
Node('div', { class: 'plus' }, '+')
)
)
}
export default BoardEmpty
|
import React from 'react';
import {fireEvent,render} from '@testing-library/react';
describe('Testing', () => {
it('First test', () => {
expect(true).toBeTruthy()
});
});
|
/**
* Created by nnnyy on 2018-11-24.
*/
const VueBus = {
CloseInventory: "CloseInentory",
StartTimer: "StartTimer",
SetAlertMsg: "SetAlertMsg",
OpenGachaBox: "OpenGachaBox",
HTTP: {
CheckLogin: "/auth/checklogin",
Login: "/auth/login"
},
SOCK: {
NotLogined: "NotLogined",
LoginRequest: "LoginRequest",
Disconnect: "disconnect",
QuizData: "QuizData",
QuizDataResult: "QuizDataResult",
QuizAnswer: "QuizAnswer",
AlertMsg: "AlertMsg",
ComboInfo: "ComboInfo",
Logout: "Logout",
QuizAnswerCnt: "QuizAnswerCnt",
CurrentComboRank: "CurrentComboRank",
AnswerFirstSelectUser: "AnswerFirstSelectUser",
QuizRecordRank: "QuizRecordRank"
}
};
module.exports = VueBus;
|
import { init } from "@rematch/core";
import { plugins } from "f-core";
import * as models from "models";
export const store = init({
models,
plugins: [plugins.actions],
});
|
import * as types from '../actions/ActionTypes';
import update from 'immutability-helper';
const initialState = {
thesaurusWords: {
status: 'INIT',
data: [],
page: 0,
totalPage: '',
categorized: false
},
thesaurusCategories: {
status: 'INIT',
data: ''
},
categorizedData: {
status: 'INIT',
data: [],
category: '',
page: '',
totalPage: ''
},
wordDetail: {
status: 'INIT',
data: [],
}
};
export default function Synonym(state, action) {
if(typeof state === "undefined")
state = initialState;
switch(action.type) {
/* ENTITY_LIST */
case types.THESAURUS_WORDS:
return update(state, {
thesaurusWords: {
status: { $set: 'WAITING' }
}
});
case types.THESAURUS_WORDS_SUCCESS:
return update(state, {
thesaurusWords: {
status: { $set: 'SUCCESS' },
data: { $set: action.data },
page: { $set: action.page }
},
});
case types.THESAURUS_WORDS_FAILURE:
return update(state, {
thesaurusWords: {
status: { $set: 'FAILURE' }
}
});
case types.THESAURUS_CATEGORY:
return update(state, {
thesaurusCategories: {
status: { $set: 'WAITING' }
}
});
case types.THESAURUS_CATEGORY_SUCCESS:
return update(state, {
thesaurusCategories: {
status: { $set: 'SUCCESS' },
data: { $set: action.data },
},
});
case types.THESAURUS_CATEGORY_FAILURE:
return update(state, {
thesaurusCategories: {
status: { $set: 'FAILURE' }
}
});
case types.SEARCH_FIRST_CHAR_THESAURUS:
return update(state, {
categorizedData: {
status: { $set: 'WAITING' }
}
});
case types.SEARCH_FIRST_CHAR_THESAURUS_SUCCESS:
return update(state, {
categorizedData: {
status: { $set: 'SUCCESS' },
data: { $set: action.data },
category: { $set: action.char },
page: { $set: action.page },
},
thesaurusWords: {
categorized: { $set: true },
}
});
case types.SEARCH_FIRST_CHAR_THESAURUS_FAILURE:
return update(state, {
categorizedData: {
status: { $set: 'FAILURE' }
}
});
case types.VIEW_THESAURUS_WORD:
return update(state, {
wordDetail: {
status: { $set: 'WAITING' }
}
});
case types.VIEW_THESAURUS_WORD_SUCCESS:
return update(state, {
wordDetail: {
status: { $set: 'SUCCESS' },
data: { $set: action.data },
},
});
case types.VIEW_THESAURUS_WORD_FAILURE:
return update(state, {
wordDetail: {
status: { $set: 'FAILURE' }
}
});
default:
return state;
}
}
|
var fs = require('fs');
var file = fs.createReadStream('../mod_1/file.txt');
var newFile = fs.createWriteStream('file-1.txt');
file.pipe(newFile);
|
import React from 'react'
import './App.css'
import './Reset.css'
import { FacebokIcon, GithubIcon, InstagramIcon, TwitterIcon } from './Icons'
import { BrowserRouter as Router, Route, Link } from 'react-router-dom'
import Home from './home/Home'
import About from './about/About'
import Post from './post/Post'
class App extends React.Component {
render() {
return (
<Router>
<div className="main">
<div className="sidebar">
<h1 className="sidebar-header">My personal blog</h1>
<p className="sidebar-content">
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis sit
amet sodales ipsum. Aenean felis nibh, dignissim eu tortor ut,
pulvinar commodo tortor. Pellentesque gravida sapien velit, in
pellentesque sapien sagittis nec.
</p>
<div className="sidebar-navigation">
<div>
<Link className="sidebar-link" to="/">
Home
</Link>
</div>
<div>
<Link className="sidebar-link" to="/about">
About
</Link>
</div>
</div>
<div className="sidebar-icons">
<FacebokIcon />
<GithubIcon />
<InstagramIcon />
<TwitterIcon />
</div>
</div>
<div>
<Route exact path="/" component={Home} />
<Route path="/about" component={About} />
<Route path="/posts" component={Post} />
</div>
</div>
</Router>
)
}
}
export default App
|
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is MozMill Test code.
*
* The Initial Developer of the Original Code is Mozilla Foundation.
* Portions created by the Initial Developer are Copyright (C) 2009
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Clint Talbert <ctalbert@mozilla.com>
* Henrik Skupin <hskupin@mozilla.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// Include required modules
var domUtils = require("dom-utils");
const TIMEOUT_MODAL_DIALOG = 5000;
const DELAY_CHECK = 100;
/**
* Observer object to find the modal dialog spawned by a controller
*
* @constructor
* @class Observer used to find a modal dialog
*
* @param {object} aOpener
* Window which is the opener of the modal dialog
* @param {function} aCallback
* The callback handler to use to interact with the modal dialog
*/
function mdObserver(aOpener, aCallback) {
this._opener = aOpener;
this._callback = aCallback;
this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
}
mdObserver.prototype = {
/**
* Set our default values for our internal properties
*/
_opener : null,
_callback: null,
_timer: null,
exception: null,
finished: false,
/**
* Check if the modal dialog has been opened
*
* @returns {object} The modal dialog window found, or null.
*/
findWindow : function mdObserver_findWindow() {
// If a window has been opened from content, it has to be unwrapped.
var window = domUtils.unwrapNode(mozmill.wm.getMostRecentWindow(''));
// Get the WebBrowserChrome and check if it's a modal window
var chrome = window.QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIWebNavigation).
QueryInterface(Ci.nsIDocShellTreeItem).
treeOwner.
QueryInterface(Ci.nsIInterfaceRequestor).
getInterface(Ci.nsIWebBrowserChrome);
if (!chrome.isWindowModal()) {
return null;
}
// Opening a modal dialog from a modal dialog would fail, if we wouldn't
// check for the opener of the modal dialog
var found = false;
if (window.opener) {
// XXX Bug 614757 - an already unwrapped node returns a wrapped node
var opener = domUtils.unwrapNode(window.opener);
found = (mozmill.utils.getChromeWindow(opener) == this._opener);
}
else {
// Also note that it could happen that dialogs don't have an opener
// (i.e. clear recent history). In such a case make sure that the most
// recent window is not the passed in reference opener
found = (window != this._opener);
}
return (found ? window : null);
},
/**
* Called by the timer in the given interval to check if the modal dialog has
* been opened. Once it has been found the callback gets executed
*
* @param {object} aSubject Not used.
* @param {string} aTopic Not used.
* @param {string} aData Not used.
*/
observe : function mdObserver_observe(aSubject, aTopic, aData) {
// Once the window has been found and loaded we can execute the callback
var window = this.findWindow();
if (window && ("documentLoaded" in window)) {
try {
this._callback(new mozmill.controller.MozMillController(window));
}
catch (ex) {
// Store the exception, so it can be forwarded if a modal dialog has
// been opened by another modal dialog
this.exception = ex;
}
if (window) {
window.close();
}
this.finished = true;
this.stop();
}
else {
// otherwise try again in a bit
this._timer.init(this, DELAY_CHECK, Ci.nsITimer.TYPE_ONE_SHOT);
}
},
/**
* Stop the timer which checks for new modal dialogs
*/
stop : function mdObserver_stop() {
delete this._timer;
}
};
/**
* Creates a new instance of modalDialog.
*
* @constructor
* @class Handler for modal dialogs
*
* @param {object} aWindow [optional - default: null]
* Window which is the opener of the modal dialog
*/
function modalDialog(aWindow) {
this._window = aWindow || null;
}
modalDialog.prototype = {
/**
* Simply checks if the modal dialog has been processed
*
* @returns {boolean} True, if the dialog has been processed
*/
get finished() {
return (!this._observer || this._observer.finished);
},
/**
* Start timer to wait for the modal dialog.
*
* @param {function} aCallback
* The callback handler to use to interact with the modal dialog
*/
start : function modalDialog_start(aCallback) {
if (!aCallback)
throw new Error(arguments.callee.name + ": Callback not specified.");
this._observer = new mdObserver(this._window, aCallback);
this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
this._timer.init(this._observer, DELAY_CHECK, Ci.nsITimer.TYPE_ONE_SHOT);
},
/**
* Stop the timer which checks for new modal dialogs
*/
stop : function modalDialog_stop() {
delete this._timer;
if (this._observer) {
this._observer.stop();
this._observer = null;
}
},
/**
* Wait until the modal dialog has been processed.
*
* @param {Number} aTimeout (optional - default 5s)
* Duration to wait
*/
waitForDialog : function modalDialog_waitForDialog(aTimeout) {
var timeout = aTimeout || TIMEOUT_MODAL_DIALOG;
if (!this._observer) {
return;
}
try {
mozmill.utils.waitFor(function () {
return this.finished;
}, "Modal dialog has been found and processed", timeout, undefined, this);
// Forward the raised exception so we can detect failures in modal dialogs
if (this._observer.exception) {
throw this._observer.exception;
}
}
finally {
this.stop();
}
}
}
// Export of classes
exports.modalDialog = modalDialog;
|
import React from 'react';
import Slider from 'material-ui/Slider';
const style = {
width: '90%',
margin: 'auto'
}
/**
* By default, the slider is continuous. The `step` property causes the slider to move in discrete increments.
*/
const SliderExampleStep = () => (
<Slider step={0.10} value={.5} style={style}/>
);
export default SliderExampleStep;
|
/*global console: false, aljabr: false, _: false */
/**
* John Eargle (mailto: jeargle at gmail.com)
* 2007-2019
* aljabr
*/
var aljabr = aljabr || {}
/**
* Immutable, validated Group.
*/
aljabr.Elements = class {
elements = []
elementToIdx = {}
/**
* Initialize the class.
* @param elements - list of strings
*/
constructor(elements) {
let model
model = this
model.elements = elements
for (let i=0; i<model.elements.length; i++) {
model.elementToIdx[model.elements[i]] = i
}
}
/**
*
*/
getElementIdx(element) {
return this.elementToIdx[element]
}
/**
*
*/
getElement(elementIdx) {
return this.elements[elementIdx]
}
/**
*
*/
setElement(elementIdx, element) {
let model, oldElement
model = this
oldElement = model.elements[elementIdx]
delete model.elementToIdx[oldElement]
model.elements[elementIdx] = element
model.elementToIdx[element] = elementIdx
}
}
/**
* Build an alphabet using latin characters where 'e' is the identity
* element.
* @param order - number of elements.
*/
aljabr.alphaElements = function(order) {
'use strict'
let i, alpha, elements
if (order > 26) {
console.error('Error: order larger than 26')
return null
}
alpha = ['e', 'a', 'b', 'c', 'd', 'f', 'g', 'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z']
elements = alpha.slice(0, order)
return elements
}
/**
* Build an alphabet using integers where 0 or 1 is the identity
* element.
* @param order - number of elements.
* @param identityOne - set identity to 1 (default false)
*/
aljabr.numElements = function(order, identityOne) {
'use strict'
let i, elements, identity
if (identityOne === undefined) {
identityOne = false
}
if (identityOne) {
identity = 1
order += 1
}
else {
identity = 0
}
elements = []
for (i=identity; i<order; i++) {
elements.push(toString(i))
}
return elements
}
/**
* This class holds the elements of a multiplication table.
* The table only contains ints or null; the ints are indices
* into an ElementSet array.
* OperatorTables are generic so they may be used for Groups,
* Rings, Fields, etc. No validation is done in this class
* for element placement, that happens in the corresponding
* Builder classes.
*/
aljabr.OperatorTable = class {
order = 0
emptyCellCount = 0
table = undefined
/**
* Initialize the class.
* @param order - number of rows (and columns) in the table
*/
constructor(order) {
'use strict'
let model, i, j
model = this
model.order = order
model.emptyCellCount = model.order * model.order
model.table = []
for (i=0; i<model.order; i++) {
model.table[i] = []
for (j=0; j<model.order; j++) {
model.table[i][j] = null
}
}
}
/**
* Set the element for a given position in the table.
* @param i - row
* @param j - column
* @param elementIdx - value to set the elementIdx to (int)
*/
setElement(i, j, elementIdx) {
'use strict'
let model
model = this
if (0 <= i && i < model.order &&
0 <= j && j < model.order &&
0 <= elementIdx && elementIdx < model.order) {
if (model.table[i][j] === null) {
model.emptyCellCount -= 1
}
model.table[i][j] = elementIdx
}
// XXX - else throw exception
}
/**
* Get element index from the table.
* @param i - row
* @param j - column
* @returns elementIdx at (i,j) in the table
*/
getElementIdx(i, j) {
'use strict'
return this.table[i][j]
}
/**
* Remove an element index from the table.
* @param i - row
* @param j - column
*/
removeElement(i, j) {
'use strict'
this.table[i][j] = null
}
/**
* @returns whether the table is filled out or not
*/
isComplete() {
'use strict'
return this.emptyCellCount === 0
}
}
/**
* Immutable, validated Group.
*/
aljabr.Group = class {
cls = 'Group'
elements = null // Elements
elementIdxs = null // array of idxs into elements
order = 0
table = null
subgroups = [] // array of created subgroups
/**
* Initialize the class.
* @param elements - list of strings representing group elements
* @param table - OperatorTable for the Group
*/
constructor(elements, table, elementIdxs = null) {
let model
model = this
model.elements = elements
model.table = table
model.order = model.table.order
if (elementIdxs == null) {
model.elementIdxs = []
for (let i=0; i<model.order; i++) {
model.elementIdxs.push(i)
}
} else if (elementIdxs.length !== model.order) {
console.error('Error: table order is different from elementIdxs order')
} else {
model.elementIdxs = elementIdxs
}
}
/**
* Get a specific element.
* @param i - position in elementIdxs
* @returns the element at position (i, j)
*/
getElement(i) {
'use strict'
return this.elements.getElement(this.elementIdxs[i])
}
/**
* Get the identity element.
* @returns the identity element
*/
getIdentityIdx() {
'use strict'
return this.table.getElementIdx(0, 0)
}
/**
* Get a specific element.
* @param i - row
* @param j - column
* @returns the element at position (i, j)
*/
getElementIdx(i, j) {
'use strict'
return this.table.getElementIdx(i, j)
}
/**
* Get the order of an element.
* @param el - element index
* @returns order of the element
*/
elementOrder(elIdx) {
'use strict'
let model, order, elPower
model = this
if (elIdx === 0) {
return 1
}
else if (elIdx >= model.order) {
console.error("Error: element index too large")
return 0
}
order = 1
elPower = elIdx
// Loop through powers of elIdx
while (elPower !== null && elPower !== 0) {
elPower = model.getElementIdx(elPower, elIdx)
order += 1
}
if (elPower === null) {
console.error('Error: element order is broken for element ' +
model.getElement(elIdx))
return 0
}
return order
}
/**
* Get the group index of an element.
* @param elIdx - index into element array
* @returns index of the element
*/
elementIndex(elIdx) {
'use strict'
let model, order
model = this
if (elIdx === 0) {
return model.order
}
else if (elIdx >= model.order) {
console.error("Error: element index too large")
return 0
}
order = model.elementOrder(elIdx)
if (order === 0) {
console.error("Error: element order is 0")
}
return model.order/order
}
/**
* Get the set of elements in the subgroup generated by
* the provided element.
* @param {[number]} generatorIdxs - indexes into element array
* @returns array of elements
*/
subgroupElements(generatorIdxs) {
'use strict'
let model, nextEl, elements, newElements
if (generatorIdxs.length < 1) {
console.error('Error: must include at least one generator')
}
model = this
elements = []
// Loop through powers of first generator
nextEl = 0
do {
elements.push(nextEl)
nextEl = model.getElementIdx(nextEl, generatorIdxs[0])
} while (nextEl != null && nextEl !== 0)
// Loop through powers of remaining generators
for (let i=1; i<generatorIdxs.length; i++) {
newElements = []
for (let j=0; j<elements.length; j++) {
nextEl = elements[j]
do {
nextEl = model.getElementIdx(nextEl, generatorIdxs[i])
if (!elements.includes(nextEl)) {
newElements.push(nextEl)
}
} while (nextEl != null && nextEl !== elements[j])
}
elements = elements.concat(newElements)
generatorIdxs = generatorIdxs.concat(newElements)
}
return [...new Set(elements)]
}
/**
* Get the cosets for the subgroup generated by the provided
* elements.
* @param {[number]} generatorIdxs - indexes into element array
* @param {boolean} left - true left, false right; default true
* @param [number] elements - array of element indices
* @returns array of elements
*/
cosets(generatorIdxs=null, left=true, elements=null) {
let model, index, cosets, multElements, cosetElements, i, multiplier, coset, tempEl
model = this
if (generatorIdxs != null && elements == null) {
elements = model.subgroupElements(generatorIdxs)
}
index = model.order/elements.length
cosets = [elements]
// Track elements used as the left multiplier
// and elements already in a known coset
multElements = []
cosetElements = []
for (i=0; i<model.order; i++) {
multElements.push(true)
cosetElements.push(true)
}
// Remove elements already in the base coset
for (i=0; i<elements.length; i++) {
multElements[elements[i]] = false
cosetElements[elements[i]] = false
}
multiplier = 0
while (cosets.length < index && multiplier < model.order) {
coset = []
// Get next multiplier
while (!multElements[multiplier]) {
multiplier += 1
}
multElements[multiplier] = false
for (i=0; i<elements.length; i++) {
if (left) {
tempEl = model.getElementIdx(elements[i], multiplier)
}
else {
tempEl = model.getElementIdx(multiplier, elements[i])
}
if (cosetElements[tempEl]) {
coset.push(tempEl)
cosetElements[tempEl] = false
}
else {
break
}
}
if (coset.length === elements.length) {
cosets.push(coset)
}
}
return cosets
}
/**
* Sort each coset and then sort the list of cosets by each one's
* first element.
* @param {[[number]]} cosets - list of cosets
*/
sortCosets(cosets) {
let sortedCosets, sortedCoset
sortedCosets = []
for (let i=0; i<cosets.length; i++) {
sortedCoset = [...cosets[i]]
sortedCoset.sort((a, b)=>{return a-b})
sortedCosets.push(sortedCoset)
}
sortedCosets.sort((a, b)=>{return a[0]-b[0]})
return sortedCosets
}
/**
* @param {[[number]]} cosets1 - list of cosets
* @param {[[number]]} cosets2 - list of cosets
*/
cosetsEqual(cosets1, cosets2) {
if (cosets1.length !== cosets2.length) {
return false
}
for (let i=0; i<cosets1.length; i++) {
for (let j=0; j<cosets1[i].length; j++) {
if (cosets1[i][j] !== cosets2[i][j]) {
return false
}
}
}
return true
}
/**
* Build a subgroup from all combinations of the identity and
* a set of generators.
* @param {[number]} generatorIdxs - indexes into element array
*/
subgroup(generatorIdxs) {
let model, elementIdxs, elements, oldElementIdxToNew, table, leftCosets, rightCosets, normal, subgroup
model = this
// Subgroup elements
elementIdxs = model.subgroupElements(generatorIdxs)
elements = []
oldElementIdxToNew = {}
for (let i=0; i<elementIdxs.length; i++) {
elements.push(model.getElement(elementIdxs[i]))
oldElementIdxToNew[elementIdxs[i]] = i
}
// Subgroup table
table = new aljabr.OperatorTable(elements.length)
for (let i=0; i<elementIdxs.length; i++) {
for (let j=0; j<elementIdxs.length; j++) {
table.setElement(
i, j,
oldElementIdxToNew[model.getElementIdx(elementIdxs[i], elementIdxs[j])]
)
}
}
leftCosets = model.sortCosets(model.cosets(generatorIdxs, true, elementIdxs))
rightCosets = model.sortCosets(model.cosets(generatorIdxs, false, elementIdxs))
normal = model.cosetsEqual(leftCosets, rightCosets)
subgroup = new aljabr.Group(new aljabr.Elements(elements), table)
model.subgroups.push({
group: subgroup,
generatorIdxs,
normal: normal
})
return subgroup
}
/**
* Create a String representation of the current operator table.
* @returns string representation of the operator table
*/
toStr() {
'use strict'
let model, colWidth, outString, i, j
model = this
// Set column width to size of largest element symbol
colWidth = 0
for (i=0; i<model.order; i++) {
if (colWidth < model.getElement(i).length) {
colWidth = model.getElement(i).length
}
}
outString = ' ' + aljabr.rJust(' ', colWidth) + ' |'
for (i=0; i<model.order; i++) {
outString += ' ' +
aljabr.rJust(model.getElement(i), colWidth) +
' |'
}
outString += '\n'
for (i=0; i<=model.order; i++) {
outString += '-' + aljabr.rJust('-', colWidth, '-') + '-|'
}
outString += '\n'
for (i=0; i<model.order; i++) {
outString += ' ' +
aljabr.rJust(model.getElement(i), colWidth) +
' |'
for (j=0; j<model.order; j++) {
if (model.getElementIdx(i, j) === null) {
outString += ' ' + aljabr.rJust('.', colWidth) + ' |'
}
else {
outString += ' ' +
aljabr.rJust(
model.getElement(model.getElementIdx(i, j)),
colWidth) +
' |'
}
}
outString += '\n'
}
return outString
}
}
/**
* Immutable, validated Field.
*/
aljabr.Field = class {
cls = 'Field'
elements = null // Elements
elementIdxs = null // list of idxs into elements
order = 0
table = null
/**
* Initialize the class.
* @param elements - list of strings representing Field elements
* @param addGroup - additive Group
* @param multGroup - multiplicative Group
*/
constructor(elements, addGroup, multGroup) {
'use strict'
let model
model = this
model.elements = elements
model.order = model.elements.length
model.addGroup = addGroup
model.multGroup = multGroup
}
/**
* Get the identity element for a given table.
* @param tableType {string} - '+' or '*'
* @returns the identity element
*/
getIdentityIdx(tableType) {
'use strict'
let model, identityIdx
model = this
if (tableType === '+') {
identityIdx = model.addGroup.getIdentityIdx()
}
else if (tableType === '*') {
identityIdx = model.multGroup.getIdentityIdx()
}
return identityIdx
}
/**
* Get a specific element from the additive table.
* @param i - row
* @param j - column
* @param tableType {string} - '+' or '*'
* @returns the element at position (i, j)
*/
getElementIdx(i, j, tableType) {
'use strict'
let model, el
model = this
if (tableType === '+') {
el = model.addGroup.getElementIdx(i, j)
}
else if (tableType === '*') {
el = model.multGroup.getElementIdx(i, j)
}
return el
}
/**
* Get the order of an element.
* @param elIdx - element index
* @param tableType {string} - '+' or '*'
* @returns order of the element
*/
elementOrder(elIdx, tableType) {
'use strict'
let model, order
model = this
if (tableType === '+') {
order = model.addGroup.elementOrder(elIdx)
}
else if (tableType === '*') {
order = model.multGroup.elementOrder(elIdx)
}
return order
}
/**
* Get the Field index of an element.
* @param el - index into element array
* @param tableType {string} - '+' or '*'
* @returns index of the element
*/
elementIndex(elIdx, tableType) {
'use strict'
let model, index
model = this
if (tableType === '+') {
index = model.addGroup.elementIndex(elIdx)
}
else if (tableType === '*') {
index = model.multGroup.elementIndex(elIdx)
}
return index
}
/**
* Create a String representation of the current operator table.
* @returns string representation of the operator table
*/
toStr() {
'use strict'
let model, colWidth, outString, i, j
console.log('Field.toStr()')
model = this
outString = model.addGroup.toStr()
outString += '\n'
outString += model.multGroup.toStr()
return outString
}
}
/**
* This class holds information about positions in an OperatorTable
* that are still available for specific elements. It does not
* perform any automatic pruning of the table. All changes must
* be initiated by GroupBuilder.
*/
aljabr.OpenTable = class {
cls = 'OpenTable'
order = 0
table = undefined // [row][col][index] = allowedElement
openPos = undefined // [element][row][col] = true or false
nextPos = null // {el: el, row: row, col: col}: next position to close
/**
* Initialize the class.
* @param order {number} - size of underlying group
*/
constructor(order) {
'use strict'
let model, i, j, k
model = this
model.order = order
// Table with bool arrays showing which elements are allowed in a cell
model.table = []
model.openPos = []
for (i=0; i<model.order; i++) {
model.table[i] = []
model.openPos[i] = []
for (j=0; j<model.order; j++) {
model.table[i][j] = []
model.openPos[i][j] = []
for (k=0; k<model.order; k++) {
model.table[i][j][k] = k
model.openPos[i][j][k] = true
}
}
}
}
/**
* Whether or not an element is a possibility for the given
* position.
* @param row {number} - row index
* @param col {number} - column index
* @param element {number} - element index
* @returns true or false
*/
isAllowed(row, col, element) {
'use strict'
if (this.table[row][col].indexOf(element) === -1) {
return false
}
return true
}
/**
* Return a list of remaining possible elements for a given
* position.
* @param row {number} - row index
* @param col {number} - column index
* @returns list of available elements
*/
allowedList(row, col) {
'use strict'
return this.table[row][col]
}
/**
* Remove all remaining elements as a possible options for a given
* position.
* @param row {number} - row index
* @param col {number} - column index
*/
clear(row, col) {
'use strict'
let model, i
model = this
model.table[row][col] = []
for (i=0; i<model.order; i++) {
model.openPos[i][row][col] = false
}
if (model.nextPos !== null &&
model.nextPos.row === row &&
model.nextPos.col === col) {
console.error('cleared nextPos')
model.nextPos = null
}
return
}
/**
* Remove element as a possible option for a given position.
* @param row {number} - row index
* @param col {number} - column index
* @param element {number} - element index
*/
remove(row, col, element) {
'use strict'
let model, elIndex
model = this
elIndex = model.table[row][col].indexOf(element)
if (elIndex > -1) {
model.table[row][col].splice(elIndex, 1)
}
model.openPos[element][row][col] = false
if (model.nextPos !== null &&
model.nextPos.el === element &&
model.nextPos.row === row &&
model.nextPos.col === col) {
console.error('removed nextPos')
model.nextPos = null
}
return
}
/**
* Get a table showing where an element can be placed.
* @param element - element index
* @returns boolean mask of table showing open positions
*/
openPositions(element) {
'use strict'
return this.openPos[element]
}
/**
* Go through open positions to find any cases where an element
* has only one available open position in a row or column.
*/
findNextPos() {
'use strict'
let model, el, row, col
model = this
if (model.nextPos !== null) {
return null
}
for (el=0; el<model.order; el++) {
for (row=0; row<model.order; row++) {
col = model.openPos[el][row].indexOf(true)
if (col === -1) {
continue
}
if (model.openPos[el][row].indexOf(true) === -1) {
model.nextPos = {el: el, row: row, col: col}
return model.nextPos
}
}
}
return null
}
/**
* Print out a table showing which elements can be placed in which
* open positions in the operator table.
*/
printOpenTable() {
'use strict'
let model, i, j
model = this
for (i=0; i<model.order; i++) {
console.log('row ' + i + '\n')
for (j=0; j<model.order; j++) {
console.log(' col ' + j + '\n')
console.log(' ')
// console.log('table[' + i + '][' + j + '].class: ' + model.table[i][j].class + '\n')
// console.log('table[' + i + '][' + j + '].length: ' + model.table[i][j].length + '\n')
// console.log('table[0][0].length: ' + model.table[0][0].length + '\n')
_.each(model.table[i][j], function(el) {
// console.log(el.class + ' ')
console.log(el + ' ')
})
console.log('\n')
}
}
}
}
/**
* This class holds information about positions in an OperatorTable
* that are still available for specific elements.
*/
aljabr.AssociationTable = class {
cls = 'AssociationTable'
order = 0
table = undefined // [row][col][index] = allowedElement
builder = undefined // GroupBuilder
/**
* Initialize the class.
*/
constructor(order, builder) {
'use strict'
let model, i, j, k
model = this
model.order = order
model.builder = builder
model.table = []
for (i=0; i<model.order; i++) {
model.table[i] = []
for (j=0; j<model.order; j++) {
model.table[i][j] = {}
}
}
}
/**
* Get association rules for a given position
* @param row - row
* @param col - column
*/
rules(row, col) {
'use strict'
return this.table[row][col]
}
/**
* Check associativity rules for this position.
* @param row - row
* @param col - column
*/
checkAssociativityRules(row, col) {
'use strict'
let model, r, firstFlag
model = this
firstFlag = true
if (model.table[row][col].length !== 0) {
for (r in model.table[row][col]) {
if (firstFlag) {
console.log('(' + row + ', ' + col + ') =')
firstFlag = false
}
console.log(' (' + r + ', ' + model.table[row][col][r] + ')')
}
}
}
/**
* Add any new associativity rules that result from the addition
* of this element at this position.
* @param i - row
* @param j - column
* @param el - element index to assign to (i, j)
*/
addAssociativityRules(row, col, el) {
'use strict'
let model, builder, tempEl1, tempEl2
model = this
builder = model.builder
if (row === col) {
// row: a, col: a, el: b
// a(aa) = (aa)a
// aa = b
// => ab = ba
if (row !== el) {
model.table[row][el][el] = row
model.table[el][row][row] = el
}
}
else {
if (el === builder.getElementIdx(row, col) &&
el === builder.getElementIdx(col, row)) {
// row: a, col: b, el: c
// a(ba) = (ab)a
// ba = c, ab = c (a and b commute)
// => ac = ca, bc = cb
if (el !== row) {
model.table[row][el][el] = row
model.table[el][row][row] = el
}
if (el !== col) {
model.table[col][el][el] = col
model.table[el][col][col] = el
}
}
else {
// b(aa) = (ba)a, a(ab) = (aa)b
// aa = c, ba = d, ab = f
// => bc = da, af = cb
// row: a, col: b, el: f, tempEl1: c, tempEl2: d
tempEl1 = builder.getElementIdx(row, row)
tempEl2 = builder.getElementIdx(col, row)
if (tempEl1 !== null && tempEl2 !== null) {
// bc = da
model.table[col][tempEl1][tempEl2] = row
model.table[tempEl2][row][col] = tempEl1
// af = cb
model.table[row][el][tempEl1] = col
model.table[tempEl1][col][row] = el
}
// row: b, col: a, el: d, tempEl1: c, tempEl2: f
tempEl1 = builder.getElementIdx(col, col)
tempEl2 = builder.getElementIdx(col, row)
if (tempEl1 !== null && tempEl2 !== null) {
// bc = da
model.table[row][tempEl1][el] = col
model.table[el][col][row] = tempEl1
// af = cb
model.table[col][tempEl2][tempEl1] = row
model.table[tempEl1][row][col] = tempEl2
}
}
// a(ba) = (ab)a, b(ab) = (ba)b
// ba = c, ab = d
// => ac = da, bd = cb
// Most general case
// c(ba) = (cb)a
// ba = d, cb = f
// cd = fa
}
}
}
/**
* This class holds an intermediate representation for a Group that
* has not been fully built. It should allow for the placement
* of Elements in an OperatorTable as long as they maintain the
* possibility of creating a valid Group.
*/
aljabr.GroupBuilder = class {
cls = 'GroupBuilder'
elements = undefined
order = 0
elementOrders = undefined
table = undefined
openTable = undefined
associationTable = undefined
factors = undefined // array of prime factors
/**
* Initialize the class.
* @param elements - Elements
*/
constructor(elements) {
'use strict'
let model, i, j, k
model = this
model.elements = elements
model.order = model.elements.length
model.table = new aljabr.OperatorTable(model.order)
model.factors = _.uniq(aljabr.factors(model.order))
console.log('factors:')
console.log(model.factors)
model.elementOrders = {left: [], right: []}
model.elementOrders.left[0] = 1
model.elementOrders.right[0] = 1
for (i=1; i<model.order; i++) {
model.elementOrders.left[i] = -1
model.elementOrders.right[i] = -1
}
// Table with bool arrays showing which elements are allowed in a cell
model.openTable = new aljabr.OpenTable(model.order)
// Remove bad identity slots
if (model.factors.indexOf(2) === -1) {
for (i=1; i<model.order; i++) {
model.openTable.remove(i, i, 0)
}
}
// Table with associations that declare pairs of cells equal
model.associationTable = new aljabr.AssociationTable(model.order, model)
// Set first column and row to identity
model.setElement(0, 0, 0)
// Last element is automatically set by setElement()
for (i=1; i<model.order-1; i++) {
model.setElement(0, i, i)
model.setElement(i, 0, i)
}
}
/**
* Get a specific element.
* @param i - row
* @param j - column
* @returns the element at position (i, j)
*/
getElementIdx(i, j) {
'use strict'
return this.table.getElementIdx(i, j)
}
/**
* Set a specific element.
* @param i - row
* @param j - column
* @param element - Element to assign to (i, j)
*/
setElement(i, j, element) {
'use strict'
let model, openTable, openList, assTable, tempEl, markQueue, head, row, col, el, x, assRules, assRow, assCol, assEl, nextPos, error
// console.log('GroupBuilder.setElement(' + i + ', ' + j + ', ' + element + ')')
model = this
openTable = model.openTable
assTable = model.associationTable
tempEl = model.getElementIdx(i, j)
if (tempEl !== null) {
if (tempEl === element) {
console.warn('element already exists at this position')
}
else {
console.error('Error: element already set to ' +
'another value, (' + i + ', ' + j +
') = ' + tempEl)
}
return null
}
// console.log('setElement(#{i}, #{j}, #{element})\n')
if (0 <= i && i < model.order &&
0 <= j && j < model.order &&
0 <= element && element < model.order) {
if (openTable.allowedList(i, j).length === 0) {
if (element !== model.table.getElementIdx(i, j)) {
console.error('Error: cannot change (' + i +
', ' + j + '): ' +
model.table.getElementIdx(i, j) +
' to ' + element)
}
else {
console.error('Error: already set')
}
return null
}
// Is this element still allowed to be placed here?
if (!openTable.isAllowed(i, j, element)) {
error = 'Error: element ' + element +
' is not allowed at (' + i + ', ' + j + ')\n'
error += ' openTable[' + i + '][' + j + ']: '
_.each(openTable.allowedList(i, j), function(x) {
error += x + ' '
})
console.error(error)
return null
}
// markQueue: queue of elements to add to the OperatorTable
markQueue = [[i, j, element]]
while (markQueue.length > 0) {
head = markQueue.splice(0, 1)[0]
row = head[0]
col = head[1]
el = head[2]
model.table.setElement(row, col, el)
// model.checkAssociativityRules(row, col)
// Add any elements required by associativity rules
assRules = assTable.rules(row, col)
if (assRules.length !== 0) {
for (assRow in assRules) {
assCol = assRules[assRow]
assEl = model.getElementIdx(assRow, assCol)
if (assEl === null) {
markQueue.push([assRow, assCol, el])
}
else if (assEl !== el) {
error = 'Error: associativity broken\n'
error += ' (' + row + ', ' + col + '): ' +
el + '\n'
error += ' (' + assRow + ', ' + assCol +
'): ' + assEl
console.error(error)
}
}
}
assTable.addAssociativityRules(row, col, el)
// Remove element from other cells in this row and column
// the if() clauses need to be separate
openTable.clear(row, col)
for (x=0; x<model.order; x++) {
// Remove from column
openTable.remove(x, col, el)
openList = openTable.allowedList(x, col)
if (openList.length === 1) {
markQueue.push([x, col, openList[0]])
}
// Remove from row
openTable.remove(row, x, el)
openList = openTable.allowedList(row, x)
if (openList.length === 1) {
markQueue.push([row, x, openList[0]])
}
}
// Check for single open positions
nextPos = openTable.findNextPos()
if (nextPos !== null) {
markQueue.push([nextPos.row, nextPos.col, nextPos.el])
}
}
}
else {
console.error('Error: parameter exceeds group order ' + model.order)
console.error(' setElement(' + i + ', ' + j + ', ' + element + ')')
}
}
/**
* TODO - return all known subsequences of powers starting with
* smallest element index
* Get the order of an element.
* @param el - element index
* @param rightSide - whether or not multiplication is on right side; default true
* @returns [order of the element (negative if order is not complete), last valid power]
*/
elementOrder(el, rightSide) {
'use strict'
let model, order, seqs, i
model = this
if (el === 0) {
return 1
}
else if (el >= model.order) {
console.error('Error: element index too large')
return 0
}
if (rightSide === undefined) {
rightSide = true
}
order = -1
seqs = model.subsequences(el, rightSide)
if (seqs.length > 0) {
for (i=0; i<seqs.length; i++) {
if (seqs[i].length > order) {
order = seqs[i].length
}
}
}
if (rightSide) {
model.elementOrders.right[el] = -order
}
else {
model.elementOrders.left[el] = -order
}
return -order
}
/**
* Get all subsequences for powers of the given element.
* @param el - element index
* @param rightSide - whether or not multiplication is on right side (col traversal); default true
* @returns array of subsequences
*/
subsequences(el, rightSide) {
'use strict'
let model, subseqs, starts, i, product
model = this
subseqs = []
if (rightSide === undefined) {
rightSide = true
}
starts = []
for (i=0; i<model.order; i++) {
starts.push(true)
}
for (i=0; i<model.order; i++) {
if (rightSide) {
product = model.table.getElementIdx(i, el)
}
else {
product = model.table.getElementIdx(el, i)
}
if (product === null) {
starts[i] = false
}
else {
starts[product] = false
}
}
for (i=0; i<starts.length; i++) {
if (starts[i]) {
subseqs.push(model.subsequence(el, i, rightSide))
}
}
return subseqs
}
/**
* Get the subsequence for powers of element1 starting at element2.
* @param el1 - element index
* @param el2 - element index
* @param rightSide - whether or not multiplication is on right side (col traversal); default true
* @returns array of elements from el2 to first null factor
*/
subsequence(el1, el2, rightSide) {
'use strict'
let model, subseq, elPower, prevPower
model = this
subseq = []
if (el1 === 0) {
return [0]
}
else if (el1 >= model.order) {
console.error('Error: element index too large')
return [0]
}
if (rightSide === undefined) {
rightSide = true
}
subseq.push(el2)
// Loop through powers of el
if (rightSide) {
elPower = model.table.getElementIdx(el2, el1)
console.log('elPower: ' + elPower)
while (elPower !== null && elPower !== el2) {
subseq.push(elPower)
elPower = model.table.getElementIdx(elPower, el1)
}
}
else {
elPower = model.table.getElementIdx(el1, el2)
while (elPower !== null && elPower !== el2) {
subseq.push(elPower)
elPower = model.table.getElementIdx(el1, elPower)
}
}
return subseq
}
/**
* Get a table showing where an element can be placed.
* @param element - element index
* @returns boolean mask of openTable showing open positions
*/
openPositions(element) {
'use strict'
return this.openTable.openPositions(element)
}
/**
* Whether the operator table is completely filled out or not
*/
isComplete() {
'use strict'
return this.table.isComplete()
}
/**
* Validate and build a corresponding Group.
*/
buildGroup() {
'use strict'
let model
model = this
// Identity was set in initialize()
// Inverses guaranteed by e in every column and every row
// Associativity guaranteed by association checks
// Must have full OperatorTable
if (model.isComplete()) {
return new aljabr.Group(new aljabr.Elements(model.elements), model.table)
}
}
/**
* Create a String representation of the current (maybe incomplete) table.
* @returns string representation of the operator table
*/
toStr() {
'use strict'
let model, elements, colWidth, i, j, outStr
model = this
elements = model.elements
// Set column width to size of largest element symbol
colWidth = 0
for (i=0; i<model.order; i++) {
if (colWidth < elements[i].length) {
colWidth = elements[i].length
}
}
outStr = ' ' + aljabr.rJust(' ', colWidth) + ' |'
for (i=0; i<model.order; i++) {
outStr += ' ' +
aljabr.rJust(elements[i], colWidth) +
' |'
}
outStr += '\n'
for (i=0; i<=model.order; i++) {
outStr += '-' + aljabr.rJust('-', colWidth, '-') + '-|'
}
outStr += '\n'
for (i=0; i<model.order; i++) {
outStr += ' ' +
aljabr.rJust(elements[i], colWidth) +
' |'
for (j=0; j<model.order; j++) {
if (model.table.getElementIdx(i, j) === null) {
outStr += ' ' + aljabr.rJust('.', colWidth) + ' |'
}
else {
outStr += ' ' +
aljabr.rJust(
elements[model.table.getElementIdx(i, j)],
colWidth
) +
' |'
}
}
outStr += '\n'
}
return outStr
}
/**
* Print out a table showing which elements can be placed in which
* open positions in the operator table.
*/
printOpenTable() {
'use strict'
this.openTable.printOpenTable()
}
}
/**
* Permutation representation of a group element from the symmetric group.
*/
aljabr.Permutor = class {
actionArray = undefined
order = 0
/**
* Initialize the class.
* @param actionArray - permutor representation
*/
constructor(actionArray) {
'use strict'
let model, i
// console.log('Permutor.init()')
model = this
model.order = actionArray.length
// Validate actionArray
// actionArray must be an array of integers from 0..actionArray.length-1
// each integer appears only once
// the array is a map from integer i to the integer actionArray[i]
for (i=0; i<model.order; i++) {
if (actionArray.indexOf(i) === -1) {
console.error('Error: bad actionArray')
}
}
model.actionArray = actionArray
}
/**
* Equality (was '===')
* @param permutor - permutor to compare against
*/
eq(permutor) {
'use strict'
return (this.toStr() === permutor.toStr())
}
/**
*
* @param permutor -
*/
operate(permutor) {
'use strict'
let model, tempActionArray, i, perm
model = this
if (model.order !== permutor.order) {
return null
}
tempActionArray = []
for (i=0; i<model.actionArray.length; i++) {
tempActionArray[i] = model.op(permutor.op(i))
}
perm = new aljabr.Permutor(tempActionArray)
return perm
}
/**
* Return an element of actionArray.
* @param num - index into actionArray
*/
op(num) {
'use strict'
//puts 'op num: ' + num.toStr()
return this.actionArray[num]
}
/**
* Return a string representation of actionArray.
*/
toStr2() {
'use strict'
let model, str, i
model = this
str = '['
for (i=0; i<model.actionArray.length; i++) {
str += model.actionArray[i] + ' '
}
str = str.trimRight()
str += ']'
return str
}
/**
* Return a string representation of actionArray.
*/
toStr() {
'use strict'
let model, str, markArray, i, j
model = this
str = ''
markArray = []
for (i=0; i<model.actionArray.length; i++) {
if (!markArray[i] && model.actionArray[i] !== i) {
markArray[i] = 1
str += '(' + i + ' '
j = model.actionArray[i]
str += j + ' '
while (!markArray[j] && model.actionArray[j] !== i) {
markArray[j] = 1
j = model.actionArray[j]
str += j + ' '
}
markArray[j] = 1
str = str.trimRight() + ') '
}
}
// Identity element represented as 'e'
str = str.trimRight()
if (str.length === 0) {
return 'e'
}
return str
}
}
aljabr.PermutationGroupBuilder = class {
generators = undefined
permutors = undefined
group = undefined
permutorOrder = 0
/**
* Initialize the class.
* Pass in array of Permutors
* @param generators - array of generators represented as +Permutors+
*/
constructor(generators) {
'use strict'
let model
// console.log('PermutationGroupBuilder.init()')
model = this
model.generators = generators
model.permutors = []
model.group = null
// XXX - getValidGenerators
model.permutorOrder = model.generators[0].order
}
/**
* Return a hash from generators to booleans (whether they're valid or not)
* A generator is valid if it has the largest order of a set of conflicting
* generators (e.g. r is valid compared with r^2 and r^3).
*/
getValidGenerators() {
'use strict'
}
/**
* Create a list of all elements with which to build the Group
* Breadth-first search using the generators and starting with the identity
* element.
*/
findElements() {
'use strict'
let model, identityActionArray, i, j, tempPermutor
model = this
// Walk each generator down the Permutor array, multiplying by the current
// permutor and adding any new results to the end of the array.
identityActionArray = []
for (i=0; i<model.permutorOrder; i++) {
identityActionArray.push(i)
}
model.permutors.push(new aljabr.Permutor(identityActionArray))
for (i=0; i<model.permutors.length; i++) {
for (j=0; j<model.generators.length; j++) {
tempPermutor = model.generators[j].operate(model.permutors[i])
if (model.permutorIndex(tempPermutor) === -1) {
model.permutors.push(tempPermutor)
}
}
}
}
/**
* Build a group from a set of permutor generators.
*/
buildGroup() {
'use strict'
let model, elementArray, elements, groupBuilder, i, j
model = this
if (model.permutors.length === 0) {
model.findElements()
}
// Create ElementSet corresponding to permutors
elementArray = []
for (i=0; i<model.permutors.length; i++) {
elementArray.push(i.toString())
}
elements = elementArray
// Loop through elements and fill out GroupBuilder
groupBuilder = new aljabr.GroupBuilder(elements)
for (i=0; i<model.permutors.length; i++) {
for (j=0; j<model.permutors.length; j++) {
groupBuilder.setElement(i, j,
model.permutorIndex(
model.permutors[j].operate(model.permutors[i])
))
// model.permutors.index(model.permutors[j].operate(model.permutors[i])))
if (groupBuilder.isComplete()) {
// console.log('COMPLETE\n')
break
}
}
if (groupBuilder.isComplete()) {
// console.log('COMPLETE\n')
break
}
}
// puts 'group:'
// puts groupBuilder
if (!groupBuilder.isComplete()) {
console.error('Error: groupBuilder is not complete')
}
model.group = groupBuilder.buildGroup()
return model.group
}
/**
* Retrieve the current group.
* @returns Group
*/
getGroup() {
'use strict'
let model
model = this
if (model.group === null) {
model.buildGroup()
}
return model.group
}
/**
* Print the permutors that generate the group.
*/
printPermutors() {
'use strict'
let model, i
model = this
for (i=0; i<model.permutors.length; i++) {
console.log(i + ': ' + model.permutors[i].toStr())
}
}
/**
* Find the index of permutor in model.permutors
*/
permutorIndex(permutor) {
'use strict'
let model, index, i
model = this
index = -1
for (i=0; i<model.permutors.length; i++) {
if (permutor.eq(model.permutors[i])) {
index = i
break
}
}
return index
}
}
aljabr.ArithmeticGroupBuilder = class {
elements = undefined
operator = undefined
group = undefined
modulo = 1
/**
* Initialize the class.
* Pass in the list of elements (integers) and the operation used
* to build the Group.
* @param elements {list} - array of elements
* @param operator {string} - '+' or '*'
*/
constructor(elements, operator, modulo) {
'use strict'
let model
// console.log('ArithmeticGroupBuilder.init()')
model = this
model.elements = elements
model.modulo = modulo
model.group = null
if (operator === '+') {
model.operator = function(x, y) {
return x+y
}
}
else if (operator === '*') {
model.operator = function(x, y) {
return x*y
}
}
else {
console.error('Error: unknown operator: ' + operator)
}
}
/**
* Build a group from a set of integers and an arithmetic operator.
*/
buildGroup() {
'use strict'
let model, elements, numElements, elementSet, elementIdxs, groupBuilder, i, j
model = this
elements = model.elements
numElements = model.elements.length
// Loop through elements and fill out GroupBuilder
elementSet = []
elementIdxs = {}
for (i=0; i<numElements; i++) {
elementSet.push(elements[i].toString())
elementIdxs[elements[i]] = i
}
groupBuilder = new aljabr.GroupBuilder(elementSet)
for (i=1; i<numElements; i++) {
for (j=1; j<numElements; j++) {
groupBuilder.setElement(
i, j, elementIdxs[model.operator(elements[i], elements[j])%model.modulo]
)
if (groupBuilder.isComplete()) {
console.log('COMPLETE\n')
break
}
}
if (groupBuilder.isComplete()) {
console.log('COMPLETE\n')
break
}
}
if (!groupBuilder.isComplete()) {
console.error('Error: groupBuilder is not complete')
}
model.group = groupBuilder.buildGroup()
return model.group
}
/**
* Retrieve the current group.
* @returns Group
*/
getGroup() {
'use strict'
let model
model = this
if (model.group === null) {
model.buildGroup()
}
return model.group
}
}
/**
* Build a cyclic group.
* @param order - order of the group
* @returns built cyclic group
*/
aljabr.buildCyclicGroup = function(order) {
'use strict'
let cycleActionArray, i, cycle, cyclicGroupBuilder
if (order <= 0) {
return null
}
cycleActionArray = []
for (i=0; i<order; i++) {
cycleActionArray[i] = null
}
if (order === 1) {
cycleActionArray[0] = 0
}
else {
for (i=0; i<order; i++) {
cycleActionArray[i] = i+1
}
cycleActionArray[order-1] = 0
}
cycle = new aljabr.Permutor(cycleActionArray)
cyclicGroupBuilder = new aljabr.PermutationGroupBuilder([cycle])
return cyclicGroupBuilder.getGroup()
}
/**
* Build a dihedral group.
* @param degree - half of the order of the group
* @returns built dihedral group
*/
aljabr.buildDihedralGroup = function(degree) {
'use strict'
let dihedralActionArray1, dihedralActionArray2, i, dihed1, dihed2, dihedralGroupBuilder
if (degree <= 0) {
return null
}
dihedralActionArray1 = []
dihedralActionArray2 = []
// XXX - should throw an exception no Dih1 or Dih2
if (degree === 1 || degree === 2) {
return aljabr.buildCyclicGroup(degree)
}
else {
for (i=0; i<degree+2; i++) {
dihedralActionArray1[i] = i+1
dihedralActionArray2[i] = i
}
dihedralActionArray1[degree-1] = 0
dihedralActionArray1[degree] = degree
dihedralActionArray1[degree+1] = degree+1
dihedralActionArray2[degree] = degree+1
dihedralActionArray2[degree+1] = degree
}
dihed1 = new aljabr.Permutor(dihedralActionArray1)
dihed2 = new aljabr.Permutor(dihedralActionArray2)
dihedralGroupBuilder = new aljabr.PermutationGroupBuilder([dihed1, dihed2])
return dihedralGroupBuilder.getGroup()
}
/**
* Build a symmetry group.
* Uses (degree*degree - degree)/2 generators.
* @param degree - order of the group is degree!
* @returns built symmetry group
*/
aljabr.buildSymmetryGroup = function(degree) {
'use strict'
let baseActionArray, numActionArrays, symmetryActionArrays, num1, num2, i, transpositions, symmetryGroupBuilder
if (degree <= 0) {
return null
}
if (degree === 1 || degree === 2) {
return aljabr.buildCyclicGroup(degree)
}
baseActionArray = []
for (i=0; i<degree; i++) {
baseActionArray[i] = i
}
numActionArrays = (degree*degree - degree)/2
symmetryActionArrays = []
// Build actionArrays like [0, 1, 2, ...] then switch
// elements at indices num1 and num2
num1 = 0
num2 = 1
for (i=0; i<numActionArrays; i++) {
symmetryActionArrays[i] = baseActionArray.slice()
symmetryActionArrays[i][num1] = num2
symmetryActionArrays[i][num2] = num1
num2 += 1
if (num2 === degree) {
num1 += 1
num2 = num1 + 1
}
}
transpositions = []
for (i=0; i<numActionArrays; i++) {
transpositions[i] = new aljabr.Permutor(symmetryActionArrays[i])
}
symmetryGroupBuilder = new aljabr.PermutationGroupBuilder(transpositions)
return symmetryGroupBuilder.getGroup()
}
/**
* Build a symmetry group.
* Uses degree - 1 generators.
* @param degree - order of the group is degree!
* @returns built symmetry group
*/
aljabr.buildSymmetryGroup2 = function(degree) {
'use strict'
let baseActionArray, numActionArrays, symmetryActionArrays, num1, num2, i, transpositions, symmetryGroupBuilder
if (degree <= 0) {
return null
}
if (degree === 1 || degree === 2) {
return aljabr.buildCyclicGroup(degree)
}
baseActionArray = []
for (i=0; i<degree; i++) {
baseActionArray[i] = i
}
numActionArrays = degree - 1
symmetryActionArrays = []
// Build actionArrays like [0, 1, 2, ...] then switch
// elements at indices 0 and i+1.
for (i=0; i<numActionArrays; i++) {
symmetryActionArrays[i] = baseActionArray.slice()
symmetryActionArrays[i][0] = i+1
symmetryActionArrays[i][i+1] = 0
}
transpositions = []
for (i=0; i<numActionArrays; i++) {
transpositions[i] = new aljabr.Permutor(symmetryActionArrays[i])
}
symmetryGroupBuilder = new aljabr.PermutationGroupBuilder(transpositions)
return symmetryGroupBuilder.getGroup()
}
/**
* Build a symmetry group.
* Uses 2 generators.
* @param degree - order of the group is degree!
* @returns built symmetry group
*/
aljabr.buildSymmetryGroup3 = function(degree) {
'use strict'
let numActionArrays, symmetryActionArrays, num1, num2, i, transpositions, symmetryGroupBuilder
if (degree <= 0) {
return null
}
if (degree === 1 || degree === 2) {
return aljabr.buildCyclicGroup(degree)
}
symmetryActionArrays = [[], []]
for (i=0; i<degree; i++) {
symmetryActionArrays[0][i] = i
symmetryActionArrays[1][i] = i+1
}
symmetryActionArrays[0][0] = 1
symmetryActionArrays[0][1] = 0
symmetryActionArrays[1][degree-1] = 0
transpositions = [
new aljabr.Permutor(symmetryActionArrays[0]),
new aljabr.Permutor(symmetryActionArrays[1])
]
symmetryGroupBuilder = new aljabr.PermutationGroupBuilder(transpositions)
return symmetryGroupBuilder.getGroup()
}
/**
* Build an alternating group.
* Uses choose(degree, 3) generators.
* @param degree - order of the group is degree!/2
* @returns built alternating group
*/
aljabr.buildAlternatingGroup = function(degree) {
'use strict'
let numActionArrays, alternatingActionArrays, i, j, k, arrayCount, transpositions, alternatingGroupBuilder
if (degree >= 1 && degree <= 3) {
return aljabr.buildCyclicGroup(degree)
}
// Number generators = choose(degree, 3)
numActionArrays = degree * (degree-1) * (degree-2) / 6
alternatingActionArrays = []
// Build actionArrays like [0, 1, 2, ...]
for (i=0; i<numActionArrays; i++) {
alternatingActionArrays[i] = []
for (j=0; j<degree; j++) {
alternatingActionArrays[i][j] = j
}
}
// Switch elements at indices num1, num2, and num3
arrayCount = 0
for (i=0; i<degree-2; i++) {
for (j=i+1; j<degree-1; j++) {
for (k=j+1; k<degree; k++) {
alternatingActionArrays[arrayCount][i] = j
alternatingActionArrays[arrayCount][j] = k
alternatingActionArrays[arrayCount][k] = i
arrayCount += 1
}
}
}
transpositions = []
for (i=0; i<numActionArrays; i++) {
transpositions[i] = new aljabr.Permutor(alternatingActionArrays[i])
}
alternatingGroupBuilder = new aljabr.PermutationGroupBuilder(transpositions)
return alternatingGroupBuilder.getGroup()
}
/**
* Build an alternating group.
* Uses 2 generators.
* @param degree - order of the group is degree!/2
* @returns built alternating group
*/
aljabr.buildAlternatingGroup2 = function(degree) {
'use strict'
let i, alternatingActionArrays, transpositions, alternatingGroupBuilder
if (degree >= 1 && degree <= 3) {
return aljabr.buildCyclicGroup(degree)
}
alternatingActionArrays = [[], []]
for (i=0; i<degree; i++) {
alternatingActionArrays[0][i] = i
alternatingActionArrays[1][i] = i+1
}
alternatingActionArrays[0][0] = 1
alternatingActionArrays[0][1] = 2
alternatingActionArrays[0][2] = 0
if (degree % 2 === 0) {
alternatingActionArrays[1][0] = 0
alternatingActionArrays[1][degree-1] = 1
}
else {
alternatingActionArrays[1][degree-1] = 0
}
transpositions = [
new aljabr.Permutor(alternatingActionArrays[0]),
new aljabr.Permutor(alternatingActionArrays[1])
]
alternatingGroupBuilder = new aljabr.PermutationGroupBuilder(transpositions)
return alternatingGroupBuilder.getGroup()
}
/**
* Build the direct product group of two existing groups.
* @param group1 - first group
* @param group2 - second group
* @returns direct product of group1 and group2
*/
aljabr.buildProductGroup = function(group1, group2) {
'use strict'
let elArray, elCount, backMap, backMap2, i, j, elements, productBuilder, el1, el2
elArray = []
elCount = 0
backMap = []
backMap2 = []
// Create new ElementSet
for (i=0; i<group1.order; i++) {
backMap[i] = []
for (j=0; j<group2.order; j++) {
elArray.push('(' +
group1.getElement(i) +
',' +
group2.getElement(j) +
')')
backMap[i][j] = elCount
elCount += 1
backMap2.push([i, j])
}
}
elements = elArray
productBuilder = new aljabr.GroupBuilder(elements)
// Loop through Groups
for (i=0; i<productBuilder.order; i++) {
for (j=0; j<productBuilder.order; j++) {
el1 = group1.getElementIdx(backMap2[i][0], backMap2[j][0])
el2 = group2.getElementIdx(backMap2[i][1], backMap2[j][1])
productBuilder.setElement(i, j, backMap[el1][el2])
}
}
return productBuilder.buildGroup()
}
/**
* Build a finite Field.
* @param order - order of the Field
* @returns built Field
*/
aljabr.buildField = function(order) {
'use strict'
let i, elements1, elements2, agb1, group1, agb2, group2, field
if (order <= 0) {
return null
}
elements1 = []
for (i=0; i<order; i++) {
elements1.push(i)
}
elements2 = []
for (i=1; i<order; i++) {
elements2.push(i)
}
agb1 = new aljabr.ArithmeticGroupBuilder(elements1, '+', 5)
group1 = agb1.buildGroup()
agb2 = new aljabr.ArithmeticGroupBuilder(elements2, '*', 5)
group2 = agb2.buildGroup()
field = new aljabr.Field(elements1, group1, group2)
return field
}
/**
* Right justify.
* @param inStr - string to justify
* @param justLen - column width in characters
* @param fillChar - character used for padding default: ' '
* @returns justified string
*/
aljabr.rJust = function(inStr, justLen, fillChar) {
'use strict'
let outStr, i
outStr = inStr
if (typeof fillChar !== 'string' ||
fillChar.length !== 1) {
fillChar = ' '
}
for (i=inStr.length; i<justLen; i++) {
outStr = fillChar + outStr
}
return outStr
}
/**
* Find all integer factors for a given number.
* @param num - number to factor
* @returns - sorted list of integer factors
*/
aljabr.factors = function(num) {
'use strict'
let primeFactors, factor, primeCount, i, powers, factors
primeFactors = aljabr.primeFactors(num)
primeCount = {}
for (i=0; i<primeFactors.length; i++) {
factor = primeFactors[i]
if (primeCount[factor] === undefined) {
primeCount[factor] = 1
}
else {
primeCount[factor]++
}
}
powers = []
for (i in primeCount) {
powers.push(aljabr.powers(i, primeCount[i]))
}
factors = []
if (powers.length > 0) {
factors = powers[0].slice()
for (i=1; i<powers.length; i++) {
factors = factors.concat(aljabr.cartProduct(factors, powers[i]))
factors = factors.concat(powers[i])
}
factors.sort(aljabr.numCompare)
}
return factors
}
/**
* Prime factorization.
* @param num - number to factor
* @param factors - temporary list of calculated prime factors
* @returns - list of prime factors
*/
aljabr.primeFactors = function(num, factors) {
'use strict'
let root, x
root = Math.sqrt(num)
if (factors === undefined) {
factors = []
}
x = 2
if (num % x) {
x = 3
while ((num % x) && ((x = x + 2) < root)) {}
}
x = (x <= root) ? x : num
factors.push(x)
return (x === num) ? factors : aljabr.primeFactors(num/x, factors)
}
/**
* Get list of powers for a given number.
* @param {number} num - number to multiply by itself
* @param {number} count - number of powers to calculate
* @returns array of powers
*/
aljabr.powers = function(num, count) {
'use strict'
let i, powers, tempNum
powers = []
tempNum = 1
for (i=0; i<count; i++) {
tempNum *= num
powers.push(tempNum)
}
return powers
}
/**
* Get all pairwise products between two lists of elements.
* @param nums1 - list of numbers
* @param nums2 - list of numbers
* @returns all pairwise products
*/
aljabr.cartProduct = function(nums1, nums2) {
'use strict'
let products, i, j
products = []
for (i=0; i<nums1.length; i++) {
for (j=0; j<nums2.length; j++) {
products.push(nums1[i] * nums2[j])
}
}
return products
}
/**
* Comparison function for sorting arrays of numbers.
* @param {number} a
* @param {number} b
* @returns a-b
*/
aljabr.numCompare = function(a, b) {
'use strict'
return a-b
}
/**
* Take the factorial of a number.
* @param {number} num
* @returns num!
*/
aljabr.factorial = function(num) {
'use strict'
let result, i
result = 1
for (i=2; i<=num; i++)
result = result * i
return result
}
//----------------------------
// Namespacing
//----------------------------
/**
* Parse dot-separated namespace strings,
* create corresponding nested namespaces,
* and add to an existing top-level namespace.
* ns_string is the namespace extension so to get
* myApp.models.model1 use:
* extend(myApp, 'models.model1')
* @param ns
* @param nsString
*/
function extend(ns, nsString) {
'use strict'
let parts, parent, pl, i
parts = nsString.split('.')
parent = ns
pl = parts.length
for (i=0; i < pl; i++) {
// create a property if it doesnt exist
if (parent[parts[i]] === undefined) {
parent[parts[i]] = {}
}
parent = parent[parts[i]]
}
return parent
}
|
import { connect } from 'react-redux';
import TagsIndexItem from './tags_index_item';
import { fetchTaggedNotes, setCurrentNote } from '../../../actions/note_actions';
import { setCurrentNotebook } from '../../../actions/notebook_actions';
import { setCurrentTag, deleteTag, fetchTags, fetchNoteTags, removeZeroIdTag } from '../../../actions/tag_actions';
const mapStateToProps = state => {
return ({
currentNote: state.notes.currentNote,
currentTag: state.tags.currentTag,
tagsState: state.tags
});
};
const mapDispatchToProps = ( dispatch, ownProps ) => {
return ({
fetchTaggedNotes: (tag) => dispatch(fetchTaggedNotes(tag)),
setCurrentNote: (note) => dispatch(setCurrentNote(note)),
setCurrentNotebook: (notebook) => dispatch(setCurrentNotebook(notebook)),
setCurrentTag: (tag) => dispatch(setCurrentTag(tag)),
deleteTag: (tag) => dispatch(deleteTag(tag)),
fetchTags: () => dispatch(fetchTags()),
fetchNoteTags: (note) => dispatch(fetchNoteTags(note)),
removeZeroIdTag: () => dispatch(removeZeroIdTag())
});
};
export default connect(
mapStateToProps,
mapDispatchToProps
)(TagsIndexItem);
|
import { connect } from 'react-redux'
import { push } from 'react-router-redux'
import { setCurrentProject, addCandidate } from '../../../actions/projects'
import ProjectsShowView from './view.js'
const mapStateToProps = state => ({
currentUser: state.currentUser,
...state.currentProject
})
const mapDispatchToProps = (dispatch, ownProps) => ({
onMount: id => {
dispatch(setCurrentProject(id))
},
addCandidate: data => {
dispatch(addCandidate(data))
},
onCandidateClick: (projectId, candidateId) => {
dispatch(push(`/project/${projectId}/candidate/${candidateId}`))
}
})
export default connect(mapStateToProps, mapDispatchToProps)(ProjectsShowView)
|
import React from 'react';
import renderer from 'react-test-renderer';
import {ShowMore} from './show-more.jsx';
import {films} from '../../mocks/test-mocks.js';
it(`ShowMore should render correctly`, () => {
const tree = renderer
.create(
<ShowMore
moviesByGenre={films}
moviesCount={1}
onShowMoreButtonClick={() => {}}/>
)
.toJSON();
expect(tree).toMatchSnapshot();
});
|
import { h, Component } from "preact";
import style from "./style";
export default ({ article }) => <section class={style.article} />;
|
import React from 'react';
import MainView from './layout/MainView';
import SplashScreen from './layout/SplashScreen';
/**
* The view for the entire app.
*
* @returns {*} The jsx to display the component
* @constructor
*/
const App = () => (
<SplashScreen>
<MainView />
</SplashScreen>
);
export default App;
|
/**
* A lookup table of cards to their index.
*/
const cardNames = {
spades: {
ace: 0,
two: 1,
three: 2,
four: 3,
five: 4,
six: 5,
seven: 6,
eight: 7,
nine: 8,
ten: 9,
jack: 10,
queen: 11,
king: 12,
},
diamonds: {
ace: 13,
two: 14,
three: 15,
four: 16,
five: 17,
six: 18,
seven: 19,
eight: 20,
nine: 21,
ten: 22,
jack: 23,
queen: 24,
king: 25,
},
clubs: {
ace: 26,
two: 27,
three: 28,
four: 29,
five: 30,
six: 31,
seven: 32,
eight: 33,
nine: 34,
ten: 35,
jack: 36,
queen: 37,
king: 38,
},
hearts: {
ace: 39,
two: 40,
three: 41,
four: 42,
five: 43,
six: 44,
seven: 45,
eight: 46,
nine: 47,
ten: 48,
jack: 49,
queen: 50,
king: 51,
},
};
export default cardNames;
|
/*
Une directive retourne une référence vers elle-même via un Object et accepte un certain normbre de paramètres.
Selon moi, les plus importants à connaitre sont restrict, replace, transclude, template, templateUrl et, bien sûr, la propriété link.
*/
myApp = angular.module('myApp', []);
myApp.directive('customButton', function () {
return {
restrict: 'A',
/*
restrict indique la méthode d'accès à l'élément. Si ton projet doit être compatible avec d'anciennes version d'IE
(et je te plains mon gars !) il est fort préférable pour ton boule d'utiliser une déclaration de type attribut ou classe
Alors c'est assez simple :
- 'A' signifie attribut,
- 'E' signifie élément,
- 'C' signifie classe,
- 'M' signifie commentaire comme le -m du commit ttahiii.
- 'EA' est la valeur par défaut, ce qui montre qu'il est possible d'utiliser plusieurs méthodes d'accès en même temps.
*/
replace: true,
/*
//// Remplace le balisage ou non ////
Indique si le balisage appelant la directive doit être remplacé ou non.
Dans l'exemple précédent, vous pouvez voir que le DOM initial est remplacé par le template de la directive.
*/
transclude: false,
/*
//// Remplace le contenu du balisage ou non ////
Indique si le DOM original doit être copié dans la directive. Dans notre exemple,
le texte ‘Click me’ apparait dans la directive lorsque celle-ci est affichée.
*/
template: '<a href="" class="myawesomebutton" ng-transclude>' +
'<i class="icon-ok-sign">TEST UN DEUX TEST</i>' +
'</a>',
link: function (scope, element, attrs) {
// Manipulation du DOM et des événements, ça se passe ICI frère !
}
};
});
|
// Given an array of integers, find the pair of adjacent elements that has the largest product and return that product.
// Example
// For inputArray = [3, 6, -2, -5, 7, 3], the output should be
// adjacentElementsProduct(inputArray) = 21.
// 7 and 3 produce the largest product.
function adjacentElementsProduct(inputArray) {
let max = inputArray[0] * inputArray[1];
inputArray.forEach((val,i,arr)=>{
if(val*arr[i+1] > max){
max = val*arr[i+1];
}
});
return max;
}
|
var expect = require('expect.js')
, dataTypes = require(__dirname + "/../data-types")
var fun = function(arr) {
if (arr.length === 0) {
return null
} else {
var midIndex = ~~(arr.length / 2)
, node = null
node = dataTypes['binary-search-tree'].createNode(arr[midIndex])
node.left = fun(arr.slice(0, midIndex))
node.right = fun(arr.slice(midIndex + 1))
return node
}
}
describe('fun', function() {
it("returns the expected tree", function() {
var arr = [1,2,3,4,5,6,7]
, tree = new dataTypes['binary-search-tree']
tree.root = fun(arr)
expect(tree.root.data).to.eql(4)
expect(tree.root.left.data).to.eql(2)
expect(tree.root.left.left.data).to.eql(1)
expect(tree.root.left.right.data).to.eql(3)
expect(tree.root.right.data).to.eql(6)
expect(tree.root.right.left.data).to.eql(5)
expect(tree.root.right.right.data).to.eql(7)
})
})
|
Template.footer.helpers({
showVersion: function() {
return app_version + ' build ' + app_build;
}
});
|
import Vue from 'vue'
import Router from 'vue-router'
import HomeView from '@/components/views/home'
import LocationView from '@/components/views/locations'
import TimetableView from '@/components/views/timetables'
Vue.use(Router)
export default new Router({
routes: [
{
path: '/',
name: 'home',
component: HomeView
},
{
path: '/locations',
name: 'locations',
component: LocationView
},
{
path: '/timetables',
name: 'timetables',
component: TimetableView
}
]
})
|
// CREAR COMPONENTE
Vue.component('card',{
props:{
clasePrincipal:{
type: String,
default:'slider-item'
}
},
template:`
<div class="flex">
<div v-for="item in menuLista" class="card">
<div class="card-top">
<img :src="item.foto" alt="Imagen de Unsplash"/>
<span>U$S {{item.precio}}</span>
</div>
<div class="card-body">
<h4>{{item.nombre}}</h4>
<p>{{item.descripcion}}</p>
<a href="#" aria-label="Más Información">Más Información</a>
</div>
</div>
</div>
`,
data(){
return{
menuLista: [
{
nombre:'Paris',
precio:'1300',
foto:'./images/paris.jpg',
descripcion:'Lorem ipsum dolor sit amet consectetur adipisicing elit. Consequatur, eum.'
},
{
nombre:'Brasil',
precio:'960',
foto:'./images/brasil.jpg',
descripcion:'Lorem ipsum dolor sit amet consectetur adipisicing elit. Consequatur, eum.'
},
{
nombre:'Japon',
precio:'1700',
foto:'./images/japon.jpg',
descripcion:'Lorem ipsum dolor sit amet consectetur adipisicing elit. Consequatur, eum.'
},
{
nombre:'Egipto',
precio:'1300',
foto:'./images/egipto.jpg',
descripcion:'Lorem ipsum dolor sit amet consectetur adipisicing elit. Consequatur, eum.'
},
],
}
},
});
const app = new Vue({
el: '#app',
data: {
}
});
|
import SwitchDelegate from './SwitchDelegate';
export default SwitchDelegate;
|
const markdownIt = require("markdown-it");
const hljs = require("highlight.js");
const PostContent = props => {
const markdownConfig = {
html: true,
linkify: true,
typographer: true,
highlight: function (str, lang) {
if (lang && hljs.getLanguage(lang)) {
try {
return hljs.highlight(lang, str, true).value;
} catch (__) {}
}
return ''; // use external default escaping
}
};
const postHTML = markdownIt(markdownConfig).render(props.text);
return (
<div>
<div dangerouslySetInnerHTML={{ __html: postHTML }} />
<style global jsx>
{`
img {
max-width: 1000px;
}
blockquote {
padding: 0 1em;
color: #6a737d;
border-left: 0.25em solid #dfe2e5;
margin-left: 0;
margin-bottom: 16px;
margin-top: 0;
}
p,
li {
word-wrap: break-word;
font-size: 18px;
line-height: 1.58;
letter-spacing: -0.003em;
}
p > :global(code) {
padding: 0.2em 0.4em;
margin: 0;
font-size: 85%;
background-color: rgba(27, 31, 35, 0.05);
border-radius: 3px;
font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo,
Courier, monospace;
}
pre {
margin-top: 0;
margin-bottom: 0;
background-color: #f6f8fa;
}
pre > :global(code) {
margin-top: 0;
margin-bottom: 0;
word-break: normal;
overflow: auto;
font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo,
Courier, monospace;
font-size: 85%;
line-height: 1.45;
border-radius: 3px;
}
`}
</style>
</div>
);
};
export default PostContent;
|
import React,{Component} from 'react';
import { Button, View, Text , Image ,StyleSheet , TextInput , TouchableOpacity } from 'react-native';
import { createStackNavigator, createAppContainer , createDrawerNavigator } from 'react-navigation';
import DetailsScreen from './DetailsScreen';
import DrawerScreen from './DrawerScreen'
class HomeScreen extends React.Component {
state ={
text : '',
id : 0,
isDrawerOpen : true
}
static navigationOptions = ({ navigation }) => {
return {
title: 'Home',
headerStyle: {
backgroundColor: '#003399',
},
headerTintColor: '#999999',
headerTitleStyle: {
fontWeight: 'bold',
},
headerRight:
<TouchableOpacity onPress={() =>
navigation.toggleDrawer()
}>
<MenuImage navigation={navigation}/>
</TouchableOpacity>,
}
};
setText = text => {
this.setState ({
text : text
})
};
render() {
return (
<View style={styles.container}>
<TextInput onChangeText={this.setText}
style = {styles.inputStyle}/>
<Button
title="Go to Details"
onPress={() =>
this.props.navigation.navigate('Details',{
name : this.state.text,
ID : 54
})
// this.props.navigation.setParams({otherParam: 'Updated!'})
}
/>
</View>
);
}
}
const RootStack = createStackNavigator(
{
Home: HomeScreen,
Details: DetailsScreen,
},
{
initialRouteName: 'Home',
}
);
const MyDrawerNavigator = createDrawerNavigator(
{
home : RootStack ,
},
{
drawerPosition : 'right',
drawerType : 'slider',
useNativeAnimations : 'true',
drawerBackgroundColor : '#dddddd',
contentComponent : DrawerScreen ,
backBehavior : 'initialRoute',
} ,
{
contentOptions: {
activeTintColor: '#e91e63',
itemsContainerStyle: {
marginVertical:10,
},
iconContainerStyle: {
opacity: 1
}
}
},
{
initialRouteName: 'home',
},
);
const MenuImage = ({navigation}) => {
if(!navigation.state.isDrawerOpen){
return <Image source={require('./accest/menu-button.png')}/>
}else{
return <Image source={require('./accest/left-arrow.png')}/>
}
}
const AppContainer = createAppContainer(MyDrawerNavigator);
export default class App extends Component {
render() {
return <AppContainer />;
}
}
const styles = StyleSheet.create({
container :{
flex: 1,
alignItems: 'center',
justifyContent: 'center' ,
backgroundColor :'#9494b8'
},
inputStyle : {
width : 200,
borderBottomColor : 'black',
borderBottomWidth : 2,
marginBottom : 30
},
bottonStyle :{
// borderRadius : 100,
marginTop : 30,
},
})
|
require("date-format-lite"); // add date format
const xssFilters = require('xss-filters');
class Storage {
constructor(connection) {
this._db = connection;
this.table = "events";
}
// get events from the table, use dynamic loading if parameters sent
async getAll(params) {
let query = "SELECT * FROM ??";
let queryParams = [
this.table
];
if (params.from && params.to) {
query += " WHERE `end_date` >= ? AND `start_date` < ?";
queryParams.push(params.from);
queryParams.push(params.to);
}
let result = await this._db.query(query, queryParams);
result.forEach((entry) => {
// format date and time
entry.id = xssFilters.inHTMLData(entry.id);
entry.text = xssFilters.inHTMLData(entry.text);
entry.start_date = entry.start_date.format("YYYY-MM-DD hh:mm");
entry.end_date = entry.end_date.format("YYYY-MM-DD hh:mm");
});
return result;
}
// create new event
async insert(data) {
let result = await this._db.query(
"INSERT INTO ?? (`start_date`, `end_date`, `text`) VALUES (?,?,?)",
[this.table, data.start_date, data.end_date, data.text]);
return {
action: "inserted",
tid: result.insertId
}
}
// update event
async update(id, data) {
await this._db.query(
"UPDATE ?? SET `start_date` = ?, `end_date` = ?, `text` = ? WHERE id = ?",
[this.table, data.start_date, data.end_date, data.text, id]);
return {
action: "updated"
}
}
// delete event
async delete(id) {
await this._db.query(
"DELETE FROM ?? WHERE `id`=? ;",
[this.table, id]);
return {
action: "deleted"
}
}
}
module.exports = Storage;
|
const dbpool = require("../config/dbconfig");
//var table = 't_admin';
var sql = '';
const pageTotolDao = {
getTotol(arr){
return new Promise((resolve,reject)=>{
//var sql = 'select count(*) as myCount from '+table;
dbpool.connect(sql,arr,(err,data)=>{
resolve(data);
})
})
},
getData(arr){
console.log(arr);
return new Promise((resolve,reject)=>{
//var sql = 'select * from '+table+' limit ?,?';
sql += ' limit ?,?';
dbpool.connect(sql,arr,(err,data)=>{
//if(!err) {
// console.log(data);
//} else {
// console.log(err);
//}
resolve(data);
})
})
}
};
const page = {
pageTotol(req,res){
var currentData = req.query.currentData;
pageTotolDao.getTotol().then(data=>{
var num = Math.ceil(data[0].myCount/currentData);
num = num.toString();
res.send(num);
})
},
getData(req,res){
var currentPage = parseInt(req.query.currentPage);
var currentData = parseInt(req.query.currentData);
pageTotolDao.getData([(currentPage-1)*currentData,currentData]).then(data=>{
console.log(data);
if(data.length>0){
res.send({flag:1,message:data})
}else{
res.send({flag:-1,message:"失败"})
}
})
}
};
page.sql = function (promas) {
sql = promas;
};
module.exports = page;
|
import React, { Component } from 'react'
import PropTypes from 'prop-types'
import GIbuildMain from './giBuildPortal/GIbuildMain'
import MonitorStatus from './MonitorStatus'
import { Prompt } from 'react-router'
export default class SassGIhistoryScope extends Component {
static propTypes = {
actions: PropTypes.object.isRequired
}
constructor(props){
super(props)
this.state={
promptFlag: false
}
}
componentDidMount(){
document.title = '新建群 | 群管理 | 栗子云'
}
componentWillMount() {
const {naviMetaData,actions} = this.props
if(naviMetaData.flatNaviList!==null){
const isUse = naviMetaData.flatNaviList.find(v => v.code=='GIScope')
if(!isUse){
actions.goTo('/v2/authority?scope=GIScope')
}else if(isUse.target.includes('/v2/NeedOwnScope')){
actions.goTo(isUse.target)
}
}
}
componentDidUpdate(prevProps,prevState){
const {naviMetaData,actions} = this.props
if(naviMetaData.flatNaviList!==null&&prevProps.naviMetaData.flatNaviList===null){
const isUse = naviMetaData.flatNaviList.find(v => v.code=='GIScope')
if(!isUse){
actions.goTo('/v2/authority?scope=GIScope')
}else if(isUse.target.includes('/v2/NeedOwnScope')){
actions.goTo(isUse.target)
}
}
}
setPromptFlagHandle=(promptFlag)=>{
this.setState({promptFlag})
}
render() {
const {promptFlag} = this.state
const {userInfo,actions,match} = this.props
return (
<div style ={{height:'100%'}}>
<div className='gc-headBox'>
<MonitorStatus turnOffws = {actions.turnOffws} userInfo={userInfo}/>
</div>
<GIbuildMain actions={actions} setPromptFlagHandle={this.setPromptFlagHandle}/>
<Prompt
when={promptFlag}
message="现在退出会丢失已设置信息，是否确认退出？"
/>
</div>
)
}
}
|
// Tools / Plugins
var gulp = require('gulp'), // https://www.npmjs.com/package/gulp
browserSync = require('browser-sync').create(), // https://www.npmjs.com/package/browser-sync
sass = require('gulp-sass'), // https://www.npmjs.com/package/gulp-sass
autoprefixer = require('autoprefixer'), // https://www.npmjs.com/package/autoprefixer
// sourcemaps = require('gulp-sourcemaps'), // https://www.npmjs.com/package/gulp-sourcemaps
postcss = require('gulp-postcss'), // https://www.npmjs.com/package/gulp-postcss
uglify = require('gulp-uglify'), // https://www.npmjs.com/package/gulp-uglify
imagemin = require('gulp-imagemin'), // https://www.npmjs.com/package/gulp-imagemin
htmlmin = require('gulp-html-minifier'), // https://www.npmjs.com/package/gulp-html-minifier
rename = require('gulp-rename'), // https://www.npmjs.com/package/gulp-html-minifier
concat = require('gulp-concat'), // https://www.npmjs.com/package/gulp-concat
merge = require('merge-stream');
// Source directory names, Change according to your file structure choice.
var srcPaths = {
root: 'src/', // source root
imgDir: 'src/img/', // static image resources
sassDir: 'src/scss/', // saas files
cssDir: 'src/css/', // place for vendor CSS files
jsDir: 'src/js/', // js sources
iconDir: 'src/ico/', // icon assets
fontDir: 'src/webfonts/', // webfonts
}
// Distribute / Build directory names, Change according to your needs.
var buildPaths = {
root: 'dist/',
imgDir: 'dist/img/',
cssDir: 'dist/css/',
jsDir: 'dist/js/',
iconDir: 'dist/ico/',
fontDir: 'dist/webfonts/',
}
// Copy minify .html templates
gulp.task('template', function () {
return gulp.src([srcPaths.root + '**/*.html'])
.pipe(gulp.dest(buildPaths.root))
.pipe(htmlmin({ collapseWhitespace: true, removeComments: true }))
.pipe(rename({ suffix: ".min" }))
.pipe(gulp.dest(buildPaths.root))
.pipe(browserSync.stream()); // browser-sync
});
// Copy static assets ( images )
gulp.task('image', function () {
return gulp.src(srcPaths.imgDir + "**/*")
.pipe(imagemin()) // compress images
.pipe(gulp.dest(buildPaths.imgDir))
.pipe(browserSync.stream()); // browser-sync
});
// Copy static assets ( icons )
gulp.task('icon', function () {
return gulp.src(srcPaths.iconDir + "**/*")
.pipe(imagemin()) // compress images
.pipe(gulp.dest(buildPaths.iconDir))
.pipe(browserSync.stream()); // browser-sync
});
// Copy static assets ( fonts )
gulp.task('font', function () {
return gulp.src(srcPaths.fontDir + "**/*")
.pipe(gulp.dest(buildPaths.fontDir))
.pipe(browserSync.stream()); // browser-sync
});
// Process SASS to CSS, and Merge static CSS
gulp.task('sass', function () {
var sassStream, vendorCssStream;
sassStream = gulp.src(srcPaths.sassDir + '**/*.scss')
//.pipe(sourcemaps.init())
.pipe(sass({ outputStyle: 'compressed' }).on('error', sass.logError))
.pipe(postcss([autoprefixer()]))
//.pipe(sourcemaps.write('.'));
vendorCssStream = gulp.src(srcPaths.cssDir + '**/*.css');
return merge(sassStream, vendorCssStream)
.pipe(concat('main.min.css'))
.pipe(gulp.dest(buildPaths.cssDir))
.pipe(browserSync.stream())
});
// Process JS files
gulp.task('js', function () {
return gulp.src([
'node_modules/jquery/dist/jquery.js',
'node_modules/bootstrap/dist/js/bootstrap.bundle.js',
srcPaths.jsDir + '**/*.js'
])
// .pipe(sourcemaps.init())
.pipe(concat('main.min.js'))
.pipe(uglify())
// .pipe(sourcemaps.write('.'))
.pipe(gulp.dest(buildPaths.jsDir))
.pipe(browserSync.stream());
});
// Serve and monitor
gulp.task('watch', ['template', 'image', 'icon', 'font', 'sass', 'js'], function () {
browserSync.init({
server: './' + buildPaths.root
});
gulp.watch(srcPaths.sassDir + '**/*.scss', ['sass']);
gulp.watch(srcPaths.cssDir + '**/*.css', ['sass']);
gulp.watch(srcPaths.jsDir + '*.js', ['js']);
gulp.watch(srcPaths.root + '**/*.html', ['template']);
gulp.watch(srcPaths.imgDir + '**/*', ['image'])
});
// Default
gulp.task('default', ['template', 'image', 'icon', 'font', 'sass', 'js', 'watch']);
|
document.addEventListener('DOMContentLoaded', function(){
// ①変数の宣言
let rowNumber;
let colNumber;
let mineNumber;
let startTime;
let timeoutId;
// let shuffledNumbers = [];
// const row = [];
let sheet = [];
let isPlaying;
let isDead;
// ②関数たち
// ランダムな配列を作る関数
function shuffle(array) {
for (let i = array.length - 1; i >= 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[array[i], array[j]] = [array[j], array[i]];
}
return array;
}
// ストップウォッチを動かす関数
function countUp() {
const d = Date.now() - startTime;
const s = String(Math.floor(d/1000)).padStart(3,'0');
document.getElementById('time').textContent = s;
timeoutId = setTimeout(() => {
countUp();
}, 1000)
}
// 難易度ボタンを押してマス分のtdを作る関数
function makeSheet(e) {
if (e.id === 'easy') {
rowNumber = 9;
colNumber = 9;
mineNumber = 10;
} else if (e.id === 'normal') {
rowNumber = 16;
colNumber = 16;
mineNumber = 40;
} else if (e.id === 'hard') {
rowNumber = 16;
colNumber = 30;
mineNumber = 99;
}
document.getElementById('counter').textContent = String(mineNumber).padStart(3, '0');
for (let i = 0; i < rowNumber; i++) {
let tr = document.createElement('tr');
for (let j = 0; j < colNumber; j++) {
let td = document.createElement('td');
tr.appendChild(td);
let val = i * colNumber + j + 1;
td.setAttribute('id', val)
}
document.getElementById('field').appendChild(tr);
}
}
// mineを配置する関数
function setMine(e) {
getRowCol(e);
const idValue = Number(e.id);
let numbers = [];
for (let i = 0; i < mineNumber; i++) {numbers.push(1);}
for (let j = 0; j < rowNumber * colNumber - mineNumber - 1; j++) {numbers.push(0);}
let shuffledNumbers = shuffle(numbers);
shuffledNumbers.splice(idValue - 1, 0, 0);
for (let i = 0; i < rowNumber; i++) {
sheet.push(shuffledNumbers.splice(0, colNumber))
}
console.table(sheet);
const tds = document.querySelectorAll('#game-table td');
tds.forEach((td) => {
const RC = getRowCol(td);
let r = RC[0];
let c = RC[1];
if (sheet[r][c] === 1){
td.classList.add('bomb');
}
})
}
// 難易度ボタン押しなおして再開するとき一旦tdを全部消す関数
function clearSheet() {
sheet = [];
const tbody = document.getElementById('field');
while(tbody.firstChild) {
tbody.removeChild(tbody.firstChild);
}
}
// tdのidから行rowと列columnを得る関数
function getRowCol(e) {
let r;
let c;
const idValue = Number(e.id);
// console.log(idValue);
if(idValue % colNumber === 0) {
c = colNumber - 1;
r = idValue / colNumber - 1;
} else {
c = idValue % colNumber - 1
r = (idValue - c - 1) / colNumber;
}
const RC = [r, c];
return RC
// console.log(r, c);
}
// 押したtdの周りにどれだけmineがあるか数える関数
function count(e) {
e.classList.add('clicked');
getRowCol(e);
const RC = getRowCol(e);
let r = RC[0];
let c = RC[1];
let sum = 0;
for(let i = 0; i < 3; i++){
for(let j = 0; j < 3; j++){
let R = r - 1 + i;
let C = c - 1 + j;
if(R < 0 || R > rowNumber - 1 || C < 0 || C > colNumber - 1) {
} else{
sum += sheet[R][C];
}
}
}
sum -= sheet[r][c];
if(sum !== 0) {
e.textContent = sum;
e.classList.add('a' + sum);
}
// console.log(sum);
return sum;
}
//0のとき周りをsweepしていく関数
function mineSweep(e) {
count(e);
const sum = count(e);
const allCountRC = [];
const include0RC = [];
if(sum === 0) {
getRowCol(e);
const RC = getRowCol(e);
let r = RC[0];
let c = RC[1];
for(let i = 0; i < 3; i++){
for(let j = 0; j < 3; j++){
let R = r - 1 + i;
let C = c - 1 + j;
let searchId = Number(e.id) - colNumber - 2 + (colNumber * i) + j;
let searchTd = document.querySelectorAll('#game-table td')[searchId];
if(R < 0 || R > rowNumber - 1 || C < 0 || C > colNumber - 1) {
allCountRC.push(9);
} else{
let clickedTd = searchTd.classList.contains('clicked');
// console.log([searchTd, clickedTd]);
count(searchTd);
let sum = count(searchTd);
allCountRC.push(sum);
if(i !== 1 || j !== 1) {
if(sum === 0 && clickedTd === false) {
include0RC.push(searchTd);
}
}
}
}
}
}
if(include0RC === []) {
return;
}
for (let i = 0; i < include0RC.length; i++) {
mineSweep(include0RC[i]);
}
if(rowNumber * colNumber - mineNumber === document.getElementsByClassName('clicked').length) {
alert('completed!!');
clearTimeout(timeoutId);
formAppear();
}
}
//tdの周りにflagが何個あるか数える関数
function countFlag(e) {
getRowCol(e);
const RC = getRowCol(e);
let r = RC[0];
let c = RC[1];
let counter = 0;
for(let i = 0; i < 3; i++){
for(let j = 0; j < 3; j++){
let R = r - 1 + i;
let C = c - 1 + j;
let searchId = Number(e.id) - colNumber - 2 + (colNumber * i) + j;
let searchTd = document.querySelectorAll('#game-table td')[searchId];
if(R < 0 || R > rowNumber - 1 || C < 0 || C > colNumber - 1) {
} else{
if(searchTd.classList.contains('flag')) {
counter++;
}
}
}
}
return counter;
}
// 数字と旗の数が同じなら周り開ける関数
function dbcSweep(e) {
let counter = countFlag(e);
let sum = count(e);
if(counter === sum) {
const RC = getRowCol(e);
let r = RC[0];
let c = RC[1];
for(let i = 0; i < 3; i++){
for(let j = 0; j < 3; j++){
let R = r - 1 + i;
let C = c - 1 + j;
let searchId = Number(e.id) - colNumber - 2 + (colNumber * i) + j;
let searchTd = document.querySelectorAll('#game-table td')[searchId];
if(R < 0 || R > rowNumber - 1 || C < 0 || C > colNumber - 1) {
} else{
if(searchTd.firstChild) {} else {
if(isDead === false){
if(searchTd.classList.contains('bomb')){
isDead = true;
clearTimeout(timeoutId);
searchTd.classList.add('bombed');
const tds3 = document.querySelectorAll('#game-table td');
tds3.forEach((td) => {
if(td.classList.contains('bomb')) {
if(td.classList.contains('flag')) {
} else {
const img = document.createElement('img');
img.src = '/assets/mine.png'
td.appendChild(img);
td.classList.add('clicked');
}
} else {
if(td.classList.contains('flag')) {
while(td.firstChild){
td.removeChild(td.firstChild);
td.classList.remove('flag');
}
const img = document.createElement('img');
img.src = '/assets/minefalse.png'
td.appendChild(img);
td.classList.add('clicked');
}
}
})
} else {
mineSweep(searchTd);
}
}
}
}
}
}
}
}
// isPlaying, isDeadが変化した時送信フォームを出す関数
function formAppear() {
if (document.querySelectorAll('.bomb').length === 99 && document.querySelectorAll('.lists-left> li')[1].textContent === "ログアウト") {
const formTime = document.getElementById('form-time')
const time = document.getElementById('time')
formTime.value = time.textContent
// document.getElementById('form-comment').removeAttribute('type', 'hidden')
document.getElementById('submit').removeAttribute('type', 'hidden')
document.getElementById('submit').setAttribute('type', 'submit')
}
}
// isPlaying, isDeadが変化した時送信フォームを消す関数
function formDestroy() {
// document.getElementById('form-comment').setAttribute('type', 'hidden')
document.getElementById('submit').setAttribute('type', 'hidden')
}
// ③ボタン操作たち
const buttons = document.querySelectorAll('.level-btn');
buttons.forEach((button) => {
//難易度ボタン
button.addEventListener('click', () => {
clearSheet();
makeSheet(button);
isPlaying = false;
isDead = false;
formDestroy();
clearTimeout(timeoutId);
document.getElementById('time').textContent = '000';
//td押す操作
const tds = document.querySelectorAll('#game-table td');
const tds2 = [...tds];
tds2.forEach((td) => {
// clickした時
td.addEventListener('click', () => {
if (isPlaying === false){
setMine(td);
isPlaying = true;
startTime = Date.now();
countUp();
}
if(td.firstChild) {} else {
if(isDead === false){
if(td.classList.contains('bomb')){
isDead = true;
clearTimeout(timeoutId);
td.classList.add('bombed');
// formAppear();
const tds3 = document.querySelectorAll('#game-table td');
tds3.forEach((td) => {
if(td.classList.contains('bomb')) {
if(td.classList.contains('flag')) {
} else {
const img = document.createElement('img');
img.src = '/assets/mine.png'
td.appendChild(img);
td.classList.add('clicked');
}
} else {
if(td.classList.contains('flag')) {
while(td.firstChild){
td.removeChild(td.firstChild);
td.classList.remove('flag');
}
const img = document.createElement('img');
img.src = '/assets/minefalse.png'
td.appendChild(img);
td.classList.add('clicked');
}
}
})
} else {
mineSweep(td);
}
}
}
})
// 右クリックしたとき
let counter = 0;
td.addEventListener('contextmenu', (e) => {
if(isDead === false) {
if(td.classList.contains('clicked')) {
e.preventDefault();
} else {
e.preventDefault();
counter++;
// console.log(counter);
while(td.firstChild){
td.removeChild(td.firstChild);
td.classList.remove('flag');
}
if (counter % 3 === 1) {
const img = document.createElement('img');
img.src = '/assets/flag.png'
td.appendChild(img);
td.classList.add('flag')
} else if (counter % 3 === 2) {
td.textContent = '?';
}
}
}
const flag = document.getElementsByClassName('flag');
const counter2 = document.getElementById('counter');
counter2.textContent = String(mineNumber - flag.length).padStart(3, '0');
})
// ダブルクリックしたとき
td.addEventListener('dblclick', () => {
if(isDead === false) {
if(td.classList.contains('flag')) {} else {
dbcSweep(td);
}
}
})
})
})
})
});
|
import React, {Component} from 'react';
import './signin.css';
import PropTypes from 'prop-types';
import Nav from 'react-bootstrap/lib/Nav';
import NavItem from 'react-bootstrap/lib/NavItem';
import Sender from './newSender';
class Login extends Component {
constructor() {
super();
this.state = {
active: "login",
usn:""
}
}
receivedData(data) {
if (data.status == 1) {
this.props.commit(this.state.usn);
// this.props.history.push("./home/"+this.state.usn);
} else {
alert(data.error);
}
}
commit(type,usn,pw){
var sender = new Sender();
var data = {
ins: type,
name: usn,
password: pw
}
sender.getData(data, this.receivedData.bind(this));
this.setState({
user:usn
})
}
submit(type) {
var event = window.event || arguments.callee.caller.arguments[0];
var usn = this.refs.userName.value;
var pw = this.refs.passWord.value;
if (type === 'login') {
if (usn !== "" && pw !== "") {
this.commit('login', usn, pw);
event.preventDefault();
event.stopPropagation();
}
} else {
var pw2 = this.refs.passWord2.value;
if (pw !== pw2) {
alert("两次密码不相同，请重新输入");
} else {
if (usn !== "" && pw !== "") {
this.commit('register', usn, pw);
event.preventDefault();
event.stopPropagation();
}
}
}
}
handleSelect(e) {
this.setState({active: e})
}
render() {
var pannel = <div className="form-signin">
<label htmlFor="inputEmail" className="sr-only">UserName</label>
<input
ref="userName"
className="form-control"
placeholder="用户名"
required
autoFocus></input>
<label htmlFor="inputPassword" className="sr-only">Password</label>
<input
ref="passWord"
type="password"
id="inputPassword"
className="form-control"
placeholder="密码"
required></input>
<button
className="submit-button btn btn-lg btn-primary btn-block"
onClick={this
.submit
.bind(this, 'login')}>登录</button>
</div>;
if (this.state.active !== 'login')
pannel = <div className="form-signin">
<label htmlFor="inputEmail" className="sr-only">UserName</label>
<input
ref="userName"
className="form-control"
placeholder="用户名"
required
autoFocus></input>
<label htmlFor="inputPassword" className="sr-only">Password</label>
<input
ref="passWord"
type="password"
id="inputPassword"
className="form-control"
placeholder="密码"
required></input>
<label htmlFor="inputPassword2" className="sr-only">Password</label>
<input
ref="passWord2"
type="password"
id="inputPassword2"
className="form-control"
placeholder="重复输入密码"
required></input>
<button
className="submit-button btn btn-lg btn-primary btn-block"
onClick={this
.submit
.bind(this, 'register')}>注册</button>
</div>;
return (
<div className="container">
<Nav
bsStyle="tabs"
justified
activeKey={this.state.active}
onSelect={this
.handleSelect
.bind(this)}>
<NavItem eventKey={'login'}>登录</NavItem>
<NavItem eventKey={'register'}>注册</NavItem>
</Nav>
{pannel}
</div>
);
}
}
Login.propTypes = {
commit: PropTypes.func.isRequired
};
export default Login;
|
$(document).ready(onReady);
function onReady(){
console.log(`I'm ready`);
getQuotes();
$('#addButton').on('click', addQuote);
// $('#refreshButton').on('click', getQuotes);
}
function getQuotes(){
console.log('in getQuote');
$.ajax({
method: 'GET',
url: '/quotes',
}).then( function(response){
console.log('back from server with:', response);
displayQuotes(response);
});
}//end getQuote
function displayQuotes(quotes){
let el = $('#quoteList');
el.empty();
for(let quote of quotes){
el.append(`<div class="card-body">"${quote.quote}" - ${quote.author}</div>`);
};// End for
}//end displayQuotes
function addQuote(){
let objectToSend = {
quote: $('#quoteIn').val(),
author: $('#authorIn').val(),
};
$('.inputs').val('');
$.ajax({
method: 'POST',
url: '/quotes',
data: objectToSend,
}).then(function (response){
console.log('posting Quote', response);
});
getQuotes();
}
|
import { Material } from "../material.js";
import { DemoShader } from "../shaders/demoshader.js";
export class DemoMaterial extends Material {
static singleton = undefined;
constructor() {
super();
this.setShader(DemoShader.get());
}
static get() {
if (!DemoMaterial.singleton) DemoMaterial.singleton = new DemoMaterial();
return DemoMaterial.singleton;
}
}
|
import test from 'tape'
import stepper from '../../../signals/processes/stepper'
import liftN from '../../../signals/processes/liftN'
import { spy } from 'sinon'
import map from 'ramda/src/map'
import addIndex from 'ramda/src/addIndex'
import flip from 'ramda/src/flip'
const mapIndexed = addIndex(map)
test('liftN', (assert) => {
const signals = [spy(), spy(), spy()]
const steps = mapIndexed(flip(stepper), signals)
const handlers = map((signal) => signal.getCall(0).args[0], signals)
assert.equal(steps[0](), 0)
assert.equal(steps[1](), 1)
assert.equal(steps[2](), 2)
const sumAll = liftN((a, b, c) => a + b + c, ...steps)
assert.equal(sumAll(), 3) // 0 + 1 + 2
handlers[0](6)
assert.equal(sumAll(), 9) // 6 + 1 + 2
handlers[1](7)
assert.equal(sumAll(), 15) // 6 + 7 + 2
handlers[2](8)
assert.equal(sumAll(), 21) // 6 + 7 + 8
assert.end()
})
|
var Signer = require(__dirname+'/../build/signer');
var PrivateKey = require(__dirname+'/../build/private_key');
var Message = require(__dirname+'/../build/message');
var Signature = require(__dirname+'/../build/signature');
describe('Signer', function() {
it('should accept a private key', function() {
var privateKey = new PrivateKey('snYo5W8kWoek9ZVo7oSqi7JHspFHk');
assert.ok(new Signer(privateKey));
});
it('should reject without a private key', function() {
assert.throws(function() {
new Signer();
});
});
it('should reject another type of object', function() {
assert.throws(function() {
new Signer('snYo5W8kWoek9ZVo7oSqi7JHspFHk');
});
});
it('should sign a message and return a signature', function() {
var privateKey = new PrivateKey('snYo5W8kWoek9ZVo7oSqi7JHspFHk');
var signer = new Signer(privateKey);
var message = new Message('important message to verify');
var signature = signer.sign(message);
assert(signature instanceof Signature);
});
it('signing should reject a non-message', function() {
var privateKey = new PrivateKey('snYo5W8kWoek9ZVo7oSqi7JHspFHk');
var signer = new Signer(privateKey);
var message = new Message('important message to verify');
assert.throws(function() {
signer.sign('string not a Message');
});
});
});
|
profiles = {
default: {
ExpressEnvironment: {
port: 8080
},
RequestDetector: {
name: 'endpoint1',
route: '/worker',
handler: (req, res) => { res.json(true); }
},
StompNotifier: {
conn: {
host: '127.0.0.1',
port: 61613,
user: 'admin',
pass: 'admin'
},
queue: '/queue/queue3'
}
}
}
exports.profiles = profiles
exports.default = profiles.default
|
import React, {Component} from 'react';
import _ from 'lodash';
import moment from 'moment';
class Week extends Component{
constructor(props){
super();
this.state={
selectedEventDates:(_.size(props.selected)>0)?(Object.assign([], props.selected)):([]),
date: props.date,
selectedDay: moment(props.selectedDay).format("YYYY-MM-DD")
};
}
componentWillMount(){
this.setState({selectedEventDates:this.props.selected});
}
componentWillReceiveProps(nextProps){
if(this.props.date!=nextProps.date){
this.setState({date:nextProps.date});
}
if(this.props.selected!=nextProps.selected){
this.setState({selectedEventDates:nextProps.selected});
}
}
returnFlag(calFinalDay){
return (_.find(this.state.selectedEventDates, function(n) { let isHighLight = (n == calFinalDay); return isHighLight; }))
}
returnHighLighted(calFinalDay){
let propsSelectedDay = _.trim(this.props.selectedDay);
let calFinDay = _.trim(calFinalDay);
if(propsSelectedDay==calFinalDay){
return true;
}else{
return false;
}
}
select(day){
if(this.props.select){
this.props.select(day);
}
}
render(){
let days = [],
date = this.state.date,
month = this.props.month;
for (let i = 0; i < 7; i++) {
let calDate = (date.date().toString().length==1)?("0" + (date.date()).toString()):(date.date().toString());
let calMonth = ((month.month()+1).toString().length==1)?("0"+ (month.month()+1).toString()):((month.month()+1).toString());
let calYear = date.year().toString();
let calFinalDay = calYear + "-" + calMonth + "-" + calDate;
let day = {
number: date.date(),
isCurrentMonth: date.month() === month.month(),
isToday: date.isSame(new Date(), "day"),
isHigh: this.returnFlag(calFinalDay),
date: date,
isSelectedDate: this.returnHighLighted(calFinalDay)
};
days.push(<span key={day.date.toString()}
className={"day" + (day.isToday ? " today" : "") + (day.isCurrentMonth ? "" : " different-month") + (day.isHigh? " highlighted selected":"") + (day.isSelectedDate?" bgGreen ":"")}
onClick={this.select.bind(this,day)}>{day.number}</span>);
date = date.clone();
date.add(1, "d");
}
if(_.size(days)>0){
return(<div className="week dates" key={days[0].toString()}>{days}</div>);
}else{
return;
}
}
}
export default Week;
|
import React, { Component } from 'react';
import { Select } from 'antd';
import axios from 'axios';
import showError from '../utils/ShowError';
const Option = Select.Option;
const PROJECTS_URL = `${process.env.REACT_APP_SERVER_URL}/api/projects`;
class ProjectSelect extends Component {
constructor(props) {
super(props);
const value = this.props.value;
this.state = {
value,
projects: [],
};
}
componentDidMount() {
this.fetchProjects();
}
componentWillReceiveProps(nextProps) {
if ('value' in nextProps) {
const value = nextProps.value;
this.setState({ value });
}
}
fetchProjects() {
axios.get(PROJECTS_URL, { params: {
searchText: '',
start: 0,
count: 100,
} })
.then((response) => {
this.setState({
projects: response.data.rows,
});
})
.catch((error) => {
showError(error);
});
}
handleChange = (value) => {
if (!('value' in this.props)) {
this.setState({ value });
}
this.triggerChange(value);
}
triggerChange = (changedValue) => {
const onChange = this.props.onChange;
if (onChange) {
onChange(changedValue);
}
}
render() {
return (
<Select
allowClear
placeholder="Select Project"
onChange={this.handleChange}
value={this.state.value}
style={{ width: '100%' }}
>
{this.state.projects.map(project => (
<Option key={project.id} value={project.id}>{project.name}</Option>
))}
</Select>
);
}
}
export default ProjectSelect;
|
require("dotenv").config();
// const morgan = require('morgan');
const mongoose = require('mongoose');
// const cors = require('cors');
// console.log(process.env);
const {
PORT = 3001,
MONGODB_URI = "mongodb://localhost/cars" //<-- implicit db creation
} = process.env;
(async () => {
try {
const conn = await mongoose.connect(MONGODB_URI);
// console.log("connected", conn);
// this is for errors after a connection has been established
mongoose.connection.on("error", (err) => {
console.log(err);
});
} catch (error) {
// this is for connection error
console.log(error);
}
})();
const Schema = mongoose.Schema;
const carSchema = new Schema({
name: {
type: String,
required: true
},
bhp: {
type: Number,
required: true
},
avatar_url: {
type: String,
default: 'https://static.thenounproject.com/png/449586-200.png'
}
});
const Car = mongoose.model('Car', carSchema);
// const cars = [
// {
// make: 'tesla',
// bhp: 3,
// },
// {
// make: 'tesla2',
// bhp: 3,
// }
// ];
const express = require("express");
const app = express();
// app.use(morgan('combined'));
// [fn, fn2, fn3]
app.use(express.static('public'));
app.use(express.json());
// app.use(cors());
// app.use(function(req, res, next){
// console.log('middleware');
// next();
// // if(req.isAuthenticated) {
// // next();
// // }
// // res.redirect('/login.html')
// })
app.get('/api/v1/cars', (req, res) => {
Car.find({}).exec((err, cars) => {
if (err) return res.status(500).send(err);
res.status(200).json(cars);
})
});//end of get
app.post('/api/v1/cars', (req, res) => {
console.log(req.body);
const car = new Car(req.body);
car.save((err, newCar) => {
if (err) return res.status(500).send(err);
res.status(201).send(newCar);
})
});//end of add
app.delete('/api/v1/cars/:id', (req, res) => {
Car.deleteOne({ _id: req.params.id }, (err) => {
if (err) return res.status(500).send(err);
res.sendStatus(204);
})
});//end of delete
app.put('/api/v1/cars/update/:id', async (req, res) => {
try {
const id = req.params.id;
const updates = req.body;
//findByIdAndUpdate returns the objects as it was before the update
const result = await Car.findByIdAndUpdate(id, updates);
const updateCar = await Car.findOne({ "_id": result.id });
res.send(updateCar);
} catch (err) {
console.log(err.message);
}
});//end of update
app.listen(PORT, () => {
console.log(`server listening on port ${PORT}`);
});
// import lodash, {slice } from 'lodash'
// const name = 'James';
// const users = require('./user.json');
// exports function a(){}
// exports function b(){}
// module.exports = function(){}
// const myFunc = require('./myFunc.js');
// const myEmitter = new EventEmitter();
// myEmitter.on('test_event', (data) => {
// console.log('test_event received', data);
// });
// myEmitter.emit('test_event', 123);
// const { exec } = require('child_process');
// const { inspect } = require('util');
// exec('./shell.sh');
// console.log(process)
// console.log(inspect(process, {
// depth: 20,
// showHidden: true,
// colors: true,
// }));
// const process = require('process');
// process.exit(1);
// console.log(process.exitCode);
// const path = require('path');
// const p = path.join('test_dir/', '/inner.txt');
// const p2 = path.join(__dirname, 'public');
// console.log(p2);
// console.log(path.resolve('test_dir', 'inner.txt'))
// console.log('p2 directory = ', path.dirname(p2));
// const filepath = './thing/thing.txt';
// console.log(path.basename(filepath));
// const fs = require('fs');
// fs.mkdir('test_dir', (err) => {
// console.log(err);
// });
// const data = new Uint8Array(Buffer.from('Hello Node.js'));
// fs.writeFile('my_text.txt', data, (err) => {
// console.log(err);
// })
// fs.readFile('./test.txt', 'utf8', (err, data) => {
// if(err) {
// console.log(err);
// return;
// }
// console.log({data});
// })
// const {readFile} = require('fs').promises;
// (async () => {
// try {
// const text = await readFile('./test.txt', 'utf8');
// console.log('text', text);
// } catch (err) {
// console.log(err);
// }
// })();
// const os = require('os');
// console.log(os.cpus());
// console.log(`I have ${os.cpus().length} cores`);
// console.log(os.userInfo());
// console.log('__filename', __filename)
// console.log('__dirname', __dirname)
// require("dotenv").config();
// console.log(process.env);
// const {
// SERVER_ID
// } = process.env;
// console.log(`Server id ${SERVER_ID}`)
// const {
// DB_URL = 'mongodb+srv//skdjfklsjdfklsjdklfjsdklfjsd',
// STRIPE_KEY=""
// } = process.env;
// db.conn(DB_URL);
// const client = new Stripe({
// password: STRIPE_KEY
// });
|
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
// Create Schema
const MedSchema = new Schema({
name: {
type: String,
// required: true,
},
email: {
type: String,
// required: true,
},
phone: {
type: Number,
// required: true,
},
age: {
type: Number,
// required: true,
},
dob: {
type: String,
// required: true,
},
city: {
type: String,
// required: true,
},
blood: {
type: String,
// required: true,
},
address: {
type: String,
// required: true,
},
desciption: {
type: String,
// required: true,
},
emergencyname: {
type: String,
// required: true,
},
emergencynum: {
type: Number,
// required: true,
},
gender: {
type: String,
// required: true,
},
});
module.exports = Med = mongoose.model("meds", MedSchema);
|
import React, {Component, Fragment} from 'react'
import {Route} from 'react-router-dom';
import './Body.css';
import Feed from "../Feed/Feed";
class Body extends Component {
render() {
return (
<Fragment>
<button onClick={()=>this.props.dispatch({
type: "NEW_LIKE"
})}>Like</button>
<Route path={"/feed/:itemId"} render={(props) => <Feed {...props}/>}/>
</Fragment>
)
}
}
export default Body
|
/**
* @jsx React.DOM
*/
/**
* Create by Drew on 1/21/2015
*/
var React = require('react'),
Bootstrap = require('react-bootstrap'),
ButtonToolbar = Bootstrap.ButtonToolbar,
Button = Bootstrap.Button;
var ButtonList = React.createClass({
render: function () {
return (
<ButtonToolbar>
<Button bsStyle="info" href="/Private">Private</Button>
<Button bsStyle="info" href="/Private2">Private 2</Button>
</ButtonToolbar>
);
}
});
module.exports = ButtonList;
|
// ip and the Promise modules used for Async Promises
import {history} from '../index.jsx';
import Promise from 'bluebird';
import crypto from 'crypto';
import * as constvars from '../constvars.jsx';
const dbServer = constvars.DBSERVER_VAR;
export const REG_ATTEMPT = 'REG_ATTEMPT';
export const LOGIN_ATTEMPT = 'LOGIN_ATTEMPT';
export const LOGOUT_ATTEMPT = 'LOGOUT_ATTEMPT';
export const UNAME_INPUT_EVENT = 'UNAME_INPUT_EVENT';
export const PWORD_INPUT_EVENT = 'PWORD_INPUT_EVENT';
export const SESSION_STATUS = 'SESSION_STATUS';
// ============= Async Action Creators =============
// Based off https://github.com/happypoulp/redux-tutorial/blob/master/09_dispatch-async-action-2.js#L24
// ===== REGISTER ASYNC ACTION CREATOR =====
export const regBtnActionCreator = () => {
return (dispatch, getState) => {
// Destructuring treats the function/object as a source
// It works on a similar principle to the "import" statement
const {heading} = getState();// <--- Destructuring
// Define init (details) for fetch request
const regInit = {
method: 'POST',
headers: {
Accept:'application/json',
'Content-Type':'application/json',
},
body: JSON.stringify({
username: heading.unameValue,
password: crypto.createHmac('sha1', heading.pwordValue).update(heading.pwordValue).digest('hex'),
}),
credentials: 'include',
};
// fetch(URL & PORT + Server-side Route, Init Details)
return fetch(dbServer + '/register', regInit)
.then((response) => {
response.json().then((data) => {
dispatch({
type: REG_ATTEMPT,
prevRegAttempt: heading.unameValue,
logStatus: data.regResult,
sessionStatus: data.sessionStatus,
currentUser: data.currentUser,
});
history.replaceState(null, '/secure');
});
});
};
};
// ===== LOGIN ASYNC ACTION CREATOR =====
export const loginBtnActionCreator = () => {
return (dispatch, getState) => {
const {heading} = getState();
// Define init (details) for fetch request
const loginInit = {
method: 'POST',
headers: {
Accept:'application/json',
'Content-Type':'application/json',
},
body: JSON.stringify({
username: heading.unameValue,
password: crypto.createHmac('sha1', heading.pwordValue).update(heading.pwordValue).digest('hex'),
}),
credentials: 'include',
};
return fetch(dbServer + '/login', loginInit)
.then((response) => {
response.json()
// json() is a prototype function of fetch responses
// it converts the response and then returns the json object
// which we are passing down the promise chain
.then((jsonValue) => {
dispatch({
type: LOGIN_ATTEMPT,
logStatus: jsonValue.logResult,// fail, success
sessionStatus: jsonValue.sessionStatus,
prevRegAttempt: '',
currentUser: jsonValue.currentUser,
});
history.replaceState(null, '/secure');
});
});
};
};
// ===== LOGOUT ASYNC ACTION CREATOR =====
export const logoutBtnActionCreator = () => {
return (dispatch, getState) => {
const {heading} = getState();
// Define init (details) for fetch request
const logoutInit = {
method: 'POST',
headers: {
Accept:'application/json',
'Content-Type':'application/json',
},
body: JSON.stringify({
username: heading.currentUser,
}),
credentials: 'include',
};
return fetch(dbServer + '/logout', logoutInit)
.then((response) => {
response.json().then((jsonValue) => {
dispatch({
type: LOGOUT_ATTEMPT,
sessionStatus: jsonValue.sessionStatus,
currentUser: jsonValue.currentUser,
});
history.replaceState(null, '/');
});
});
};
};
// ===== SESSION STATUS ASYNC ACTION CREATOR =====
export const sessionStatusActionCreator = (doneCallback) => {
return (dispatch, getState) => {
// Define init (details) for fetch request
const sessionInit = {
method: 'POST',
headers: {
Accept:'application/json',
'Content-Type':'application/json',
},
credentials: 'include',
};
fetch(dbServer + '/sessionStatus', sessionInit)
.then((response) => {
response.json().then((jsonValue) => {
dispatch({
type: SESSION_STATUS,
sessionStatus: jsonValue.sessionStatus,// active or none
currentUser: jsonValue.currentUser,
});
doneCallback();
});
});
};
};
// ================ Action Creators ================
export const unameInputActionCreator = (text) => {
return {
type: UNAME_INPUT_EVENT,
unameValue: text,
};
};
export const pwordInputActionCreator = (text) => {
return {
type: PWORD_INPUT_EVENT,
pwordValue: text,
};
};
// {
// type: SAMPLE,
// //optionals
// error: "the error",
// payload: "the payload",
// meta: "some meta information"
// }
// https://github.com/acdlite/flux-standard-action#actions
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.