text
stringlengths 7
3.69M
|
|---|
const dataFormatter = require('./helpers/dataFormatter')
const offchain = require('./helpers/offchain')
const ClaimManager = artifacts.require('ClaimManager')
const ScryptVerifier = artifacts.require('ScryptVerifier')
contract('ClaimManager', function (accounts) {
const steps = 2050
const claimDeposit = 1
const [
dogeRelayAddress,
claimant,
otherClaimant,
challenger,
] = accounts
let claimManager,
scryptVerifier,
scryptRunner
let claimID, sessionId
let tx, session, result, log, deposit
const serializedBlockHeader = '030162002adb34dfa6574cf127a781ecb9683ca28f911a59020628c90c72b4a3d9942233a3b905b2388b020085dbd9e03209db4493f5420336d882d0b78b54f728b8f90058f7115a2c83221a00000000'
const testScryptHash = 'ce60a0d4a7c2223a94437d44fe4d33a30489436714d18376f9ebc5e2bd6e5682'
context('normal conditions', function () {
before(async () => {
scryptRunner = await offchain.scryptRunner()
console.log('scryptRunner deployed')
scryptVerifier = await ScryptVerifier.new()
claimManager = await ClaimManager.new(scryptVerifier.address)
await claimManager.setDogeRelay(dogeRelayAddress, { from: dogeRelayAddress })
})
it('claimant checks scrypt, after implicitly making a deposit', async () => {
try {
tx = await claimManager.checkScrypt(serializedBlockHeader, testScryptHash, otherClaimant, 'bar', { from: dogeRelayAddress, value: claimDeposit })
log = tx.logs.find(l => l.event === 'ClaimCreated')
claimID = log.args.claimID.toNumber()
} catch (e) {
console.log(e)
}
deposit = await claimManager.getBondedDeposit.call(claimID, otherClaimant, { from: claimant })
assert.equal(deposit.toNumber(), claimDeposit)
})
it('claimant checks scrypt, after explicitely making a deposit', async () => {
await claimManager.makeDeposit({ from: claimant, value: claimDeposit })
try {
tx = await claimManager.checkScrypt(serializedBlockHeader, testScryptHash, claimant, 'foo', { from: dogeRelayAddress })
log = tx.logs.find(l => l.event === 'ClaimCreated')
claimID = log.args.claimID.toNumber()
} catch (e) {
console.log(e)
}
deposit = await claimManager.getBondedDeposit.call(claimID, claimant, { from: claimant })
assert.equal(deposit.toNumber(), claimDeposit)
})
it('challenger challenges', async () => {
await claimManager.makeDeposit({ from: challenger, value: claimDeposit })
tx = await claimManager.challengeClaim(claimID, { from: challenger })
// check that the challenger's deposits were bonded.
deposit = await claimManager.getBondedDeposit.call(claimID, challenger, { from: challenger })
assert.equal(deposit.toNumber(), claimDeposit)
})
it('begins verification game', async () => {
tx = await claimManager.runNextVerificationGame(claimID, { from: claimant })
log = tx.logs.find(l => l.event === 'VerificationGameStarted')
assert.equal(log.args.claimID.toNumber(), claimID)
assert.equal(log.args.claimant, claimant)
assert.equal(log.args.challenger, challenger)
sessionId = await claimManager.getSession.call(claimID, challenger)
})
// Need to throw some asserts in here lol >:D
// Might need more verification steps
it('participates in verification game', async () => {
// First challenge
// Each call to query sets the new medstep
// Intial high step is currently 2050 (assuming this is the final number of steps)
tx = await scryptVerifier.query(sessionId, 1, { from: challenger })
session = dataFormatter.newSession(await scryptVerifier.getSession.call(sessionId))
// console.log("Session after first query: \n", session, "\n")
// claimant responds to first query.
results = dataFormatter.newResult(await scryptRunner.getStateProofAndHash.call(session.input, session.medStep, { from: claimant }))
tx = await scryptVerifier.respond(sessionId, session.medStep, results.stateHash, { from: claimant })
session = dataFormatter.newSession(await scryptVerifier.getSession.call(sessionId))
// console.log("Session after first response: \n", session, "\n")
results = dataFormatter.newResult(await scryptRunner.getStateProofAndHash.call(session.input, session.medStep))
// console.log("Results after first response: \n", session, "\n")
// second query from the challenger.
tx = await scryptVerifier.query(sessionId, 0, { from: challenger })
})
it('finalizes verification game', async () => {
session = dataFormatter.newSession(await scryptVerifier.getSession.call(sessionId))
// console.log("Session after second query: \n", session, "\n")
var preState = dataFormatter.newResult(await scryptRunner.getStateProofAndHash.call(session.input, session.lowStep)).state
var postStateAndProof = dataFormatter.newResult(await scryptRunner.getStateProofAndHash.call(session.input, session.highStep))
var postState = postStateAndProof.state
var proof = postStateAndProof.proof || '0x00'
// console.log("... using\n PreState: ".yellow + preState + "\n PostState: ".yellow + postState + "\n Proof: ".yellow + proof + "\n")
// the final call for the verification game
// can only happen when lowStep + 1 == highStep (typically lowStep = 0, highStep = 1)
tx = await scryptVerifier.performStepVerification(sessionId, claimID, preState, postState, proof, claimManager.address, { from: claimant, gas: 3000000 })
log = tx.logs.find(l => l.event === 'ChallengerConvicted')
assert.equal(log.args.sessionId.toNumber(), sessionId)
log = tx.logs.find(l => l.event === 'ClaimantConvicted')
assert.equal(log, undefined)
// check that the callback to ClaimManager went through.
const sessionDecidedEvent = claimManager.SessionDecided({ fromBlock: 0, toBlock: 'latest' })
sessionDecidedEvent.watch((err, resp) => {
assert.equal(sessionDecidedEvent.args.sessionId, sessionId)
assert.equal(sessionDecidedEvent.args.winner, claimant)
assert.equal(sessionDecidedEvent.args.loser, challenger)
})
sessionDecidedEvent.stopWatching()
})
it('checks bonded deposits', async () => {
// check that the loser's deposits were transferred to the winner.
deposit = await claimManager.getBondedDeposit.call(claimID, claimant, { from: claimant })
assert.equal(deposit.toNumber(), 2 * claimDeposit)
deposit = await claimManager.getBondedDeposit.call(claimID, challenger, { from: challenger })
assert.equal(deposit.toNumber(), 0)
})
it('checks unbonded deposits', async () => {
// Check that participants can unbond their deposit
await claimManager.unbondDeposit(claimID, claimant, { from: claimant })
deposit = await claimManager.getDeposit.call(claimant, { from: claimant })
await claimManager.unbondDeposit(claimID, challenger, { from: challenger })
deposit = await claimManager.getDeposit.call(challenger, { from: challenger })
})
})
})
|
// Your server.js file should require the basic npm packages we've used in class: express, body-parser and path.
var app = require("express")();
var bodyParser = require("body-parser");
var path = require("path");
var routeDir = path.join(__dirname, "app", "routing");
var apiRoutes = require( path.join(routeDir, "apiRoutes" ));
var htmlRoutes = require( path.join(routeDir, "htmlRoutes"));
// Check env variable first for Heroku instance.
const PORT = process.env.PORT || 3000;
// Sets up the Express app to handle data parsing
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
// Using express routes for modularirty for http route handling.
// See http://expressjs.com/en/guide/routing.html
// htmlRoutes must come last due to catch-all clause in it
app.use('/api', apiRoutes);
app.use('/', htmlRoutes);
// listening function should come last after all helper functions are in place
app.listen(PORT, function(){
console.log(`Friend Finder listening on port ${PORT}!`)
});
|
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/ninjaGold');
const gameSchema = new mongoose.schema({
logs: [{type: Schema.Types.OjbectId, ref: 'Log'}]
}, {timestamps: true});
var Game = mongoose.model('game', gameSchema);
const logSchema = new mongose.schema({
game: {type: Schema.Types.ObjectId, ref: 'Game'},
message: {type: String}
}, {timestamps: true});
var Log = mongoose.model('Log', logSchema);
module.exports = {
Game: Game,
Log: Log
}
|
import React, { Component } from 'react';
import { NavLink } from 'react-router-dom';
//import '../qazy.min.js';
import './Portfolio.css';
import dummy_png from '../assets/img/dummy.png';
/**
* Component: Portfolio
* Props: dataImage, dataAuthor, dataCategory, dataPublished, dataExcerpt
*/
class Portfolio extends Component
{
componentDidMount() {
/*
Lazy images
*/
var lazy = document.getElementsByClassName('lazy');
if(lazy.length){
for (var i=0; i < lazy.length; i++) {
var lazyDataSrc = lazy[i].getAttribute('data-src');
if(lazyDataSrc) {
lazy[i].setAttribute('src', lazyDataSrc);
}
}
}
}
render() {
return (
<div className="col-12 col-sm-6 portfolio-item">
<div className="card h-100">
<NavLink to="post">
<img className="card-img-top lazy" src={dummy_png} data-src={this.props.dataImage} alt="" />
</NavLink>
<div className="card-body">
<h4 className="card-title">
<NavLink to="post">{this.props.dataTitle}</NavLink>
</h4>
<small className="post-meta">
<NavLink to="post">{this.props.dataAuthor}</NavLink>,
<NavLink to="category">{this.props.dataCategory}</NavLink>,
<NavLink to="post">{this.props.dataPublished}</NavLink>
</small>
<p className="card-text">{this.props.dataExcerpt}</p>
</div>
</div>
</div>
);
}
}
export default Portfolio;
|
var mongodb = require('mongodb');
var MongoClient = mongodb.MongoClient;
var url = 'mongodb://localhost:27017/haohuola';
var perPageNumber=20;
exports.index = function(req, res) {
//首页
var home=require('../routes/home');
home.run(req,res,'home');
}
exports.publish = function(req, res) {
var publish=require('../routes/publish');
publish.run(req,res);
}
exports.post = function(req, res) {
var post=require('../routes/post');
post.run(req,res);
}
exports.category = function(req, res) {
var category=require('../routes/category');
category.run(req,res);
}
exports.search = function(req, res) {
var search=require('../routes/search');
search.run(req,res);
}
exports.mall = function(req, res) {
var mall=require('../routes/mall');
mall.run(req,res);
}
exports.cn = function(req, res) {
var home=require('../routes/home');
home.run(req,res,'cn');
}
exports.haitao = function(req, res) {
var home=require('../routes/home');
home.run(req,res,'haitao');
}
exports.baicai = function(req, res) {
var home=require('../routes/home');
home.run(req,res,'baicai');
}
exports.notFound = function(req, res) {
res.send('<h1 style="text-align:center;font-weight:200;font-size:6em;margin-top:100px;">404<br><span style="font-size:30px;">Not Found</span></h1>', 404);
}
|
// mouse = [DomObject, position, direction, memorizedMaze, directionWheel];
// function Theseus(maze, mouse){
// 1st level function
function explorationStrategy(maze, mouse){
goal = false;
wheel = 3;
while(!goal){
// checking for directionWheel rotation (+90°) due to previous vector memorized in current square
if(mouse[3][mouse[1]-1][1] != 0){
mouse[4] = quadrant(mouse[4] + 1);
}
else{
mouse[4] = 3;
}
squareExploration(maze, mouse);
}
}
// 2nd level function
function squareExploration(maze, mouse){
position = mouse[1];
reverseDirection = quadrant(mouse[2] + 2);
memorizedMaze = mouse[3];
wheelDirection = mouse[4];
alert('Mouse is in square #' +position+ ' \n facing the ' +convertDirection(quadrant(mouse[2]))+ '\n the wheel is locked on ' +convertDirection(wheelDirection));
exit = false;
attempt = 0;
direction = wheelDirection;
while(!exit){
if(attempt < 4){
alert('Testing for obstacle and previous vector in the : ' + convertDirection(direction));
openWay = fullDirectionTest(maze, mouse, direction);
}
else{
alert('Now testing for obstacle (only) in the : ' + convertDirection(direction));
openWay = obstacleTest(maze, position, direction);
}
if(openWay){
alert('mouse moving towards ' +convertDirection(direction));
mouse = moveThisWay(mouse, direction);
exit = true;
}
else{
direction = quadrant(direction+1);
attempt += 1;
}
}
return mouse;
}
// 3rd level functions
function fullDirectionTest(maze, mouse, direction){
position = mouse[1];
memorizedMaze = mouse[3];
switch(direction){
case 1:
nextPosition = position + 5;
break;
case 2:
nextPosition = position + 1;
break;
case 3:
nextPosition = position - 5;
break;
case 4:
nextPosition = position - 1;
break;
}
aimedSquare = memorizedMaze[nextPosition-1];
if(typeof(aimedSquare) !='undefined'){
if(aimedSquare[1] == 0 && maze[position-1][1].indexOf(direction) == -1){
return true;
}
else{
return false;
}
}
else{
alert('mouse is on a edge of the maze');
return false
}
}
function obstacleTest(maze, position, direction){
if(maze[position-1][1].indexOf(direction) == -1){
return true;
}
else{
return false;
}
}
function moveThisWay(mouse, direction){
switch(direction){
case 1:
mouse[3][mouse[1]-1][1] = 1;
mouse[1] += 5;
mouse[2] = 1;
break;
case 2:
mouse[3][mouse[1]-1][1] = 2;
mouse[1] += 1;
mouse[2] = 2;
break;
case 3:
mouse[3][mouse[1]-1][1] = 3;
mouse[1] -= 5;
mouse[2] = 3;
break;
case 4:
mouse[3][mouse[1]-1][1] = 4;
mouse[1] -= 1;
mouse[2] = 4;
break;
default:
alert('moveThisWay direction ERROR');
}
}
function quadrant(direction){
if(direction > 4){
direction -= 4;
}
return direction;
}
//
function convertDirection(direction){
switch(direction){
case 1:
return 'North';
break;
case 2:
return 'East';
break;
case 3:
return 'South';
break;
case 4:
return 'West';
break
default:
return 'Direction Error';
}
}
// function goalStrategy(){}
// }
|
// 3. Agregando Webpack
// Sintaxis de CommandJS
// crear archivo webpack.config.js
//<script src="public/js/bundle.js"></script>
// Para matar un servicio en la terminal, hacer click en el tacho de basura o ctrl +c
// Porque path, es para obtener la dirección actual, es decir,
// C:\htmlCSSJavaScript\JavaScriptModernoGuiaConstruye10Proyectos\Curso JS Moderno\53-Webpack-ESLint.BAbel
// Se realiza para no escribir toda la dirección
const path = require('path');
// creamos una entrada y una salida
module.exports = {
// Archivo principal del proyecto
entry: './js/app.js',
output: {
//__dirname para tomar la dirección
// Lo compila en public/js luego bundle.js
path: path.resolve(__dirname, 'public/js'),
filename: 'bundle.js'
// Escribe otro script en package.json
// "webpack": "webpack"
// Escribir en la Terminal npm run webpack
// Esto compilará nuestros archivos
// Escribir un modo (development o production) sino dará un Warning
// "webpack": "webpack --mode=development"
// El mode se puede agregar en package.json o webpack.confi.js
},
mode: 'development',
// 5. Creando un Servidor con webpack dev server
// Parecido al plugin Live-Server para VS Code. El de webpack funcionará en cualquier editor de código
// En la Terminal npm i --save-dev webpack-dev-server
devServer: {
// A punta a la carpeta principal
contentBase: path.join(__dirname, '/'),
compress: true,
port: 9000,
// en package.json se agrega "dev": "webpack serve"
// npm run dev
//click en el link http://localhost:9000/
// Lo que no hace, es que cada vez que realizo un cambio este se actualice solo.
// Se soluciona añadiendo un watch
publicPath: "/public/js",
watchContentBase: true
},
// Ver el archivo bundle.js esto contendrá todo el código. Versión compilada con mayor performance
// Mayor soporte ejemplo IE6 habilitar el loader de babel
// 4. Agregando Babel por medio de Webpack
// La forma de realizar es con loader es similar a un plugin
// https://webpack.js.org/loaders/babel-loader/
// npm install -D babel-loader @babel/core @babel/preset-env webpack
// notar que anteriormente se instalaron los dos últimos
// Ir a la terminal npm i --save-dev babel-loader
// Se eliminan archivos entrada.js y salida.js
// en la terminal: npm run webpack
// Resultado: babel(Código transpilado) funcionando bajo webpack,
module: {
rules: [
{
// Expresión regular que Busca todos los archivos js
test: /\.js$/,
// Excluir carpeta
exclude: /(node_modules)/,
// Utilizar babel
use: {
loader: 'babel-loader',
options: {
presets: ['@babel/preset-env']
}
}
},
{
enforce: 'pre',
test: /\.js$/,
exclude: /(node_modules)/,
loader: 'eslint-loader',
options: {
fix: true
}
}
]
}
// 6. Agregando Live Reload
// En package.json "watch": "webpack --w"
// --w agrega el watch
// "dev": "concurrently --kill-others \"npm run watch\" \"webpack serve\"",
// "watch": "webpack --watch"
// instalar concurrently
// npm i --save-dev concurrently
// De esta forma podemos correr dos o más script al mismo tiempo
// 7. Añadiendo ESLint a nuestro código. https://eslint.org/
// En VS Code ir a Extensions, instalar ESLint
// Agregar ESLint al Proyecto - Terminal - npm i --save-dev eslint
// Crear un archivo de ESLint. En la Terminal npx eslint --init
// Te realiza una serie de preguntas. Te crea un archivo llamado .eslintrc.js
// ¿Como ESLint ignora ciertos archivos? Presionar Ctrl Shif + p
// escribir json, dice Preferences: open settings se abrirá un archivo
// {
// "files.autoSave": "afterDelay",
// "workbench.colorTheme": "Flatland Monokai",
// "diffEditor.wordWrap": "off",
// "editor.wordWrap": "on",
// "liveServer.settings.donotShowInfoMsg": true
// }
// Agregar la sgte línea "main": ".eslintrc.js",
// para realizar un chequeo completo de un archivo.js. En la Terminal npx eslint prueba.js
// 8. Agregando la Guía de Estilos de Airbnb
// https://github.com/airbnb/javascript
// Requisitos Babel y requiere que uses babel-preset-airbnb, polyfills en su aplicación,
// con airbnb-browser-shims
// Aierbnb tiene una seríe de buenas prácticas para escribir código
// En la terminal npx eslint --init mostrará una serie de pregunta
// indicar enforce code style, Use a popular style guide - seleccionar Airbnb
// Pregunta por instalar dependencias. respuesta yes
// 9. Solucionar errores con ESlint y Airbnb StyleGuide
// Corregir errores automaticamente con eslint y webpack
// en la terminal npm i --save-dev eslint-loader
// npm run dev entregará una serie de errores de código que se debe configurar para que se corriga
// automaticamente
}
|
const jwt = require("jsonwebtoken");
const User = require("../Models/User");
const APP_SECRET = require("dotenv/config");
const SECRET = process.env.APP_SECRET;
module.exports = async (req, res, next) => {
try {
const token = req.headers.authorization;
if (!token) return res.status(401).json({ message: "Não autorizado" });
const payload = jwt.verify(token, SECRET);
const user = await User.getByEmail(payload.userData);
if (!user) {
return {
error: true,
code: "invalid_data",
message: "invalid token",
statusCode: 400,
};
}
req.user = payload.userData;
return next();
} catch (error) {
return res.status(401).json({ message: error.message });
}
};
|
import Input from 'atoms/input'
import Logo from 'molecules/logo'
import Nav from 'organisms/nav'
import PropTypes from 'prop-types'
import React from 'react'
import * as styles from './styles'
const Header = ({
containerStyle, contentStyle, value, onChange,
}) => {
const inputId = 'header-input'
return (
<header css={[styles.headerBase, containerStyle]}>
<div css={[styles.content, contentStyle]}>
<Logo containerStyle={styles.logoContainerStyle} />
<Input
name={inputId}
dataTestId={inputId}
id={inputId}
placeholder="Inserir endereço"
containerStyle={styles.inputContainerStyle}
value={value}
onChange={onChange}
/>
<Nav containerStyle={styles.githubCentralContainerStyle} />
</div>
</header>
)
}
Header.propTypes = {
containerStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
contentStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
onChange: PropTypes.func.isRequired,
value: PropTypes.string.isRequired,
}
Header.defaultProps = {
containerStyle: {},
contentStyle: {},
}
export default Header
|
import { LightningElement, api, track ,wire} from 'lwc';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
import ReturnPBEList from '@salesforce/apex/NewProductByDiscount.ReturnPBEList_quote';
import ReturnPBEList_search from '@salesforce/apex/NewProductByDiscount.ReturnPBEList_search';
import product_back from '@salesforce/apex/NewProductByDiscount.product_back';
import check_pb2id from '@salesforce/apex/NewProductByDiscount.check_PB2Id';
import Return_PB2 from '@salesforce/apex/NewProductByDiscount.Return_PB2';
import PB2_back from '@salesforce/apex/NewProductByDiscount.PB2_back';
import quote_find_oppoid from '@salesforce/apex/NewProductByDiscount.quote_find_oppoid';
const columns = [
{ label: 'Name', fieldName: 'nameUrl',
type: 'url',
typeAttributes: {label:{fieldName:'Name'},target: '_blank'}},
{ label: 'Part Number', fieldName: 'productcode'},
{ label: 'List Price', fieldName: 'unitprice'}
];
export default class DemoButtonMenu extends LightningElement {
@api recordId;
@api
focusOnError(sfieldId){
/* eslint-disable no-console */
console.log('Id Recieved in child component : ',sfieldId);
this.template.querySelector(`[data-id="${this.sfieldId}"]`).focus();
}
@track result_message = "";
@track product;
@track pricebook_name = "";
@track pricebook_id = "test";
@track error;
@track add_product_pricebook = false;
@track add_product_choose_product = false; // if true choose_product will be present
@track add_product_discount = false; // if true add_prisect_discount will be present
@track columns = columns;
@track add_product_display_list = [];
@track add_product_discount_list = [];
@track updata_list = [];
@track pricebook_select = [];
@track opp_id = "";
@track
items = [
{
id: 'menu-item-1',
label: 'add product',
value: 'add_product',
},
{
id: 'menu-item-2',
label: 'edit product',
value: 'edit_product',
},
];
@wire(quote_find_oppoid,{quoteid:'$recordId'})
get_opp_id({error,data}){
if(data){
console.log("get_in")
this.opp_id = data;
console.log(this.opp_id);
}else if(error){
console.log(error);
}
}
@wire(ReturnPBEList,{quoteid:'$recordId'})
wiredContacts({ error, data }) {
if (data) {
console.log("test");
this.product = data;
this.add_product_discount_list = [];
this.do_for();
console.log(data);
} else if (error) {
this.error = error;
this.contacts = undefined;
}
}
@wire(Return_PB2)get_pricebook_name({ error, data }) {
if (data) {
for(let i = 0;i < data.length;i++){
this.pricebook_select[i] = {
label:data[i].Name,
value:data[i].Id,
}
}
} else if (error) {
this.error = error;
this.contacts = undefined;
}
}
do_for(){
for(let i =0;i<this.product.length;i++){
this.add_product_display_list[i] = {
Id : this.product[i].Id,
Name :this.product[i].Name,
productcode:this.product[i].Product2.ProductCode,
unitprice:this.product[i].UnitPrice.toFixed(2).toString(),
nameUrl:'/lightning/r/PricebookEntry/'+this.product[i].Id+'/view',
quantity:'1',
discount:'100',
total : this.product[i].UnitPrice.toFixed(2).toString(),
select_id:"",
product2id:this.product[i].Product2Id,
sale_price:this.product[i].UnitPrice.toFixed(2).toString()
};
}
}
handleMenuSelect(event) {//this function is for add_product
console.log(this.recordId);
const chooses = event.detail.value;
//if(chooses === "add_product"){
check_pb2id({opp_id:this.opp_id})
.then(result => {
if(result==='0'){
this.add_product_pricebook = true;
}
else{
this.pricebook_name = result;
console.log("check");
this.add_product_choose_product = true;
console.log(this.add_product_display_list);
}
})
.catch(error => {
this.error = error;
});
//this.add_product_pricebook= true;
//}
}
handle_select(event){
for(let i = 0 ;i < this.pricebook_select.length;i++){
if(event.detail.value==this.pricebook_select[i].value){
this.pricebook_name = this.pricebook_select[i].label;
this.pricebook_id = event.detail.value;
break;
}
}
//this.pricebook_name = event.detail.value;
}
add_product_pricebook_next_page(){
PB2_back({opp_id:this.opp_id,pb2_id:this.pricebook_id})
.then(result => {
console.log(result);
this.product = result;
do_for();
})
.catch(error => {
this.error = error;
});
console.log(this.product);
this.add_product_pricebook = false;
}
add_product_pricebook_close_page(){
this.add_product_pricebook = false;
}
add_product_choose_product_close_page(){//this function is for add_product
this.add_product_choose_product = false;
}
add_product_choose_product_next_page(){//this function is for add_product
var el = this.template.querySelector('lightning-datatable');
var get_select = el.getSelectedRows();
this.add_product_discount_list = [];
for(let i = 0 ; i<get_select.length;i++){
this.add_product_discount_list[i] = get_select[i];
this.add_product_discount_list[i].select_id = i.toString();
}
this.add_product_discount = true;
this.add_product_choose_product = false;
}
handleKeyUp(evt) {//輸入文字按enter搜尋文字
const isEnterKey = evt.keyCode === 13;
if (isEnterKey) {
this.queryTerm = evt.target.value;
console.log(evt.target.value);
ReturnPBEList_search({word:evt.target.value,opp_id:this.opp_id})
.then(result => {
this.add_product_display_list = [];
this.product = result;
console.log("test");
this.do_for();
})
.catch(error => {
this.error = error;
});
}
}
add_product_discount_next_page(){
for(let i = 0; i < this.add_product_discount_list.length;i++){
this.updata_list[i] = this.add_product_discount_list[i].Id+","+this.add_product_discount_list[i].sale_price+","+this.add_product_discount_list[i].quantity+","+this.add_product_discount_list[i].discount;
}
console.log(this.updata_list);
console.log(this.recordId);
product_back({products:this.updata_list,opp_id:this.opp_id,status:true})
.then(result => {
console.log(result);
this.result_message = result;
this.showNotification();
})
.catch(error => {
this.error = error;
});
this.add_product_discount = false;
}
add_product_discount_close_page(){
for(let i = 0; i < this.add_product_discount_list.length;i++){
this.add_product_discount_list[i].total = "";
this.add_product_discount_list[i].discount = "1";
this.add_product_discount_list[i].quantity = "0";
}
this.add_product_discount = false;
}
discount_save(evt){
var now_select = "";
var total = 0;
var sale_price = 0;
now_select = evt.target.name;
for(let i = 0 ; i < this.add_product_discount_list.length;i++){
if(now_select === this.add_product_discount_list[i].select_id){
this.add_product_discount_list[i].discount = evt.target.value;
total = parseFloat(this.add_product_discount_list[i].discount)/100*parseFloat(this.add_product_discount_list[i].quantity)*parseFloat(this.add_product_discount_list[i].unitprice);
console.log(total);
this.add_product_discount_list[i].total = total.toFixed(2).toString();
console.log(this.add_product_discount_list[i].discount)
console.log(now_select);
sale_price= parseFloat(this.add_product_discount_list[i].discount)/100*parseFloat(this.add_product_discount_list[i].unitprice);
this.add_product_discount_list[i].sale_price = sale_price.toFixed(2).toString();
}
}
}
quantity_save(evt){
var now_select = "";
var total = 0;
now_select = evt.target.name;
for(let i = 0 ; i < this.add_product_discount_list.length;i++){
if(now_select === this.add_product_discount_list[i].select_id){
this.add_product_discount_list[i].quantity = evt.target.value;
total = parseFloat(this.add_product_discount_list[i].discount)/100*parseFloat(this.add_product_discount_list[i].quantity)*parseFloat(this.add_product_discount_list[i].unitprice);
this.add_product_discount_list[i].total = total.toFixed(2).toString();
}
}
}
showNotification() {
var variant_status = "";
var evt;
if(this.result_message ==='Insert successed'){
variant_status = 'success';
evt = new ShowToastEvent({
title: '訊息回報',
message:this.result_message,
variant: variant_status,
});
}else{
variant_status = 'error'
evt = new ShowToastEvent({
title: '訊息回報',
message:this.result_message,
variant: variant_status,
});
}
this.dispatchEvent(evt);
}
}
|
import { combineReducers } from 'redux';
import entities, { STATE_KEY as ENTITIES_STATE_KEY } from './entities';
import rtc, { STATE_KEY as RTC_STATE_KEY } from './rtc';
import socket, { STATE_KEY as SOCKET_STATE_KEY } from './socket';
import ui, { STATE_KEY as UI_STATE_KEY } from './ui';
const rootReducer = combineReducers({
[ENTITIES_STATE_KEY]: entities,
[RTC_STATE_KEY]: rtc,
[SOCKET_STATE_KEY]: socket,
[UI_STATE_KEY]: ui,
});
export default rootReducer;
|
(function(window, $){
$(window).on('load resize', function() {
var $frame = $('.bhs_parts_iframe', parent.document);
var innerHeight = $frame.get(0).contentWindow.document.body.scrollHeight;
var innerWidth = $frame.get(0).contentWindow.document.body.scrollWidth;
$frame.attr('height', innerHeight + 'px');
$frame.attr('width', innerWidth + 'px');
})
})(window, jQuery)
|
({
post_page: {
headline: 'Woooooow!',
dateline: 'Your first enduro.js project',
$text_type: 'textarea',
post: 'Scroll down to see what\'s sdgsdgdsg'
}
})
|
import React, {useState} from "react";
import FeedCardStyled from "./FeedCardStyled.style";
import store from "../../redux/store";
function FeedCard(props) {
const [user, setUser] = useState(store.getState())
return(
<FeedCardStyled className="card mt-4">
{
user.userId === props.data.authorId && <i className="fas fa-pencil-alt" onClick={props.editStory}></i>
}
<div className="card-infos">
<h2>{props.data.title}</h2>
<p>{props.data.content}</p>
</div>
</FeedCardStyled>
)
}
export default FeedCard
|
import * as ACTIONS from '../constants/game.constants';
export function pauseGame() {
return { type: ACTIONS.GAME_PAUSE };
}
export function startGame() {
return (dispatch, getState) => {
const state = getState();
if (state.controllers.canPlay === false) {
setTimeout(() => dispatch(startGame()), state.controllers.speed);
}
dispatch({ type: ACTIONS.GAME_PROGRESS });
};
}
|
import React, { lazy } from 'react'
const TvTopRated = lazy(() => import('../Base/TvTopRated'))
const TvTopRatedPage = () => {
return (
<>
<div className="Container-main">
<TvTopRated/>
</div>
</>
)
}
export default TvTopRatedPage
|
var chunkArray = require("../chunkArray");
var chai = require("chai");
var expect = chai.expect;
describe ("chunkArray", function(){
it("case 1", function(){
expect(chunkArray(["a", "b", "c", "d"], 2)).to.eql([["a", "b"], ["c", "d"]]);
});
it("case 2", function(){
expect(chunkArray([0, 1, 2, 3, 4, 5], 3)).to.eql([[0, 1, 2], [3, 4, 5]]);
expect(chunkArray([0, 1, 2, 3, 4, 5], 2)).to.eql([[0, 1], [2, 3], [4, 5]]);
expect(chunkArray([0, 1, 2, 3, 4, 5], 4)).to.eql([[0, 1, 2, 3], [4, 5]]);
expect(chunkArray([0, 1, 2, 3, 4, 5, 6], 3)).to.eql([[0, 1, 2], [3, 4, 5], [6]]);
expect(chunkArray([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)).to.eql([[0, 1, 2, 3], [4, 5, 6, 7], [8]]);
expect(chunkArray([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)).to.eql([[0, 1], [2, 3], [4, 5], [6, 7], [8]]);
});
});
|
import chai, {
expect,
} from 'chai';
import chaiHttp from 'chai-http';
import app from '../app';
chai.use(chaiHttp);
// ============== ENTRY API ROUTE ============
describe('GET/ test', () => {
it('should return Welcome to Banka', (done) => {
chai.request(app)
.get('/')
.end((err, res) => {
expect(res).to.have.status(200);
expect(res.body).to.be.an('object');
expect(res.body.message).to.equal('Welcome to Banka');
done(err);
});
});
});
|
import App from "./App.svelte";
import "./styles/modern-normalize.css";
import "./styles/global.css";
const app = new App({
target: document.getElementById("app"),
});
export default app;
|
const { MaxHeap } = require("./maxHeap");
let maxHeap;
beforeEach(() => {
maxHeap = new MaxHeap();
});
describe("MaxHeap", () => {
it("should construct a MaxHeap object", () => {
expect(maxHeap.priorityQueue).toEqual([]);
});
describe("insert", () => {
it("should insert an item", () => {
maxHeap.insert(100);
expect(maxHeap.priorityQueue[0]).toBe(100);
});
it("should insert multiple items", () => {
maxHeap.insert(100);
maxHeap.insert(10);
maxHeap.insert(20);
expect(maxHeap.priorityQueue[0]).toBe(100);
expect(maxHeap.priorityQueue[1]).toBe(10);
expect(maxHeap.priorityQueue[2]).toBe(20);
});
it("should recursively swap child with parent if child is greater than parent", () => {
maxHeap.insert(10);
maxHeap.insert(100);
maxHeap.insert(50);
maxHeap.insert(20);
maxHeap.insert(30);
maxHeap.insert(60);
maxHeap.insert(120);
expect(maxHeap.priorityQueue[0]).toBe(120);
expect(maxHeap.priorityQueue[1]).toBe(30);
expect(maxHeap.priorityQueue[2]).toBe(100);
expect(maxHeap.priorityQueue[3]).toBe(10);
expect(maxHeap.priorityQueue[4]).toBe(20);
expect(maxHeap.priorityQueue[5]).toBe(50);
expect(maxHeap.priorityQueue[6]).toBe(60);
});
});
it("getMax should return the root node", () => {
maxHeap.insert(100);
maxHeap.insert(300);
expect(maxHeap.getMax()).toBe(300);
});
it("extractMax should remove and return the root node", () => {
maxHeap.insert(10);
maxHeap.insert(100);
maxHeap.insert(50);
maxHeap.insert(20);
maxHeap.insert(30);
maxHeap.insert(60);
maxHeap.insert(120);
expect(maxHeap.extractMax()).toBe(120);
expect(maxHeap.priorityQueue[0]).toBe(100);
expect(maxHeap.priorityQueue[1]).toBe(30);
expect(maxHeap.priorityQueue[2]).toBe(60);
expect(maxHeap.priorityQueue[3]).toBe(10);
expect(maxHeap.priorityQueue[4]).toBe(20);
expect(maxHeap.priorityQueue[5]).toBe(50);
});
});
|
import firebase from "firebase";
const firebaseConfig = {
apiKey: "AIzaSyBi4B4SyTKinslyATWUXHF7WmwuG4KYyL8",
authDomain: "ecommerce-57c95.firebaseapp.com",
projectId: "ecommerce-57c95",
storageBucket: "ecommerce-57c95.appspot.com",
messagingSenderId: "831200733850",
appId: "1:831200733850:web:328eaed86df96e69bbcd23",
};
firebase.initializeApp(firebaseConfig);
export const auth = firebase.auth();
export const googleAuthProvider = new firebase.auth.GoogleAuthProvider();
|
import styled from "styled-components";
export const Title = styled.div`
font-size: 18px;
font-weight: bold;
color: #00458a;
`;
export const ContainerOutline = styled.div`
border-top: 2px solid #00458a;
padding: 5px;
`;
export const CardContainer = styled.div`
display: inline-block;
vertical-align: top;
cursor: pointer;
margin: 5px;
width: 140px; /* enough space to fit 3 cards at max page width of 1200px */
height: 200px;
transition: ${({ theme }) => theme.boxShadow};
box-shadow: 0 0 11px rgba(83, 68, 68, 0.2);
&:hover {
box-shadow: 0 0 11px rgba(33, 33, 33, 0.4);
}
`;
export const ImageContainer = styled.div`
position: relative;
text-align: center; /* needed to allow vertical centering */
line-height: 150px; /* overall post card height - post header height | used to center photo in white space*/
height: 150px; /* overall post card height - post header height | used to center photo in white space*/
width: 140px;
background-color: #f3f7f9;
overflow: hidden;
`;
export const ImageBackgroundWrapper = styled.div`
position: absolute;
left: 0;
top: 0;
filter: opacity(0.2);
-webkit-filter: opacity(0.2);
background-size: cover;
min-width: 100%;
min-height: 100%;
background-position: center;
`;
export const ImageWrapper = styled.img`
max-height: 100%; /* overall post card height - post header height | used to center photo in white space*/
max-width: 100%;
vertical-align: middle; /* center vertically */
margin: 0 auto; /* center horizontally */
position: relative;
border: 1px solid rgb(255, 255, 255);
margin-top: -2px;
`;
export const DetailsContainer = styled.div`
padding: 0 5px 5px 5px;
white-space: "nowrap";
overflow: "hidden";
text-overflow: "ellipsis";
`;
export const TitleWrapper = styled.div`
font-weight: bold;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
`;
export const DimsWrapper = styled.div`
font-size: 0.7rem;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
`;
|
import Game from './Game.js';
console.log("Hello")
const game = new Game()
console.log(game.getMoves())
game.createGameBoard()
|
define([
"dcl",
"dojo/Deferred",
"dojo/json",
"dojo/promise/all",
"decor/Stateful",
"dojo/when"
], function (
dcl,
Deferred,
json,
all,
Stateful,
when) {
return dcl([Stateful], {
packages: null,
getDependentPackages: function (packageName) {
var pkg = this.findPackage(packageName);
var packages = [];
return when(this._addDependentPackages(pkg, packages), function () {
return packages;
});
},
_addDependentPackages: function (pkg, packages) {
var def = new Deferred();
packages.push(pkg);
require(["requirejs-text!" + pkg.location + "/package.json"], function (packageJsonTxt) {
var packageJson = json.parse(packageJsonTxt);
var depPkgName;
if (packageJson.jam && packageJson.jam.dependencies) {
var loadDepPackagesPromise = [];
for (depPkgName in packageJson.jam.dependencies) {
if (packageJson.jam.dependencies.hasOwnProperty(depPkgName)) {
var devPkg = this.findPackage(depPkgName);
loadDepPackagesPromise.push(this._addDependentPackages(devPkg, packages));
}
};
when(all(loadDepPackagesPromise), function () {
def.resolve();
}, function () {
def.reject();
})
} else {
def.resolve();
}
}.bind(this));
return def.promise;
},
findPackage: function (pkgName) {
return this.packages.filter(function (pkg) {
return pkg.name === pkgName;
})[0];
}
})
});
|
import { makeStyles } from '@material-ui/core/styles'
export default makeStyles((theme) => ({
mainContainer: {
position: 'relative',
[theme.breakpoints.down('md')]: {
padding: 0
}
},
smMargin: {
margin: theme.spacing(1)
},
actionDiv: {
[theme.breakpoints.down('md')]: {
flexDirection: 'column-reverse'
}
},
maxWidth: {
maxWidth: '79.333333%',
flexBasis: '100%',
[theme.breakpoints.down('md')]: {
maxWidth: '100%',
flexBasis: '100%'
}
},
sticky: {
position: 'sticky',
top: '5%',
[theme.breakpoints.down('md')]: {
position: 'relative'
}
},
marginTop: {
marginTop: '2rem'
},
searchRoot: {
maxWidth: '90%'
},
formRoot: {
width: '19.666666%',
[theme.breakpoints.down('md')]: {
width: '100%'
}
},
form: {
maxWidth: '100%'
},
pagination: {
borderRadius: 12
}
}))
|
require('./models/db');
const express = require('express');
const employeeController = require('./controllers/employeeController')
const path = require('path')
var exphbs = require('express-handlebars');
var bodyParser = require('body-parser')
const app = express();
const port = 3000;
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.engine('handlebars', exphbs({defaultLayout: 'main', layoutsDir: path.join(__dirname, 'views/layouts')}));
app.set('views', path.join(__dirname, '/views/'));
app.set('view engine', 'handlebars');
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`)
})
app.use('/employee', employeeController);
|
angular.module('app')
.run(function($http, $rootScope){
$rootScope.is_authenticated = window.localStorage.getItem('IS_AUTHENTICATED');
$rootScope.username = window.localStorage.getItem('USER_NAME');
});
|
var mongoose=require('mongoose');
var Schema=mongoose.Schema;
var itemSchema=new Schema({
email:{ type: String, required: true, unique: true },
items:[ {
name:String,
purchase_date: [Date],
diff_days_purchase:[Number]
}]
});
var Item=mongoose.model('Item',itemSchema);
module.exports=Item;
|
const StateMachine = require('javascript-state-machine')
const waitForEvent = require('../util/waitForEvent')
const timeout = require('../util/timeout')
const calculateMidpoint = require('../util/math').calculateMidpoint
const fs = require('fs')
module.exports = (web3, api) => ({
run: async (cmd, claim, challenger, autoDeposit = false) => new Promise(async (resolve, reject) => {
const getNewMedStep = async (sessionId) => {
let session = await api.getSession(sessionId)
return calculateMidpoint(session.lowStep.toNumber(), session.medStep.toNumber())
}
try {
const { claimManager } = api
let sessionId
const m = new StateMachine({
init: 'init',
transitions: [
{ name: 'start', from: 'init', to: 'ready' },
{ name: 'challenge', from: 'ready', to: 'didChallenge' },
{ name: 'playGame', from: 'didChallenge', to: 'done'},
{ name: 'cancel', from: '*', to: 'cancelled' },
{ name: 'skipChallenge', from: 'ready', to: 'didChallenge'}
],
methods: {
onStart: async (tsn) => {
if('sessionId' in claim) {
return true;
}else{
cmd.log('Checking deposits...')
const minDeposit = await api.getMinDeposit()
const currentDeposit = await api.getDeposit(challenger)
if (currentDeposit.lt(minDeposit)) {
cmd.log('Not enough ETH deposited.')
// if we don't have enough deposit, either add some or throw
// let's just add exactly the right amount for now
if (autoDeposit) {
const neededAmount = minDeposit.sub(currentDeposit)
const myBalance = await api.getBalance(challenger)
if (myBalance.gte(neededAmount)) {
cmd.log(`Depositing ${web3.fromWei(neededAmount, 'ether')} ETH...`)
await api.makeDeposit({from: challenger, value: neededAmount})
cmd.log(`Deposited ${web3.fromWei(neededAmount, 'ether')} ETH.`)
} else {
throw new Error(`
You don't have enough ETH to submit a deposit that would be greater than minDeposit.
`)
}
} else {
throw new Error(`
Your deposited ETH in ClaimManager is lower than minDeposit and --deposit was not enabled.`
)
}
}
return false;
}
},
onBeforeChallenge: async (tsn) => {
cmd.log('Challenging...')
//console.log(claim.id)
if(!('sessionId' in claim)) {
await api.challengeClaim(claim.id, {from: challenger})//bonds deposit
}
},
onAfterChallenge: async (tsn) => {
const sendQuery = async () => {
claim.sessionId = await api.claimManager.getSession.call(claim.id, challenger)
//Initial query
fs.writeFile('./challenges/'+claim.id+'.json', JSON.stringify(claim), (err) => {if(err) console.log(err)})
let session = await api.getSession(claim.sessionId)
let medStep = calculateMidpoint(session.lowStep.toNumber(), session.highStep.toNumber())
await api.query(claim.sessionId, medStep, {from: challenger})
}
//Figure out if first challenger
let currentChallenger = await api.claimManager.getCurrentChallenger.call(claim.id)
let verificationOngoing = await api.claimManager.getVerificationOngoing.call(claim.id)
if(currentChallenger == challenger && !verificationOngoing) {
await api.claimManager.runNextVerificationGame(claim.id, {from: challenger})
await sendQuery()
}else if(currentChallenger == challenger && verificationOngoing) {//should only happen if rebooting during game
let lastSteps = api.scryptVerifier.getLastSteps.call(claim.sessionId)
let claimantLastStep = lastSteps[0].toNumber()
let challengerLastStep = lastSteps[0].toNumber()
if(claimantLastStep == challengerLastStep) {
let medStep = await getNewMedStep(result.args.sessionId.toNumber())
console.log("Querying step: " + medStep)
await api.query(sessionId, medStep, {from: challenger})
if(medStep == 0) resolve()
}
}else if(currentChallenger != challenger && verificationOngoing) {
const verificationGameStartedEvent = api.claimManager.VerificationGameStarted({claimID: claim.id, challenger: challenger})
await new Promise(async (resolve, reject) => {
verificationGameStartedEvent.watch(async (err, result) => {
if(err) reject(err)
if(result) resolve()
})
})
verificationGameStartedEvent.stopWatching()
sendQuery()
}else{//this case probably won't happen but this should cover us if it does
await api.claimManager.runNextVerificationGame(claim.id, {from: challenger})
const verificationGameStartedEvent = api.claimManager.VerificationGameStarted({claimID: claim.id, challenger: challenger})
await new Promise(async (resolve, reject) => {
verificationGameStartedEvent.watch(async (err, result) => {
if(err) reject(err)
if(result) resolve()
})
})
verificationGameStartedEvent.stopWatching()
sendQuery()
}
},
onBeforePlayGame: async (tsn) => {
//playGame
let newResponseEvent = api.scryptVerifier.NewResponse({sessionId: claim.sessionId, challenger: challenger})
await new Promise(async (resolve, reject) => {
newResponseEvent.watch(async (err, result) => {
if(err) reject(err)
if(result) {
let medStep = await getNewMedStep(claim.sessionId)
console.log("Querying step: " + medStep)
await api.query(claim.sessionId, medStep, {from: challenger})
if(medStep == 0) resolve()
}
})
})
newResponseEvent.stopWatching()
},
onAfterPlayGame: async (tsn) => {
let sessionDecidedEvent = api.claimManager.SessionDecided({sessionId: claim.sessionId})
await new Promise((resolve, reject) => {
sessionDecidedEvent.watch(async (err, result) => {
if(err) reject(err)
if(result) {
console.log(result)
resolve()
}
})
})
sessionDecidedEvent.stopWatching()
fs.unlinkSync('./challenges/'+claim.id+'.json')
resolve()
},
onCancel: (tsn, err) => { reject(err) },
}
})
if(await m.start()) {
await m.playGame()
}else{
await m.challenge()
await m.playGame()
}
} catch (error) {
reject(error)
}
}),
})
|
rightFit.User = (function(){
var userAccount;
return {
checkLogin: function(){
var access_token = localStorage.getItem("access_token");
if(access_token && access_token != '' && access_token != undefined){
//mainView.router.loadPage('pages/dashboard.html');
rightFit.Router.goPage('dashboard.html');
}else{
mainView.router.loadPage('index.html');
//rightFit.Router.goPage('index');
}
},
getCurrentUser: function getCurrentUser() {
return userAccount;
},
login: function(email,password){
return new Promise(function(resolve,reject){
$$.ajax({
url: 'http://localhost:3000/api/users/login',
method: 'post',
dataType: 'json',
data: {email:email,password:password},
beforeSend: function(){
console.log('validate data');
},
error: function(xhr, status){
console.log('error');
console.log(xhr);
console.log(status);
reject( new Error( 'Could not log in.'));
return false;
},
success: function(data, status, xhr){
console.log('success');
console.log(data);
console.log(xhr);
console.log(status);
localStorage.setItem("access_token", data.id);
//return true;
resolve();
}
});
});
},
logOut: function(){
return new Promise(function(resolve,reject){
localStorage.removeItem('access_token');
resolve();
});
}
}
})()
|
/**
*
* Cats
*
*/
import React, { useEffect, useState } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { createStructuredSelector } from 'reselect';
import { compose } from 'redux';
import { makeStyles } from '@material-ui/core/styles';
import { TextField, Button } from '@material-ui/core';
import { useInjectSaga } from 'utils/injectSaga';
import { useInjectReducer } from 'utils/injectReducer';
import makeSelectCats from './redux/selectors';
import reducer from './redux/reducer';
import saga from './redux/saga';
import * as actions from './redux/actions';
const useStyles = makeStyles(() => ({
root: {
width: '100vw',
height: '100vh',
padding: 100,
},
formWrapper: {
display: 'flex',
justifyContent: 'space-between',
border: '1px solid black',
borderRadius: 25,
padding: 80,
},
catsWrapper: {
display: 'flex',
flexWrap: 'wrap',
marginTop: '80px',
},
catCard: {
border: '1px solid black',
borderRadius: 25,
marginRight: 25,
marginBottom: 25,
padding: 20,
},
}));
export function Cats(props) {
const {
cats: { cats },
fetchCats,
addCat,
deleteCat,
} = props;
const classes = useStyles();
useInjectReducer({ key: 'cats', reducer });
useInjectSaga({ key: 'cats', saga });
const [name, setName] = useState('');
const [age, setAge] = useState(0);
const [breed, setBreed] = useState('');
const onAddCatClick = async () => {
await addCat({
name,
age,
breed,
});
setName('');
setAge(0);
setBreed('');
};
useEffect(() => {
fetchCats();
}, []);
return (
<div className={classes.root}>
<div className={classes.formWrapper}>
<TextField
onChange={e => setName(e.target.value)}
value={name}
label="Name"
/>
<TextField
onChange={e => setAge(e.target.value)}
value={age}
type="number"
label="Age"
/>
<TextField
onChange={e => setBreed(e.target.value)}
value={breed}
label="Breed"
/>
<Button variant="contained" color="primary" onClick={onAddCatClick}>
Add cat
</Button>
</div>
<div className={classes.catsWrapper}>
{cats.map(cat => (
<div className={classes.catCard}>
<h4>Name: {cat.name}</h4>
<h4>Age: {cat.age}</h4>
<h4>Breed: {cat.breed}</h4>
<Button
variant="contained"
color="secondary"
// eslint-disable-next-line no-underscore-dangle
onClick={() => deleteCat(cat._id)}
>
Delete cat
</Button>
</div>
))}
</div>
</div>
);
}
Cats.propTypes = {
cats: PropTypes.object.isRequired,
fetchCats: PropTypes.func.isRequired,
addCat: PropTypes.func.isRequired,
deleteCat: PropTypes.func.isRequired,
};
const mapStateToProps = createStructuredSelector({
cats: makeSelectCats(),
});
const mapDispatchToProps = {
...actions,
};
const withConnect = connect(
mapStateToProps,
mapDispatchToProps,
);
export default compose(withConnect)(Cats);
|
import styled from 'styled-components'
export const Section = styled.section`
padding: ${(props) => props.theme.spacings.large};
display: block;
background-image: url(${(props) => props.specialBackground});
background-repeat: repeat;
@media ${(props) => props.theme.breakpoints.mobile} {
padding: ${(props) => props.theme.spacings.small}
${(props) => props.theme.spacings.xSmall};
}
@media ${(props) => props.theme.breakpoints.tablet} {
padding: ${(props) => props.theme.spacings.medium}
${(props) => props.theme.spacings.small};
}
`
|
export const style = `
<style>
#extendedForm {
padding: 10px;
}
#extendedForm .addRow {
color: green;
font-weight: bold;
font-size: 12px;
padding: .2em .4em;
}
#extendedForm .removeRow {
color: red;
font-weight: bold;
font-size: 12px;
padding: .2em .6em;
}
#extendedForm h1 {
font-size: 16px;
padding-top: 4px;
padding-bottom: 4px;
}
#extendedForm h2 {
font-size: 12px;
margin-top: 12px;
margin-bottom: 4px;
}
#extendedForm th {
text-align: left;
vertical-align: middle;
}
#extendedForm input[type=number]{
width: 60px;
}
#extendedForm input, #extendedForm select {
margin-top: 3px;
margin-bottom: 3px;
}
</style>`;
export const dataNormalization = `
{% if keepOriginal %}
<h1>Preprocessing</h1>
<table>
<tr>
<th align="left">Filters:</th>
<td>
<table>
<tr>
<th></th><th></th>
<th>Name</th>
<th>Options</th>
</tr>
<tr data-repeat='normalization.filters'>
<td>
<select onchange="updateOptions(this);" data-field='name'>
<option value=""></option>
<option value="centerMean">Center Mean</option>
<option value="growingX">Ensure growing value of X</option>
<option value="scaleSD">Divide by SD</option>
<option value="rescale">Rescale (0 to 1)</option>
<option value="normalize">Normalize (sum to 1)</option>
<option value="pareto">Pareto normalization</option>
<option value="calibrate" data-options="from,to,nbPeaks,targetX">Calibrate</option>
<option value="sg" data-options="windowSize,derivative,polynomial">Savitzky-Golay</option>
<option value="xFunction" data-options="function">X function</option>
<option value="yFunction" data-options="function">Y function</option>
</select>
</td>
<td>
<input style="display:none" type='number' placeholder="min" data-field='options.min' size="5">
<input style="display:none" type='number' placeholder="max" data-field='options.max' size="5">
<input style="display:none" type='number' placeholder="value" data-field='options.value' size="5">
<input style="display:none" type='number' placeholder="from" data-field='options.from' size="5">
<input style="display:none" type='number' placeholder="to" data-field='options.to' size="5">
<input style="display:none" type='number' placeholder="nbPeaks" data-field='options.nbPeaks' size="5">
<input style="display:none" type='number' placeholder="targetX" data-field='options.targetX' size="5">
<input style="display:none" type='number' placeholder="windowSize" data-field='options.windowSize' size="5">
<input style="display:none" type='number' placeholder="derivative" data-field='options.derivative' size="5">
<input style="display:none" type='number' placeholder="polynomial" data-field='options.polynomial' size="5">
<textarea style="display:none" placeholder="function" data-field="options.function" cols="20" rows=3"></textarea>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<th align="left">Range:</th>
<td>
from: <input type="number" name="normalization.from" step="any"> -
to: <input type="number" name="normalization.to" step="any">
<button onclick="resetFromTo()">Reset</button>
</td>
</tr>
<tr>
<th align="left">Exclusions:</th>
<td>
<table>
<tr>
<th></th><th></th>
<th>From</th>
<th>To</th>
</tr>
<tr data-repeat='normalization.exclusions'>
<td><input type='number' data-field='from' size="5"></td>
<td><input type='number' data-field='to' size="5"></td>
</tr>
</table>
</td>
</tr>
<tr>
<th align="left">Nb points:</th>
<td>
<input type='number' name='normalization.numberOfPoints' size="6">
</td>
</tr>
</table>
<h1>Matrix processing</h1>
<table>
<tr>
<th align="left">Scaling (matrix columns):</th>
<td>
<table>
<tr>
<th></th><th></th>
<th>Name</th>
<th>Options</th>
</tr>
<tr data-repeat='postProcessing.filters'>
<td>
<select onchange="updateOptions(this);" data-field='name'>
<option value=""></option>
<option value="pqn">PQN</option>
<option value="centerMean">Center Mean</option>
<option value="rescale">Rescale (0 to 1)</option>
</select>
</td>
<td>
<input style="display:none" type='number' placeholder="min" data-field='options.min' size="5">
</td>
</tr>
</table>
</td>
</tr>
</table>
<script>
function updateOptions(source) {
let options=source.options[source.options.selectedIndex].getAttribute('data-options');
let show=options ? options.split(',') : [];
let optionsElement = $(source).parent().next();
optionsElement.find('input').hide();
optionsElement.find('textarea').hide();
for (let key of show) {
optionsElement.find('input[placeholder='+key+']').show();
optionsElement.find('textarea[placeholder='+key+']').show();
}
}
function resetFromTo() {
require(['src/util/api'], function(API) {
API.doAction('resetMinMax');
});
}
</script>
{% endif %}
`;
export const spectraDisplay = `
<h1>Spectra display preferences</h1>
<table>
<tr>
<th>Spectra:</th>
<td>
<input type='radio' name='display.selection' value='all'>All
<input type='radio' name='display.selection' value='selected'>Selected
<input type='radio' name='display.selection' value='none'>None
</td>
</tr>
{% if keepOriginal %}
<tr>
<th>Display:</th>
<td>
<input type='radio' name='display.original' value='true'> Original data
<input type='radio' name='display.original' value='false'> Normalized data
</td>
</tr>
{% else %}
<input type='hidden' name='display.original' value='false'>
{% endif %}
<tr>
<th>Box-plot shadow</th>
<td>
<input type="checkbox" name="display.boxplot" checked>
<span onclick="toggle(this);">▶</span>
<div style="display: none">
<b>Box plot preferences:</b><br>
Q2 stroke width: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.q2StrokeWidth"> - color: <input type="color" name="display.boxplotOptions.q2StrokeColor"><br>
Q1/Q3 fill opacity: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.q13FillOpacity"> - color: <input type="color" name="display.boxplotOptions.q13FillColor"><br>
min/max fill opacity: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.minMaxFillOpacity"> - color: <input type="color" name="display.boxplotOptions.minMaxFillColor"><br>
</div>
</td>
</tr>
<tr>
<th>
Display tracking info:
</th>
<td>
<input type="checkbox" name="display.trackingInfo">
</td>
</tr>
<tr>
<th>
Correlation point index:
</th>
<td>
<input type="number" name="display.correlationIndex">
</td>
</tr>
</table>
<script>
function toggle(element) {
let nextStyle=element.nextElementSibling.style
if (nextStyle.display==="none") {
nextStyle.display = "block";
element.innerHTML='▼';
} else {
nextStyle.display = "none";
element.innerHTML='▶';
}
}
</script>
`;
export const displayTwigPreferences = `
<style>
#displayPreferences select {
background-color: #DDD;
font-size: small;
}
</style>
<div id="displayPreferences">
Display:
<select name='display.selection'>
<option value="">None</option>
<option value="selected">Selected</option>
<option value="all">All</option>
</select>
{% if keepOriginal %}
—
<select name='display.original'>
<option value="true">Original</option>
<option value="false">Normalized</option>
</select>
{% else %}
<input type='hidden' name='display.original' value='false'>
{% endif %}
—
Box-plot:
<select name='display.boxplot'>
<option value="">None</option>
<option value="selected">Selected</option>
<option value="all">All</option>
</select>
<div style="display:none">
Q2 stroke width: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.q2StrokeWidth"> - color: <input type="color" name="display.boxplotOptions.q2StrokeColor"><br>
Q1/Q3 fill opacity: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.q13FillOpacity"> - color: <input type="color" name="display.boxplotOptions.q13FillColor"><br>
min/max fill opacity: <input type="number" step="any" style="width:50px" name="display.boxplotOptions.minMaxFillOpacity"> - color: <input type="color" name="display.boxplotOptions.minMaxFillColor"><br>
</div>
<label>
<input type="checkbox" name="display.trackingInfo">
Tracking info
</label>
— Correlation:
<select name='display.correlation'>
<option value="">None</option>
<option value="selected">Selected</option>
<option value="all">All</option>
</select>
<input type="hidden" name="display.correlationIndex" step="any" value="{{preferences.display.correlationIndex}}" style="width: 50px">
</div>
`;
export const tocOfflineTwig = `
{% if tocClicked %}
{%set data=tocClicked %}
{% endif %}
{% if tocHovered %}
{%set data=tocHovered %}
{% endif %}
{% if tocSample %}
{%set data=tocSample %}
{% endif %}
{%set value=data.value %}
<style>
#toc, #toc tbody {
font-size: 1em;
font-family: Arial, Helvetica, sans-serif;
}
#toc h1 {
font-size:1.5em;
text-align: left;
}
#toc h2 {
font-size:1.2em;
text-align: center;
}
#toc td, #toc th {
vertical-align: top;
text-align: left;
}
</style>
{% macro showProperties(object) %}
{% if object is iterable %}
<table>
{% for key, value in object %}
<tr>
<th>{{key}}</th>
<td>{{ _self.showProperties(value) }}</td>
</tr>
{% endfor %}
</table>
{% else %}
{% if object is same as (false) %}
<span style="color:red">✘</span>︎
{% elseif object is same as (true) %}
<span style="color:green">✔</span>
{% else %}
{{object}}
{% endif %}
{% endif %}
{% endmacro %}
{% import _self as macros %}
{% if value %}
<div id='toc'>
<h1>{{value.reference}}</h1>
<h2>{{value.title}}</h2>
<div class="molecule">
{{rendertype(value.ocl.value,{width:300, height:120, coordinates: value.ocl.coordinates},"oclID")}}
</div>
<table>
{% if value.misc %}
<tr>
<th>Meta information:</th>
<td>
{{ macros.showProperties(value.misc) }}
</td>
</tr>
{% endif %}
</table>
</div>
{% endif %}
`;
|
/**
* @overview JavaScript API (Data management) for Tenken Application
* @copyright Copyright 2014 FUJITSU LIMITED
*/
var TenkenData = {};
//============================================================================
// Common methods and valiables
//============================================================================
// Set force reload mode
TenkenData.setSuperReloadMode = function(_mode)
{
// Force reload mode
Tenken.config.SuperReload=_mode;
}
// Get force reload mode
TenkenData.getSuperReloadMode = function()
{
return(Tenken.config.SuperReload);
}
//============================================================================
// Scenario data management
//============================================================================
// Data management class (Scenario)
TenkenData.Scenario = {};
// Create TenkenARdata to receive data from AR server
TenkenData.Scenario.arScenario=new TenkenARdata(TenkenConst.TableName.scenario);
// Memory region to manage data (Scenario)
TenkenData.Scenario.ListAll = [];
// Current seleted scenario name
TenkenData.Scenario.ScenarioName = null;
// Process TenkenData obtained from the server and copy it.
TenkenData.Scenario.createDataList = function()
{
try
{
if ( null == TenkenData.Scenario.arScenario ) return;
var datas = TenkenData.Scenario.arScenario.getDataValue();
if ( null == datas ) return;
if ( null == TenkenData.Scenario.ListAll ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var dataValue = datas[i];
if ( null != dataValue )
{
var newObj=new Object();
// Check if it's target scenario
if ( dataValue.ar_description )
{
if ( -1 == dataValue.ar_description.indexOf("#tenken#") )
{
// Skip to next scenario since it's not the target
continue;
}
}
else
{
// Skip to next scenario as scenario without the description is not the target.
continue;
}
// Cope all data (per QAttribute)
for ( var name in dataValue )
{
switch ( name )
{
case "ar_name":
newObj.name=dataValue[name];
break
case "ar_description":
newObj.description=dataValue[name];
break
case "ar_id":
newObj.scenarioId=dataValue[name];
break
default:
newObj[name]=dataValue[name];
break;
}
}
TenkenData.Scenario.ListAll.push(newObj);
}
}
}
catch(e)
{
alert("Exception : TenkenData.Scenario.createDataList\n" + e);
}
}
// Success callback method upon data retrieval (Scenario)
TenkenData.Scenario.cbDataSuccessScenario = function(_result)
{
try
{
// Copy obtained data
TenkenData.Scenario.ListAll.length = 0;
TenkenData.Scenario.createDataList();
if ( TenkenData.Scenario.ListAll.length <= 0 )
{
TenkenData.AllGet.abortInvalidData(null, null, null, "Scenario is not registered, or the scenario does not exist.\nPlease register scenario for Tenken.", null);
return;
}
TenkenData.AllGet.saveStorageScenario();
// Call download completion callback method (if registered), and operator list of operator selection dialog when scenario data download is complete.
var elm = document.getElementById("selectScenarioId");
if ( null != TenkenData.AllGet.downloadScenarioSuccessFunc )
{
TenkenData.AllGet.downloadScenarioSuccessFunc();
}
}
catch (e)
{
alert("Exception : cbDataSuccessScenario\n" + e);
}
}
// Error callback method upon data retrieval (Scenario)
TenkenData.Scenario.cbDataErrorScenario = function(_result)
{
var message = "Failed to obtain data (scenario) from AR server. Please check operation mode and network connectivity to try again.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:Scenario:" + message , detail);
if ( null != TenkenData.AllGet.downloadScenarioErrorFunc )
{
// Clear callback so that it only calls once
var func=TenkenData.AllGet.downloadScenarioErrorFunc;
TenkenData.AllGet.downloadScenarioErrorFunc=null;
func(detail);
}
}
// Retrieve data from AR Server. (Scenario)
TenkenData.Scenario.getScenario = function()
{
try
{
if ( null == TenkenData.Scenario.arScenario )
{
TenkenData.Scenario.arScenario=new TenkenARdata(TenkenConst.TableName.scenario);
}
if ( TenkenData.Scenario.arScenario.getBusyStatus() == true )
{
alert("Communication in process.\nPlease retry again at later time.");
return;
}
// Set force reload mode.
TenkenData.Scenario.arScenario.setReload(TenkenData.getSuperReloadMode());
// Query param: none
// Initialize query parameter
TenkenData.Scenario.arScenario.clearWhere();
// Sort param: scenario ID
// Initialize sort parameter
TenkenData.Scenario.arScenario.clearSort();
// Set sort order
TenkenData.Scenario.arScenario.setSortDesc(false);
// Sort query: Scene ID
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.Scenario.arScenario.addSort("ar_id", null, "0", "9223372036854775000", "LONG");
// Retrieve data
TenkenData.Scenario.arScenario.getArData(TenkenData.Scenario.cbDataSuccessScenario, TenkenData.Scenario.cbDataErrorScenario);
}
catch (e)
{
alert("Exception: getScenario\n" + e);
}
}
// Save data to local storage (Scenario)
TenkenData.Scenario.saveStorage = function()
{
Tenken.Storage.ScenarioList.set(JSON.stringify(TenkenData.Scenario.ListAll));
if ( null != TenkenData.Scenario.ScenarioName )
{
Tenken.Storage.ScenarioName.set(JSON.stringify(TenkenData.Scenario.ScenarioName));
}
};
// Load data from loacl storage (Scenario)
TenkenData.Scenario.loadStorage = function()
{
var data=Tenken.Storage.ScenarioList.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.Scenario.ListAll=tmplist;
}
else
{
TenkenData.Scenario.ListAll.length=0;
}
tmplist = JSON.parse(Tenken.Storage.ScenarioName.get());
if ( null != tmplist )
{
TenkenData.Scenario.ScenarioName = tmplist;
}
else
{
TenkenData.Scenario.ScenarioName = null;
}
}
else
{
TenkenData.Scenario.ListAll.length=0;
TenkenData.Scenario.ScenarioName = null;
}
};
// Set current working scenario name
TenkenData.Scenario.setScenarioName = function(_nameScenario)
{
TenkenData.Scenario.ScenarioName=_nameScenario;
};
// Get current working scenario name
TenkenData.Scenario.getScenarioName = function()
{
return(TenkenData.Scenario.ScenarioName);
};
// Get Scenario name from Scenario ID
TenkenData.Scenario.getScenarioNameFromId = function(_id)
{
var nameScenario = null;
if ( !_id || _id <=0 )
{
// Return null since it's invalid scenario ID or everything is the target (=0)
return(null);
}
if ( null == TenkenData.Scenario.ListAll || 0 == TenkenData.Scenario.ListAll.length )
{
// If Scenario data is not present, load from local storage
TenkenData.Scenario.loadStorage();
}
if ( null == TenkenData.Scenario.ListAll || 0 == TenkenData.Scenario.ListAll.length )
{
// return null as there is no scenario data
return(null);
}
// Search from scenario list
var lenScenaio=TenkenData.Scenario.ListAll.length;
for ( var i=0 ; i < lenScenaio; i++ )
{
if ( _id == TenkenData.Scenario.ListAll[i].scenarioId )
{
nameScenario=TenkenData.Scenario.ListAll[i].name;
break;
}
}
return(nameScenario);
};
// Append downloaded scenario data as selection of the specified select tag element.
TenkenData.Scenario.selectScenarioNameHTML = function(_select)
{
if ( _select )
{
TenkenData.Scenario.loadStorage();
var lenScenario = TenkenData.Scenario.ListAll.length;
if ( 0 < lenScenario )
{
_select.length=(lenScenario + 1);
_select.options[0].text="Select";
for ( var i = 0 ; i < lenScenario ; i++ )
{
_select.options[i+1].text=TenkenData.Scenario.ListAll[i].name;
_select.options[i+1].value=TenkenData.Scenario.ListAll[i].scenarioId;
}
}
else
{
_select.length=2;
_select.options[0].text="Select";
_select.options[1].text="(Download)";
_select.options[0].value="";
_select.options[1].value="";
}
}
};
//============================================================================
// Data management of Scenes
//============================================================================
// Data management class (Scene)
TenkenData.Scene = {};
// Create TenkenARdata to send and receive data from AR Server
TenkenData.Scene.arScene=new TenkenARdata(TenkenConst.TableName.scene);
// Data management region (Scene)
TenkenData.Scene.ListAll = [];
// To store downloaded scene name list
TenkenData.Scene.SceneNames = null;
// Process and copy retrieved TenkenData
TenkenData.Scene.createDataList = function()
{
try
{
if ( null == TenkenData.Scene.arScene ) return;
var datas = TenkenData.Scene.arScene.getDataValue();
if ( null == datas ) return;
if ( null == TenkenData.Scene.ListAll ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var dataValue = datas[i];
if ( null != dataValue )
{
var newObj=new Object();
// Copy entire data (per Qttribute)
for ( var name in dataValue )
{
switch ( name )
{
case "ar_name":
newObj.name=dataValue[name];
break
case "ar_description":
newObj.description=dataValue[name];
break
case "ar_id":
newObj.sceneid=dataValue[name];
break
default:
newObj[name]=dataValue[name];
break;
}
}
if ( null == TenkenData.Scene.SceneNames )
{
TenkenData.Scene.SceneNames = new Object();
}
// Save scene name
TenkenData.Scene.SceneNames[newObj.sceneid]=newObj.name;
// Determine to display messages and asset names.
// If following string is specified in the message (ar_description)
// we need to display them. (case-sensitive)
//
// #MSG# : messages
// #TENKEN# : display asset names
//
if ( newObj.description )
{
if ( 0 <= newObj.description.indexOf("#MSG#") )
{
newObj.dispMSG=true;
}
if ( 0 <= newObj.description.indexOf("#TENKEN#") )
{
newObj.dispASSET=true;
}
}
TenkenData.Scene.ListAll.push(newObj);
}
}
}
catch(e)
{
alert("Exception : TenkenData.Scene.createDataList \n" + e);
}
}
// Success callback method upon data retrieval
TenkenData.Scene.cbDataSuccessScene = function(_result)
{
try
{
// copy data retrieved
TenkenData.Scene.ListAll.length=0;
TenkenData.Scene.createDataList();
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload();
}
}
catch (e)
{
alert("Exception : TenkenData.Scene.cbDataSuccessScene\n" + e);
}
}
// Error callback handler upon data retrieval. (Scene)
TenkenData.Scene.cbDataErrorScene = function(_result)
{
var message = "Failed to download data (Scene) from AR server. Please check operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:Scene:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Get data from AR server (Scene)
TenkenData.Scene.getScene = function()
{
try
{
if ( null == TenkenData.Scene.arScene )
{
TenkenData.Scene.arScene=new TenkenARdata(TenkenConst.TableName.scene);
}
if ( TenkenData.Scene.arScene.getBusyStatus() == true )
{
alert("Communication in progress.\nPlease retry at later time.");
return;
}
// Set force reload
TenkenData.Scene.arScene.setReload(TenkenData.getSuperReloadMode());
// Query param:
// Initialize query param
TenkenData.Scene.arScene.clearWhere();
// Query 1: Set selected scenario ID
TenkenData.Scene.arScene.addWhere("arscn_scenarioid", null, Tenken.config.ScenarioId, null, "LONG");
// Sort param:
TenkenData.Scene.arScene.clearSort();
// Set sort order
TenkenData.Scene.arScene.setSortDesc(false);
// Sort query: Scene ID
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.Scene.arScene.addSort("ar_id", null, "0", "9223372036854775000", "LONG");
// Retrieve data
TenkenData.Scene.arScene.getArData(TenkenData.Scene.cbDataSuccessScene, TenkenData.Scene.cbDataErrorScene);
}
catch (e)
{
alert("Exception: TenkenData.Scene.getScene\n" + e);
}
}
// Store data to local storage (scene)
TenkenData.Scene.saveStorage = function()
{
Tenken.Storage.SceneList.set(JSON.stringify(TenkenData.Scene.ListAll));
if ( null !=TenkenData.Scene.SceneNames )
{
Tenken.Storage.SceneNames.set(JSON.stringify(TenkenData.Scene.SceneNames));
}
};
// Load data from local storage (scene)
TenkenData.Scene.loadStorage = function()
{
var data=Tenken.Storage.SceneList.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.Scene.ListAll = tmplist;
}
else
{
TenkenData.Scene.ListAll.length = 0;
}
tmplist = JSON.parse(Tenken.Storage.SceneNames.get());
if ( null != tmplist )
{
TenkenData.Scene.SceneNames = tmplist;
}
else
{
TenkenData.Scene.SceneNames = null;
}
}
else
{
TenkenData.Scene.ListAll.length = 0;
TenkenData.Scene.SceneNames = null;
}
};
// Get scene name
TenkenData.Scene.getSceneName = function(_sceneid)
{
if ( null != TenkenData.Scene.SceneNames && null != TenkenData.Scene.SceneNames[_sceneid] )
{
return(TenkenData.Scene.SceneNames[_sceneid]);
}
return null;
};
//============================================================================
// Manage AR overlay data
//============================================================================
// Class to manage data (AR overlay data)
TenkenData.SuperimposedGraphic = {};
// Create TenkenARdata to send/receive data from AR server
TenkenData.SuperimposedGraphic.arSuperimposedGraphic=new TenkenARdata(TenkenConst.TableName.SuperimposedGraphic);
;
// Data management region for AR overlay data. Use with object type.
TenkenData.SuperimposedGraphic.objSuperimposedGraphics=null;
// To store selected scenario ID, scene ID, and marker ID
TenkenData.SuperimposedGraphic.setSecenarioId = -1;
TenkenData.SuperimposedGraphic.setSceneId = -1;
TenkenData.SuperimposedGraphic.setMarkerId = -1;
// Process and copy downloaded TenkenData
TenkenData.SuperimposedGraphic.createDataList = function()
{
try {
if ( null == TenkenData.SuperimposedGraphic.arSuperimposedGraphic ) return;
var contents=null;
var datas = TenkenData.SuperimposedGraphic.arSuperimposedGraphic.getDataValue();
if ( null == datas ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var sd=datas[i];
if ( null != sd )
{
// Check that AR overlay data of scene ID, marker ID is not null
var value=new Object();
if(sd.arsen_sceneid != null && sd.armk_markerid != null)
{
if ( null == contents ) contents = new Object();
var sceneId=sd.arsen_sceneid;
var markerId=sd.armk_markerid
var value=new Object();
// Transform JSON representation of AR overlay data definition to an object
if ( null != sd.arpoi_superimposedgraphic )
{
value = AR.Renderer.parseSuperimposedGraphic(sd.arpoi_superimposedgraphic);
}
if( null == contents[sceneId]) contents[sceneId] = new Object();
if( null == contents[sceneId][markerId])
{
contents[sceneId][markerId] = new Array(value);
}
else
{
contents[sceneId][markerId].push(value);
}
}
}
}
// Store processed AR overlay data into per scene ID and marker ID
if ( null != contents )
{
for(scene in contents)
{
if( null == TenkenData.SuperimposedGraphic.objSuperimposedGraphics ) TenkenData.SuperimposedGraphic.objSuperimposedGraphics = new Object();
if(TenkenData.SuperimposedGraphic.objSuperimposedGraphics[scene] == null)
{
TenkenData.SuperimposedGraphic.objSuperimposedGraphics[scene] = contents[scene];
}
else
{
for(marker in contents[scene])
{
TenkenData.SuperimposedGraphic.objSuperimposedGraphics[scene][marker] = contents[scene][marker];
}
}
}
}
}
catch(e)
{
alert("Exception : TenkenData.SuperimposedGraphic.createDataList\n" + e);
}
}
// Success callback method upon data retrieval (AR overlay data)
TenkenData.SuperimposedGraphic.cbDataSuccessSuperimposedGraphic = function(_result)
{
try
{
// Copy retrieved data
TenkenData.SuperimposedGraphic.objSuperimposedGraphics=null;
TenkenData.SuperimposedGraphic.createDataList();
}
catch (e)
{
alert("Exception : TenkenData.SuperimposedGraphic.cbDataSuccessSuperimposedGraphic\n" + e);
}
}
// Error callback method upon data retrieval (AR overlay data)
TenkenData.SuperimposedGraphic.cbDataErrorSuperimposedGraphic = function(_result)
{
var message = "Failed to download data (AR overlay data) from AR server. Please check operation mode and network connectivity to try again.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:SuperimposedGraphic:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Retrieve data from AR server (AR Overlay data)
TenkenData.SuperimposedGraphic.getSuperimposedGraphic = function(_scenarioId, _sceneId, _markerId)
{
try
{
if ( null == TenkenData.SuperimposedGraphic.arSuperimposedGraphic )
{
TenkenData.SuperimposedGraphic.arSuperimposedGraphic=new TenkenARdata(TenkenConst.TableName.SuperimposedGraphic);
}
if ( TenkenData.SuperimposedGraphic.arSuperimposedGraphic.getBusyStatus() == true )
{
alert("Communication in progress.\nPlease try again at later time.");
return;
}
// Set force reload mode.
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.setReload(TenkenData.getSuperReloadMode());
// Query parameter:
// Initialize query
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.clearWhere();
// Query 1: scenario ID
if ( null != _scenarioId )
{
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.addWhere("arscn_scenarioid", null, _scenarioId, null, "LONG");
}
// Query 2: scene ID
if ( null != _sceneId )
{
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.addWhere("arsen_sceneid", null, _sceneId, null, "LONG");
}
// Query 3: marker ID
if ( null != _markerId )
{
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.addWhere("armk_markerid", null, _markerId, null, "LONG");
}
// Sort paramenter: none
// Initialize sort parameter
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.clearSort();
// Set sort older to ascending
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.setSortDesc(false);
// Retrieve data
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.getArData(
TenkenData.SuperimposedGraphic.cbDataSuccessSuperimposedGraphic,
TenkenData.SuperimposedGraphic.cbDataErrorSuperimposedGraphic);
}
catch (e)
{
alert("Exception: TenkenData.SuperimposedGraphic.getSuperimposedGraphic\n" + e);
}
}
// Store data to local storage (AR Overlay data)
TenkenData.SuperimposedGraphic.saveStorage = function()
{
if(TenkenData.SuperimposedGraphic.objSuperimposedGraphics != null)
{
Tenken.Storage.SuperimposedGraphic.set(JSON.stringify(TenkenData.SuperimposedGraphic.objSuperimposedGraphics));
}
};
// Load data from local storage (AR Overlay data)
TenkenData.SuperimposedGraphic.loadStorage = function()
{
var data=Tenken.Storage.SuperimposedGraphic.get();
if ( null != data )
{
TenkenData.SuperimposedGraphic.objSuperimposedGraphics = AR.Renderer.parseSuperimposedGraphic(data);
}
else
{
TenkenData.SuperimposedGraphic.objSuperimposedGraphics=null;
}
};
//============================================================================
// Data management to each assets
//============================================================================
// Data managemet class (asset data)
TenkenData.Asset = {};
// Create TenkenARdata to send/receive data from server
TenkenData.Asset.arAsset=new TenkenARdata(TenkenConst.TableName.asset);
// Data management region (asset data)
TenkenData.Asset.ListAll = [];
// Process and copy downloaded TenkenData
TenkenData.Asset.createDataList = function()
{
try
{
if ( null == TenkenData.Asset.arAsset ) return;
var datas = TenkenData.Asset.arAsset.getDataValue();
if ( null == datas ) return;
if ( null == TenkenData.Asset.ListAll ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var dataValue = datas[i];
if ( null != dataValue )
{
var newObj=new Object();
// Copy entire data (per QAttribute)
for ( var name in dataValue )
{
switch ( name )
{
case "msgICON":
// additional message icon information
// (format: "icon name;icon image file")
if ( null != dataValue[name] )
{
var iconInfo = dataValue[name].split(";");
if ( null == newObj.msgICON ) newObj.msgICON = new Array();
newObj.msgICON.push(iconInfo);
}
break
case "tenkenICON":
// check input icon information
// (format: "icon name;icon image file")
if ( null != dataValue[name] )
{
var iconInfo = dataValue[name].split(";");
if ( null == newObj.tenkenICON ) newObj.tenkenICON = new Array();
newObj.tenkenICON.push(iconInfo);
}
break
case "graphURL":
// Check graph icon information
// (format: "icon name;graph URL")
if ( null != dataValue[name] )
{
var iconInfo = dataValue[name].split(";");
if ( null == newObj.graphURL ) newObj.graphURL = new Array();
newObj.graphURL.push(iconInfo);
}
break
default:
// Additional icon information
// (format: "icon name;icon image file;file name to open when tapped")
if ( null != dataValue[name] && name.substr(0,4) == "icon" )
{
var iconInfo = dataValue[name].split(";");
if ( null == newObj.listICON ) newObj.listICON = new Array();
newObj.listICON.push(iconInfo);
}
else
{
newObj[name]=dataValue[name];
}
break;
}
}
// Check duplicate and mandatory data
TenkenData.Asset.checkData(newObj);
// Add new
TenkenData.Asset.ListAll.push(newObj);
}
}
}
catch(e)
{
alert("Exception : TenkenData.Asset.createDataList\n" + e);
}
}
// Success callback method upon data retrieval (Asset data)
TenkenData.Asset.cbDataSuccessAsset = function(_result)
{
try
{
// Copy retrieved data
TenkenData.Asset.ListAll.length=0;
TenkenData.Asset.createDataList();
if ( TenkenData.Asset.ListAll.length <= 0 )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.asset, null, null, null, "None of valid asset data is registered.\nPlease register asset data.\n", null);
return;
}
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload();
}
}
catch (e)
{
alert("Exception : TenkenData.Asset.cbDataSuccessAsset\n" + e);
}
}
// Error callback method upon data retrieval (Asset data)
TenkenData.Asset.cbDataErrorAsset = function(_result)
{
var message = "Failed to download data (Asset list) from AR server. Please check operation mode and network connectivity to try again.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:Asset:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Retrieve data from AR Server (Asset data)
TenkenData.Asset.getLastData = function()
{
try
{
if ( null == TenkenData.Asset.arAsset )
{
TenkenData.Asset.arAsset=new TenkenARdata(TenkenConst.TableName.asset);
}
if ( TenkenData.Asset.arAsset.getBusyStatus() == true )
{
alert("Communication in progress.\nPlease try again at later time.");
return;
}
// Set force reload mode
TenkenData.Asset.arAsset.setReload(TenkenData.getSuperReloadMode());
// Query parameter:none
// Initialize query parameter
TenkenData.Asset.arAsset.clearWhere();
// Sort parameter:
// Initialize sort parameter
TenkenData.Asset.arAsset.clearSort();
// Set sort order to ascdending
TenkenData.Asset.arAsset.setSortDesc(false);
// Sort query: marker ID
// Marker ID of 0 do not exist in AR, but is specified here to use marker ID of 0 as an asset that do not use markers
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.Asset.arAsset.addSort("markerid", null, "0", "9223372036854775000", "LONG")
// Retrieve data
TenkenData.Asset.arAsset.getArData(TenkenData.Asset.cbDataSuccessAsset, TenkenData.Asset.cbDataErrorAsset);
}
catch (e)
{
alert("Exception: TenkenData.Asset.getAsset\n" + e);
}
}
// Check mandatory and duplicate data of received data.
// If there is an issue in data, output data error and return to initial screen.
//
// Check item
// QAttribute name : Check item
// assetid : null duplicate
// assetname : null duplicate
// markerid : null duplicate
// markername : null duplicate
TenkenData.Asset.checkData = function(_data)
{
try
{
var err=false;
var errName=null;
var errValue=null;
var errMsg=null;
if ( null == _data ) return;
// Check null (value is mandatory)
if ( null == _data.assetid )
{
err=true;
errName="assetid";
}
else if ( null == _data.assetname )
{
err=true;
errName="assetname";
}
else if ( null == _data.markerid )
{
err=true;
errName="markerid";
}
else if ( null == _data.markername )
{
err=true;
errName="markername";
}
if ( true == err )
{
errMsg="Mandatory data is missing.";
}
else
{
// Check duplicate
var len=TenkenData.Asset.ListAll.length;
for ( var i = 0 ; i < len ; i++ )
{
var ad=TenkenData.Asset.ListAll[i];
if ( _data.assetid == ad.assetid )
{
err=true;
errName="assetid";
errValue=_data.assetid;
}
else if ( _data.assetname == ad.assetname )
{
err=true;
errName="assetname";
errValue=_data.assetname;
}
else if ( _data.markerid == ad.markerid )
{
err=true;
errName="markerid";
errValue=_data.markerid;
}
else if ( _data.markername == ad.markername )
{
err=true;
errName="markername";
errValue=_data.markername;
}
}
if ( true == err )
{
errMsg="Duplicate data found.";
}
}
// If error exist in data, output message and return to the initial screen.
if ( true == err )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.asset, errName, errValue, null, errMsg);
}
}
catch (e)
{
alert("Exception: TenkenData.Asset.checkData\n" + e);
}
}
// Storage data into local storage (Asset data)
TenkenData.Asset.saveStorage = function()
{
Tenken.Storage.lastAssetData.set(JSON.stringify(TenkenData.Asset.ListAll));
};
// Load data from local storage (Asset data)
TenkenData.Asset.loadStorage = function()
{
var data=Tenken.Storage.lastAssetData.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.Asset.ListAll = tmplist;
}
else
{
TenkenData.Asset.ListAll.length = 0;
}
}
else
{
TenkenData.Asset.ListAll.length = 0;
}
};
// Get asset data (object type) from matching asset ID
TenkenData.Asset.getDatafromAssetId = function(_assetid)
{
if ( null == _assetid || "" == _assetid )
{
return(null);
}
var qvalue=null;
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
if ( _assetid == TenkenData.Asset.ListAll[i].assetid )
{
qvalue = TenkenData.Asset.ListAll[i];
break;
}
}
return(qvalue);
}
// Get marker ID of the matching asset ID
TenkenData.Asset.getMarkerIdfromAssetId = function(_assetid)
{
if ( null == _assetid || "" == _assetid )
{
return(null);
}
var markerid=-1;
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
if ( _assetid == TenkenData.Asset.ListAll[i].assetid )
{
markerid = TenkenData.Asset.ListAll[i].markerid;
break;
}
}
return(markerid);
}
// Get asset name from the matching marker ID
TenkenData.Asset.getAssetNamefromMarkerId = function(_markerid)
{
if ( 0 >= TenkenData.Asset.ListAll.length )
{
return(-1);
}
var assetname = "";
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
if ( _markerid == TenkenData.Asset.ListAll[i].markerid )
{
assetname = TenkenData.Asset.ListAll[i].assetname;
break;
}
}
return(assetname);
}
// Get Asset data (object type) of the matching marker ID
TenkenData.Asset.getDatafromMarkerId = function(_markerid)
{
var qvalue=null;
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
if ( _markerid == TenkenData.Asset.ListAll[i].markerid )
{
qvalue = TenkenData.Asset.ListAll[i];
break;
}
}
return(qvalue);
}
// Get entire asset data (object type) array of the matching marker ID
TenkenData.Asset.getDataListfromMarkerId = function(_markerid)
{
var ret = [];
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
if ( _markerid == TenkenData.Asset.ListAll[i].markerid )
{
ret.push(TenkenData.Asset.ListAll[i]);
}
}
return(ret);
}
// Delete data of specified asset ID
TenkenData.Asset.deleteAsset = function(_assetid)
{
// Search asset id from the bottom, and delete.
var lenList = TenkenData.Asset.ListAll.length;
for ( i = (lenList - 1) ; i >= 0 ; i-- )
{
if (_assetid == TenkenData.Asset.ListAll[i].assetid )
{
TenkenData.Asset.ListAll.splice(i,1);
}
}
}
//============================================================================
// Data management for message data
//============================================================================
// Data management class (Message data)
TenkenData.MsgEvent = {};
// Create TenkenARdata for send/retrieve data from the server (for current and previous values)
TenkenData.MsgEvent.arMessageEventLast=new TenkenARdata(TenkenConst.TableName.messageevent);
TenkenData.MsgEvent.arMessageEventCurrent=new TenkenARdata(TenkenConst.TableName.messageevent);
// Data management region (Message Data). For current and previous values
TenkenData.MsgEvent.Last = [];
TenkenData.MsgEvent.Current = [];
// Process and copy downloaded TenkenData
TenkenData.MsgEvent.createDataList = function()
{
// Message data will not be transformed, and copied as-is.
// Although, add process that will move display coordinate to (X,Y,Z)
// per marker ID, so that it will not overlap with message context on the display
try
{
if ( null == TenkenData.MsgEvent.arMessageEventLast || null == TenkenData.MsgEvent.Last ) return;
var datas = TenkenData.MsgEvent.arMessageEventLast.getDataValue();
if ( null == datas ) return;
var countList=datas.length;
var markerid=-1;
var MsgList = new Object();
var saveIndex=0;
for ( var i=0 ; i < countList ; i++ )
{
markerid=-1;
var dataValue = datas[i];
if ( null != dataValue )
{
var newObj=new Object();
// Copy entire data (per QAttribute)
for ( var name in dataValue )
{
newObj[name]=dataValue[name];
if ( "markerid" == name )
{
markerid=dataValue[name];
}
}
if ( -1 != markerid )
{
if ( null == MsgList[markerid] ) MsgList[markerid]= new Array();
;
// Store sort order as automated message display logic per marker will change the order
newObj.saveIndex=saveIndex++;
MsgList[markerid].push(newObj);
}
}
}
// Register data.
// Also, automatically change the display coordinate of messages per markers.
// (Display as-is only if data is at X=Y=Z=0)
var sX = window.screen.width;
var sY = window.screen.height;
sizeX = sX / 5120;
sizeY = sY / 3200;
if ( sizeX < 0.2 || sizeX > 1.0 ) sizeX = 0.5;
if ( sizeY < 0.2 || sizeY > 1.0 ) sizeY = 0.5;
sizeZ = sizeX;
// Fix X=0.7, and change each Y by -0.2 starting from 0.7 per Marker ID
var LX=0.7;
var LY=0.6;
var LZ=0.0;
var L_STEP = - 0.2; // fixed
var index=0;
for ( var markerid in MsgList )
{
var data=MsgList[markerid];
var lenMsgData=data.length;
LZ=0.0;
index=0;
for ( var i=0 ; i < lenMsgData ; i++ )
{
if ( markerid == data[i].markerid )
{
if ( (null == data[i].x || 0 == data[i].x ) &&
(null == data[i].y || 0 == data[i].y ) &&
(null == data[i].z || 0 == data[i].z ) )
{
data[i].x=LX;
data[i].y=Math.round((LY + (L_STEP * index++)) * 1000) / 1000;
data[i].z=LZ;
}
}
TenkenData.MsgEvent.Last[data[i].saveIndex]=data[i];
}
}
}
catch(e)
{
alert("Exception : TenkenData.MsgEvent.createDataList\n" + e);
}
}
// Success callback method upon data retrieval (message data)
TenkenData.MsgEvent.cbDataSuccessMessageEvent = function(_result)
{
try
{
// Copy data
TenkenData.MsgEvent.Last.length=0;
TenkenData.MsgEvent.createDataList();
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload();
}
}
catch (e)
{
alert("Exception : cbDataSuccessMessageEvent\n" + e);
}
}
// Error callback method upon data retrieval (message data)
TenkenData.MsgEvent.cbDataErrorMessageEvent = function(_result)
{
var message = "Failed to download data (Messages) from AR server. Please check the operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:messageevent:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Get data from AR server. (Message data)
TenkenData.MsgEvent.getLastData = function()
{
try
{
if ( null == TenkenData.MsgEvent.arMessageEventLast )
{
TenkenData.MsgEvent.arMessageEventLast=new TenkenARdata(TenkenConst.TableName.messageevent);
}
if ( TenkenData.MsgEvent.arMessageEventLast.getBusyStatus() == true )
{
alert("Communication in progress.\nPlease try again at later time.");
return;
}
// Set force reload mode
TenkenData.MsgEvent.arMessageEventLast.setReload(TenkenData.getSuperReloadMode());
// Query parameter: none
// Initialize query parameter
TenkenData.MsgEvent.arMessageEventLast.clearWhere();
// Query 1: OR query of selected scenario ID and 0
// Marker ID=0 means that it's shared asset that do not use markers
TenkenData.MsgEvent.arMessageEventLast.addWhere("ScenarioId", null, [0, Tenken.config.ScenarioId], null, "LONG");
// Query 2: Messages that has Enabled=true.
// (true=valid, and message that has not yet been marked as reporting complete)
TenkenData.MsgEvent.arMessageEventLast.addWhere("Enable", null, "true", null, "STRING");
// Sort paramenter:
// Initialize sort parameter
TenkenData.MsgEvent.arMessageEventLast.clearSort();
// Set sort order as ascending
TenkenData.MsgEvent.arMessageEventLast.setSortDesc(true);
// Sort parameter 1: Sort by checked datetime
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.MsgEvent.arMessageEventLast.addSort("occurrencetime", null, "0", "9223372036854775000", "LONG");
// Retrieve data
TenkenData.MsgEvent.arMessageEventLast.getArData(TenkenData.MsgEvent.cbDataSuccessMessageEvent, TenkenData.MsgEvent.cbDataErrorMessageEvent);
}
catch (e)
{
alert("Exception: getMessageEvent\n" + e);
}
}
// Save to local storage (Message data)
TenkenData.MsgEvent.saveStorage = function()
{
Tenken.Storage.currentMessageEventData.set(JSON.stringify(TenkenData.MsgEvent.Current));
Tenken.Storage.lastMessageEventData.set(JSON.stringify(TenkenData.MsgEvent.Last));
};
// Load from local storage (Message data)
TenkenData.MsgEvent.loadStorage = function()
{
var data=Tenken.Storage.lastMessageEventData.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.MsgEvent.Last = tmplist;
}
else
{
TenkenData.MsgEvent.Last.length = 0;
}
tmplist = JSON.parse(Tenken.Storage.currentMessageEventData.get());
if ( null != tmplist )
{
TenkenData.MsgEvent.Current = tmplist;
}
else
{
TenkenData.MsgEvent.Current.length = 0;
}
}
else
{
TenkenData.MsgEvent.Last.length = 0;
TenkenData.MsgEvent.Current.length = 0;
}
};
// Clear current messages
TenkenData.MsgEvent.clearCurrentMsgEvent = function()
{
TenkenData.MsgEvent.Current.length = 0;
Tenken.Storage.currentMessageEventData.remove();
}
// Get current and previous message data (Object type) in array that matches with the marker ID
TenkenData.MsgEvent.getMsgEventListFromMarkerId = function(_markerid)
{
// Have current and downloaded message data as the target
var targetList = [];
if ( 0 < TenkenData.MsgEvent.Current.length )
{
targetList.push(TenkenData.MsgEvent.Current);
}
if ( 0 < TenkenData.MsgEvent.Last.length )
{
targetList.push(TenkenData.MsgEvent.Last);
}
var msgeventlist = [];
for ( var i= 0 ; i < targetList.length ; i++ )
{
var lists = targetList[i];
if ( null != lists )
{
for ( var j = 0 ; j < lists.length ; j++ )
{
if ( -1 == _markerid ||
_markerid == lists[j].markerid )
{
msgeventlist.push(lists[j]);
}
}
}
}
return(msgeventlist);
}
// Get current and previous message data (Object type) in array that matches with the asset ID
TenkenData.MsgEvent.getMsgEventListFromAssetId = function(_assetid)
{
// Have current and downloaded message data as the target
var targetList = [];
if ( 0 < TenkenData.MsgEvent.Current.length )
{
targetList.push(TenkenData.MsgEvent.Current);
}
if ( 0 < TenkenData.MsgEvent.Last.length )
{
targetList.push(TenkenData.MsgEvent.Last);
}
var msgeventlist = [];
for ( var i= 0 ; i < targetList.length ; i++ )
{
var lists = targetList[i];
if ( null != lists )
{
for ( var j = 0 ; j < lists.length ; j++ )
{
if ( _assetid == lists[j].targetassetid )
{
msgeventlist.push(lists[j]);
}
}
}
}
return(msgeventlist);
}
// Get current and previous message data (Object type) in array that matches with msgid and occurrencetime
// msgid should be unique id. the method will only return the first one found.
TenkenData.MsgEvent.getMsgEventFromMsgIdTime = function(_msgid,_occurrencetime)
{
// Have current and downloaded message data as the target
var targetList = [];
if ( 0 < TenkenData.MsgEvent.Current.length )
{
targetList.push(TenkenData.MsgEvent.Current);
}
if ( 0 < TenkenData.MsgEvent.Last.length )
{
targetList.push(TenkenData.MsgEvent.Last);
}
var msgevent = null;
for ( i = 0 ; null == msgevent && i < targetList.length ; i++ )
{
var lists = targetList[i];
for ( var j = 0 ; j < lists.length ; j++ )
{
if ( -1 == _msgid ||
(_msgid == lists[j].msgid &&
_occurrencetime == lists[j].occurrencetime))
{
msgevent = lists[j];
break;
}
}
}
return(msgevent);
}
// Get Message data of msgid (Current data)
TenkenData.MsgEvent.getMsgEventFromMsgIdCurrent = function(_msgid)
{
var msgevent = null;
var lenList = TenkenData.MsgEvent.Current.length;
for ( i = 0 ; i < lenList ; i++ )
{
if (_msgid == TenkenData.MsgEvent.Current[i].msgid )
{
msgevent=TenkenData.MsgEvent.Current[i];
break;
}
}
return(msgevent);
}
// Get Message data of msgid (Previous data)
TenkenData.MsgEvent.getMsgEventFromMsgIdLast = function(_msgid)
{
var msgevent = null;
var lenList = TenkenData.MsgEvent.Last.length;
for ( i = 0 ; i < lenList ; i++ )
{
if (_msgid == TenkenData.MsgEvent.Last[i].msgid )
{
msgevent=TenkenData.MsgEvent.Last[i];
break;
}
}
return(msgevent);
}
// Delete Message data of msgid (Current data)
TenkenData.MsgEvent.deleteMsgEventCurrent = function(_msgid)
{
// delete from back (Current)
var lenList = TenkenData.MsgEvent.Current.length;
for ( i = (lenList - 1) ; i >= 0 ; i-- )
{
if (_msgid == TenkenData.MsgEvent.Current[i].msgid )
{
TenkenData.MsgEvent.Current.splice(i,1);
}
}
}
// Delete Message data that are other than Enabled="true" (Only previous)
TenkenData.MsgEvent.deleteMsgEventDisable = function()
{
// Search from back and delete.
var lenList = TenkenData.MsgEvent.Last.length;
for ( i = (lenList - 1) ; i >= 0 ; i-- )
{
if ("true" != TenkenData.MsgEvent.Last[i].Enable )
{
TenkenData.MsgEvent.Last.splice(i,1);
}
}
}
// Add new message data (current)
TenkenData.MsgEvent.addCurrentMsgEvent = function(_msg)
{
try {
var MsgEvent=new Object();
MsgEvent.version = _msg.version;
MsgEvent.qentityId = _msg.qentityId;
MsgEvent.msgid = _msg.msgid;
MsgEvent.msgname = _msg.msgname;
MsgEvent.description = _msg.description;
MsgEvent.registrationtime = _msg.registrationtime;
if ( null != _msg.registrationtime ) MsgEvent.regDatetimeStr = new Tenken.DatetimeValue(_msg.registrationtime).toStringFullTime();
MsgEvent.registrant = _msg.registrant;
MsgEvent.markerid = _msg.markerid;
MsgEvent.markername = _msg.markername;
MsgEvent.x = _msg.x;
MsgEvent.y = _msg.y;
MsgEvent.z = _msg.z;
MsgEvent.targetassetid = _msg.targetassetid;
MsgEvent.title = _msg.title;
MsgEvent.level = _msg.level;
MsgEvent.value = _msg.value;
MsgEvent.occurrencetime = _msg.occurrencetime;
if ( null != _msg.occurrencetime ) MsgEvent.occDatetimeStr = new Tenken.DatetimeValue(_msg.occurrencetime).toStringFullTime();
MsgEvent.operator = _msg.operator;
MsgEvent.ScenarioId = _msg.ScenarioId;
if ( null != _msg.Enable ) MsgEvent.Enable = _msg.Enable;
if ( null != _msg.Answer ) MsgEvent.Answer = _msg.Answer;
// add
TenkenData.MsgEvent.Current.push(MsgEvent);
return(MsgEvent);
}
catch (e)
{
alert("Exception : TenkenData.MsgEvent.addCurrentMsgEvent\n" + e);
}
}
// Switch from Current to Last (Previous) of Message data
TenkenData.MsgEvent.moveCurrentDataToLastData = function()
{
// Move entire current messages to last (previous) list
for ( var i=TenkenData.MsgEvent.Current.length - 1 ; 0 <= i ; i-- )
{
if ( null != TenkenData.MsgEvent.Current[i] )
{
// add from top
TenkenData.MsgEvent.Last.unshift(TenkenData.MsgEvent.Current[i]);
}
}
// Clear current messages
TenkenData.MsgEvent.clearCurrentMsgEvent();
// Store moved messages to local storage
TenkenData.MsgEvent.saveStorage();
}
//============================================================================
// Checklist data management
//============================================================================
// Only the latest value of each checklist item per asset (latest one record) will be downloaded as previous data.
// The current checklist data will be used from the data stored in local storage. This makes that current value do not have any data right after download.
// As checklist need to obtain data per assets, we're not using TenkenARData, but retrieving data directly from AR server.
// Data management class (Checklist result)
TenkenData.TenkenEvent = {};
// Create TenkenARdata to send/retrieve from server
TenkenData.TenkenEvent.arTenkenEventCurrent=new TenkenARdata(TenkenConst.TableName.tenkenevent);
// Data management region (checklist result data). For current and previous data
TenkenData.TenkenEvent.Last = [];
TenkenData.TenkenEvent.Current = [];
// Flag to store if data retrieval is in progress
TenkenData.TenkenEvent.getphase = false;
// Interval timer ID of data retrieval
TenkenData.TenkenEvent.IntervalTenkenEventId = null;
// Total data count of retrieval data
TenkenData.TenkenEvent.downloadCount = 0;
// Maximum data count of retrieval data
TenkenData.TenkenEvent.downloadMaxCount = 0;
// Next retrival data count to retrieve data
TenkenData.TenkenEvent.NextCnt = 0;
// Interval timer used when retrieving checklist data
TenkenData.TenkenEvent.IntervalGetTenkenEvent = function()
{
try
{
if ( TenkenData.TenkenEvent.downloadCount >= TenkenData.TenkenEvent.downloadMaxCount )
{
// End as processed finished
TenkenData.TenkenEvent.stopIntervalGetTenkenEvent();
// Finish when all data is read.
TenkenData.TenkenEvent.getphase=false;
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload2();
}
return;
}
if ( TenkenData.TenkenEvent.NextCnt <= TenkenData.TenkenEvent.downloadCount )
{
// Finished downloading to the next count. Proceed with next download.
var startCnt = TenkenData.TenkenEvent.NextCnt;
if ( ( TenkenData.TenkenEvent.downloadMaxCount - TenkenData.TenkenEvent.NextCnt ) < Tenken.config.DownloadStep )
{
TenkenData.TenkenEvent.NextCnt = TenkenData.TenkenEvent.downloadMaxCount;
}
else
{
TenkenData.TenkenEvent.NextCnt += Tenken.config.DownloadStep;
}
// Retrieve data only for checklist items that are defined.
var targetList=TenkenData.TenkenTable.getTenkenTargetList();
var strLog= "download=" + TenkenData.TenkenEvent.downloadCount
+ ",start=" + startCnt
+ ",next=" + TenkenData.TenkenEvent.NextCnt
+ ",max=" + TenkenData.TenkenEvent.downloadMaxCount;
Tenken.Util.logdebug("GET NEXT DATA:TenkenEvent:" + strLog);
for ( var i=startCnt ; i < TenkenData.TenkenEvent.NextCnt ; i++ )
{
var target=targetList[i];
//Create query object
var query = new TenkenARvalue.QuadQuery();
query.type = "RECORDSANDCOUNT";
// Max limit to query (obtain only the latest of each data)
query.limitRange = new TenkenARvalue.Range(1);
query.qattributeOrderIndexRange = new TenkenARvalue.Range(1,100);
// Set qtype of retistered operator data
query.qtypeNameRanges = new Array(new TenkenARvalue.Range(TenkenConst.TableName.tenkenevent));
query.whereExpressions = new Array();
// Query parameter:
// Query 1: OR query of selected scenario ID and 0
// marker ID=0 is for shared assets that do not use markers
var cond = new Array();
cond.push(new TenkenARvalue.Range(0))
cond.push(new TenkenARvalue.Range(Tenken.config.ScenarioId));
query.whereExpressions.push(new TenkenARvalue.QuadQueryExpression(new TenkenARvalue.Range("ScenarioId"), cond, "LONG"));
// Query 1: Asset ID (assetid)
if( null != target.assetid )
{
query.whereExpressions.push(new TenkenARvalue.QuadQueryExpression(new TenkenARvalue.Range("targetassetid"), new TenkenARvalue.Range(target.assetid), "STRING"));
}
// Query 3: Check type (type)
if( null != target.type )
{
query.whereExpressions.push(new TenkenARvalue.QuadQueryExpression(new TenkenARvalue.Range("type"), new TenkenARvalue.Range(target.type), "STRING"));
}
// If we're going to skip assets that is in stopped state.
if ( true == Tenken.config.skipStopLastData )
{
// Query 4: Initial State(assetstatus)=START
// Set assetstatus="START"
// Check value do not exist for assets that are in Stopped state. Get the last check value that was in start state.
query.whereExpressions.push(new TenkenARvalue.QuadQueryExpression(new TenkenARvalue.Range("assetstatus"), new TenkenARvalue.Range("START"), "STRING"));
}
// Sort parameter:
// Sort 1: Registered Date and time (registrationtime)
// Obtain a single latest record by sorting with registration date desc.
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
query.sortOrderExpressions = new Array(new TenkenARvalue.QuadQueryExpression(new TenkenARvalue.Range("registrationtime"), new TenkenARvalue.Range(0,9223372036854775000), "LONG", true));
// Transform to string
var getQuery = TenkenARvalue.makeQuadQuery(query);
Tenken.Util.logdebug("GET_DATA_REQUEST:TenkenEvent:" + i);
// Set force reload mode
var mode=TenkenData.getSuperReloadMode();
// Retrieve check result data from AR server.
AR.Data.getArServerData(
getQuery,
mode,
TenkenData.TenkenEvent.getDataSuccess,
TenkenData.TenkenEvent.getDataError
);
}
}
}
catch (e)
{
Tenken.Util.logerr(e);
alert("Exception : TenkenData.TenkenEvent.IntervalGetTenkenEvent\n" + e);
}
return;
}
// Start interval timer to retrieve check results
TenkenData.TenkenEvent.setIntervalGetTenkenEvent = function()
{
if ( null == TenkenData.TenkenEvent.IntervalTenkenEventId )
{
TenkenData.TenkenEvent.IntervalTenkenEventId = setInterval('TenkenData.TenkenEvent.IntervalGetTenkenEvent()', Tenken.config.getIntervalTime);
}
}
// Stop interval timer to retrieve check results
TenkenData.TenkenEvent.stopIntervalGetTenkenEvent = function()
{
if ( null != TenkenData.TenkenEvent.IntervalTenkenEventId )
{
clearInterval(TenkenData.TenkenEvent.IntervalTenkenEventId);
TenkenData.TenkenEvent.IntervalTenkenEventId = null;
}
}
// Retrieve data from AR server (Check result data)
TenkenData.TenkenEvent.getLastData = function()
{
try
{
if ( true == TenkenData.TenkenEvent.getphase )
{
return;
}
// Retrieve only the number defined in checklist table
var targetList=TenkenData.TenkenTable.getTenkenTargetList();
if ( null == targetList || 0 >= targetList.length )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, null, null, null, "Has not retrieved check result table to get check result data.\nEither data is not defined, or retrieval has failed.", null);
return;
}
TenkenData.TenkenEvent.getphase=true;
TenkenData.TenkenEvent.Last.length=0;
TenkenData.TenkenEvent.Current.length=0;
Tenken.Util.loginfo("GET_COUNT:TenkenEvent:" + targetList.length);
TenkenData.TenkenEvent.NextCnt = 0;
TenkenData.TenkenEvent.downloadCount = 0;
TenkenData.TenkenEvent.downloadMaxCount =targetList.length;
// Set the timer and retrieve in the method.
TenkenData.TenkenEvent.setIntervalGetTenkenEvent();
} catch(e){
Tenken.Util.logerr(e);
}
};
// Success callback mothod upon data retrieval (check result data)
TenkenData.TenkenEvent.getDataSuccess = function(_result)
{
Tenken.Util.loginfo("GET_DATA_RESPONSE:SUCCESS:TenkenEvent:" + TenkenData.TenkenEvent.downloadCount);
if ( null != _result.getValue() )
{
// Get necessary data and store into TenkenData.TenkenEvent.Last
TenkenData.TenkenEvent.extractData(_result.getValue());
}
};
// Get check result data from received JSON object
TenkenData.TenkenEvent.extractData = function(_data)
{
try {
if ( null == _data ) return;
// Record count received
var recordCount = _data.records.length;
TenkenData.TenkenEvent.downloadCount++;
Tenken.Util.logdebug("downloadCount:TenkenEvent:" + TenkenData.TenkenEvent.downloadCount + " , " + recordCount);
for(var recordIndex = 0; recordIndex < recordCount; recordIndex++)
{
// Search records one by one
var record = _data.records[recordIndex];
var valueLength = record.qvalues.length;
var value =new Object();
value.version = record.version;
value.qentityId = record.id;
// Retrieve only the number specified in qvalue. Define by attributeName
for(var valueIndex = 0; valueIndex < valueLength; valueIndex++)
{
var qvalue = record.qvalues[valueIndex];
if ( null != qvalue.stringValue )
{
value[qvalue.qattributeName] = qvalue.stringValue;
}
else if ( null != qvalue.floatValue )
{
value[qvalue.qattributeName] = qvalue.floatValue;
}
else if ( null != qvalue.longValue )
{
value[qvalue.qattributeName] = qvalue.longValue;
}
}
// Add new (Previous value)
TenkenData.TenkenEvent.Last.push(value);
}
}
catch (e)
{
alert("Exception : TenkenData.TenkenEvent.extractData\n" + e);
}
};
// Error callback method upon data retrieval (Check result data)
TenkenData.TenkenEvent.getDataError = function(_result)
{
var message = "Failed to retrieve data (Check result) from AR server. Please check the operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
// Clear the timer
TenkenData.TenkenEvent.stopIntervalGetTenkenEvent();
TenkenData.TenkenEvent.getphase=false;
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:TenkenEvent:" + message + ":" + detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
};
// Get if the data retrieval is in progress
TenkenData.TenkenEvent.isGetPhase = function()
{
return(TenkenData.TenkenEvent.getphase);
}
// Clear check result data (Only the Current)
TenkenData.TenkenEvent.clearCurrentTenkenEvent = function()
{
TenkenData.TenkenEvent.Current.length = 0;
Tenken.Storage.currentTenkenEventData.remove();
}
// Intialize check result data that matches the marker ID (Current only)
TenkenData.TenkenEvent.resetCurrentTenkenEventTable = function(_markerid)
{
// Make current and downloaded check result data as the target.
for ( var i = 0 ; i < TenkenData.TenkenEvent.Current.length ; i++ )
{
var tenkendata=TenkenData.TenkenEvent.Current[i];
if ( _markerid == tenkendata.markerid )
{
// Initialize
// Use as-is for the asset data those are not modified.
// (description,type,markerid,markername,targetassetid,assetstatus)
tenkendata.tenkenid=null;
tenkendata.tenkenname=null;
tenkendata.registrationtime=null;
tenkendata.registrant=null;
tenkendata.occurrencetime=null;
tenkendata.operator=null;
tenkendata.F01=null;
tenkendata.F02=null;
tenkendata.F03=null;
tenkendata.F04=null;
tenkendata.F05=null;
tenkendata.S01=null;
tenkendata.S02=null;
tenkendata.S03=null;
tenkendata.S04=null;
tenkendata.S05=null;
}
}
return;
}
// Retrieve check result data (Object type) that matches with specified assetid, TenkenType, and DataEntryName
TenkenData.TenkenEvent.getData = function(_targetList, _targetassetid, _tenkentype, _dataentryname)
{
var tenken = null;
for ( i = 0 ; i < _targetList.length ; i++ )
{
var lists = _targetList[i];
if ( null == lists ) continue;
for ( var j = 0 ; j < lists.length ; j++ )
{
var tmptenken = lists[j];
if ( tmptenken.type == _tenkentype &&
(null == _targetassetid ||
"" == _targetassetid ||
tmptenken.targetassetid == _targetassetid) &&
( null == _dataentryname || tmptenken[_dataentryname] != null) )
{
if ( null == tenken || (tmptenken.occurrencetime > tenken.occurrencetime))
{
tenken = tmptenken;
}
}
}
}
return tenken;
}
// Process and copy downloaded TenkenData
TenkenData.TenkenEvent.createData = function(_targetList, _update, _tenken)
{
try
{
var newData=true;
for ( i = 0 ; i < _targetList.length ; i++ )
{
var tmptenken = _targetList[i];
if ( null == tmptenken ) continue;
if ( tmptenken.type == _tenken.type &&
tmptenken.targetassetid == _tenken.targetassetid &&
true == _update )
{
var value=tmptenken;
newData=false;
}
}
if ( true == newData )
{
var value =new Object();
}
value.version=_tenken.version;
value.qentityId =_tenken.qentityId;
value.tenkenid=_tenken.tenkenid;
value.tenkenname=_tenken.tenkenname;
value.description=_tenken.description;
value.type=_tenken.type;
value.registrationtime=_tenken.registrationtime;
if ( null != value.registrationtime )
{
value.regDatetimeStr = new Tenken.DatetimeValue(value.registrationtime).toStringFullTime();
}
value.registrant=_tenken.registrant;
value.markerid=_tenken.markerid;
value.markername=_tenken.markername;
value.targetassetid=_tenken.targetassetid;
value.assetstatus=_tenken.assetstatus;
value.occurrencetime=_tenken.occurrencetime;
if ( null != value.occurrencetime )
{
value.occDatetimeStr = new Tenken.DatetimeValue(value.occurrencetime).toStringFullTime();
}
value.operator=_tenken.operator;
value.ScenarioId=_tenken.ScenarioId;
if ( true == newData )
{
_targetList.push(value);
}
}
catch (e)
{
alert("Exception : TenkenData.TenkenEvent.createData\n" + e);
}
return(value);
}
// Store to local storage (check result data)
TenkenData.TenkenEvent.saveStorage = function()
{
if ( 0 < TenkenData.TenkenEvent.Last.length )
{
Tenken.Storage.lastTenkenEventData.set(JSON.stringify(TenkenData.TenkenEvent.Last));
}
if ( 0 < TenkenData.TenkenEvent.Current.length )
{
Tenken.Storage.currentTenkenEventData.set(JSON.stringify(TenkenData.TenkenEvent.Current));
}
};
// Load from local storage (check result data)
TenkenData.TenkenEvent.loadStorage = function()
{
var data=Tenken.Storage.lastTenkenEventData.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.TenkenEvent.Last = tmplist;
}
else
{
TenkenData.TenkenEvent.Last.length = 0;
}
tmplist = JSON.parse(Tenken.Storage.currentTenkenEventData.get());
if ( null != tmplist )
{
TenkenData.TenkenEvent.Current = tmplist;
}
else
{
TenkenData.TenkenEvent.Current.length = 0;
}
}
else
{
TenkenData.TenkenEvent.Last.length = 0;
TenkenData.TenkenEvent.Current.length = 0;
}
};
// Copy entire current check results to previous values
TenkenData.TenkenEvent.copyCurrentDataFromLastData = function()
{
var rowFunc = function(_table, _group, _row, _poi2, _valueEntryName, _value, _assetstatus)
{
// Automatically set previous check results to current values.
// Do not set if SetLastData is null, or value except true is set, or POI is not set.
if ( null == _row.SetLastData ||
"true" !=_row.SetLastData.toLowerCase() ||
null == _poi2 ) return;
// Set or register Current POI2 value
var tmpPOI2=TenkenData.TenkenEvent.getData(TenkenData.TenkenEvent.Current, _row.AssetId, _row.TenkenType, null);
if ( tmpPOI2 )
{
currentPoi2=tmpPOI2;
}
else
{
// Register new
var value =new Object();
value.version=_poi2.version;
value.qentityId=_poi2.qentityId;
value.tenkenid=_poi2.tenkenid;
value.tenkenname=_poi2.tenkenname;
value.Description=_poi2.Description;
value.type=_poi2.type;
value.registrationtime=null;
value.registrant=null;
value.markerid=_poi2.markerid;
value.markername=_poi2.markername;
value.targetassetid=_poi2.targetassetid;
value.assetstatus=_poi2.assetstatus;
value.occurrencetime=null;
value.operator=null;
value.ScenarioId=_poi2.ScenarioId;
var currentPoi2=TenkenData.TenkenEvent.createData(
TenkenData.TenkenEvent.Current, true, value);
}
if ( currentPoi2 ) currentPoi2[_valueEntryName] = _poi2[_valueEntryName];
}
TenkenData.TenkenTable.foreachTables(TenkenData.TenkenEvent.Last, null, null, rowFunc);
}
// Initialize check result that includeds specified tableid
TenkenData.TenkenEvent.resetCurrentTenkenEventTableTableId = function(_tabledid)
{
// 1. Create assetid list that matches TenkenTable.TableId and _tableid
var listAssetId=new Object();
var rowFunc = function(_table, _group, _row, _poi2, _valueEntryName, _value, _assetstatus)
{
if ( _table && _row && _tabledid == _table.TableId)
{
listAssetId[_row.AssetId] = _row.AssetId;
}
}
TenkenData.TenkenTable.foreachTables(null, null, null, rowFunc);
// 2. Create markerid list that matches asset.assetid from assetid list
var listMarkerIds=new Object();
var markerid=-1;
for ( var assetid in listAssetId )
{
markerid=TenkenData.Asset.getMarkerIdfromAssetId(assetid);
if ( 0 <= markerid )
{
listMarkerIds[markerid]=markerid;
}
}
// 3. Initialize current check results with markerid list.
for ( var markerid in listMarkerIds )
{
TenkenData.TenkenEvent.resetCurrentTenkenEventTable(markerid);
}
}
//============================================================================
// Data managenet for operators
//============================================================================
// Data Management class (operator data)
TenkenData.UserData = {};
// Create TenkenARdata to send/receive data from AR server.
TenkenData.UserData.arUserData=new TenkenARdata(TenkenConst.TableName.userdata);
// Data management region (operator data)
TenkenData.UserData.ListAll = [];
// Process and copy downloaded TenkenData.
TenkenData.UserData.createDataList = function()
{
try
{
if ( null == TenkenData.UserData.arUserData ) return;
var datas = TenkenData.UserData.arUserData.getDataValue();
if ( null == datas ) return;
if ( null == TenkenData.UserData.ListAll ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var dataValue = datas[i];
if ( null != dataValue )
{
var newObj=new Object();
if ( null != dataValue )
{
// Copy entire data (per QAttribute)
for ( var name in dataValue )
{
newObj[name]=dataValue[name];
}
// Check mandatory and duplicate data
TenkenData.UserData.checkData(newObj);
// Add new
TenkenData.UserData.ListAll.push(newObj);
}
}
}
}
catch(e)
{
alert("Exception : TenkenData.UserData.createDataList \n" + e);
}
}
// Success callback handler upon data retrieval (operator data)
TenkenData.UserData.cbDataSuccessUserData = function(_result)
{
try
{
// Copy retrieved data
TenkenData.UserData.ListAll.length=0;
TenkenData.UserData.createDataList();
if ( TenkenData.UserData.ListAll.length <= 0 )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.userdata, null, null, null, "有効な作業者データが登録されていません。\n作業者データを登録してください。", null);
return;
}
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload();
}
}
catch (e)
{
alert("Exception : TenkenData.UserData.cbDataSuccessUserData\n" + e);
}
}
// Error callback handler upon data retrieval (operator data)
TenkenData.UserData.cbDataErrorUserData = function(_result)
{
var message = "Failed to obtain data (operator list) from AR server. Please check the operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:UserData:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Retrieve data from AR server. (operator data)
TenkenData.UserData.getData = function()
{
try
{
if ( null == TenkenData.UserData.arUserData )
{
TenkenData.UserData.arUserData=new TenkenARdata(TenkenConst.TableName.userdata);
}
if ( TenkenData.UserData.arUserData.getBusyStatus() == true )
{
alert("Communication in progress.\nPlease retry at later time.");
return;
}
// Set force reload mode.
TenkenData.UserData.arUserData.setReload(TenkenData.getSuperReloadMode());
// Query parameter:
// Initialize query parameter
TenkenData.UserData.arUserData.clearWhere();
// Query 1: OR query of selected scenario ID and 0
// Marker ID=0 is for shared assets that do not use markers
TenkenData.UserData.arUserData.addWhere("ScenarioId", null, [0, Tenken.config.ScenarioId], null, "LONG");
// Set query 2
// Sort parameter：
// Initialize sort parameter
TenkenData.UserData.arUserData.clearSort();
// Set sort order as ascending
TenkenData.UserData.arUserData.setSortDesc(false);
// Sort 1: Sort index (SortIndex)
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.UserData.arUserData.addSort("SortIndex", null, "0", "9223372036854775000", "LONG");
// Retrieve data
TenkenData.UserData.arUserData.getArData(TenkenData.UserData.cbDataSuccessUserData, TenkenData.UserData.cbDataErrorUserData);
}
catch (e)
{
alert("Exception: TenkenData.UserData.getUserData\n" + e);
}
}
// Check mandatory and duplicate data of received data.
// If there is an issue in data, output data error and return to initial screen.
//
// Check items
// QAttribute name : Check items
// userid : null duplicate
// username : null duplicate
// ScenarioId : null
TenkenData.UserData.checkData = function(_data)
{
try
{
var err=false;
var errName=null;
var errValue=null;
var errMsg=null;
if ( null == _data ) return;
// check null
if ( null == _data.userid )
{
err=true;
errName="userid";
}
else if ( null == _data.username )
{
err=true;
errName="username";
}
else if ( null == _data.ScenarioId )
{
err=true;
errName="ScenarioId";
}
if ( true == err )
{
errMsg="Mandatory data is not set.";
}
else
{
// Check duplicate
var len=TenkenData.UserData.ListAll.length;
for ( var i = 0 ; i < len ; i++ )
{
var ud=TenkenData.UserData.ListAll[i];
if ( _data.userid == ud.userid )
{
err=true;
errName="userid";
errValue=_data.userid;
}
else if ( _data.username == ud.username )
{
err=true;
errName="username";
errValue=_data.username;
}
}
if ( true == err )
{
errMsg="Duplicate data exists.";
}
}
// If there is an issue in data, output error and move to initial screen.
if ( true == err )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.userdata, errName, errValue, null, errMsg);
}
}
catch (e)
{
alert("Exception: TenkenData.UserData.checkData\n" + e);
}
}
// Store data to local storage (operator data)
TenkenData.UserData.saveStorage = function()
{
Tenken.Storage.UserData.set(JSON.stringify(TenkenData.UserData.ListAll));
};
// Load data from local storage (operator data)
TenkenData.UserData.loadStorage = function()
{
var data=Tenken.Storage.UserData.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.UserData.ListAll = tmplist;
}
else
{
TenkenData.UserData.ListAll.length = 0;
}
}
else
{
TenkenData.UserData.ListAll.length = 0;
}
};
// Construct downloaded operator list to HTML's select tag using option tag.
TenkenData.UserData.getUserNameHTML = function()
{
TenkenData.UserData.loadStorage();
var str = '';
for ( var i = 0 ; i < TenkenData.UserData.ListAll.length ; i++ )
{
str += '<option value="' + TenkenData.UserData.ListAll[i].username + '">' + TenkenData.UserData.ListAll[i].username;
}
if ( 0 >= TenkenData.UserData.ListAll.length )
{
str += '<option value="">(Please download)'
}
return str;
};
// Add downloaded operator data as select tag of specified Element
TenkenData.UserData.selectUserNameHTML = function(_select)
{
if ( _select )
{
TenkenData.UserData.loadStorage();
if ( 0 < TenkenData.UserData.ListAll.length )
{
_select.length=(TenkenData.UserData.ListAll.length + 1);
_select.options[0].text="Select";
for ( var i = 0 ; i < TenkenData.UserData.ListAll.length ; i++ )
{
_select.options[i+1].text=TenkenData.UserData.ListAll[i].username;
_select.options[i+1].value=TenkenData.UserData.ListAll[i].username;
}
}
else
{
_select.length=2;
_select.options[0].text="Select";
_select.options[1].text="(Download)";
_select.options[0].value="";
_select.options[1].value="";
}
}
};
//============================================================================
// Data management of checklist table
//============================================================================
// Data management class (checklist data)
TenkenData.TenkenTable = {};
// Create TenkenARdata to send/receive from AR server.
TenkenData.TenkenTable.arTenkenTable=new TenkenARdata(TenkenConst.TableName.tenkentable);
// Data management region (Checklist data)
TenkenData.TenkenTable.ListTables = [];
// Success callback handler upon data retrieval (Checklist data)
TenkenData.TenkenTable.cbDataSuccessTenkenTable = function(_result)
{
try
{
// Copy retrieved data
TenkenData.TenkenTable.ListTables.length = 0;
TenkenData.TenkenTable.createDataList();
if ( TenkenData.TenkenTable.ListTables.length <= 0 )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, null, null, null, "有効な点検項目データが登録されていません。\n点検項目データを登録してください。", null);
return;
}
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownload();
}
}
catch (e)
{
alert("Exception : cbDataSuccessTenkenTable\n" + e);
}
}
// Error callback handler upon data retrieval (Checklist data)
TenkenData.TenkenTable.cbDataErrorTenkenTable = function(_result)
{
var message = "Failed to download data (Checklist) from AR server. Please check operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION")
{
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else
{
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("GET_DATA_RESPONSE:ERROR:tenkentable:" + message , detail);
if ( TenkenData.AllGet.getPhase() == false )
{
TenkenData.AllGet.afterDownloadError(detail);
}
}
// Retrieve data from AR server (Checklist data)
TenkenData.TenkenTable.getData = function()
{
try
{
if ( null == TenkenData.TenkenTable.arTenkenTable )
{
TenkenData.TenkenTable.arTenkenTable=new TenkenARdata(TenkenConst.TableName.tenkentable);
}
if ( TenkenData.TenkenTable.arTenkenTable.getBusyStatus() == true )
{
alert("通信中です。\nしばらく時間をおいてから再度実行してください。");
return;
}
// Set force reload mode.
TenkenData.TenkenTable.arTenkenTable.setReload(TenkenData.getSuperReloadMode());
// Query paremeter:
// Initialize query parameter
TenkenData.TenkenTable.arTenkenTable.clearWhere();
// Query 1: OR query of selected scenario ID and 0
// Marker ID=0 is shared assets that do not use markers
TenkenData.TenkenTable.arTenkenTable.addWhere("ScenarioId", null, [0, Tenken.config.ScenarioId], null, "LONG");
// Sort parameter
// Initialize sort parameter
TenkenData.TenkenTable.arTenkenTable.clearSort();
// Set sort order as ascending
TenkenData.TenkenTable.arTenkenTable.setSortDesc(false);
// Sort 1: Index value of sort table.
// JavaScript will round max long value of 9223372036854775807 to 9223372036854776000 that
// will cause an error, hence hard coding 9223372036854776000 here.
TenkenData.TenkenTable.arTenkenTable.addSort("SortIndexOfTable", null, "0", "9223372036854775000", "LONG");
// Sort 2: Group index value of sort table
TenkenData.TenkenTable.arTenkenTable.addSort("SortIndexOfRowGroup", null, "0", "9223372036854775000", "LONG");
// Sort 3: Row index value of sort table
TenkenData.TenkenTable.arTenkenTable.addSort("SortIndexOfRow", null, "0", "9223372036854775000", "LONG");
// Retrieve data
TenkenData.TenkenTable.arTenkenTable.getArData(
TenkenData.TenkenTable.cbDataSuccessTenkenTable,
TenkenData.TenkenTable.cbDataErrorTenkenTable);
}
catch (e)
{
alert("Exception: TenkenData.TenkenTable.getData\n" + e);
}
}
// Retrieve Checklist data (Object type) that matches with selected table ID
TenkenData.TenkenTable.getTable = function(_tableid)
{
try {
if ( null == _tableid)
{
return(null);
}
for ( var i = 0 ; i < TenkenData.TenkenTable.ListTables.length ; i++ )
{
var table=TenkenData.TenkenTable.ListTables[i];
if ( _tableid == table.TableId )
{
return(table);
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getTable\n" + e);
}
}
// Retrieve Checklist data (Object type) that matches with select table ID and group ID.
TenkenData.TenkenTable.getRowGroup = function(_tableid, _rowgroupid)
{
try{
if ( null == _tableid )
{
return(null);
}
for ( var i = 0 ; i < TenkenData.TenkenTable.ListTables.length ; i++ )
{
var table=TenkenData.TenkenTable.ListTables[i];
if ( _tableid == table.TableId )
{
for ( var j = 0 ; j < table.listRowGroups.length ; j++ )
{
var rowgroup=table.listRowGroups[j];
if ( _rowgroupid == rowgroup.RowGroupId )
{
return(rowgroup);
}
}
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getRowGroup\n" + e);
}
}
// Retrieve Checklist data that matches with all the table ID, group ID, and Row ID.
TenkenData.TenkenTable.getRow = function(_tableid, _rowgroupid, _rowid)
{
try {
if ( null == _tableid || null == _rowid )
{
return(null);
}
for ( var i = 0 ; i < TenkenData.TenkenTable.ListTables.length ; i++ )
{
var table=TenkenData.TenkenTable.ListTables[i];
if ( _tableid == table.TableId )
{
if ( null != _rowgroupid )
{
// Search from RowGroup if RowGroup value is specified.
for ( var j = 0 ; j < table.listRowGroups.length ; j++ )
{
var rowgroup=table.listRowGroups[j];
if ( _rowgroupid == rowgroup.RowGroupId )
{
for ( var k = 0 ; k < rowgroup.listRows.length ; k++ )
{
var row=trowgroup.listRows[k];
if ( _rowid == row.RowId )
{
return(row);
}
}
}
}
}
else
{
// Search from Table if RowGroup is not specified.
for ( var j = 0 ; j < table.listRowsTable.length ; j++ )
{
var row=table.listRowsTable[j];
if ( _rowid == row.RowId )
{
return(row);
}
}
}
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getRow\n" + e);
}
}
// Retrieve group data (an array) of Checklist data that matches with group id of the specified table list (an array)
TenkenData.TenkenTable.getRowGroupFromTable = function(_table, _rowgroupid)
{
try {
if ( null == _table || null == _rowgroupid )
{
return(null);
}
for ( var i = 0 ; i < _table.listRowGroups.length ; i++ )
{
var rowgroup=_table.listRowGroups[i];
if ( _rowgroupid == rowgroup.RowGroupId )
{
return(rowgroup);
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getRowGroupFromTable\n" + e);
}
}
// Retrieve Checklist row (Object type) data that matches with the RowId of specified group list (an array)
TenkenData.TenkenTable.getRowFromRowGroup = function(_rowgroup, _rowid)
{
try {
if ( null == _rowgroup || null == _rowid )
{
return(null);
}
for ( var i = 0 ; i < _rowgroup.listRows.length ; i++ )
{
var row=_rowgroup.listRows[i];
if ( _rowid == row.RowId )
{
return(row);
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getRowFromRowGroup\n" + e);
}
}
// Retrieve checklist row data (Object type) that matches with RowId of specified table list (an array)
TenkenData.TenkenTable.getRowFromTable = function(_table, _rowid)
{
try {
if ( null == _table || null == _rowid )
{
return(null);
}
for ( var i = 0 ; i < _table.listRowsTable.length ; i++ )
{
var row=_table.listRowsTable[i];
if ( _rowid == row.RowId )
{
return(row);
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getRowFromTable\n" + e);
}
}
// Retrieve checlist row data (Object type) that matches with the specified RowId
TenkenData.TenkenTable.getRowFromRowId = function(_rowid)
{
try {
if ( null == _rowid )
{
return(null);
}
for ( var i=0 ; i < TenkenData.TenkenTable.ListTables.length ; i++ )
{
var table=TenkenData.TenkenTable.ListTables[i];
// Group is set. Search from Group
if ( null != table.listRowGroups && 0 < table.listRowGroups.length )
{
// Group is set.
for ( var j=0 ; j < table.listRowGroups.length ; j++ )
{
var group=table.listRowGroups[j];
// Display checklist (Row)
for ( var k=0 ; k < group.listRows.length ; k++ )
{
var row=group.listRows[k];
if ( _rowid == row.RowId ) return(row);
}
}
}
// Search from items that Group is not set.
for ( var k=0 ; k < table.listRowsTable.length ; k++ )
{
var row=table.listRowsTable[k];
if ( _rowid == row.RowId ) return(row);
}
}
return(null);
}
catch (e)
{
alert("Exception : TenkenData.getRowFromRowId\n" + e);
}
}
// Retrieve table id that includes asset id.
// Search per Row as there could be multiple AssetId in a single TableId
TenkenData.TenkenTable.getTableIdFromAssetId = function(_assetid)
{
var tableid=null;
var rowFunc = function(_table, _group, _row, _poi2, _valueEntryName, _value, _assetstatus)
{
// Return immediately if tableid is already found.
if ( null != tableid ) return;
if ( _row )
{
if ( _assetid == _row.AssetId )
{
tableid=_table.TableId;
}
}
}
TenkenData.TenkenTable.foreachTables(TenkenData.TenkenEvent.Last, null, null, rowFunc);
return tableid;
}
// Save data to local storage (Checklist data)
TenkenData.TenkenTable.saveStorage = function()
{
Tenken.Storage.TenkenTable.set(JSON.stringify(TenkenData.TenkenTable.ListTables));
};
// Load data from local storage (Checklist data)
TenkenData.TenkenTable.loadStorage = function()
{
var data=Tenken.Storage.TenkenTable.get();
if ( null != data )
{
var tmplist = JSON.parse(data);
if ( null != tmplist )
{
TenkenData.TenkenTable.ListTables = tmplist;
}
else
{
TenkenData.TenkenTable.ListTables.length = 0;
}
}
else
{
TenkenData.TenkenTable.ListTables.length = 0;
}
};
// foreach method to call elements (table, group, checklist item) per checklist data array.
TenkenData.TenkenTable.foreachTables = function(_targetlist, _tableFunc, _rowGroupFunc, _rowFunc)
{
try
{
var lenTable=TenkenData.TenkenTable.ListTables.length;
for(var i = 0; i < lenTable ; i++)
{
var table = TenkenData.TenkenTable.ListTables[i];
if(null != _tableFunc ) _tableFunc(true, table);
if ( null != table.listRowGroups )
{
// If there is a group
var lenRowGroups=table.listRowGroups.length;
for(var j = 0; j < lenRowGroups; j++)
{
var rowGroup = table.listRowGroups[j];
if(null != _rowGroupFunc ) _rowGroupFunc(true, table, rowGroup);
var lenRows=rowGroup.listRows.length;
for(var k = 0; k < lenRows; k++)
{
var row = rowGroup.listRows[k];
if(null != _rowFunc)
{
// TenkenData.TenkenEvent.Current
// TenkenData.TenkenEvent.Last
var poi2 = null;
if ( null != _targetlist )
{
poi2 = TenkenData.TenkenEvent.getData([_targetlist], row.AssetId, row.TenkenType, /*row.DataEntryName*/ null);
}
var value = ( null == poi2 ) ? null : poi2[row.DataEntryName];
var assetstatus = ( null == poi2 ) ? null : poi2.assetstatus;
_rowFunc( table,
rowGroup,
row,
poi2,
row.DataEntryName,
value,
assetstatus);
}
}
if(null != _rowGroupFunc) _rowGroupFunc(false, table, rowGroup);
}
}
if ( null != table.listRowsTable )
{
// If there isn't a group
var lenRowsTable=table.listRowsTable.length;
for(var k = 0; k < lenRowsTable ; k++)
{
var row = table.listRowsTable[k];
if(null != _rowFunc)
{
var poi2 = null;
if ( null != _targetlist )
{
poi2 = TenkenData.TenkenEvent.getData([_targetlist], row.AssetId, row.TenkenType, /*row.DataEntryName*/ null);
}
var value = ( null == poi2 ) ? null : poi2[row.DataEntryName];
var assetstatus = ( null == poi2 ) ? null : poi2.assetstatus;
_rowFunc( table,
null,
row,
poi2,
row.DataEntryName,
value,
assetstatus);
}
}
}
if(null != _tableFunc) _tableFunc(false, table);
}
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.foreachTables\n" + e);
}
};
// Create check target asset list and table name to use when retrieving check results
TenkenData.TenkenTable.getTenkenTargetList = function()
{
try
{
var tenkenTargetlist = [];
for(var i = 0; i < TenkenData.TenkenTable.ListTables.length; i++)
{
var table = TenkenData.TenkenTable.ListTables[i];
if ( null != table.listRowGroups )
{
// When there is a group
for(var j = 0; j < table.listRowGroups.length; j++)
{
var rowGroup = table.listRowGroups[j];
for(var k = 0; k < rowGroup.listRows.length; k++)
{
var row = rowGroup.listRows[k];
var value = new Object();
value.table=table.TableId;
value.type=row.TenkenType;
value.assetid=row.AssetId;
var found=0;
for(var l = 0; l < tenkenTargetlist.length; l++)
{
var setvalue=tenkenTargetlist[l];
if (setvalue.table == table.TableId &&
setvalue.type == row.TenkenType &&
setvalue.assetid == row.AssetId )
{
found=1;
break;
}
}
if ( 0 == found )
{
tenkenTargetlist.push(value);
}
}
}
}
if ( null != table.listRowsTable )
{
// When there is no group
for(var k = 0; k < table.listRowsTable.length; k++)
{
var row = table.listRowsTable[k];
var value = new Object();
value.table=table.TableId;
value.type=row.TenkenType;
value.assetid=row.AssetId;
var found=0;
for(var l = 0; l < tenkenTargetlist.length; l++)
{
var setvalue=tenkenTargetlist[l];
if (setvalue.table == table.TableId &&
setvalue.type == row.TenkenType &&
setvalue.assetid == row.AssetId )
{
found=1;
break;
}
}
if ( 0 == found )
{
tenkenTargetlist.push(value);
}
}
}
}
}
catch (e)
{
alert("Exception : TenkenData.TenkenTable.getTenkenTargetList\n" + e);
}
return(tenkenTargetlist);
};
// Process and copy selected checklist (Object type) of TenkenData
TenkenData.TenkenTable.createListTenkenTable = function(_value)
{
try {
var tmptable=TenkenData.TenkenTable.getTable(_value.TableId);
if ( null == tmptable )
{
// Create new
var table=new Object();
table.listRowGroups=[];
// Create Row list directly under Table if RowGroup is null.
// We'll create unconditionally here.
table.listRowsTable=[];
table.TableId=_value.TableId;
table.TableName=_value.TableName;
table.SortIndexOfTable=_value.SortIndexOfTable;
table.AssetStatusStoppable=_value.AssetStatusStoppable;
table.ScenarioId=_value.ScenarioId;
TenkenData.TenkenTable.ListTables.push(table);
}
else
{
// Use existing table (Use initial value not overwriting the value)
// If we need to cross check with existing, add here.
var table=tmptable;
}
// Create RowGroup list
if ( null != table && _value.RowGroupId )
{
var tmpgroup=TenkenData.TenkenTable.getRowGroupFromTable(table, _value.RowGroupId);
if ( null == tmpgroup )
{
var rowgroup=new Object();
rowgroup.listRows=[];
rowgroup.RowGroupId=_value.RowGroupId;
rowgroup.RowGroupName=_value.RowGroupName;
rowgroup.SortIndexOfRowGroup=_value.SortIndexOfRowGroup;
rowgroup.ScenarioId=_value.ScenarioId;
table.listRowGroups.push(rowgroup);
}
else
{
var rowgroup=tmpgroup;
}
}
// Check max and min range
var checkFloatLimit = function(_dataname, _value)
{
if ( null != _value )
{
// If number, check that it's in the range of AR's FLOAT (-9999999～9999999)
if ( _value < -9999999 || 9999999 < _value )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, _dataname, _value, null, "Number outside AR's FLOAT range specified.\nPlease specify number between -9999999 and 9999999.");
}
}
}
// Create Row list
if ( null != _value.RowId && null != table )
{
// Create Row under RowGroup if RowGroupId is set.
if ( null != _value.RowGroupId && null != rowgroup)
{
var tmprow=TenkenData.TenkenTable.getRowFromRowGroup(rowgroup, _value.RowId);
if ( null == tmprow )
{
var row=new Object();
// Save Table and Group information into Row.
for ( dataname in _value )
{
// Store Max/Min and base value for QAttribute name that starts with LimitValue.
// Define for secondary value except for LimitHigh, LimitLow, and LimitBase.
if ( null != _value[dataname] && dataname.substr(0,10) == "LimitValue" )
{
// Additional minimum, maximum, and base value (format: min;max;base)
var limitInfoTmp = _value[dataname].split(";");
var limitInfo = new Array(3);
// Minimum value.
limitInfo[0]=(Tenken.isNumber(limitInfoTmp[0]) == true) ? parseFloat(limitInfoTmp[0]) : null;
// Maximum value.
limitInfo[1]=(Tenken.isNumber(limitInfoTmp[1]) == true) ? parseFloat(limitInfoTmp[1]) : null;
// Base value or the base RowId
limitInfo[2] = limitInfoTmp[2];
if ( null == row.listLimit ) row.listLimit = new Array();
checkFloatLimit(dataname, limitInfo[0]);
checkFloatLimit(dataname, limitInfo[1]);
if( true == Tenken.isNumber(limitInfoTmp[2]) )
{
checkFloatLimit(dataname, limitInfo[2]);
}
// Add new.
row.listLimit.push(limitInfo);
}
else
{
// Add new.
row[dataname] = _value[dataname];
}
}
rowgroup.listRows.push(row);
}
else
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, "RowId", _value.RowId, null, "Same RowId exist in a group (Checklist item already exists)");
}
}
else
{
// Create Row directly under Table if RowGroupId is null.
var tmprow=TenkenData.TenkenTable.getRowFromTable(table, _value.RowId);
if ( null == tmprow )
{
var row=new Object();
// Save table and group information into Row.
for ( dataname in _value )
{
// Store Max/Min and base value for QAttribute name that starts with LimitValue.
// Define for secondary value except for LimitHigh, LimitLow, and LimitBase.
if ( null != _value[dataname] && dataname.substr(0,10) == "LimitValue" )
{
// Additional minimum, maximum, and base value (format: min;max;base)
var limitInfoTmp = _value[dataname].split(";");
var limitInfo = new Array(3);
// minimum value
limitInfo[0]=(Tenken.isNumber(limitInfoTmp[0]) == true) ? parseFloat(limitInfoTmp[0]) : null;
// maximum value
limitInfo[1]=(Tenken.isNumber(limitInfoTmp[1]) == true) ? parseFloat(limitInfoTmp[1]) : null;
// base value or base RowId.
limitInfo[2] = limitInfoTmp[2];
checkFloatLimit(dataname, limitInfo[0]);
checkFloatLimit(dataname, limitInfo[1]);
if( true == Tenken.isNumber(limitInfoTmp[2]) )
{
checkFloatLimit(dataname, limitInfo[2]);
}
if ( null == row.listLimit ) row.listLimit = new Array();
row.listLimit.push(limitInfo);
}
else
{
row[dataname] = _value[dataname];
}
}
table.listRowsTable.push(row);
}
else
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, "RowId", _value.RowId, null, "Same RowId exist in a table (Checklist item already exists)");
}
}
}
}
catch(e)
{
alert("Exception : TenkenData.TenkenTable.createListTenkenTable\n" + e);
}
}
// Check mandatory and duplicate data of received data.
// If there is an issue in data, output data error and return to initial screen.
//
// Check items
// QAttribute name : Check items
// TableId : null
// TableName : null
// RowId : null
// RowName : null
// RowGoupName : null (Only when value is set in RowGroupId)
// ValueType : null
// AssetId : null
// TenkenType : null
// DataEntryName : null
// ScenarioId : null
// We will not perform mandatory check for the follwing. When value is not set, set default.
// AssetStatusStoppable : If not set, proceed as true.
// SetLastData : If not set, proceed as false.
TenkenData.TenkenTable.checkData = function(_data)
{
try
{
var err=false;
var errName=null;
var errValue=null;
var errMsg=null;
if ( null == _data ) return;
var funcCheck=function(_name)
{
if ( null == _data[_name] )
{
err=true;
errName=_name;
}
}
if ( false == err ) funcCheck("TableId");
if ( false == err ) funcCheck("TableName");
if ( false == err ) funcCheck("RowId");
if ( false == err ) funcCheck("RowName");
if ( false == err ) funcCheck("AssetId");
if ( false == err ) funcCheck("TenkenType");
if ( false == err ) funcCheck("DataEntryName");
if ( false == err ) funcCheck("ScenarioId");
if ( null != _data.RowGroupId )
{
if ( false == err ) funcCheck("RowGroupName");
}
if ( false == err ) funcCheck("ValueType");
if ( true == err )
{
errMsg="Mandatory field without data exists";
}
else
{
// Check if selection is wrong
if ( null != _data.ValueType )
{
switch(_data.ValueType)
{
case "NUMBER":
// Selection is correct.
// Check if DataEntryName has name with valid numbers
if ( _data.DataEntryName != "F01" &&
_data.DataEntryName != "F02" &&
_data.DataEntryName != "F03" &&
_data.DataEntryName != "F04" &&
_data.DataEntryName != "F05" )
{
err=true;
errName="DataEntryName";
errValue=_data.DataEntryName;
errMsg=_data.ValueType + "F01 to F05 is not specified for the type of DataEntryName\n";
}
break;
case "WEATHER":
case "OKNG":
case "STRING":
case "MARUBATSU":
// Selection is correct.
// Check if DataEntryName has name with valid numbers
if ( _data.DataEntryName != "S01" &&
_data.DataEntryName != "S02" &&
_data.DataEntryName != "S03" &&
_data.DataEntryName != "S04" &&
_data.DataEntryName != "S05" )
{
err=true;
errName="DataEntryName";
errValue=_data.DataEntryName;
errMsg=_data.ValueType + "S01 to S05 is not specified for the type of DataEntryName\n";
}
break;
default:
err=true;
errName="ValueType";
errValue=_data.ValueType;
errMsg="Can not use specified type.";
break;
}
}
}
// If error exists in data, output error and return to initial screen.
if ( true == err )
{
TenkenData.AllGet.abortInvalidData(TenkenConst.TableName.tenkentable, errName, errValue, null, errMsg);
}
}
catch (e)
{
alert("Exception: TenkenData.TenkenTable.checkData\n" + e);
}
}
// Process and copy downloaded TenkenData
TenkenData.TenkenTable.createDataList = function()
{
try {
if ( null == TenkenData.TenkenTable.arTenkenTable || null == TenkenData.TenkenTable.ListTables ) return;
var datas = TenkenData.TenkenTable.arTenkenTable.getDataValue();
if ( null == datas ) return;
var countList=datas.length;
for ( var i=0 ; i < countList ; i++ )
{
var dataValue=datas[i];
if ( null != dataValue )
{
// Goto next item by removing from checklist, as it is invalid item if Disable="true" is set.
if ( null != dataValue.Disable && "true" == dataValue.Disable.toLowerCase() )
{
continue;
}
// Check mandatory data
TenkenData.TenkenTable.checkData(dataValue);
TenkenData.TenkenTable.createListTenkenTable(dataValue);
}
}
}
catch(e)
{
alert("Exception : TenkenData.TenkenTable.createDataList\n" + e);
}
}
//============================================================================
// Manage entire retrieve data
//============================================================================
// Data management class (Entire data retrieval)
TenkenData.AllGet = function() {};
// Save scenario's callbacks
TenkenData.AllGet.downloadScenarioSuccessFunc=null;
TenkenData.AllGet.downloadScenarioErrorFunc=null;
// Save entire data callback (Except for scenario data)
TenkenData.AllGet.downloadSuccessFunc=null;
TenkenData.AllGet.downloadErrorFunc=null;
// Flag to determine if it's abort state
TenkenData.AllGet.abortON=false;
// Confirm if download is in progress
TenkenData.AllGet.getPhase = function()
{
// Retrun status complete even if dowload is in progress if abort is set.
if ( true == TenkenData.AllGet.abortON )
{
// Data retrieve complete or not retrieved.
return(false);
}
// Confirm other than scenario and check results (tenkenevent)
if ( (null != TenkenData.Asset.arAsset &&
TenkenData.Asset.arAsset.getBusyStatus() == true) ||
(null != TenkenData.MsgEvent.arMessageEventLast &&
TenkenData.MsgEvent.arMessageEventLast.getBusyStatus() == true ) ||
(null != TenkenData.UserData.arUserData &&
TenkenData.UserData.arUserData.getBusyStatus() == true ) ||
(null != TenkenData.Scene.arScene &&
TenkenData.Scene.arScene.getBusyStatus() == true ) ||
(null != TenkenData.SuperimposedGraphic.arSuperimposedGraphic&&
TenkenData.SuperimposedGraphic.arSuperimposedGraphic.getBusyStatus() == true ) ||
(null != TenkenData.TenkenTable.arTenkenTable &&
TenkenData.TenkenTable.arTenkenTable.getBusyStatus() == true ) ||
TenkenData.TenkenEvent.isGetPhase() == true )
{
// Data retrieve in progress
return(true);
}
else
{
// Data retrieve complete or not retrieved
return(false);
}
}
// Check if download is in progress (Only Scenario data)
TenkenData.AllGet.getPhaseScenario = function()
{
if (null != TenkenData.Scenario.arScenario && TenkenData.Scenario.arScenario.getBusyStatus() == true )
{
return(true);
}
else
{
return(false);
}
}
// Download entire data (except for scenario and check results)
TenkenData.AllGet.download = function(_mode, _downloadSuccess, _downloadError)
{
Tenken.Util.loginfo("GET_ALL_DATA1:START");
// Save callback methods called after entire download
TenkenData.AllGet.downloadSuccessFunc=_downloadSuccess;
TenkenData.AllGet.downloadErrorFunc=_downloadError;
// Set force reload mode
var mode=( false == _mode ) ? false : true;
TenkenData.setSuperReloadMode(mode);
// Download each data
// Scene data
TenkenData.Scene.getScene();
// AR Overlay data. Download without specifying scene ID and marker ID here.
TenkenData.SuperimposedGraphic.getSuperimposedGraphic(Tenken.config.ScenarioId, null, null);
// Asset data
TenkenData.Asset.getLastData();
// Checklist table data
TenkenData.TenkenTable.getData();
// Message data
TenkenData.MsgEvent.getLastData();
// Workder data
TenkenData.UserData.getData();
}
// Download check results
TenkenData.AllGet.download2 = function()
{
Tenken.Util.loginfo("GET_ALL_DATA2:START");
// Check results
TenkenData.TenkenEvent.getLastData();
}
// Download scenarios
TenkenData.AllGet.downloadScenario = function(_mode, _downloadSuccess, _downloadError)
{
Tenken.Util.loginfo("GET_ALL_DATA_SCENARIO:START");
// Save callback called after entire download.
TenkenData.AllGet.downloadScenarioSuccessFunc=_downloadSuccess;
TenkenData.AllGet.downloadScenarioErrorFunc=_downloadError;
// Set force reload mode.
var mode=( false == _mode ) ? false : true;
TenkenData.setSuperReloadMode(mode);
// Scenario data
TenkenData.Scenario.getScenario();
}
// Save each data into local storage (except for scenario)
TenkenData.AllGet.saveStorage = function()
{
TenkenData.Asset.saveStorage();
TenkenData.MsgEvent.saveStorage();
TenkenData.TenkenEvent.saveStorage();
TenkenData.UserData.saveStorage();
TenkenData.Scene.saveStorage();
TenkenData.SuperimposedGraphic.saveStorage();
TenkenData.TenkenTable.saveStorage();
}
// Load each data from local storage (except for scenario)
TenkenData.AllGet.loadStorage = function()
{
TenkenData.Asset.loadStorage();
TenkenData.MsgEvent.loadStorage();
TenkenData.TenkenEvent.loadStorage();
TenkenData.UserData.loadStorage();
TenkenData.Scene.loadStorage();
TenkenData.SuperimposedGraphic.loadStorage();
TenkenData.TenkenTable.loadStorage();
}
// Save scenario data into local storage
TenkenData.AllGet.saveStorageScenario = function()
{
TenkenData.Scenario.saveStorage();
}
// Load scenario data from local storage
TenkenData.AllGet.loadStorageScenario = function()
{
TenkenData.Scenario.loadStorage();
}
// The method will be called after download has completed except for scenario and check results.
// If success, entire data will be stored in local storage and displays operator who downloaded in the operator list.
TenkenData.AllGet.afterDownload = function()
{
Tenken.Util.loginfo("GET_ALL_DATA1:END:SUCCESS");
TenkenData.AllGet.download2();
}
// Delete items that is not needed for selected scenario
// (Delete ScenarioId=0 or none selected scenario)
TenkenData.AllGet.SkipDisableData = function()
{
try {
//--------------------------------------------------
// Re-create list that are valid assets only for
// selected scenario.
//--------------------------------------------------
var tmpListAsset=[];
// Retrieve valid asset ID inside checklist table
var listAssets=new Object();
var funcRow=function(_table, _group, _row, _poi, _valueEntryName, _value, _assetstatus)
{
if ( null == _row ) return;
// Save selected assetid those are valid within the checklist
listAssets[_row.AssetId]=_row.AssetId;
}
TenkenData.TenkenTable.foreachTables(null, null, null, funcRow);
// Re-create asset list those checklist are only valid from selected assetid list.
// Make array list of assetid for items that is not used in checklist table.
var found=0;
var arrayDeleteAsset=[];
for ( var i = 0 ; i < TenkenData.Asset.ListAll.length ; i++ )
{
found=0;
for ( assetid in listAssets )
{
if ( assetid == TenkenData.Asset.ListAll[i].assetid )
{
found=1;
break;
}
}
if ( 0 == found )
{
arrayDeleteAsset.push(TenkenData.Asset.ListAll[i].assetid);
}
}
if ( 0 < arrayDeleteAsset.length )
{
for ( var i =0 ; i < arrayDeleteAsset.length ; i++ )
{
TenkenData.Asset.deleteAsset(arrayDeleteAsset[i]);
}
}
//--------------------------------------------------
// Re-create AR overlay data those are valid from
// Marker ID from selected scenario
//--------------------------------------------------
// Create valid marker ID list
var listMarkerIds=new Object();
for ( var aid in listAssets )
{
var mid=-1;
mid=TenkenData.Asset.getMarkerIdfromAssetId(aid);
listMarkerIds[mid]=mid;
}
// Delete invalid marker id data from AR overlay data
for(var scene in TenkenData.SuperimposedGraphic.objSuperimposedGraphics)
{
var listScenes=TenkenData.SuperimposedGraphic.objSuperimposedGraphics[scene];
for(var markerid in listScenes)
{
if ( null == listMarkerIds[markerid] )
{
delete TenkenData.SuperimposedGraphic.objSuperimposedGraphics[scene][markerid];
}
}
}
}
catch (e)
{
alert("Exception : TenkenData.AllGet.SkipDisableData\n" + e);
}
}
// Post process after entire data download
TenkenData.AllGet.afterDownload2 = function()
{
Tenken.Util.loginfo("GET_ALL_DATA2:END:SUCCESS");
TenkenData.AllGet.SkipDisableData();
TenkenData.AllGet.saveStorage();
// Pre download.
TenkenData.AllGet.PreloadData();
// Call operator list in operator selection windows and download complete callback methods (if registered) after entire download is complete.
var elm = document.getElementById("operatorselect");
if ( null != elm )
{
elm.innerHTML=TenkenData.UserData.getUserNameHTML();
}
if ( null != TenkenData.AllGet.downloadSuccessFunc )
{
TenkenData.AllGet.downloadSuccessFunc();
}
}
// Called when download failed (after completion of entire data).
// End by displaying error message.
TenkenData.AllGet.afterDownloadError = function(_errorMsg)
{
Tenken.Util.logerr("GET_ALL_DATA1:END:ERROR:" + _errorMsg);
if ( null != TenkenData.AllGet.downloadErrorFunc )
{
// Clear callback so it will only be called once.
var func=TenkenData.AllGet.downloadErrorFunc;
TenkenData.AllGet.downloadErrorFunc=null;
func(_errorMsg);
}
}
// If error exists on operator data when recieving data, clear the data and return to initial screen (index.html)
TenkenData.AllGet.abortInvalidData = function(_table, _qattribute, _value, _msghead, _msg)
{
// Do nothing while abort in progress.
if ( true == TenkenData.AllGet.abortON ) return;
TenkenData.AllGet.abortON=true;
// Delete storage and AR's offline storage data
Tenken.Storage.clear();
AR.Data.clearResourceStorage(Tenken.Util.noop, Tenken.Util.noop);
// Output message
var str="";
if ( null != _msghead )
{
str=_msghead;
}
else
{
str="Error in data.\n\n";
}
if ( _table ) str += "Table name=" + _table + "\n";
if ( _qattribute ) str += "QAttribute name=" + _qattribute + "\n";
if ( _value ) str += "value=" + _value + "\n";
if ( _msg ) str += "\n" + _msg + "\n";
str += "\nAboring process. Returning to initial screen.\n";
alert(str);
// Move to initial screen
location.replace(TenkenConst.PageName.top);
}
// Pre download
TenkenData.AllGet.PreloadData = function()
{
// check if predownload is invalid.
var skipPreload=false;
var skipPreloadSG=false;
var skipPreloadAsset=false;
if ( null != Tenken.config.ScenarioId && 0 < TenkenData.Scenario.ListAll.length)
{
var lenScenaio=TenkenData.Scenario.ListAll.length;
for ( var i=0 ; i < lenScenaio; i++ )
{
var asset=TenkenData.Scenario.ListAll[i];
if ( Tenken.config.ScenarioId == TenkenData.Scenario.ListAll[i].scenarioId )
{
if ( 0 <= asset.description.indexOf("#unpreload#"))
{
// Value set. Invalidate pre-download of selected scenario.
skipPreload=true;
}
if ( 0 <= asset.description.indexOf("#unpreloadsg#"))
{
// Value set. Invalidate pre-download of AR overlay data.
skipPreloadSG=true;
}
if ( 0 <= asset.description.indexOf("#unpreloadasset#"))
{
// Value set. Invalidate pre-download of files of additional icons in asset table.
skipPreloadAsset=true;
}
}
}
}
if ( false == Tenken.config.preloadFile || true == skipPreload )
{
return; // Do nothing as we're skipping predownload.
}
preloadSuperimposedGraphics = [];
//Pre download AR overlay data
if ( true != skipPreloadSG )
{
var listSG=TenkenData.SuperimposedGraphic.objSuperimposedGraphics;
if ( null != listSG )
{
for(scene in listSG)
{
if( null != listSG[scene])
{
for(marker in listSG[scene])
{
var arraySG=listSG[scene][marker];
if ( null != arraySG && 0 < arraySG.length )
{
for ( var i=0 ; i < arraySG.length ; i++ )
{
var sg=arraySG[i];
if ( null != sg )
{
preloadSuperimposedGraphics.push(sg);
}
}
}
}
}
}
}
if ( 0 < preloadSuperimposedGraphics.length )
{
Tenken.ARRendering.createSuperimposedGraphicsPreload(preloadSuperimposedGraphics);
}
}
// Pre download if URL is specified for additional icon of assets.
if ( false == Tenken.config.preloadAssetFile || true == skipPreloadAsset )
{
return; // Do nothing as we're skipping pre dowload.
}
if ( !AR.Data.cacheUrlResource ) return;
var len=TenkenData.Asset.ListAll.length;
for ( var i=0 ; i < len ; i++ )
{
var asset=TenkenData.Asset.ListAll[i];
if ( null != asset && null != asset.listICON)
{
var lenListIcon=asset.listICON.length;
for ( var j = 0 ; j < lenListIcon ; j++ )
{
if ( null == asset.listICON[j] ) continue;
var iconInfo=asset.listICON[j];
if ( null == iconInfo[2] || "" == iconInfo[2] ) continue;
// Remove non http value.
// Also remove value that do not start with http:// and minimum of 8 chars.
var strURL=iconInfo[2];
if ( strURL.length < 8 ) continue;
if ( 0 <= strURL.indexOf("?") ) continue;
var strProtcol=strURL.substring(0,4);
if ( "http" != strProtcol.toLowerCase() ) continue;
AR.Data.cacheUrlResource(strURL, Tenken.Util.noop, Tenken.Util.noop);
}
}
}
}
//============================================================================
// Data send (Check result: tenkenevent)
//============================================================================
// Sequence value to hand over to callback upon sending check results
TenkenData.TenkenEvent.onSuccess = null;
TenkenData.TenkenEvent.onError = null;
TenkenData.TenkenEvent.cbValue = null;
// Create check data
TenkenData.TenkenEvent.createTenkenDataQuad = function(_data)
{
// Create QUAD
var quad = new TenkenARvalue.Quad(TenkenConst.TableName.tenkenevent);
// Set type name of QUAD
quad.qtypeName = TenkenConst.TableName.tenkenevent;
var Id = ( null != _data.tenken_id ) ? new TenkenARvalue.QValue(quad.qtypeName, "tenkenid", null, _data.tenken_id, null) : null;
var Name = ( null != _data.tenken_name ) ? new TenkenARvalue.QValue(quad.qtypeName, "tenkenname", _data.tenken_name, null, null) : null;
var Description = ( null != _data.description ) ? new TenkenARvalue.QValue(quad.qtypeName, "description", _data.description, null, null) : null;
var Type = ( null != _data.type ) ? new TenkenARvalue.QValue(quad.qtypeName, "type", _data.type, null, null) : null;
var Registrationtime = ( null != _data.registrationtime ) ? new TenkenARvalue.QValue(quad.qtypeName, "registrationtime", null, _data.registrationtime, null) : null;
var RegDatetimeStr = ( null != _data.regDatetimeStr ) ? new TenkenARvalue.QValue(quad.qtypeName, "regDatetimeStr", _data.regDatetimeStr, null, null) : null;
var Registrant = ( null != _data.registrant ) ? new TenkenARvalue.QValue(quad.qtypeName, "registrant", _data.registrant, null, null) : null;
var Markerid = ( null != _data.markerid ) ? new TenkenARvalue.QValue(quad.qtypeName, "markerid", null, _data.markerid, null) : null;
var Markername = ( null != _data.markername ) ? new TenkenARvalue.QValue(quad.qtypeName, "markername", _data.markername, null, null) : null;
var Targetassetid = ( null != _data.targetassetid ) ? new TenkenARvalue.QValue(quad.qtypeName, "targetassetid", _data.targetassetid, null, null) : null;
var AssetStatus = ( null != _data.assetstatus ) ? new TenkenARvalue.QValue(quad.qtypeName, "assetstatus", _data.assetstatus, null, null) : null;
var Occurrencetime = ( null != _data.occurrencetime ) ? new TenkenARvalue.QValue(quad.qtypeName, "occurrencetime", null, _data.occurrencetime, null) : null;
var OccDatetimeStr = ( null != _data.occDatetimeStr ) ? new TenkenARvalue.QValue(quad.qtypeName, "occDatetimeStr", _data.occDatetimeStr, null, null) : null;
var Operator = ( null != _data.operator ) ? new TenkenARvalue.QValue(quad.qtypeName, "operator", _data.operator, null, null) : null;
var ScenarioId = ( null != _data.ScenarioId ) ? new TenkenARvalue.QValue(quad.qtypeName, "ScenarioId", null, _data.ScenarioId, null) : null;
var F01 = ( null != _data.F01 ) ? new TenkenARvalue.QValue(quad.qtypeName, "F01", null, null, _data.F01) : null;
var F02 = ( null != _data.F02 ) ? new TenkenARvalue.QValue(quad.qtypeName, "F02", null, null, _data.F02) : null;
var F03 = ( null != _data.F03 ) ? new TenkenARvalue.QValue(quad.qtypeName, "F03", null, null, _data.F03) : null;
var F04 = ( null != _data.F04 ) ? new TenkenARvalue.QValue(quad.qtypeName, "F04", null, null, _data.F04) : null;
var F05 = ( null != _data.F05 ) ? new TenkenARvalue.QValue(quad.qtypeName, "F05", null, null, _data.F05) : null;
var S01 = ( null != _data.S01 ) ? new TenkenARvalue.QValue(quad.qtypeName, "S01", _data.S01, null, null) : null;
var S02 = ( null != _data.S02 ) ? new TenkenARvalue.QValue(quad.qtypeName, "S02", _data.S02, null, null) : null;
var S03 = ( null != _data.S03 ) ? new TenkenARvalue.QValue(quad.qtypeName, "S03", _data.S03, null, null) : null;
var S04 = ( null != _data.S04 ) ? new TenkenARvalue.QValue(quad.qtypeName, "S04", _data.S04, null, null) : null;
var S05 = ( null != _data.S05 ) ? new TenkenARvalue.QValue(quad.qtypeName, "S05", _data.S05, null, null) : null;
// Set valid QValue of QUAD.
var values =[];
if ( null != Id ) values.push(Id);
if ( null != Name ) values.push(Name);
if ( null != Description ) values.push(Description);
if ( null != Type ) values.push(Type);
if ( null != Registrationtime ) values.push(Registrationtime);
if ( null != RegDatetimeStr ) values.push(RegDatetimeStr);
if ( null != Registrant ) values.push(Registrant);
if ( null != Markerid ) values.push(Markerid);
if ( null != Markername ) values.push(Markername);
if ( null != Targetassetid ) values.push(Targetassetid);
if ( null != AssetStatus ) values.push(AssetStatus);
if ( null != Occurrencetime ) values.push(Occurrencetime);
if ( null != OccDatetimeStr ) values.push(OccDatetimeStr);
if ( null != Operator ) values.push(Operator);
if ( null != ScenarioId ) values.push(ScenarioId);
if ( null != F01 ) values.push(F01);
if ( null != F02 ) values.push(F02);
if ( null != F03 ) values.push(F03);
if ( null != F04 ) values.push(F04);
if ( null != F05 ) values.push(F05);
if ( null != S01 ) values.push(S01);
if ( null != S02 ) values.push(S02);
if ( null != S03 ) values.push(S03);
if ( null != S04 ) values.push(S04);
if ( null != S05 ) values.push(S05);
quad.qvalues=values;
// Transform to string.
var rtndata = JSON.stringify(quad);
return rtndata;
};
// Success callback method upon upload (Check result data)
TenkenData.TenkenEvent.cbPostSuccess = function(_result)
{
if ( null != TenkenData.TenkenEvent.onSuccess ) TenkenData.TenkenEvent.onSuccess(TenkenData.TenkenEvent.cbValue);
};
// Error callback method upon upload (Check result data)
TenkenData.TenkenEvent.cbPostError = function(_result)
{
try
{
var message = "Failed to upload check results. Please check operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION"){
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else {
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr("POST_TENKENEVENT_RESPONSE:ERROR:" + message + ":" + detail);
alert("Failed to upload check results.\n\nPlease check operation mode and network connectivity.\n\nPlease restart Tenken application if network is online.\n\n" + detail);
}
catch (e)
{
alert("Exception : TenkenData.TenkenEvent.cbPostError\n" + e);
}
if ( null != TenkenData.TenkenEvent.onError ) TenkenData.TenkenEvent.onError(TenkenData.TenkenEvent.cbValue);
};
// Send check results.
// _markerids : Specify marker ID to send. Array.
// Send everything if null is set.
// _submitall : false: Do not send check results for asset that is in STOP state.
// true or other: Send check results for asset that is even in STOP state.
TenkenData.TenkenEvent.submitTenkenEvent = function(_markerids, _submitall, _onSuccess, _onError, _value)
{
try
{
if ( null != _onSuccess ) TenkenData.TenkenEvent.onSuccess = _onSuccess;
if ( null != _onError ) TenkenData.TenkenEvent.onError = _onError;
if ( null != _value ) TenkenData.TenkenEvent.cbValue = _value;
var tenkenlists = [];
// Change registered DateTime to send DateTime and send data.
var nowdatetime=new Date().getTime();
TenkenData.TenkenTable.foreachTables(
TenkenData.TenkenEvent.Current,
null,
null,
function(_table, _group, _row, _poi2, _valueEntryName, _value, _assetstatus)
{
if ( null == _poi2 ) return;
if ( false == _submitall && "STOP" == _assetstatus )
{
// Do not send check results for asset in STOP state.
return;
}
// IF marker id array is specified, check if item are target to send, and if not, skip them.
if ( null != _markerids )
{
var targetid=false;
for ( var j = 0 ; j < _markerids.length ; j++ )
{
// Mark as send target if marker ID is selected or marker ID is 0.
if ( _markerids[j] == _poi2.markerid )
{
targetid=true;
break;
}
}
if ( true != targetid )
{
// Skip and proceed to next as it is not the target marker id.
return;
}
}
var replaceindex = -1;
var tmptenken = null;
for ( var l = 0 ; l < tenkenlists.length ; l++ )
{
tmptenken = tenkenlists[l];
if ( _table.TableId == tmptenken.table_id &&
(null == _group || _group.RowGroupdId == tmptenken.rowgroups_id) &&
_row.TenkenType == tmptenken.type )
{
replaceindex = l;
break;
}
}
if ( -1 != replaceindex )
{
var tenken=tmptenken;
}
else
{
var startdatetime = Tenken.Storage.startDatetime.get();
if ( null == startdatetime )
{
startdatetime = nowdatetime;
}
var operator = Tenken.Storage.operator.get();
var tenken = {};
tenken.table_id = _table.TableId;
tenken.table_name = _table.TableName;
tenken.rowgroups_id = ( _group ) ? _group.RowGroupdId : null;
tenken.rowgroups_name = ( _group ) ? _group.RowGroupdName : null;
tenken.tenken_id = nowdatetime; // Use current DateTime as tenkenid.
if ( null != _group && null != _group.RowGroupdName )
{
tenken.tenken_name = _table.TableName + "_" + _group.RowGroupdName;
}
else
{
tenken.tenken_name = _table.TableName;
}
tenken.description = _poi2.description;
tenken.type = _poi2.type;
tenken.registrationtime = nowdatetime;
tenken.regDatetimeStr = new Tenken.DatetimeValue(nowdatetime).toStringFullTime();
tenken.registrant = operator;
tenken.markerid = _poi2.markerid;
tenken.markername = _poi2.markername;
tenken.targetassetid = _row.AssetId;
tenken.assetstatus = (_assetstatus != null) ? _assetstatus : "START";
tenken.occurrencetime = startdatetime;
tenken.occDatetimeStr = new Tenken.DatetimeValue(startdatetime).toStringFullTime();
tenken.operator = operator;
tenken.ScenarioId=Tenken.config.ScenarioId;
}
// Do not set checklist value of F01-F05, and S01-S05 for stopped assets
if ( "STOP" != _assetstatus )
{
/* entryname: F01 F02 F03 F04 F05 S01 S02 S03 S04 S05 */
tenken[_row.DataEntryName]=_value;
}
if ( -1 != replaceindex )
{
tenkenlists[replaceindex]=tenken;
}
else
{
tenkenlists.push(tenken);
}
}
);
if ( tenkenlists.length <= 0 )
{
alert("No valid data to send.");
// Do not send if there is nothing registered.
// Call success callback method.
if ( null != _onSuccess )
{
_onSuccess(_value);
}
else
{
return;
}
}
// Create send data and store
for ( var j = 0 ; j < tenkenlists.length ; j++ )
{
TenkenData.TenkenEvent.arTenkenEventCurrent.addPostData(
TenkenData.TenkenEvent.createTenkenDataQuad(tenkenlists[j]));
}
TenkenData.TenkenEvent.arTenkenEventCurrent.postArData(
TenkenData.TenkenEvent.cbPostSuccess,
TenkenData.TenkenEvent.cbPostError);
}
catch(e) {
alert("Error occured while uploading check results.\n" + e);
return false;
}
}
//============================================================================
// Data send (Messages: messageevent)
//============================================================================
// Sequence value to hand over to callback upon sending check results
TenkenData.MsgEvent.onPostSuccess = null;
TenkenData.MsgEvent.onPostError = null;
TenkenData.MsgEvent.cbPostValue = null;
// Create operator data to register.
TenkenData.MsgEvent.CreateCommentDataQuad = function(_data)
{
// Create QUAD
var quad = new TenkenARvalue.Quad(TenkenConst.TableName.messageevent);
// Set type name of QUAD
quad.qtypeName = TenkenConst.TableName.messageevent;
// Create attributes of QUAD
var Id = ( null != _data.msgid ) ? new TenkenARvalue.QValue(quad.qtypeName, "msgid", null, _data.msgid, null) : null;
var Name = ( null != _data.msgname ) ? new TenkenARvalue.QValue(quad.qtypeName, "msgname", _data.msgname, null, null) : null;
var Description = ( null != _data.description ) ? new TenkenARvalue.QValue(quad.qtypeName, "description", _data.description, null, null) : null;
var Registrationtime = ( null != _data.registrationtime ) ? new TenkenARvalue.QValue(quad.qtypeName, "registrationtime", null, _data.registrationtime, null) : null;
var RegDatetimeStr = ( null != _data.regDatetimeStr ) ? new TenkenARvalue.QValue(quad.qtypeName, "regDatetimeStr", _data.regDatetimeStr, null, null) : null;
var Registrant = ( null != _data.registrant ) ? new TenkenARvalue.QValue(quad.qtypeName, "registrant", _data.registrant, null, null) : null;
var Markerid = ( null != _data.markerid ) ? new TenkenARvalue.QValue(quad.qtypeName, "markerid", null, _data.markerid, null) : null;
var Markername = ( null != _data.markername ) ? new TenkenARvalue.QValue(quad.qtypeName, "markername", _data.markername , null, null) : null;
var X = ( null != _data.x ) ? new TenkenARvalue.QValue(quad.qtypeName, "x", null, null, _data.x) : null;
var Y = ( null != _data.y ) ? new TenkenARvalue.QValue(quad.qtypeName, "y", null, null, _data.y) : null;
var Z = ( null != _data.z ) ? new TenkenARvalue.QValue(quad.qtypeName, "z", null, null, _data.z) : null;
var Targetassetid = ( null != _data.targetassetid ) ? new TenkenARvalue.QValue(quad.qtypeName, "targetassetid", _data.targetassetid , null, null) : null;
var Title = ( null != _data.title ) ? new TenkenARvalue.QValue(quad.qtypeName, "title", _data.title, null, null) : null;
var Level = ( null != _data.level ) ? new TenkenARvalue.QValue(quad.qtypeName, "level", null, _data.level, null) : null;
var Value = ( null != _data.value ) ? new TenkenARvalue.QValue(quad.qtypeName, "value", _data.value, null, null) : null;
var Occurrencetime = ( null != _data.occurrencetime ) ? new TenkenARvalue.QValue(quad.qtypeName, "occurrencetime", null, _data.occurrencetime, null) : null;
var OccDatetimeStr = ( null != _data.occDatetimeStr ) ? new TenkenARvalue.QValue(quad.qtypeName, "occDatetimeStr", _data.occDatetimeStr, null, null) : null;
var Operator = ( null != _data.operator ) ? new TenkenARvalue.QValue(quad.qtypeName, "operator", _data.operator, null, null) : null;
var ScenarioId = ( null != _data.ScenarioId ) ? new TenkenARvalue.QValue(quad.qtypeName, "ScenarioId", null, _data.ScenarioId, null) : null;
var Enable = ( null != _data.Enable ) ? new TenkenARvalue.QValue(quad.qtypeName, "Enable", _data.Enable, null, null) : null;
var Answer = ( null != _data.Answer ) ? new TenkenARvalue.QValue(quad.qtypeName, "Answer", _data.Answer, null, null) : null;
// Set valid QValue to QUAD
var values =[];
if ( null != Id ) values.push(Id);
if ( null != Name ) values.push(Name);
if ( null != Description ) values.push(Description);
if ( null != Registrationtime ) values.push(Registrationtime);
if ( null != RegDatetimeStr ) values.push(RegDatetimeStr);
if ( null != Registrant ) values.push(Registrant);
if ( null != Markerid ) values.push(Markerid);
if ( null != Markername ) values.push(Markername);
if ( null != X ) values.push(X);
if ( null != Y ) values.push(Y);
if ( null != Z ) values.push(Z);
if ( null != Targetassetid ) values.push(Targetassetid);
if ( null != Title ) values.push(Title);
if ( null != Level ) values.push(Level);
if ( null != Value ) values.push(Value);
if ( null != Occurrencetime ) values.push(Occurrencetime);
if ( null != OccDatetimeStr ) values.push(OccDatetimeStr);
if ( null != Operator ) values.push(Operator);
if ( null != ScenarioId ) values.push(ScenarioId);
if ( null != Enable ) values.push(Enable);
if ( null != Answer ) values.push(Answer);
quad.qvalues=values;
// Transform into string.
var rtndata = JSON.stringify(quad);
return rtndata;
};
// Success callback handler upon upload (Messages)
TenkenData.MsgEvent.cbPostSuccess = function(_result)
{
if ( null != TenkenData.MsgEvent.onPostSuccess ) TenkenData.MsgEvent.onPostSuccess(TenkenData.MsgEvent.cbPostValue);
};
// Error callback handler upon upload (Messages)
TenkenData.MsgEvent.cbPostError = function(_result)
{
try {
var message = "Failed to upload messages. Please check operation mode and network connectivity.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION"){
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else {
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr(message, detail);
alert("Failed to upload messages.\n\nPlease check operation mode and network connectivity.\n\nPlease restart Tenken application if network is online.\n\n" + detail);
Tenken.Util.logerr("POST_MSGEVENT_RESPONSE:ERROR:" + message + ":" + detail);
}
catch (e)
{
alert("Exception : TenkenData.MsgEvent.cbPostError \n" + e);
}
if ( null != TenkenData.MsgEvent.onPostError ) TenkenData.MsgEvent.onPostError(TenkenData.MsgEvent.cbPostValue);
};
// Send Messages
TenkenData.MsgEvent.submitMsgEvent = function(_markerids, _onSuccess, _onError, _value)
{
try
{
if ( null != _onSuccess ) TenkenData.MsgEvent.onPostSuccess = _onSuccess;
if ( null != _onError ) TenkenData.MsgEvent.onPostError = _onError;
if ( null != _value ) TenkenData.MsgEvent.cbPostValue = _value;
// Change registered DateTime to send DateTime and send data.
var nowdatetime=new Date().getTime();
// Messages (New registration)
// Do not send if nothing is registered.
if ( TenkenData.MsgEvent.Current.length <= 0 )
{
// Call success callback method.
if ( null != _onSuccess )
{
_onSuccess(_value);
}
else
{
return;
}
}
for ( var i = 0 ; i < TenkenData.MsgEvent.Current.length ; i++ )
{
var msgevent=TenkenData.MsgEvent.Current[i];
// IF marker id array is specified, check if item are target to send, and if not, skip them.
if ( null != _markerids )
{
var targetid=false;
for ( var j = 0 ; j < _markerids.length ; j++ )
{
if ( _markerids[j] == msgevent.markerid )
{
targetid=true;
break;
}
}
if ( true != targetid )
{
// Skip and proceed to next as it is not the target marker id.
continue;
}
}
// Change registered DateTime to send DateTime and send data.
msgevent.registrationtime =nowdatetime;
msgevent.regDatetimeStr = new Tenken.DatetimeValue(nowdatetime).toStringFullTime();
TenkenData.MsgEvent.arMessageEventCurrent.addPostData(
TenkenData.MsgEvent.CreateCommentDataQuad(msgevent));
}
Tenken.Util.loginfo("POST_MSGEVENT_REQUEST:allcount:" + TenkenData.MsgEvent.Current.length);
TenkenData.MsgEvent.arMessageEventCurrent.postArData(
TenkenData.MsgEvent.cbPostSuccess,
TenkenData.MsgEvent.cbPostError);
}
catch(e) {
alert("Error occured uploading Messages.\n" + e);
return false;
}
}
//============================================================================
// Data send (Completion report:messageevent)
//============================================================================
// Sequence value to hand over to callback upon sending completion report
TenkenData.MsgEvent.arCompleteMessageEvent=null;
TenkenData.MsgEvent.onCompletePostSuccess = null;
TenkenData.MsgEvent.onCompletePostError = null;
TenkenData.MsgEvent.cbCompletePostValue = null;
// Success callback method upon upload (Completion result)
TenkenData.MsgEvent.completeMsgEventSuccess = function(_result)
{
if ( null != TenkenData.MsgEvent.onCompletePostSuccess ) TenkenData.MsgEvent.onCompletePostSuccess(TenkenData.MsgEvent.cbCompletePostValue);
};
// Error callback method upon upload (Completion result)
TenkenData.MsgEvent.completeMsgEventError = function(_result)
{
try
{
var message = "Failed to updalod Messages (Completion report)\n\nPlease check operation mode and network connectivity.\n\nPlease restart Tenken application if network is online.";
var detail="";
if(_result.getStatus() == "AR_HTTP_EXCEPTION"){
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
} else {
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr(message, detail);
alert(message + "\n\n" + detail);
Tenken.Util.logerr("POST_COMPLETEMSGEVENT_RESPONSE:ERROR:" + message + ":" + detail);
}
catch (e)
{
alert("Exception : TenkenData.MsgEvent.completeMsgEventError\n" + e);
}
if ( null != TenkenData.MsgEvent.onCompletePostError ) TenkenData.MsgEvent.onCompletePostError(TenkenData.MsgEvent.cbCompletePostValue);
};
// Send completion report of messages (update exsting messages)
TenkenData.MsgEvent.completeMsg = function(_onSuccess, _onError, _value)
{
if ( null != _onSuccess ) TenkenData.MsgEvent.onCompletePostSuccess = _onSuccess;
if ( null != _onError ) TenkenData.MsgEvent.onCompletePostError = _onError;
if ( null != _value ) TenkenData.MsgEvent.cbCompletePostValue = _value;
if ( null == TenkenData.MsgEvent.arCompleteMessageEvent ) TenkenData.MsgEvent.arCompleteMessageEvent=new TenkenARdata(TenkenConst.TableName.messageevent);
TenkenData.MsgEvent.deleteMsgEventDatas.length = 0
for ( var i = 0 ; i < TenkenData.MsgEvent.Last.length ; i++ )
{
var msgevent=TenkenData.MsgEvent.Last[i];
if ( "true" != msgevent.Enable && null != msgevent.Answer)
{
TenkenData.MsgEvent.arCompleteMessageEvent.addPostData(
TenkenData.MsgEvent.CreateCommentDataQuad(msgevent));
// Add original version and QentityId to delete list.
var deleteMsg=new Object();
deleteMsg.version=msgevent.version;
deleteMsg.qentityId=msgevent.qentityId;
TenkenData.MsgEvent.deleteMsgEventDatas.push(deleteMsg);
}
}
if ( 0 == TenkenData.MsgEvent.deleteMsgEventDatas.length )
{
// End by calling success callback method as there is no completion report.
if ( null != _onSuccess ) _onSuccess(_value);
return;
}
TenkenData.MsgEvent.arCompleteMessageEvent.postArData(
TenkenData.MsgEvent.completeMsgEventSuccess,
TenkenData.MsgEvent.completeMsgEventError);
}
//============================================================================
// Data delete (Original data for completion report:messageevent)
//============================================================================
// Sequence value to hand over to callback upon deleting completion report
TenkenData.MsgEvent.arDeleteteMessageEvent=null;
TenkenData.MsgEvent.onDeleteSuccess = null;
TenkenData.MsgEvent.onDeleteError = null;
TenkenData.MsgEvent.cbDeleteValue = null;
// List to delete completion report
TenkenData.MsgEvent.deleteMsgEventDatas = [];
// Success callback method when message deletion of completion report registration has ended
TenkenData.MsgEvent.deleteMsgEventSuccess = function(_result)
{
try
{
// Clear send data.
TenkenData.MsgEvent.deleteMsgEventDatas.length=0;
// Delete messages where completion report is set.
TenkenData.MsgEvent.deleteMsgEventDisable();
if ( null != TenkenData.MsgEvent.onDeleteSuccess ) TenkenData.MsgEvent.onDeleteSuccess(TenkenData.MsgEvent.cbDeleteValue);
}
catch (e)
{
alert("Exception : TenkenData.MsgEvent.deleteMsgEventSuccess\n" + e);
}
};
// Error callback method when message deletion of completion report registration has ended
TenkenData.MsgEvent.deleteMsgEventError = function(_result)
{
try
{
var message = "Failed to uplaod messages (modify completion report)\n\nPlease check operation mode and network connectivity.\n\nPlease restart Tenken application if network is online.";
var detail="";
var ErrorStatus=0;
if(_result.getStatus() == "AR_HTTP_EXCEPTION"){
detail = _result.getValue().status + " : " + _result.getValue().statusText + "\n" + _result.getValue().responseText;
ErrorStatus=_result.getValue().status;
} else {
detail += _result.getStatus() + "\n"+ _result.getValue();
}
Tenken.Util.logerr(message, detail);
// Clear send data.
TenkenData.MsgEvent.deleteMsgEventDatas.length=0;
// It sometimes return with 404 Not Found upon delete.
// When 404 is returned, process the same as success.
if ( 404 == ErrorStatus )
{
// Call upload success callback method
if ( null != TenkenData.MsgEvent.onDeleteSuccess ) TenkenData.MsgEvent.onDeleteSuccess(TenkenData.MsgEvent.cbDeleteValue);
return;
}
else
{
alert(message + "\n\n" + detail);
}
Tenken.Util.logerr("DELETE_MSGEVENT_RESPONSE:ERROR:" + message + ":" + detail);
}
catch (e)
{
alert("Exception : TenkenData.MsgEvent.deleteMsgEventError\n" + e);
}
if ( null != TenkenData.MsgEvent.onDeleteError ) TenkenData.MsgEvent.onDeleteError(TenkenData.MsgEvent.cbDeleteValue);
};
// Delete original message that has completed report.
TenkenData.MsgEvent.deleteMsgEvent = function(_onSuccess, _onError, _value)
{
try {
if ( null != _onSuccess ) TenkenData.MsgEvent.onDeleteSuccess = _onSuccess;
if ( null != _onError ) TenkenData.MsgEvent.onDeleteError = _onError;
if ( null != _value ) TenkenData.MsgEvent.cbDeleteValue = _value;
// Check if delete data exists after completion report.
var lenDeleteMsg=TenkenData.MsgEvent.deleteMsgEventDatas.length;
if ( lenDeleteMsg <= 0 )
{
// Data not present. Call success callback method.
if ( null != _onSuccess ) _onSuccess(_value);
return;
}
if ( null == TenkenData.MsgEvent.arDeleteteMessageEvent ) TenkenData.MsgEvent.arDeleteteMessageEvent=new TenkenARdata(TenkenConst.TableName.messageevent);
Tenken.Util.loginfo("DELETE_MSGEVENT_REQUEST:allcount:" + lenDeleteMsg);
for ( var i=0 ; i < lenDeleteMsg ; i++ )
{
var deleteMsg=TenkenData.MsgEvent.deleteMsgEventDatas[i];
var deleteData=new TenkenARvalue.QDelete(deleteMsg.qentityId, deleteMsg.version );
TenkenData.MsgEvent.arDeleteteMessageEvent.addDeleteData(deleteData);
}
TenkenData.MsgEvent.arDeleteteMessageEvent.deleteArData(TenkenData.MsgEvent.deleteMsgEventSuccess, TenkenData.MsgEvent.deleteMsgEventError);
}
catch (e)
{
alert("Exception : Tenken.GUI.deleteMsgEvent\n" + e);
}
}
|
var editor;
var html="";
var config = {};
config.width = '99%';//编辑器的宽度
config.height = 650;//编辑器的高度
config.toolbar ='Full';
//config.skin='office2003';
config.language = 'zh-cn';
config.toolbarCanCollapse=false;
config.toolbarLocation='top';
config.toolbarStartupExpanded =true;
config.filebrowserUploadUrl = '../fileUpload.shtml?type=File' ;
config.filebrowserImageUploadUrl = '../fileUpload.shtml?type=Image' ;
//config.toolbar = 'Basic'; //基础
//config.toolbar_Full = [//自定义
//['Image','Smiley','SpecialChar']];
// 图片浏览配置
config.filebrowserImageBrowseUrl = '../browerServer.shtml?type=image';
config.resize_enabled = true;
CKEDITOR.on('instanceReady', function (e) {
//$("#cke_content").hide();
})
CKEDITOR.on('dialogDefinition',function (ev) {
var dialogName = ev.data.name;
var dialogDefinition = ev.data.definition;
dialogDefinition.removeContents('advanced');
dialogDefinition.removeContents('Link');
});
|
// Styled Components uses Stylis for CSS preprocessing
const { serialize, compile, stringify } = stylis;
// Used to generate a unique ID per styled component
let counter = 0;
// Reference to the <style> tag injected in the <head>
let styleTag = null;
/**
* Simple hashing function, the real styled-components uses the MurmurHash
* algorithm and then converts the hash number to an alphabetic name:
*
* https://github.com/styled-components/styled-components/blob/v3.3.3/src/utils/generateAlphabeticName.js#L13
*
* @param {String} s
* @returns {Number}
*/
const hash = (s) =>
s.split("").reduce((a, b) => {
a = (a << 5) - a + b.charCodeAt(0);
return a & a;
}, 0);
/**
* Styled Components generates its own <style> tag which contain all the
* styles for each component. If the tag doesn't exist, this function will
* create and inject it into the head
*/
const createOrGetStyleTag = () => {
if (!styleTag) {
const style = document.createElement("style");
style.setAttribute("data-styled-components", "");
document.head.appendChild(style);
styleTag = style;
}
return styleTag;
};
/**
* Concat all the string chunks from the tagged template[1] with the
* results of the expressions one by one; and if an expression is a
* function it is called with the component’s props.
*
* @param {String[]} - Array of template strings
* @param {Function[]} - Array of template expressions
* @param {Record} - Component props
*/
const interpolateStyles = (strs, exprs, props) => {
const evaluatedStyles = exprs.reduce((result, expr, index) => {
const isFunc = typeof expr === "function";
const value = isFunc ? expr(props) : expr;
return result + value + strs[index + 1];
}, strs[0]);
return evaluatedStyles;
};
/**
* Classnames are unique based off the componentId and evaluated styles.
* Which means if we evaluate to new styles we create a new classname. Unused
* styles aren't removed because of unecessary performance overhead:
*
* https://github.com/styled-components/styled-components/issues/1431#issuecomment-358097912
*/
const createClassname = (componentId, evaluatedStyles) => {
const className = "c-" + hash(componentId + evaluatedStyles);
return className;
};
/**
* Inject the styles into the <style> tag if the className doesn't already
* exist
*/
const injectStyles = (className, evaluatedStyles) => {
const selector = "." + className;
const style = createOrGetStyleTag();
if (!style.innerText.includes(selector)) {
const cssStr = serialize(
compile(`${selector}{${evaluatedStyles}}`),
stringify
);
style.appendChild(document.createTextNode(cssStr));
}
};
const styled = (TargetComponent) => (strs, ...exprs) => {
counter++;
const componentId = "sc-" + hash("sc" + counter);
const StyledComponent = ({ className = "", ...props }) => {
// On every rerender we evaluate the styles since props has changed
const evaluatedStyles = interpolateStyles(strs, exprs, props);
// Create a className based off newly evaluated styles
const generatedClassName = createClassname(componentId, evaluatedStyles);
// We only inject in new styles if there are changes to the newly
// evaluated styles
React.useEffect(() => {
injectStyles(generatedClassName, evaluatedStyles);
}, [generatedClassName]);
return (
<TargetComponent
{...props}
className={className + " " + componentId + " " + generatedClassName}
/>
);
};
StyledComponent.componentId = componentId;
return StyledComponent;
};
styled.button = styled("button");
styled.span = styled("span");
window.styled = styled;
/**
[1]
A tagged template:
const Button = styled.button`
color: coral;
background: ${(props) => props.success ? 'green' : 'blue'};
padding: 1rem;
`;
Is the same as:
const Button = styled('button')([
'color: coral; background: ',
'; padding: 0.25rem 1rem;'
], (props) => props.success ? 'green' : 'blue');
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates
*/
|
import React from "react";
import BaseInfoSection from "./details/BaseInfoSection";
import EducationSection from "./details/EducationSection";
import ValuesSection from "./details/ValuesSection";
import InterestsSection from "./details/InterestsSection";
import {accordionComponent} from "../../../decorators/@withAccordion";
@accordionComponent
class DetailsAccordion extends React.Component {
render () {
return <div>
<BaseInfoSection />
<EducationSection />
<ValuesSection />
<InterestsSection />
</div>
}
}
export default DetailsAccordion
|
import { useContext, useRef } from 'react';
import { useHistory } from 'react-router';
import './NewRoomForm.css';
import Button from './../UI/Button';
import { UserContext } from './../../contexts/UserContext';
import { RoomContext } from './../../contexts/RoomContext';
const NewRoomForm = () => {
const history = useHistory();
const auth = useContext(UserContext);
const room = useContext(RoomContext);
const nameInputRef = useRef();
const privateInputRef = useRef();
if (!auth.user) history.push('/');
const createRoomHandler = (e) => {
e.preventDefault();
room.createRoom(
nameInputRef.current.value,
auth.user.id,
privateInputRef.current.checked
);
};
return (
<div className='new-room-container'>
<div className='new-room-form-container'>
<h1>New Room</h1>
<form onSubmit={createRoomHandler}>
<div className='name-control'>
<input
required
ref={nameInputRef}
placeholder='Name'
id='name'
type='text'
autoComplete='off'
/>
</div>
<div className='check-control'>
<input ref={privateInputRef} id='check' type='checkbox' />
<label htmlFor='check'>Private</label>
</div>
<Button type='submit'>Create New Room</Button>
</form>
</div>
</div>
);
};
export default NewRoomForm;
|
const Web3 = require('web3');
const { ClientInterface } = require('./interfaces/client');
const pLimit = require('p-limit');
const rlay = require('@rlay/web3-rlay');
const RlayEntities = require('./rlay');
const EntityMetaFactory = require('./entityMetaFactory');
const RlayOntology = require('@rlay/ontology');
const { SchemaPayload } = require('./schemaPayload');
const { Payload } = require('./payload');
const { Negative } = require('./negative');
const { mix } = require('mixwith');
const check = require('check-types');
const { ClientConfig } = require('./clientConfig');
const { wrapDebug } = require('./utils.js');
const debug = require('./debug');
/**
* The `Client`, ORM, and main interface for users
*/
class ClientBase extends mix(EntityMetaFactory).with(ClientInterface) {
/**
* Create a new Client instance
*
* @param {ClientConfig} config - The configuration for the client
*/
constructor (config = {}) {
super();
this.config = new ClientConfig();
this.initConfig(config);
this.kafka = this.config.kafka;
this.web3 = new Web3(this.config.RpcUrl);
rlay.extendWeb3WithRlay(this.web3);
this.web3.eth.defaultAccount = this.config.address;
this.rlay = rlay;
this.rlayOntology = RlayOntology;
this.SchemaPayload = SchemaPayload;
this.Payload = Payload;
this.schema = {};
this.storeLimit = pLimit(this.config.storeLimit);
this.readLimit = pLimit(this.config.readLimit);
// set client for RlayEntities
Object.keys(RlayEntities).forEach(entity => {
RlayEntities[entity].client = this;
});
Object.assign(this, RlayEntities);
this.Individual = this.Rlay_Individual;
}
async createEntity (entity) {
const thisDebug = debug.extend('createEntity');
const debugFnRlay = (debugObject) => {
thisDebug.extend('performance').extend('rlay')(`${Date.now() - debugObject.startTimestamp}ms`)
}
const debugFnKafka = (debugObject) => {
thisDebug.extend('performance').extend('kafka')(`${Date.now() - debugObject.startTimestamp}ms`)
}
return this.storeLimit(async () => {
const rlayStoreEntityPromise = this.rlay.store(this.web3, entity, { backend: this.config.backend })
const promises = [wrapDebug(rlayStoreEntityPromise, debugFnRlay)];
if (this.kafka) {
const entityObject = this.getEntityFromPayload(entity);
const kafkaStoreEntityPromise = this.kafka.producer.send({
topic: this.kafka.topicName,
messages: [{ key: entityObject.cid, value: JSON.stringify(entityObject.payload) }]
});
promises[1] = wrapDebug(kafkaStoreEntityPromise, debugFnKafka);
}
return Promise.all(promises).then(results => results[0]);
})
}
async createEntities (entities) {
const thisDebug = debug.extend('createEntities');
thisDebug.extend('entities')(entities.length);
const debugFnRlay = (debugObject) => {
thisDebug.extend('performance').extend('rlay')(`${Date.now() - debugObject.startTimestamp}ms`)
}
const debugFnKafka = (debugObject) => {
thisDebug.extend('performance').extend('kafka')(`${Date.now() - debugObject.startTimestamp}ms`)
}
return this.storeLimit(async () => {
const rlayStoreEntitiesPromise = this.rlay.
storeEntities(this.web3, entities, { backend: this.config.backend });
const promises = [wrapDebug(rlayStoreEntitiesPromise, debugFnRlay)];
if (this.kafka) {
const kafkaStoreEntitiesPromise = this.kafka.producer.send({
topic: this.kafka.topicName,
messages: entities.map(entity => {
const entityObject = this.getEntityFromPayload(entity);
return { key: entityObject.cid, value: JSON.stringify(entityObject.payload) };
})
});
promises[1] = wrapDebug(kafkaStoreEntitiesPromise, debugFnKafka);
}
return Promise.all(promises).then(results => results[0]);
});
}
async findEntityByCID (cid) {
return this.readLimit(async () => {
return this.web3.rlay.experimentalGetEntity(cid, { backend: this.config.backend });
});
}
async findEntityByCypher (query) {
return this.readLimit(async () => {
return this.web3.rlay.experimentalNeo4jQuery(query, { backend: 'myneo4j' });
});
}
getEntityCid (payload) {
return this.rlayOntology.getEntityCid(payload);
}
initConfig (config) {
if (config.kafka) {
if (!check.string(config.kafka.topicName) ||
!check.object(config.kafka.producer)) {
throw new Error('invalid kafka config: expected topicName to be string and producer to be an object');
}
}
Object.assign(this.config, config);
}
// eslint-disable-next-line class-methods-use-this
isNegative (value) {
return value instanceof Negative
}
// eslint-disable-next-line class-methods-use-this
negative (obj) {
return new Negative(obj);
}
initSchema (schemaCIDs, schema) {
this.schema = Object.assign(this.schema, schemaCIDs);
// transform this.schema['abc'] = "0x00xx" to
// this.schema['abc'] = { cid: "0x00xx" }
Object.keys(schemaCIDs).forEach(key => {
const cid = this.schema[key];
this.schema[key] = { cid };
});
// add additional schema info from @param: `schema`
schema.forEach(assertion => {
if (this.schema[assertion.key]) {
this.schema[assertion.key] = Object.assign(
this.schema[assertion.key],
assertion.assertion
);
// convert to proper Rlay Entity
this.schema[assertion.key] = this.getEntityFromPayload(
this.schema[assertion.key]
);
}
});
}
initClient () {
Object.keys(this.schema).forEach(key => {
const schemaEntity = this.schema[key];
try {
this[key] = this.fromSchema(schemaEntity);
} catch (_) { }
});
}
}
module.exports = { ClientBase };
|
// pages/auth/auth.js
import common from '../../common/common';
const app = getApp();
Page({
/**
* 页面的初始数据
*/
data: {
url:null
},
/**
* 生命周期函数--监听页面加载
*/
onLoad: function (options) {
// setTimeout(function(){
// wx.reLaunch({
// url: '../index/index',
// })
// },2000)
},
/**
* 生命周期函数--监听页面初次渲染完成
*/
onReady: function () {
},
/**
* 生命周期函数--监听页面显示
*/
onShow: function () {
let that = this;
wx.login({
success: function (res) {
// console.log(res.code);
wx.request({
url: common.basePath + common.InterfaceUrl.login,
data: {
code: res.code
},
method: 'GET',
success(res) {
console.log(res)
wx.setStorageSync('token', res.data.body.token);
// app.globalData.visitorId = res.data.body.visitorId;
wx.request({
url: common.basePath + common.InterfaceUrl.again,
data: {
token: wx.getStorageSync('token'),
// visitorId: app.globalData.visitorId
},
method: 'GET',
// header: {
// 'content-type': 'application/x-www-form-urlencoded' // 默认值
// },
success(ret) {
// console.log(ret)
if (ret.data.errorCode == -2004 || ret.data.errorCode == -2003) {
that.setData({
url:'index'
})
// setTimeout(function () {
// wx.reLaunch({
// url: '../index/index',
// })
// }, 5000)
} else if (ret.data.errorCode == 1) {
app.globalData.fkResonCon = ret.data.body.accessPurpose;
app.globalData.phone = ret.data.body.intervieweeCompanyPhone;
app.globalData.address = ret.data.body.intervieweeCompanyArea;
app.globalData.fkPhone = ret.data.body.visitor.contactNumber;
app.globalData.fkName = ret.data.body.visitor.name;
app.globalData.selectCompany = ret.data.body.visitor.visitCompanyName;
app.globalData.memberId = ret.data.body.visitor.visitPerson.id;
app.globalData.selectMember = ret.data.body.visitor.visitPerson.name;
app.globalData.fkTime = ret.data.body.visitor.visitTime.substring(0, ret.data.body.visitor.visitTime.indexOf(" "));
app.globalData.visitorId=ret.data.body.visitor.id;
that.setData({
url: 'success'
})
// setTimeout(function () {
// wx.reLaunch({
// url: '../success/success?success=' + true,
// })
// }, 5000)
} else {
wx.showToast({
title: '未知错误',
icon:'none'
})
}
}
})
}
})
}
})
},
jump:function(){
if(this.data.url){
if(this.data.url=='index'){
wx.reLaunch({
url: '../index/index',
})
}else{
wx.reLaunch({
url: '../success/success?success=' + true,
})
}
}else{
console.log("还没判断")
}
}
})
|
import React, { Component } from 'react';
import {
Page,
Navbar,
List,
ListItem,
ListInput,
Toggle,
BlockTitle,
Row,
Button,
Range,
Block,
Icon
} from 'framework7-react';
import { dict } from '../../Dict';
import ModelStore from "../../stores/ModelStore";
import * as MyActions from "../../actions/MyActions";
import TaskForm from "../../containers/tasks/form"
import Framework7 from 'framework7/framework7.esm.bundle';
import { conf } from '../../conf';
export default class DocumentUpdate extends Component {
constructor() {
super();
this.submit = this.submit.bind(this);
this.setInstance = this.setInstance.bind(this);
this.getInstance = this.getInstance.bind(this);
this.handleChangeValue = this.handleChangeValue.bind(this);
this.pageAfterIn = this.pageAfterIn.bind(this);
this.loadTags = this.loadTags.bind(this);
this.removeTag = this.removeTag.bind(this);
this.deleteTaskConfirm = this.deleteTaskConfirm.bind(this);
this.deleteTask = this.deleteTask.bind(this);
this.deleteInstance = this.deleteInstance.bind(this);
this.state = {
token: window.localStorage.getItem('token'),
task: {},
id: null,
title: null,
details: null,
privateTask: true,
details: null,
tags: [],
isPublic: false,
selectedMode: false,
archived: false,
archiveNote: null,
}
}
componentWillMount() {
ModelStore.on("got_instance", this.getInstance);
ModelStore.on("set_instance", this.setInstance);
ModelStore.on("deleted_instance", this.deleteInstance);
}
componentWillUnmount() {
ModelStore.removeListener("got_instance", this.getInstance);
ModelStore.removeListener("set_instance", this.setInstance);
ModelStore.removeListener("deleted_instance", this.deleteInstance);
}
pageAfterIn() {
this.loadTags();
}
loadTags() {
const self = this;
const app = self.$f7;
app.autocomplete.create({
openIn: 'popup', //open in page
openerEl: '#autocomplete-standalone-ajax', //link that opens autocomplete
multiple: true, //allow multiple values
valueProperty: 'id', //object's "value" property name
textProperty: 'title', //object's "text" property name
limit: 50,
searchbarPlaceholder: dict.search,
searchbarDisableText: dict.cancel,
popupCloseLinkText: dict.close,
notFoundText: dict.not_found,
preloader: true, //enable preloader
source: function (query, render) {
var autocomplete = this;
var results = [];
if (query.length === 0) {
render(results);
return;
}
// Show Preloader
autocomplete.preloaderShow();
// Do Ajax request to Autocomplete data
app.request({
url: conf.server + '/tags/search',
method: 'GET',
dataType: 'json',
//send "query" to server. Useful in case you generate response dynamically
data: {
q: query
},
success: function (item) {
// Find matched items
for (var i = 0; i < item.data.length; i++) {
if (item.data[i].title.indexOf(query) >= 0) results.push(item.data[i]);
}
// Hide Preoloader
autocomplete.preloaderHide();
// Render items by passing array with result items
render(results);
}
});
},
on: {
change: function (value) {
if (value && value[value.length - 1]) {
self.setState({ tags: self.state.tags.concat({ title: value[value.length - 1].title, id: value[value.length - 1].id }) })
}
},
},
});
}
submit() {
this.$$('.btn').hide();
this.$$('.btn-notice').text(dict.submitting);
var data = {
id: this.state.id, title: this.state.title, public: this.state.isPublic,
details: this.state.details, tags: this.state.tags, archive_note: this.state.archiveNote,
archived: this.state.archived
}
if (this.state.title && this.state.title.length > 0) {
MyActions.updateInstance('tasks', data, this.state.token);
} else {
const self = this;
self.$f7.dialog.alert(dict.incomplete_data, dict.alert);
}
}
componentDidMount() {
this.loadData();
}
loadData() {
const f7: Framework7 = Framework7.instance;
f7.toast.show({ text: dict.receiving, closeTimeout: 2000, position: 'top' });
if (this.$f7route.params['taskId']) {
MyActions.getInstance('tasks', this.$f7route.params['taskId'], this.state.token);
}
}
getInstance() {
var task = ModelStore.getIntance()
var klass = ModelStore.getKlass()
if (task && klass === 'Task') {
this.setState({
title: task.title,
details: task.details,
id: task.id,
task: task,
defaultTask: task.default_task,
tags: task.the_tags,
isPublic: task.is_public,
archived: task.archived,
archiveNote: task.archive_note,
}, () => this.loadTags());
}
}
removeTag(id) {
this.setState({
tags: this.state.tags.filter(function (tag) {
return tag.id !== id
})
});
}
handleChangeValue(obj) {
console.log(obj)
this.setState(obj);
}
deleteTaskConfirm(){
const self = this;
const app = self.$f7;
app.dialog.confirm(dict.are_you_sure, dict.alert, self.deleteTask)
}
deleteTask(){
var data = { id: this.state.id}
MyActions.removeInstance('tasks', data, this.state.token);
}
deleteInstance() {
this.$f7router.navigate('/tasks/');
}
setInstance() {
var task = ModelStore.getIntance()
var klass = ModelStore.getKlass()
if (task && klass === 'Task') {
this.$$('.btn').show();
this.$f7router.navigate('/tasks/' + task.id);
}
}
render() {
const { task, defaultTask, title, details, isPublic, tags, selectedMode, archived, archiveNote } = this.state;
return (
<Page onPageAfterIn={this.pageAfterIn.bind(this)} backLink={dict.back} backLinkForce={true}>
<Navbar title={dict.task_form} backLink={dict.back} />
<BlockTitle>{dict.task_form}</BlockTitle>
<TaskForm
task={task} title={title} isPublic={isPublic}
tags={tags} removeTag={this.removeTag} selectedMode={selectedMode}
details={details} defaultTask={defaultTask} submit={this.submit}
editing={true} handleChange={this.handleChangeValue}
deleteTaskConfirm={this.deleteTaskConfirm}
archived={archived} archiveNote={archiveNote}
/>
</Page>
);
}
}
|
/**
* Chat Area Component
*/
import React, { Component } from 'react';
import MessageBlock from './MessageBlock';
import { FormGroup, Input } from 'reactstrap';
import { Scrollbars } from 'react-custom-scrollbars';
import { connect } from 'react-redux';
import Button from '@material-ui/core/Button';
import IconButton from '@material-ui/core/IconButton';
import Menu from '@material-ui/core/Menu';
import MenuItem from '@material-ui/core/MenuItem';
import { withRouter } from 'react-router-dom';
import MenuIcon from '@material-ui/icons/Menu';
// actions
import { sendMessageToUser } from 'Actions';
// app layouts
import { getAppLayout } from 'Helpers/helpers';
class ChatArea extends Component {
state = {
message: '',
anchorEl: null,
chatOptions: [
'Mute Notifications',
'Block',
'Clear Chat',
'Send Contact'
]
}
handleClose = () => {
this.setState({ anchorEl: null });
};
chatOptionsHandler = event => {
this.setState({ anchorEl: event.currentTarget });
}
onSubmitMessage(event) {
event.preventDefault();
if (this.state.message !== '') {
let data = {
user: this.props.selectedUser,
message: this.state.message,
isAdmin: true,
time: 'Just Now'
}
this.props.sendMessageToUser(data);
this.setState({ message: '' });
setTimeout(() => {
this.refs.chatScroll.scrollToBottom();
}, 200);
}
}
getScrollHeight() {
const { location } = this.props;
const appLayout = getAppLayout(location)
if (this.props.fullHeight) {
return 'calc(100vh - 226px)';
} else {
switch (appLayout) {
case 'app':
return 'calc(100vh - 198px)';
case 'agency':
return 'calc(100vh - 387px)';
case 'boxed':
return 'calc(100vh - 387px)';
case 'horizontal':
return 'calc(100vh - 250px)';
default:
break;
}
}
}
render() {
const { selectedUser, admin_photo_url } = this.props;
if (selectedUser === null) {
return (
<div className="chat-box-main">
<div className="text-center">
<i className="zmdi zmdi-comments font-3x mb-2"></i>
<Button className="d-none sidebar-toggler" onClick={this.props.onMenuIconPress}>Select user</Button>
</div>
</div>
);
}
const { chatOptions, anchorEl } = this.state;
return (
<div className="chat-main-body">
<div className="chat-head">
<div className="d-flex justify-content-between align-items-center">
<div className="media align-items-center">
<IconButton
className="mr-3 chat-sidebar-toggler d-none"
color="inherit"
aria-label="open drawer"
onClick={this.props.onMenuIconPress}
>
<MenuIcon />
</IconButton>
<div className="mr-10">
<img
src={selectedUser.photo_url}
alt="user profile"
className="rounded-circle"
width="40"
height="40"
/>
</div>
<div className="media-body mt-1">
<h5 className="mb-0">{selectedUser.first_name} {selectedUser.last_name}</h5>
<span className="font-xs text-muted">{selectedUser.status}</span>
</div>
</div>
<div>
<IconButton className="bg-primary text-white video-icon">
<i className="zmdi zmdi-videocam"></i>
</IconButton>
<IconButton className="bg-primary text-white">
<i className="zmdi zmdi-attachment-alt"></i>
</IconButton>
<IconButton
aria-owns={anchorEl ? 'simple-menu' : null}
aria-haspopup="true"
onClick={this.chatOptionsHandler}
>
<i className="zmdi zmdi-more-vert"></i>
</IconButton>
<Menu
id="simple-menu"
anchorEl={anchorEl}
open={Boolean(anchorEl)}
onClose={this.handleClose}
>
{chatOptions.map((option, key) => (
<MenuItem key={key} onClick={this.handleClose}>{option}</MenuItem>
))}
</Menu>
</div>
</div>
</div>
<Scrollbars
className="rct-scroll"
autoHide
ref="chatScroll"
style={{ height: this.getScrollHeight() }}
>
<div className="chat-body p-30">
{selectedUser.previousChats.map((previousChat, key) => (
<MessageBlock
even={!previousChat.isAdmin}
key={key}
selectedUserPhotoUrl={selectedUser.photo_url}
data={previousChat}
adminPhotoUrl={admin_photo_url}
/>
))}
</div>
</Scrollbars>
<div className="chat-footer d-flex px-4 align-items-center py-3">
<form onSubmit={(event) => this.onSubmitMessage(event)} className="mr-3 w-100">
<FormGroup className="mb-0">
<Input
type="text"
id="search-msg"
placeholder="Type your message"
value={this.state.message}
className="msg-input"
onChange={(event) => this.setState({ message: event.target.value, })}
/>
</FormGroup>
</form>
<Button
variant="contained"
color="primary"
onClick={(event) => this.onSubmitMessage(event)}
className="submit-btn bg-primary"
>
Send
<i className="zmdi zmdi-mail-send ml-2"></i>
</Button>
</div>
</div>
);
}
}
const mapStateToProps = ({ chatAppReducer }) => {
return chatAppReducer;
}
export default withRouter(connect(mapStateToProps, {
sendMessageToUser
})(ChatArea));
|
import React from 'react'
import { useSelector } from 'react-redux'
const Notification = () => {
console.log('graaah ', useSelector((state) => state))
const message = useSelector((state) => state.notification.message)
const errorMessage = useSelector((state) => state.notification.errorMessage)
return (
(message && <div className="infoText">{message}</div>) ||
(errorMessage && <div className="error">{errorMessage}</div>) ||
null
)
}
export default Notification
|
'use strict';
export const STORE_RATES_DATA = 'STORE_RATES_DATA';
export const STORE_APP_SETTINGS_DATA = 'STORE_APP_SETTINGS_DATA';
export const STORE_BANKS_DATA = 'STORE_BANKS_DATA';
|
/**
* @name NitroPerksReBoot
* @author Hexa
*/
module.exports = (() => {
const config = {
"info": {
"name": "NitroPerksReBoot",
"authors": [{
"name": "Hexa",
"github_username": "ArgyleFelix"
}],
"version": "2.0.0",
"description": "Unlock all screensharing modes, use cross-server emotes and gif emojis.",
"github": "https://github.com/ArgyleFelix/NitroPerksReBoot",
"github_raw": "https://raw.githubusercontent.com/ArgyleFelix/NitroPerksReBoot/main/NitroPerksReBoost.plugin.js"
},
"main": "NitroPerksReBoot.plugin.js"
};
return !global.ZeresPluginLibrary ? class {
constructor() {
this._config = config;
}
getName() {
return config.info.name;
}
getAuthor() {
return config.info.authors.map(a => a.name).join(", ");
}
getDescription() {
return config.info.description;
}
getVersion() {
return config.info.version;
}
load() {
BdApi.showConfirmationModal("Library Missing", `The library plugin needed for ${config.info.name} is missing. Please click Download Now to install it.`, {
confirmText: "Download Now",
cancelText: "Cancel",
onConfirm: () => {
require("request").get("https://rauenzi.github.io/BDPluginLibrary/release/0PluginLibrary.plugin.js", async (error, response, body) => {
if (error) return require("electron").shell.openExternal("https://betterdiscord.net/ghdl?url=https://raw.githubusercontent.com/rauenzi/BDPluginLibrary/master/release/0PluginLibrary.plugin.js");
await new Promise(r => require("fs").writeFile(require("path").join(BdApi.Plugins.folder, "0PluginLibrary.plugin.js"), body, r));
});
}
});
}
start() {}
stop() {}
} : (([Plugin, Api]) => {
const plugin = (Plugin, Api) => {
const {
Patcher,
DiscordModules,
DiscordAPI,
Settings,
PluginUtilities
} = Api;
return class NitroPerksReBoot extends Plugin {
defaultSettings = {
"emojiSize": "40",
"screenSharing": true,
"emojiBypass": true,
};
settings = PluginUtilities.loadSettings(this.getName(), this.defaultSettings);
originalNitroStatus = 0;
clientsidePfp;
screenShareFix;
getSettingsPanel() {
return Settings.SettingPanel.build(_ => this.saveAndUpdate(), ...[
new Settings.Switch("Enable Nitro Scrteen Share", this.settings.screenSharing, value => this.settings.screenSharing = value),
new Settings.Switch("Enable Emoji Bypass", this.settings.emojiBypass, value => this.settings.emojiBypass = value),
new Settings.Slider("Size", "Choose Emoji Size. (40 is recommended)", 16, 64, this.settings.emojiSize, size=>this.settings.emojiSize = size, {markers:[16,20,32,40,64], stickToMarkers:true}),
])
}
saveAndUpdate() {
PluginUtilities.saveSettings(this.getName(), this.settings)
if (!this.settings.screenSharing) {
switch (this.originalNitroStatus) {
case 1:
BdApi.injectCSS("screenShare", `#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(1) > div > button:nth-child(4) {
display: none;
}`)
this.screenShareFix = setInterval(()=>{
document.querySelector("#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(1) > div > button:nth-child(3)").click()
clearInterval(this.screenShareFix)
}, 100)
break;
default:
BdApi.injectCSS("screenShare", `#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(1) > div > button:nth-child(4) {
display: none;
}
#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(1) > div > button:nth-child(3) {
display: none;
}
#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(2) > div > button:nth-child(3) {
display: none;
}`)
this.screenShareFix = setInterval(()=>{
document.querySelector("#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(1) > div > button:nth-child(2)").click()
document.querySelector("#app-mount > div.layerContainer-yqaFcK > div.layer-2KE1M9 > div > div > form > div:nth-child(2) > div > div > div.flex-1xMQg5.flex-1O1GKY.horizontal-1ae9ci.horizontal-2EEEnY.flex-1O1GKY.directionRow-3v3tfG.justifyStart-2NDFzi.alignStretch-DpGPf3.noWrap-3jynv6.modalContent-BM7Qeh > div:nth-child(2) > div > button:nth-child(2)").click()
clearInterval(this.screenShareFix)
}, 100)
break;
}
}
if (this.settings.screenSharing) BdApi.clearCSS("screenShare")
if (this.settings.emojiBypass) {
Patcher.before(DiscordModules.MessageActions, "sendMessage", (_, [, msg]) => {
msg.validNonShortcutEmojis.forEach(emoji => {
if (emoji.url.startsWith("/assets/")) return;
msg.content = msg.content.replace(`<${emoji.animated ? "a" : ""}${emoji.allNamesString.replace(/~\d/g, "")}${emoji.id}>`, emoji.url + `&size=${this.settings.emojiSize} `)
})
});
Patcher.before(DiscordModules.MessageActions, "editMessage", (_,obj) => {
let msg = obj[2].content
if (msg.search(/\d{18}/g) == -1) return;
msg.match(/<a:.+?:\d{18}>|<:.+?:\d{18}>/g).forEach(idfkAnymore=>{
obj[2].content = obj[2].content.replace(idfkAnymore, `https://cdn.discordapp.com/emojis/${idfkAnymore.match(/\d{18}/g)[0]}?size=${this.settings.emojiSize}`)
})
});
}
if(!this.settings.emojiBypass) Patcher.unpatchAll(DiscordModules.MessageActions)
}
onStart() {
this.originalNitroStatus = DiscordAPI.currentUser.discordObject.premiumType;
this.saveAndUpdate()
DiscordAPI.currentUser.discordObject.premiumType = 2
}
onStop() {
DiscordAPI.currentUser.discordObject.premiumType = this.originalNitroStatus;
Patcher.unpatchAll();
}
};
};
return plugin(Plugin, Api);
})(global.ZeresPluginLibrary.buildPlugin(config));
})();
|
/**
* Created by KJain on 8/11/2016.
*/
var MongoClient = require('mongodb').MongoClient;
var db;
var connected = false;
module.exports = {
connect: function(url, callback){
MongoClient.connect(url, function(err, _db){
if (err) {
console.log('Unable to connect to the mongoDB server. Error:', err);
}
db = _db;
connected = true;
callback(db);
});
},
collection: function(name){
if (!connected) {
throw new Error('Must connect to Mongo before calling "collection"');
}
return db.collection(name);
}
};
|
import React from 'react';
import './WeDoCard.css';
function WeDoCard(props) {
const weDoCard = props;
return (
<div className={`wedocard ${weDoCard.backgroundColor}`}>
<img
className="wedocard-img"
src={require(`../../../assets/whatwedo/${weDoCard.image}`)}
alt={weDoCard.title}
/>
<div className="wedocard-body">
<h4>{weDoCard.title}</h4>
<p>{weDoCard.description}</p>
<a href={weDoCard.buttonLink}>
<button className={`wedocard-button ${weDoCard.backgroundColor}`}>
{weDoCard.button}
</button>
</a>
</div>
</div>
);
}
export default WeDoCard;
|
import React from 'react'
import './Team.css'
import TeamArray from './TeamArray'
import TeamCard from './TeamCard'
function Team() {
return (
<div className='team-container'>
<h2 className='team-quote'>Without bonding and Coordination every project is a failure. LOOK at who makes KICKSUP great. ;)</h2>
<div className='team-members'>
{
TeamArray.map((item,index)=>{
return(
<TeamCard src={item.src} name={item.name} role={item.role}/>
)
})
}
</div>
<h2>and You!</h2>
</div>
)
}
export default Team
|
const bcrypt = require('bcrypt');
const express = require('express');
const UserService = require('../services/user');
const uuidv1 = require('uuid/v1');
const userPublic = express.Router();
userPublic.post('/', (req, res) => {
// create user
const {
username,
email,
password
} = req.body;
// console.log(req.body);
if (!username || !email || !password) {
res.json({
message: 'require username, email, and password.'
});
return;
} else {
bcrypt.hash(password, 10)
.then(cryptPass => {
return UserService.create(username, email, cryptPass);
})
.then(_ => {
res.status(201).json({
message: `${username} created`,
});
}).catch((err) => {
res.status(400).json({
error: `could not create ${username}, try again`,
})
})
}
});
userPublic.get('/:user_id', (req, res) => {
// gets user's info; probably ALL info
const {
user_id
} = req.params;
UserService.read(user_id)
.then(data => {
// console.log(data)
res.status(200).json({
username: data.username,
bio: data.bio,
})
return;
}).catch(err => {
// console.log(err)
res.json({
error: 'user not found',
})
return;
})
});
userPublic.get('/:user_id/posts', (req, res) => {
// gets all user's posts
const {
user_id
} = req.params;
UserService.read(user_id)
.then(data => {
return UserService.getAllPosts(data.id)
}, err => {
res.status(400).json({
message: `could not find ${user_id}`,
})
return;
})
.then(data => {
res.status(200).json({
data,
})
return;
})
.catch(err => {
res.status(400).json({
message: 'no posts found',
})
return;
});
});
userPublic.get('/:user_id/posts/:post_id', (req, res) => {
// gets specific post from user
const {
user_id,
post_id
} = req.params;
UserService.read(user_id)
.then(data => {
return UserService.getPost(data.id, post_id);
}, err => {
res.status(400).json({
message: `could not find ${user_id}`,
})
return;
})
.then(data => {
res.status(200).json({
data,
})
return;
})
.catch(err => {
res.status(400).json({
message: 'no posts found',
})
return;
});
});
userPublic.get('/:user_id/comments', (req, res) => {
// gets all user comments
const {
user_id
} = req.params;
UserService.read(user_id)
.then(data => {
return UserService.getAllComments(data.id)
}).then(data => {
res.status(200)
.json({
data,
});
return;
}).catch(err => {
res.status(404)
.json({
message: 'Comments not found',
});
return;
})
});
userPublic.get('/:user_id/comments/:comment_id', (req, res) => {
// gets specific comment from user
const {
user_id,
comment_id
} = req.params;
UserService.read(user_id)
.then(data => {
return UserService.getComment(data.id, comment_id)
}).then(data => {
res.status(200)
.json({
data,
});
return;
}).catch(err => {
res.status(404)
.json({
message: 'Comment not found',
});
return;
})
});
userPublic.post('/login', (req, res) => {
// user login
const {
username,
password
} = req.body;
let token = "";
let id = -1;
UserService.read(username)
.then(data => {
if (data.username !== username) {
res.status(401).json({
message: 'login info invalid, try again'
})
return;
}
id = data.id;
return bcrypt.compare(password, data.password);
}).then(result => {
if (!result) {
throw new Error(`The password didn't match.`)
} else {
token = uuidv1();
return UserService.login(id, token);
}
})
.then(data => {
res.status(200)
.json({
message: 'login successful',
token,
});
return;
})
.catch(err => {
console.log(err)
res.json({
message: 'error, try again'
});
return;
});
});
module.exports = userPublic;
|
function Public() {
}
//返回行业value
Public.prototype.returnIndustryName = function(val){
switch(val){
case "computer":
return "计算机/互联网/通信/电子";
case "accounting":
return "会计/金融/银行/保险";
case "trade":
return "贸易/消费/制造/运营";
case "pharmacy":
return "制药/医疗";
case "advertisement":
return "广告/媒体";
case "realEstate":
return "房地产/建筑";
case "education":
return "专业服务/教育/培训";
case "service":
return "服务业";
case "logistics":
return "物流/运输";
case "energy":
return "能源/原材料";
}
};
//返回职称
Public.prototype.returnpositionName = function(val){
switch (val){
case "staffMember":
return "职员";
case "management":
return "管理人员";
case "seniorManagement":
return "高级管理人员";
case "other":
return "其他";
}
};
//返回婚姻状态
Public.prototype.returnMarriageName = function(val){
switch (val){
case "unmarried":
return "未婚";
case "married":
return "已婚已育";
case "marUnbred":
return "已婚未育";
case "divorce":
return "离异";
}
};
//返回爱好
Public.prototype.returnEnjoinName = function(val){
switch (val){
case "photography":
return "摄影";
case "greenPlanting":
return "绿植";
case "pet":
return "宠物";
case "fashion":
return "时尚";
case "painting":
return "绘画";
case "music":
return "音乐";
case "motion":
return "运动";
}
};
//返回配送方式
Public.prototype.returnSendPart = function(val){
switch (val){
case "deliveryService":
return "送货上门";
case "selfLifting":
return "自提"
}
};
//返回快递状态
Public.prototype.returnExpressStatus = function(status){
switch (status){
case "wait":
return "待发货";
case "no_pay":
return "待支付";
case "running":
return "确认收货";
case "end":
return "已完成";
}
};
var publicServe = new Public();
|
import {canvas, createCanvas} from '../createFunctions/createCanvas';
import {STATE} from '../const/const';
import {
createButtons,
drawButtons,
} from '../createFunctions/createButtonsForMenu';
import {activateHovering} from '../designFunctions/activateHovering';
import {choseMenu} from '../designFunctions/activateClickForMenu';
import {createMenu} from './mainMenu';
import {navigationMenu} from './navigationMenu/navigationMenu';
import {choseCaracterScreen} from './choseCaracterScreen';
/**
* createCaracter Button
*/
const createCaracter = createButtons(
canvas.width / 2 - 100,
canvas.height / 2 - 100,
200,
50,
'Caracter',
'white'
);
const cancel = createButtons(
canvas.width / 2 - 100,
canvas.height / 2 - 25,
200,
50,
'Cancel',
'white'
);
export const playScreen = () => {
/**
* remove old components
*/
createCanvas();
/** Set State */
STATE.setTitle('Ingame');
/** Draw Button */
drawButtons(createCaracter, cancel);
};
/**
* Activate Hovering
*/
activateHovering(
() => {
navigationMenu('Ingame', playScreen, 'Ingame');
},
createCaracter,
cancel
);
/**
* Activate Click
*/
choseMenu(() => {
navigationMenu('Ingame', choseCaracterScreen, 'choseCaracter');
}, createCaracter);
choseMenu(() => {
navigationMenu('Ingame', createMenu, 'Menu');
}, cancel);
|
import React from 'react'
import { db } from '../firebase'
import './List.css'
export default class MyList extends React.Component {
state = {
item: null,
length: 0,
}
componentDidMount() {
const data = db.collection('Classes');
data.get()
.then(snapshot => {
const len = snapshot.size
this.setState({ length: len })
const item = []
snapshot.forEach(doc => {
const data = doc.data()
item.push(data)
})
this.setState({ item: item })
})
}
render() {
return (
<div style={{width:"1200px"}} >
<div className='ribbon' >
Found {this.state.length} Pidgin classes around you.
</div>
<div style={{ display: 'flex', maxWidth: '100%', flexWrap: 'wrap', justifyContent: 'space-around' }} >
{
this.state.item &&
this.state.item.map(item => {
return (
<a href={"/class/"+item.id} style={{color:"inherit"}} >
<div className='items' >
<div style={{ overflow:"hidden", width: '100%', maxHeight: '200px' }} >
{
item.i1 ? (
<img alt="s" src={item.i1} width="100%" />
) : (
<img alt="s" src={item.i2} width="100%" />
)
}
</div>
<div style={{ textAlign: 'left' }} >
<div className='heading' >{item.name}</div>
<div style={{ fontSize: '13px', lineHeight: 'normal', margin: '15px 0px', color: 'grey' }} >{item.address}</div>
<div className='fees' >Staring Fees: ₹{item.fees}</div>
</div>
<div style={{ display: 'flex', justifyContent: 'space-between', border: 'solid 1px grey', padding: '10px', marginTop: '15px' }} >
<div className='detail' >{item.type}</div>
<div className='detail' >Age: {item.age}+</div>
</div>
</div>
</a>
)
})
}
</div>
</div>
)
}
}
|
class Restaurant {
constructor(budget) {
this.budgetMoney = Number(budget);
this.menu = {};
this.stockProducts = {};
this.history = [];
}
loadProducts(products) {
let result = [];
for (let entry of products) {
entry = entry.split(' ');
let productTotalPrice = Number(entry.pop());
let productQuantity = Number(entry.pop());
let productName = entry.join(' ');
if (productTotalPrice <= this.budgetMoney) {
if (this.stockProducts[productName]) {
this.stockProducts[productName] += productQuantity;
}
else {
this.stockProducts[productName] = productQuantity;
}
this.budgetMoney -= productTotalPrice;
result.push(`Successfully loaded ${productQuantity} ${productName}`);
}
else {
result.push(`There was not enough money to load ${productQuantity} ${productName}`);
}
}
this.history = [...this.history, ...result];
return this.history.join('\n');
}
addToMenu(meal, neededProducts, price) {
if (!this.menu[meal]) {
this.menu[meal] = { neededProducts: [], price: price };
for (let i = 0; i < neededProducts.length; i++) {
let [productName, productQuantity] = neededProducts[i].split(' ');
this.menu[meal].neededProducts.push({ productName: productName, productQuantity: productQuantity });
}
let mealsCount = Object.keys(this.menu).length;
if (mealsCount == 1) {
return `Great idea! Now with the ${meal} we have 1 meal in the menu, other ideas?`;
}
else if (mealsCount > 1) {
return `Great idea! Now with the ${meal} we have ${mealsCount} meals in the menu, other ideas?`;
}
}
else {
return `The ${meal} is already in the our menu, try something different.`;
}
}
showTheMenu() {
let result = [];
let mealsCount = Object.keys(this.menu).length;
if (mealsCount > 0) {
for (const meal in this.menu) {
result.push(`${meal} - $ ${this.menu[meal].price}`);
}
}
else if (mealsCount == 0) {
result.push(`Our menu is not ready yet, please come later...`);
}
return result.join('\n');
}
makeTheOrder(meal) {
let orderedMeal = this.menu[meal];
if (orderedMeal == undefined) {
return `There is not ${meal} yet in our menu, do you want to order something else?`;
}
else {
let neededProducts = orderedMeal.neededProducts;
for (let i = 0; i < neededProducts.length; i++) {
let productName = neededProducts[i].productName;
let productQuantity = neededProducts[i].productQuantity;
if (!this.stockProducts[productName] || this.stockProducts[productName] < productQuantity) {
return `For the time being, we cannot complete your order (${meal}), we are very sorry...`;
}
}
for (let i = 0; i < neededProducts.length; i++) {
let productName = neededProducts[i].productName;
let productQuantity = neededProducts[i].productQuantity;
this.stockProducts[productName] -= productQuantity;
}
this.budgetMoney += orderedMeal.price;
return `Your order (${meal}) will be completed in the next 30 minutes and will cost you ${orderedMeal.price}.`;
}
}
}
|
/**
* A wrapper around a Google map. Use centerMap(latitude, longitude) to center
* the map at the specified location.
*/
Ext.define('webapp.view.map', {
extend : 'Ext.panel.Panel', //'Ext.Component',
renderTo: Ext.getBody(),
xtype : 'gpsmappanel',
height: 500,
width: 1000,
config : {
store : null
},
padding : 8,
html : '<p>Google Map Area</p>',
initComponent : function() {
this.markers = [];
this.callParent();
// 41.8894° N, 87.5906° W Chicago Lighthouse
this.centerMap(41.8894, -87.5906);
},
renderMap : function() {
//debugger;
//var image = "BlackNYelloCircle.png"; //'http://google.com/mapfiles/kml/paddle/pause.png';
// Assert : centerMap() has been run, and therefore,
// this.latitude and this.longitude are set.
var cfg = {
zoom : this.zoom,
center : new google.maps.LatLng(this.latitude, this.longitude),
mapTypeId : google.maps.MapTypeId.ROADMAP
};
this.map = new google.maps.Map(this.body.dom, cfg); //(this.getEl().dom, cfg);
this.renderMarkers();
},
centerMap : function(latitude, longitude) {
//debugger;
// Save the latitude/longitude
this.latitude = latitude;
this.longitude = longitude;
// If we're visible, render the map right away. Else
// wait until someone clicks on the tab.
if (this.isVisible()) {
this.renderMap();
} else {
//debugger;
this.on('show', this.renderMap, this, {
single : true
});
}
},
saveCenterAndZoomMap : function(latitude, longitude, zoom) {
//debugger;
// Save the latitude/longitude
this.latitude = latitude;
this.longitude = longitude;
this.zoom = zoom;
},
highlight : function(record){
if (this.selection === record){
return;
}
this.selection = record;
var markers = this.getMarkers();
for (var i = 0 ; i < markers.length ; i++){
var marker = markers[i];
if (marker.record === record){
marker.setIcon('resources/images/YellowStar.png');
} else {
marker.setIcon();
}
}
},
addMarker : function(lat,long) {
//debugger;
var ll = new google.maps.LatLng(lat,long);
var marker = new google.maps.Marker({
position : ll,
title : 'new point',
// animation: google.maps.Animation.DROP,
listeners: {
click: function(e){
Ext.Msg.alert('It\'s fine', 'and it\'s art.');
}
}
});
//marker.setIcon('resources/images/BlackNYelloCircle.png');
var me = this;
marker.setMap(me.map);
this.markers.push(marker);
},
getMarkers : function() {
return (this.markers || []);
},
removeMarkers : function() { //businesses) {
//debugger;
var tmarkers = this.getMarkers();
var tme = this;
var tmap = tme.map;
// Hide the previously saved markers
var markers = this.getMarkers();
Ext.Array.forEach(markers, function(marker) {
marker.setMap(null);
});
},
setMarkers : function() { //businesses) {
//debugger;
// Hide the previously saved markers
var markers = this.getMarkers();
Ext.Array.forEach(markers, function(marker) {
marker.setMap(null);
});
/*
this.markers = [];
var me = this;
var markers = this.getMarkers();
Ext.Array.forEach(markers, function(marker) {
me.markers.push(marker);
//marker.setMap(null);
});
*/
/*
// For each business, push a new marker onto the array
var me = this;
var ll = new google.maps.LatLng(41.8,-87.6); //(r.data.latitude, r.data.longitude);
var marker = new google.maps.Marker({
position : ll,
title: 'test'
});
me.markers.push(marker);
*/
// If we're visible, render the markers right away. Else
// wait until someone clicks on the tab.
if (this.isVisible()) {
this.renderMarkers();
} else {
this.on('show', this.renderMarkers, this, {
single : true
});
}
},
// @private
renderMarkers : function() {
//debugger;
// This method must always be run after setMarkers()
// Assert: this.map is set.
var me = this;
var t = this.getMarkers();
Ext.Array.forEach(this.getMarkers(), function(marker) {
marker.setMap(me.map);
});
}
});
|
var audio_context = window.AudioContext || window.webkitAudioContext,
con = new audio_context(),
osc = con.createOscillator(),
lfo = con.createOscillator(),
lfo_amp = con.createGain(), /* simple amplifier */
mouse_control = document.querySelector('.mouse_control'),
mousecon = document.getElementById('mousecon');
lfo_amp.gain.value = 40;
osc.frequency.value = 400;
lfo.frequency.value = 35; //0.25;
lfo.connect(lfo_amp);
lfo_amp.connect(osc.frequency);
osc.connect(con.destination);
//osc.start();
lfo.start();
//mouse_control.mousemove = function(event) {trackMouse(event)};
//mousecon.addEventListener("mousemove", trackMouse, false);
mousecon.onmousemove = trackMouse;
function trackMouse(e) {
lfo.frequency.value = e.clientX;
console.log(e.clientX);
};
|
$(function () {
var user = {}
$('#chat').hide();
$('#footer').hide();
$('#warn').hide();
var socket = io(),
$nameForm = $('#name-form'),
$nameInput = $('#name-input'),
$name = $('#name'),
$chat = $('#chat'),
$warn = $('#warn'),
$messages = $('#messages'),
$chatForm = $('#chat-form'),
$m = $('#m'),
myName = "",
userList = [];
$('#login-btn').click(function(){
socket.emit('logged', $nameInput.val(), function(res){
if (res){
$name.hide()
$chat.show()
$('#footer').show()
myName = $nameInput.val()
$messages.append($('<div class="ui success message">').html('Te has conectado como: ' + $nameInput.val()))
} else {
$warn.html('The username you entered is already being used by someone else. <br> Please try again with another.').show();
setTimeout(hideWarning, 3000);
}
})
})
$chatForm.submit(function(e){
e.preventDefault();
socket.emit('chat message', $m.val());
$messages.append($('<div class="ui message">')
.html('<div class="header"><strong>' + myName + ' </strong> says:</div><p>' + $m.val() + '</p>'))
$m.val('');
$('#chat').scrollTop($('#chat').prop("scrollHeight"));
});
socket.on('chat message', function(msg){
$messages.append($('<div class="ui message">')
.html('<div class="header"><strong>' + msg.username + ' </strong> says:</div><p>'+ msg.message + '</p>'));
$('#chat').scrollTop($('#chat').prop("scrollHeight"));
});
socket.on('userlists', function(data){
$('#userslist').html(data.list.map(function(val){
return '<p>'+val+'</p>';
}));
});
function hideWarning(){
$('#warn').hide()
}
});
|
const path = require('path');
let webpack =require('webpack');
// 插件都是一个类，所以我们命名的时候尽量用大写开头
const HtmlWebpackPlugin = require('html-webpack-plugin');
// 清理文件
const CleanWebpackPlugin = require('clean-webpack-plugin');
// Vue 插件
const VueLoaderPlugin = require('vue-loader/lib/plugin');
module.exports = {
// 入口文件
entry: './src/main.js',
// 出口文件
output: {
// 打包后的文件名称
filename: 'bundle.js',
// 打包后的目录，必须是绝对路径
path: path.resolve('dist')
},
// 处理对应模块
module: {
rules: [
{
test: /\.css$/,
// 从右向左解析
use: [
'vue-style-loader',
'style-loader',
{
loader: 'css-loader',
options: { importLoaders: 1 }
},
'postcss-loader',
],
},
{
test: /\.less$/,
use: [
'vue-style-loader',
'css-loader',
'less-loader',
'postcss-loader',
]
},
{
test: /\.(jpe?g|png|gif)$/,
use: [
{
loader: 'url-loader',
options: {
// 小于 8k 的图片自动转成 base64，并且不会保存实体图片
limit: 8192,
outputPath: 'images/'
}
}
]
},
{
test: /\.(htm|html)$/,
use: 'html-withimg-loader'
},
{
test: /\.(eot|ttf|woff|svg)$/,
use: 'file-loader'
},
{
test: /\.js$/,
use: 'babel-loader',
include: /src/,
exclude: /node_modules/
},
{
test: /\.vue$/,
loader: 'vue-loader'
}
]
},
// 插件
plugins: [
new HtmlWebpackPlugin({
template: './src/index.html',
hash: true,
}),
new CleanWebpackPlugin(),
new webpack.HotModuleReplacementPlugin(),
new VueLoaderPlugin(),
],
// 开发服务器配置
devServer: {
contentBase: './dist',
host: 'localhost',
port: 8080,
// 自动打开浏览器
open: true,
// 开启热更新
hot: true
},
resolve: {
// 别名
alias: {
// $: './src/jquery.js'
'@': path.resolve(__dirname, 'src/'),
},
// 省略后缀
extensions: ['.js', '.vue', '.json', '.css', '.less']
},
// 模式配置
mode: 'development'
}
|
import {url} from './Data.js'
const lineButton = document.getElementById('lineButton')
const barButton = document.getElementById('barButton')
const cancelLine = document.getElementById('cancelLine')
const cancelBar = document.getElementById('cancelBar')
const startLineChart = function(){
load().then((value)=>{value.plot('line').line();})
}
const startBarChart = function(){
load().then((value)=>{value.plot('bar').bar();})
}
const cancelLineChart = function(){
if(document.getElementById('line').childNodes[0]==undefined){
alert('삭제할 내용이 없어');
return 0;
}
const chart = confirm("원 차트를 지우겠습니까?");
if (chart == false)
alert('지우기 취소')
else
document.querySelector('#line > .plot-container').remove();
}
const cancelBarChart = function(){
if(document.getElementById('bar').childNodes[0]==undefined){
alert('삭제할 내용이 없어');
return 0;
}
const chart = confirm("원 차트를 지우겠습니까?");
if (chart == false)
alert('지우기 취소')
else
document.querySelector('#bar > .plot-container').remove();
}
lineButton.addEventListener('click',startLineChart);
barButton.addEventListener('click',startBarChart);
cancelLine.addEventListener('click',cancelLineChart);
cancelBar.addEventListener('click',cancelBarChart);
async function load () {
const get_date = [];
const get_sum = [];
const datas = await Promise.all(Set_Date().map(date =>
dfd.read_csv(`${url}${date}.csv`)
));
datas.forEach(data => {
get_sum.push(data.body__items__item__incDec.data[data.body__items__item__incDec.data.length - 1]);
get_date.push(data.body__items__item__createDt.data[0].slice(2,10));
})
let df_sum = new dfd.DataFrame({'sum':get_sum},{index:get_date}); //df_sum은 Series 형태이므로 DataFrame 형태로 변환
return df_sum;
//df_sum.plot('bar').bar();
}
function Set_Date(){
let tDate = new Date('2020-03-03'); // 2020년 03월 04일 부터 시작
let Year,Month,Day; // 각 날짜별 날짜 생성
const date_array = []; // 해당 필요부분 넣을 배열 생성
for(let i=0;i<89;i++)
{
tDate.setDate(tDate.getDate()+1) // 3월 4일 계산 후 하루씩 증가
Year = tDate.getFullYear().toString().slice(2,4); // 2020년이 아닌 뒤의 두자리 수만 필요하므로 slice 사용
Month = (tDate.getMonth()+1).toString().length==1 ? '0'+ (tDate.getMonth()+1).toString() :(tDate.getMonth()+1).toString() ; // 한자리 수 인경우 앞에 0을 붙인다.
Day = tDate.getDate().toString().length==1? '0'+tDate.getDate().toString() : tDate.getDate().toString();
date_array.push(Year+Month+Day); //합친 내용을 배열로 만들어 준다.
}
return date_array; //해당 배열을 반환한다.
}
|
export default {
"DateAndAuthorisation": {
"New_Course_Start_Year": "2016/7",
"New_Course_Start_Month": "March",
"Has_Faculty_Approval_Been_Given": true,
"Will_The_Course_Comply_With_The_Academic_Awards_Framework": false,
},
"CourseInformation": {
"Faculty": "",
"Department": "",
"SubjectGroup": "",
"CoursePlanner": ""
}
}
|
import reflectanceImage from "url:../img/projektbeschrieb.png";
import ndviZeitreiheImage from "url:../img/ndvi_zeitreihe.png";
import useCase2Viewer from "url:../img/uc2_viewer_screenshot.jpg";
import sentinel_orbits from "url:../img/sentinel_orbits.jpg";
import sommersturm2017Image from "url:../img/sommersturm_2017.jpg";
import nbrDiff from "url:../img/nbr_diff.png";
import ndviAnomalienImage from "url:../img/ndvi_anomalien.PNG";
import SchlussberichtWeb from "url:../assets/Schlussbericht_Web.pdf";
import { getVideoElement } from "./main_util";
const descriptionContent = {
main_title: "Waldmonitoring Use-Cases mit Sentinel Satellitenbildern",
authors:
"Dominique Weber (HAFL), Alexandra Erbach (HAFL), Christian Rosset (HAFL), Hanskaspar Frei (KARTEN-WERK GmbH), Thomas Bettler (BAFU)",
hint: `<div style='padding:20px 0'>August 2020</div>
<div>Auf dieser Seite werden die Ergebnisse des Forschungsprojektes <strong>«Einsatz von Fernerkundungsdaten in Forstbetrieben und Forstdiensten anhand von konkreten Use-Cases»</strong> vorgestellt,
welches von der Fachhochschule für Agrar-, Forst- und Lebensmittelwissenschaften BFH-HAFL im Auftrag und mit Unterstützung des Bundesamtes für Umwelt (BAFU) und KARTEN-WERK GmbH durchgeführt wurde.</div>
<div style="height:16px"></div>
<div>Das Hauptziel des Projektes war die Implementierung von Kartenviewern sowie Geodiensten (Erklärung dazu siehe z.B. <a href="https://www.geo.admin.ch/de/geo-dienstleistungen/geodienste.html" rel="noopener noreferrer" target="_blank">hier</a>) für konkrete Use-Cases mit existierenden,
möglichst frei verfügbaren Fernerkundungsdaten. Es wurden 3 Use-Cases zusammen mit VertreterInnen aus der Praxis ausgearbeitet
(Abgleich von Angebot und Nachfrage), und die Informationen, Daten und Resultate bedarfsgerecht bereitgestellt.</div>
<div style="height:8px"></div>
<div>Folgende Anwendungsfälle wurden bearbeitet:</div>
<ul style="margin-block-start: 8px; margin-block-end:8px">
<li style="padding:4px 0">Use-Case 1 - <strong>Monitoring jährlicher Waldveränderungen (forstliche Eingriffe und andere)</strong></li>
<li>Use-Case 2 - <strong>Rasche Erfassung von Sommersturmschäden</strong></li>
<li style="padding:4px 0">Use-Case 3 - <strong>Hinweiskarten zur Vitalität von Waldflächen</strong></li>
</ul>
<div>Auf dieser Seite finden Sie Hinweise zur korrekten Verwendung der Kartenviewer und Geodienste sowie Videoanleitungen
und Hintergrundinformationen. Zu Beginn wird auf den Hintergrund des Projektes sowie die verwendeten Daten eingegangen.
Daraufhin werden die drei Use-Cases nacheinander vorgestellt, wobei jeweils Hinweise zur Benutzung sowie Hintergrundinformationen
zur Methode bereitgestellt werden, veranschaulicht durch Grafiken und Video-Tutorials. Nach einer kurzen Erläuterung zu den
Kartenviewern und Geodiensten wird schliesslich noch ein Ausblick auf den Fortgang des Projektes gegeben.</div>
<div style='padding:12px 0'><strong>Wichtig:</strong> Die bereitgestellten Daten und Services sind bis dato ausschliesslich für Testzwecke gedacht.</div>`,
blocks: [
{
title: "Inhalt",
content: `<div><table>
<tr><td class="contents">1 Hintergrund</td></tr>
<tr><td class="contents">2 Daten</td></tr>
<tr><td class="contents">3 Use-Case 1 - Jährliche Waldveränderungen</td></tr>
<tr><td class="contents">4 Use-Case 2 - Test Sommersturmschäden 2017</td></tr>
<tr><td class="contents">5 Use-Case 3 - Hinweiskarte zur Vitalität</td></tr>
<tr><td class="contents">6 Kartenviewer und Geodienste</td></tr>
<tr><td class="contents">7 Ausblick</td></tr>
</table></div><div style="height:16px"></div>`
},
{
title: "1 Hintergrund",
content: `Das Angebot an Fernerkundungsdaten sowie leistungsstarken Analysetools nimmt ständig zu.
Wälder lassen sich folglich immer häufiger und detailreicher erfassen. Damit dieses Potenzial in
der Praxis jedoch stärker genutzt wird und einen faktischen Mehrwert erzielt, braucht es praxistaugliche
Tools und die Bereitstellung von bedarfsgerechten Informationen. Dies erfordert einen intensiven Austausch
zwischen Forschung und Praxis. Um den Bedarf der Praxis von Anfang an zu bedienen, wurde im Rahmen dieses
Forschungsprojektes eine Expertengruppe mit je drei VertreterInnen von Forstbetrieben und Forstdiensten gebildet.
Die drei Use-Cases wurden in enger Zusammenarbeit mit den Praxispersonen ausgebarbeitet.
<div style="height:16px"></div>
Dieses Projekt baut auf den Resultaten der Projekte <a href="https://www.planfor.ch/article/22" rel="noopener noreferrer" target="_blank">
«Waldmonitoring mit Sentinel-2 Satellitenbildern»</a> und
<a href="https://www.planfor.ch/article/21" rel="noopener noreferrer" target="_blank">
«Praxistauglicher Einsatz von Fernerkundung im Waldbereich»</a> auf.
<div style="height:24px"></div>
`
},
{
title: "2 Daten",
content: `Im Fokus dieses Projektes lag die Nutzung von schweizweit frei verfügbaren Daten. Dafür eignen sich insbesondere die Sentinel-2-Satellitenbilder,
deren Mehrwert für die Waldwirtschaft bereits aufgezeigt werden konnte
(<a href="https://www.szf-jfs.org/doi/abs/10.3188/szf.2018.0026" rel="noopener noreferrer" target="_blank">SZF Artikel</a>,
<a href="https://www.planfor.ch/event/19" rel="noopener noreferrer" target="_blank">FOWALA Kurs</a>).
Zusätzlich wurde die nationale Waldmaske (swissTLM3D) verwendet und es können verschiedene Hintergrundkarten
(z.B. Luftbilder) dargestellt werden.
<div style="height:16px"></div>
<strong>Sentinel-2</strong><br />
Seit Ende 2015 sind Sentinel-2-Satellitenbilder frei erhältlich und grossflächig verfügbar.
Die häufige Wiederholung der Aufnahmen (alle 2-5 Tage) in für Vegetationsanalysen wichtigen
Spektralbändern bietet dabei ein grosses Potenzial für die Nutzung im Waldbereich. In einem bereits
abgeschlossenen Projekt (<a href="https://www.planfor.ch/article/22" rel="noopener noreferrer" target="_blank">
Weber & Rosset, 2019</a>) konnte aufgezeigt werden, dass sich starke Waldveränderungen
wie Holzschläge oder Sommersturmschäden zeitnah erfassen lassen. Auch für die Klassifizierung von Hauptbaumarten
und die Beurteilung der Vitalität wurde ein grosses Potenzial festgestellt.
<div style="height:16px"></div>
<strong>Vegetationsindizes</strong><br />
Vegetationsindizes werden aus der Kombination mehrerer Spektralbänder berechnet und eignen sich zur <strong>Beurteilung
des Vegetationszustandes</strong>. Zum Beispiel kann mit solchen Indizes das Verhältnis der Reflexionen im roten und nahen
infraroten Spektralbereich abgebildet werden, welches sich in Abhängigkeit vom Chlorophyllgehalt der Pflanzen und
der Zellstruktur der Blätter ändert (siehe Abb. 1). Basierend auf Reflexionsverhältnissen im roten (ca. 630–690 nm),
nahen infraroten (ca. 780– 900 nm) und kurzwellig infraroten (ca. 1400-3000 nm) Spektralbereich dienen sie als Indikatoren
für die Dichte, Produktivität und Vitalität der Vegetation und eignen sich somit für das <strong>Monitoring von Waldveränderungen</strong>.
<ol>
<li>
<strong>NDVI</strong> (<a href="https://en.wikipedia.org/wiki/Normalized_difference_vegetation_index" rel="noopener noreferrer" target="_blank">Normalized Difference Vegetation Index</a>): Der NDVI ist der am
häufigsten verwendete Vegetationsindex. Er berechnet sich aus den Reflexionswerten
im nahen Infrarotbereich (NIR) und im roten sichtbaren Bereich (Rot) des Lichtspektrums:<br /><br />
NDVI=(NIR-Rot)/(NIR+Rot)
<br /><br />
Durch die Normierung ergibt sich ein Wertebereich zwischen −1 und +1.
Negative Werte bezeichnen Wasserflächen. Ein Wert zwischen 0 und 0.2 entspricht nahezu
vegetationsfreien Flächen, während ein Wert nahe 1 auf eine hohe Vegetationsbedeckung
mit vitalen grünen Pflanzen schließen lässt.
<div style="height:16px"></div>
<img src="${reflectanceImage}" alt="plant reflection" style="max-width:100%"/>
<div style="height:16px"></div>
<div style="font-size:12px">Abb. 1 : Reflexionsgrad der Vegetation [%] in Abhängigkeit von der Wellenlänge des Lichtes [nm].
Der starke Anstieg der Reflexion innerhalb des roten und nahen infraroten Spektralbereichs ist ein Indikator für die
Vitalität von Pflanzen und eignet sich zur Unterscheidung von gesunder (grüne Kurve) und gestresster (schwarze Kurve) Vegetation.
(Bildquelle: <a href="https://www.micasense.com/faq" rel="noopener noreferrer" target="_blank">https://www.micasense.com/faq</a>)</div>
</li>
<li>
<div style="height:24px"></div>
<strong>NBR</strong> (Normalized Burn Ratio): Der NBR, auch NDII genannt (Normalized Difference Infrared Index),
wird häufig für die Erkennung von Waldbrandflächen aber auch für die Detektion anderer Waldveränderungen wie
Sturmschadflächen verwendet. Er berechnet sich aus den Reflexionswerten im nahen (NIR) und kurzwelligen (SWIR) Infrarotbereich:
<br /><br />
NBR=(NIR-SWIR)/(NIR+SWIR)
<br /><br />
</li>
</ol>
<div style="height:16px"></div>
<strong>Waldmaske</strong><br />
Die Waldmaske wurde aus dem topografischen Landschaftsmodell der Schweiz (swissTLM3D) abgeleitet
(<a href="https://shop.swisstopo.admin.ch/de/products/landscape/tlm3D" rel="noopener noreferrer" target="_blank">https://shop.swisstopo.admin.ch/de/products/landscape/tlm3D</a>).
<div style="height:16px"></div>
<strong>Hintergrundkarten</strong><br />
Als Hintergrundkarten werden die Luftbilder und Landeskarten von swisstopo, sowie das Vegetationshöhenmodell
des LFI als <a href="https://shop.swisstopo.admin.ch/de/products/geoservice/swisstopo_geoservices/WMTS_info" rel="noopener noreferrer" target="_blank">swisstopo Geodienste</a> eingebunden.
<div style="height:24px"></div>
`
},
{
title: "3 Use-Case 1 - Jährliche Waldveränderungen",
content: `<strong>Starke und flächige Waldveränderungen</strong> können mit Sentinel-2-Satellitenbildern erkannt
und als <strong>jährliche Hinweiskarten</strong> angeboten werden. Die dargestellten Veränderungen beziehen sich
auf eine starke <strong>Abnahme der Vegetationsaktivität zwischen August (Vorjahr) und Juni (Folgejahr)</strong>.
Die Stärke der Veränderung ist grob dargestellt (siehe Legende im Kartenviewer). Die räumliche Auflösung
beträgt 10 x 10 m. Kleinräumige und schwache Veränderungen sind damit nicht detektierbar.
Ausserdem kann keine Aussage über die Ursache der Veränderung getroffen werden.
Es kann sich also sowohl um Holzschläge, Sturmschäden als auch um andere Veränderungen handeln.<br /><br />
Das folgende <strong>Video</strong> erläutert die <strong>Benutzung des Kartenviewers</strong> «<a href="http://waldmonitoring.ch/veraenderung">Jährliche Veränderungen</a>»:
<div style="height:16px"></div>
${getVideoElement("mYK2KJqgrhM")}
<div style="height:16px"></div>
<u>Hintergrundinformationen zur Methode</u><br /><br />
Für die automatische Detektion von Veränderungsflächen wurden die Unterschiede zwischen zwei Jahren mit dem NDVI
(Normalized Difference Vegetation Index; siehe Abschnitt 2) untersucht. Um bewölkte Aufnahmen automatisch herauszufiltern,
wurde dabei für jeden Pixel (10 x 10 m) der maximale NDVI-Wert aller verfügbaren Bilder der Sommermonate (Juni – August) verwendet.
Während dieser Zeit ist praktisch die gesamte Vegetation grün. So entstehen nahezu wolkenfreie, jährliche Rasterbilder mit dem
maximalen NDVI (<strong>«NDVI Maximum Komposit»</strong>). Aus diesen Kompositen wird die <strong>Differenz</strong> zwischen zwei Jahren gebildet. Die Differenzwerte
spiegeln dementsprechend die Stärke der Veränderung wider. So weisen Werte näher -1 auf stärkere Waldveränderungen (z.B. Räumungen)
hin. Mittels Schwellenwert wurden die Veränderungsflächen zudem als Vektordaten (Polygone) ausgeschieden und sind
<a href="http://waldmonitoring.ch/services">hier</a> per Web Map Service (WMS) Dienst verfügbar.
Bisher wurden Veränderungskarten für die Jahre 2016/2017, 2017/2018 und 2018/2019 gerechnet.
Ab Herbst 2020 wird die Veränderungskarte für 2019/2020 zur Verfügung stehen. Die nachstehende Abbildung veranschaulicht das Vorgehen.
<div style="height:8px"></div>
<img src="${ndviZeitreiheImage}" alt="plant reflection" style="max-width:100%"/>
<div style="height:16px"></div>
<div style="font-size:12px">Abb. 2 : Veranschaulichung der Methode zur Erkennung von Waldveränderungen auf Basis des
Sentinel-2-NDVI. Aus allen verfügbaren Sentinel-2-Aufnahmen der Sommermonate wird pro Jahr ein NDVI Maximum Komposit Raster erstellt.
Aus diesen Kompositen wird jeweils die Differenz zwischen zwei Jahren gebildet (∆NDVI), wie hier im Beispiel zwischen 2017 und 2018.</div>
<div style="height:24px"></div>
`
},
{
title: "4 Use-Case 2 - Test Sommersturmschäden 2017",
content: `Im Rahmen des zweiten Use-Cases wurde eine Methode für die automatische Bereitstellung von
schweizweiten <strong>Hinweiskarten für Sommersturmschäden</strong> auf Basis von Sentinel-2-Satellitenbildern entwickelt.
Als Beispiel und für den Praxistest wurden die Sommerstürme (Ende <a href="http://www.sturmarchiv.ch/index.php?title=Extremereignisse_2017#Juli" rel="noopener noreferrer" target="_blank">
Juli</a> und Anfang <a href="http://www.sturmarchiv.ch/index.php?title=Extremereignisse_2017%23August" rel="noopener noreferrer" target="_blank">August</a>) im Jahr 2017 ausgewählt.
Zwischen dem 5.7.2017 und dem 19.8.2017 können alle verfügbaren Sentinel-2-Aufnahmen, welche mindestens einen Teil
der Schweiz abdecken, vom Benutzer/Benutzerin ausgewählt werden. So kann nach einem Sturmereignis rasch geprüft werden,
ob eine brauchbare, sprich <strong>möglichst wolkenfreie</strong>, Aufnahme zur Verfügung steht. Daraufhin werden im Kartenviewer potenzielle
Veränderungsflächen angezeigt, falls welche vorhanden sind.<br /><br />
Diese ausgewiesenen Veränderungsflächen basieren auf der Abnahme des Normalized Burn Ratio Vegetationsindexes
(NBR; siehe Abschnitt 2). In einem Vorgängerprojekt
(<a href="https://www.planfor.ch/article/22" rel="noopener noreferrer" target="_blank">Weber & Rosset, 2019</a>)
hat sich dieser Index als geeignet für die Detektion von Sturmschadflächen erwiesen.<br /><br />
Die Werte in der Legende des Kartenviewers stellen die <strong>Abnahme des NBR</strong> multipliziert mit 100 dar,
gemittelt pro Veränderungsfläche (Polygon). Die Multiplikation mit 100 erfolgt dabei lediglich aus Speicherplatzgründen
(Ganzzahl statt Dezimalzahl). Die Differenzbildung erfolgt aus dem <strong>Bild des ausgewählten Datums</strong> und einem Referenzzustand
vor dem vermuteten Ereignis / ausgewählten Datum. Als Referenz wird ein möglichst <strong>wolkenfreies Komposit</strong> (siehe auch Abschnitt 3)
aller verfügbaren Bilder der <strong>45 Tage vor dem ausgewählten Datum</strong> verwendet. Werte näher bei -100 weisen auf stärkere Schäden hin.
Auch Wolken werden angezeigt (siehe Abb. 3), um fehlerhafte Rückschlüsse auf das Nichtvorhandensein von Schäden zu vermeiden.
Das gleiche gilt für sogenannte NoData- Flächen, das heisst Flächen, für die zum gewählten Zeitpunkt keine Sentinel-2-Daten zur
Verfügung stehen (siehe Abb. 3). Da die Schweiz durch zwei Orbits abgedeckt wird, wird an einem Aufnahmedatum immer nur ein Teil
der Fläche der Schweiz erfasst (siehe Abb. 4). Der andere Teil wird im Kartenviewer jeweils als NoData-Fläche gekennzeichnet.
<br /><br />
Die Veränderungspolygone wurden mittels Schwellenwert (-15) und ab einer Mindestgrösse von 5 Aren ausgeschieden.
Für jede ausgeschiedene Veränderungsfläche wurden neben dem Zeitpunkt (time) zudem Flächengrösse (area), sowie Mittelwert (mean),
Maximalwert (max) und 90%-Quantil (p90) der NBR-Differenzwerte berechnet und als Attribute in den Vektordaten gespeichert.
Das Attribut class differenziert zwischen Veränderungsflächen (class = 1), Wolken (class = -1), und NoData (class = -2).
Die Vektordaten stehen <a href="http://waldmonitoring.ch/services">hier</a> als Web Feature Service (WFS) Dienst zur Verfügung.<br /><br />
<div style="height:16px"></div>
<img src="${useCase2Viewer}" alt="useCase 2 viewer screenshot" style="max-width:100%"/>
<div style="height:8px"></div>
<div style="font-size:12px">Abb. 3 : Hinweis auf Veränderungen gemäss Sentinel-2-Aufnahme vom 5.8.2017
(Screenshot aus dem Kartenviewer). Mithilfe der Legende können potenzielle Schadflächen (gelb bis rot),
Wolken (grau schraffiert) und Flächen mit keinen Daten (grau ausgefüllt) unterschieden werden. Das blau
umrandete Symbol stellt einen Link auf Sentinel Playground bereit, sodass das zugrundeliegende Satellitenbild
einfach visuell überprüft werden kann (Plausibilitätskontrolle).</div>
<div style="height:32px"></div>
<img src="${sentinel_orbits}" alt="sentinel orbits" style="max-width:100%"/>
<div style="height:8px"></div>
<div style="font-size:12px">Abb. 4 : Darstellung der beiden Sentinel-Orbits, welche die Fläche der Schweiz abdecken.
An einem Aufnahmedatum wird entweder Orbit 108 oder 65 erfasst. Für den überlappenden Bereich ist die Bildverfügbarkeit
am höchsten (alle 2-3 Tage).</div>
<div style="height:24px"></div>
Die Resultate wurden teilweise mit Referenzdaten der WSL validiert und erwiesene flächige Schäden konnten gut erkannt
und abgegrenzt werden (siehe Abb. 5). Jedoch werden bis dato auch diverse Flächen fälschlicherweise als Schadflächen
ausgeschieden. Dies geschieht insbesondere an Wolkenrändern, sowie im Zusammenhang mit Schnee oder Schattenwurf an
steilen Nordhängen. In diesen Fällen ist bei der Interpretation der Ergebnisse besondere Vorsicht geboten. <br />
Nach Möglichkeit sollte immer ein <strong>wolkenfreier Aufnahmezeitpunkt</strong> ausgewählt werden. Zu diesem Zweck wird für jedes
Aufnahmedatum ein Direkt-Link auf Sentinel Playground bereitgestellt (siehe blau umrandetes Symbol in Abb. 3), sodass
jedes Bild einfach visuell überprüft werden kann. Aufnahmedatum und Bildausschnitt werden dabei im Link gespeichert und
direkt übernommen. In Nussbaumen TG betrug die Wartezeit zwischen dem Sturm vom 2.8.2017 und der nächsten verfügbaren
wolkenfreien Aufnahme zum Beispiel 13 Tage (siehe Abb. 5). Das genaue Vorgehen zur Auswahl einer brauchbaren Aufnahme
wird im untenstehenden <strong>Video</strong> erklärt und veranschaulicht.
<div style="height:16px"></div>
<img src="${sommersturm2017Image}" alt="plant reflection" style="max-width:100%"/>
<div style="font-size:12px">Abb. 5 : Gute räumliche Abgrenzung von flächigen Schäden im Falle eines Sturmereignisses
in Nussbaumen TG am 2.8.2017. Die ausgewiesenen potenziellen Schadflächen wurden mit Referenzdaten der WSL (in Gelb)
abgeglichen.</div>
<div style="height:24px"></div>
Das folgende <strong>Video</strong> erläutert die <strong>Benutzung des Kartenviewers</strong>
«<a href="http://waldmonitoring.ch/stoerungen">Sommersturmschäden 2017</a>»:
<div style="height:16px"></div>
${getVideoElement("aamvbhKXoNU")}
<div style="height:16px"></div>
<u>Hintergrundinformationen zur Methode</u><br /><br />
Für jede Sentinel-2-Aufnahme innerhalb der definierten Zeitspanne (5.7. bis 19.8.2017) wurde zuerst der NBR berechnet
(<strong style="color:green">NBR<sub>Aktuell</sub></strong>), siehe Abb. 6). Wolken wurden dabei mittels der
<a href="https://sentinel.esa.int/web/sentinel/technical-guides/sentinel-2-msi/level-1c/cloud-masks" rel="noopener noreferrer" target="_blank">ESA Wolkenmaske</a>
ausgeschieden. Daraufhin wurde der NBR für die <strong>Referenzperiode</strong> berechnet, welche als das <strong>45-Tages-Fenster</strong>
vor dem ausgewählten Aufnahmedatum definiert wurde. <br />
Zu diesem Zweck wurde zuerst mittels der in Abschnitt 3 beschriebenen <i>NDVI Maximum Komposit Methode</i> aus allen verfügbaren
Aufnahmen innerhalb der 45-tägigen Zeitspanne ein möglichst wolkenfreies Komposit erstellt. Für dieses wurde dann wiederum der
NBR berechnet (<strong style="color:blue">NBR<sub>Referenz</sub></strong>, siehe Abb. 6). Aus diesen beiden Bildern wurde daraufhin die Differenz gebildet (<strong>∆NBR</strong>), und die
Veränderungsflächen wurden mittels Schwellenwert ausgeschieden. Die nachfolgende Abbildung veranschaulicht das Vorgehen.
<div style="height:24px"></div>
<img src="${nbrDiff}" alt="plant reflection" style="max-width:100%"/>
<div style="font-size:12px">Abb. 6 : Darstellung des Arbeitsflusses zu Use-Case 2. Für jede Sentinel-2-Aufnahme wird der
NBR berechnet (NBR Aktuell). Daraufhin wird der NBR für die Referenzperiode berechnet, welche als das 45-Tages-Fenster
vor dem ausgewählten Aufnahmedatum definiert wurde. Zu diesem Zweck wird aus allen verfügbaren Aufnahmen innerhalb der
45-tägigen Zeitspanne ein möglichst wolkenfreies Komposit erstellt, für welches wiederum der NBR berechnet wird (NBR Referenz).
Aus diesen beiden Bildern wird die Differenz gebildet (∆NBR), und die Veränderungsflächen werden mittels Schwellenwert
ausgeschieden.</div>
<div style="height:24px"></div>
Dieser Prozess erfolgte wie beschrieben zunächst testweise für den Sommer 2017, jedoch ist die automatisierte Bereitstellung der
Veränderungsflächen für die ganze Schweiz möglich und angedacht. Dabei würden die Informationen für alle verfügbaren Aufnahmen
innerhalb der letzten 45 Tage ab dem jeweils aktuellen Datum mittels sogenannten «rollenden Archiven» zur Verfügung gestellt werden.
Die vollautomatische Analyse und Bereitstellung der Resultate sollte innerhalb von 2-5 Tagen nach Bildaufnahme möglich sein.<br /><br />
Eine anspruchsvolle Situation stellt sich jedoch im Winter: Vegetationszustand, Beleuchtungsintensität, Wolken, Schatten und Schnee
stellen zusätzliche Herausforderungen dar. Ein möglicher Lösungsansatz wäre eine Kombination mit Sentinel-1 Daten, welche von
Bewölkungs- und Beleuchtungsintensität nicht beeinflusst werden
(siehe dazu ein <a href="https://www.wsl.ch/de/projekte/sturmhinweiskarte.html" rel="noopener noreferrer" target="_blank">laufendes Projekt an der WSL</a>).
<div style="height:24px"></div>`
},
{
title: "5 Use-Case 3 - Hinweiskarte zur Vitalität",
content: `Auch die Vitalität von Waldflächen kann mit Sentinel-2-Satellitenbildern grob erfasst werden.
Durch den <strong>Vergleich des aktuellen Vegetationszustandes mit den Vorjahren</strong> lassen sich daraus <strong>Hinweiskarten
zur Veränderung der Vitalität</strong> erstellen. Hier handelt es sich allerdings um einen ersten Test.
Eine Validierung und Verfeinerung der Methode steht noch aus.<br /><br />
Als Indikator für die Vitalität wurde wiederum der NDVI-Vegetationsindex verwendet (siehe Abschnitt 2).
Auf der Karte dargestellt werden sogenannte <strong>NDVI-Anomalien</strong>. Dabei werden jeweils die NDVI-Medianwerte des zweimonatigen
Zeitfensters (z.B. Juni - Juli) mit den Medianwerten aller Vorjahre (bis 2015) innerhalb derselben Zeitperiode verglichen
(siehe Abb. 7). Negative Werte deuten auf eine Abnahme der Vitalität hin, positive Werte deuten auf eine Zunahme der Vitalität hin.
Je weiter die Werte von null abweichen (Erwartungswert), desto wahrscheinlicher ist es, dass eine effektive Veränderung stattfand.
Ob es sich bei der Veränderung um Borkenkäferbefall, Trockenstress oder einen Holzschlag handelt, wird hierbei nicht unterschieden.
So können z.B. negative Werte sowohl einen Holzschlag wie auch eine vorzeitige Herbstverfärbung beschreiben. Wir sprechen daher von
Hinweiskarten und für die Interpretation ist immer auch Expertenwissen über die Wälder und gegebenenfalls eine Feldbegehung notwendig.
Durch die Kombination von Satellitenaufnahmen innerhalb des zweimonatigen Fensters können viele Probleme mit Wolken und andere
Fehlerquellen reduziert, jedoch nicht vollständig ausgeschlossen werden. Weiter ist zu berücksichtigen, dass die Sentinel-2-Daten
erst seit 2015 verfügbar sind, was für die Detektion von Anomalien bis jetzt ein relativ kurzer Zeitraum ist (eine höhere Aussagekraft
wird mit jedem zusätzlichen Jahr erwartet).
<div style="height:24px"></div>
Das folgende <strong>Video</strong> erläutert die <strong>Benutzung des Kartenviewers</strong>
«<a href="http://waldmonitoring.ch/vitalitaet">Hinweiskarten zur Vitalität</a>»:
<div style="height:16px"></div>
${getVideoElement("wraBOBSfcdk")}
<div style="height:16px"></div>
<u>Hintergrundinformationen zur Methode</u><br /><br />
Die Berechnung der NDVI-Anomalien basiert auf dem sogenannten <a href="https://de.wikipedia.org/wiki/Standardisierung_(Statistik)" rel="noopener noreferrer" target="_blank">Z-Wert</a>
(siehe z.B. <a href="https://www.sciencedirect.com/science/article/pii/S0034425718305509" rel="noopener noreferrer" target="_blank">Meroni et al., 2019</a>):<br /><br />
Z<sub>i</sub> = (NDVI<sub>median,i</sub> - NDVI<sub>median,ref</sub>) / NDVI<sub>sd,ref</sub>
<div style="height:16px"></div>
Im Gegensatz zu Meroni et al. haben wir den Median anstatt dem arithmetischen Mittel verwendet,
da dieser robuster gegenüber Ausreissern ist. NDVI<sub>median,i</sub> bezeichnet somit den <strong>Median</strong> der NDVI-Werte pro
<strong>zweimonatigem Zeitfenster</strong> i. NDVI<sub>median,ref</sub> bezeichnet den <strong>Median</strong> der NDVI-Werte innerhalb der <strong>gleichen</strong>
zweimonatigen Zeitfenster (z.B. Juni - Juli) der Referenzperiode. NDVI<sub>sd,ref</sub> ist die <strong>Standardabweichung</strong> aller
NDVI-Werte innerhalb der gleichen zweimonatigen Zeitfenster (z.B. Juni- Juli) der Referenzperiode.<br /><br />
Die Standardabweichung gibt Auskunft über die Variabilität der NDVI-Werte innerhalb der Referenzperiode.
Je grösser die Variabilität ist, desto kleiner wird die Wahrscheinlichkeit, dass Veränderungen, insbesondere schwache,
ausgeschieden werden, was sich in Z-Werten nahe null widerspiegelt. Die Berechnung erfolgt pixelbasiert für jeden 10 x 10 m Pixel,
und die Pixelwerte in den Hinweiskarten entsprechen dem jeweiligen Z-Wert.
<div style="height:16px"></div>
<img src="${ndviAnomalienImage}" alt="ndvi anomalien" style="max-width:100%"/>
<div style="font-size:12px">Abb. 7 : NDVI-Zeitreihen-Beispiel zur Veranschaulichung der Z-Wert-Methode.
Die blauen Punkte entsprechen den tatsächlichen NDVI-Werten an einem bestimmten Ort (pixelbasiert).
Die blauen Linien stellen Interpolationen dar und haben keine weitere Bedeutung. Die Referenzperiode bezieht
sich in diesem Fall auf 2016 bis 2018, dargestellt in Grün. 2019 stellt in diesem Beispiel den aktuellen Zustand
dar und ist in Rot gekennzeichnet. Die gestrichelten Linien stellen jeweils die beiden Mediane dar, die miteinander
verglichen werden, das heisst der Median über Juni/Juli aller Jahre der Referenzperiode (in Grün) mit dem Median
über Juni/Juli des aktuellen Jahres (in Rot).</div>
<div style="height:24px"></div>`
},
{
title: "6 Kartenviewer und Geodienste",
content: `Für jeden Use-Case wird ein eigener <strong>Kartenviewer</strong> angeboten. Alle Kartenviewer
sind über die Startseite <a href="http://waldmonitoring.ch">http://waldmonitoring.ch</a>
erreichbar und weisen, je nach Use-Case, unterschiedliche Funktionalitäten auf. Sie wurden auch für die Verwendung ausserhalb
des Büros konzipiert und können daher auf <strong>mobilen Geräten</strong> benutzt werden.<br />
Es ist vorgesehen, die Kartenviewer durch weitere Funktionalitäten, wie zum Beispiel die Positionierung über GPS,
in einem Nachfolgeprojekt zu ergänzen.<br />
Die dargestellten Karten können auch als <strong>Geodienste</strong> (WMS, WMTS, WFS) in eine GIS-Umgebung eingebunden werden.
Durch Klick auf die Kachel „<a href="http://waldmonitoring.ch/services">Geodienste</a>“
erfahren Sie mehr darüber. Einfache Video-Tutorials zeigen anhand von Beispielen, wie Sie die Services in QGIS einbinden können.<br /><br />
Die gesamte Webapplikation ist Open Source und unter: <a href="https://github.com/HAFL-FWI/Digital-Forest-Monitoring/tree/master/webapp" rel="noopener noreferrer" target="_blank">https://github.com/HAFL-FWI/Digital-Forest-Monitoring/tree/master/webapp</a> verfügbar.
Bei Fragen oder Verbesserungswünschen wenden Sie sich bitte an untenstehenden Kontakt.<br /><br />
Hanskaspar Frei von KARTEN-WERK GmbH, <a href="mailto:hkfrei@karten-werk.ch">hkfrei@karten-werk.ch</a>
<div style="height:24px"></div>
`
},
{
title: "7 Ausblick",
content: `Im Rahmen eines Nachfolgeprojektes soll der Nutzen von Fernerkundung für die forstliche Praxis weiter erhöht werden.
Dazu wird die aktuelle Lösung (Kartenviewer, Geodienste) in Umfang (weiterentwickelte bzw. neue Use-Cases und Tools) und
Qualität (bedarfsgerechte Darstellung etc.) ausgebaut. Zudem soll die effektive Verwendung in der Praxis durch intensiven
Austausch und den Aufbau einer Community signifikant gesteigert werden.<br /><br />
In diesem Rahmen sollen unter anderem konkrete Einsatzbeispiele zur effektiven Verwendung der Daten und Tools in der
Praxis gesammelt, dokumentiert und bereitgestellt werden. Wer dazu beitragen möchte, weitere Anregungen oder generell
Interesse hat, aktiver Teil der User Community zu werden, kann sich sehr gerne jederzeit bei Alexandra Erbach (<a href="mailto:alexandra.erbach@bfh.ch">alexandra.erbach@bfh.ch</a>) melden.
<div style="height:18px"></div>
<div><a href="${SchlussberichtWeb}" rel="noopener noreferrer" target="_blank">Download Schlussbericht als PDF</a></div>
<div style="height:24px"></div>
`
}
]
};
export default descriptionContent;
|
angular.module('pokedex')
.controller('pokemonController', function($scope, $routeParams, $http, $templateCache) {
$scope.carregando = true;
$http.get("https://pokeapi.co/api/v2/pokemon/" + $routeParams.name, {
cache: $templateCache
}).
then(function(response) {
$scope.pokemon = response.data;
$scope.erro = false;
}, function(response) {
$scope.erro = true;
$scope.data = response.data || 'Request failed';
$scope.status = response.status;
}).finally(function() {
$scope.carregando = false;
});
});
|
import React, { useState } from "react";
import { NavLink } from "react-router-dom";
import heartPng from "./heart-png.webp";
import logo from "./logo.jpeg"
export default function NavBar() {
const [clicked, switchClicked] = useState(false);
return (
<>
{window.innerHeight < window.innerWidth ? (
<>
<nav id="nav" className="row">
<NavLink id="nav__nav-link" className="col-2" to="/story">
<p>Ruby's Story</p>
</NavLink>
<NavLink id="nav__nav-link" className="col-2" to="/blog">
<p >
Team <br />
#HearWithRuby
</p>
</NavLink>
<NavLink id="nav__nav-link" className="col-4" to="/">
<img src={logo} alt="Hear With Ruby Logo"/>
</NavLink>
<NavLink id="nav__nav-link" className="col-2" to="/help">
<p>
Help Hearing, <br />
With Ruby
</p>
</NavLink>
<NavLink id="nav__nav-link" className="col-2" to="/gallery">
<p>Gallery</p>
</NavLink>
</nav>
<div className="double-line" />
<div className="diamond" />
<div className="double-line__right" />
</>
) : (
<>
<nav>
<img
src={heartPng}
alt="Heart"
onClick={() => switchClicked(!clicked)}
/>
</nav>
<dropdown style={clicked ? { width: "150px" } : { width: "0" }}>
<NavLink className="link" to="/story">
<p onClick={() => switchClicked(!clicked)}>Ruby's Story</p>
</NavLink>
<NavLink className="link" to="/blog">
<p onClick={() => switchClicked(!clicked)}>Team #HWR</p>
</NavLink>
<NavLink className="link" to="/">
<p onClick={() => switchClicked(!clicked)} id="title">
Hear With Ruby
</p>
</NavLink>
<NavLink className="link" to="/help">
<p onClick={() => switchClicked(!clicked)}>
Help Hearing, With Ruby
</p>
</NavLink>
<NavLink className="link" to="/gallery">
<p onClick={() => switchClicked(!clicked)}>Gallery</p>
</NavLink>
</dropdown>
</>
)}
</>
);
}
|
'use strict';
module.exports = (sequelize, DataTypes) => {
const User = sequelize.define('User', {
id: {
type:DataTypes.UUID,
primaryKey:true
},
display_name: DataTypes.STRING,
name: DataTypes.STRING,
email: DataTypes.STRING,
phone: DataTypes.STRING,
password: DataTypes.STRING,
auth_token: DataTypes.STRING,
log_type: DataTypes.STRING,
role: DataTypes.STRING
}, {
defaultScope: {
attributes: { exclude: ['password'] },
}
});
User.associate = function(models) {
User.hasMany(models.Question,{
foreignKey:'created_by',
as:'questions'
});
User.hasMany(models.Answer,{
foreignKey:'created_by',
as:'answers'
});
User.hasMany(models.Project,{
foreignKey:'created_by',
as:'projects'
});
User.hasMany(models.Transaction,{
foreignKey:'created_by',
as:'transactions'
});
};
return User;
};
|
Ext.define('Assessmentapp.assessmentapp.shared.com.model.assessmentcontext.survey.AssessmentQuestionsExtDTOModel.AssessmentQuestionsExtDTOModel', {
"extend": "Ext.data.Model",
"fields": [{
"name": "questionNumber",
"type": "string",
"defaultValue": ""
}, {
"name": "question",
"type": "string",
"defaultValue": ""
}, {
"name": "yesLinkedQuestion",
"type": "string",
"defaultValue": ""
}, {
"name": "noLinkedQuestion",
"type": "string",
"defaultValue": ""
}, {
"name": "keywordForInference",
"type": "string",
"defaultValue": ""
}]
});
|
'use strict'
const tap = require('tap')
const importFresh = require('import-fresh')
const TypeString = require('../types/string')
const Utils = require('../lib/utils')
const Helper = require('./helper')
tap.test('index > default singleton api', async t => {
const h = Helper.get('test-index')
const sywac = importFresh('../index').string('-b, --branch <name>').boolean('-f, --force')
let result = await sywac.parse([])
h.assertNoErrors(t, result)
t.equal(result.argv.b, undefined)
t.equal(result.argv.branch, undefined)
t.equal(result.argv.f, false)
t.equal(result.argv.force, false)
t.same(result.argv._, [])
t.equal(Object.keys(result.argv).length, 5)
h.assertTypeDetails(t, result, 0, ['_'], 'array:string', [], 'default', [], [])
h.assertTypeDetails(t, result, 1, ['b', 'branch'], 'string', undefined, 'default', [], [])
h.assertTypeDetails(t, result, 2, ['f', 'force'], 'boolean', false, 'default', [], [])
result = await sywac.parse(['-fb', 'master'])
h.assertNoErrors(t, result)
t.equal(result.argv.b, 'master')
t.equal(result.argv.branch, 'master')
t.equal(result.argv.f, true)
t.equal(result.argv.force, true)
t.same(result.argv._, [])
t.equal(Object.keys(result.argv).length, 5)
h.assertTypeDetails(t, result, 0, ['_'], 'array:string', [], 'default', [], [])
h.assertTypeDetails(t, result, 1, ['b', 'branch'], 'string', 'master', 'flag', [0, 1], ['-fb', 'master'])
h.assertTypeDetails(t, result, 2, ['f', 'force'], 'boolean', true, 'flag', [0], ['-fb'])
})
tap.test('index > configured singleton api', async t => {
const name = 'happy'
const h = Helper.get(name)
let customUtilsCalled = false
class CustomUtils extends Utils {
stringToArgs (str) {
customUtilsCalled = true
return super.stringToArgs(str)
}
}
class CustomString extends TypeString { get datatype () { return 'custom' } }
const result = await importFresh('../index')
.configure({
name: name,
utils: new CustomUtils(),
factories: {
string: opts => new CustomString(opts)
}
})
.string('-s, --string <str>').boolean('-b, --bool')
.parse('--string=value --bool one')
h.assertNoErrors(t, result)
t.equal(result.argv.s, 'value')
t.equal(result.argv.string, 'value')
t.equal(result.argv.b, true)
t.equal(result.argv.bool, true)
t.same(result.argv._, ['one'])
t.equal(Object.keys(result.argv).length, 5)
t.equal(customUtilsCalled, true)
h.assertTypeDetails(t, result, 1, ['s', 'string'], 'custom', 'value', 'flag', [0], ['--string=value'])
h.assertTypeDetails(t, result, 2, ['b', 'bool'], 'boolean', true, 'flag', [1], ['--bool'])
Helper.get(require('path').basename(__filename, '.js')).assertTypeDetails(t, result, 0, ['_'], 'array:string', ['one'], 'positional', [2], ['one'])
})
|
var express = require('express');
var router = express.Router();
const fs = require("fs");
const path = require("path");
const PUBLIC_PATH = path.resolve(__dirname, '../public');
/* GET home page. */
router.get('/', function(req, res, next) {
res.render('index', { title: 'Express' });
});
// 文件的下载
router.get('/download/:path', function(req, res, next) {
// 获取参数
let filePath = req.params.path;
// 拼接文件的绝对路径
let downloadPath = path.resolve(PUBLIC_PATH, filePath);
// 得到文件名
let {base: fileName} = path.parse(downloadPath);
// 文件的信息
let stat;
try{
// 通过fs模块获取文件的信息，报错就代表着不存在该文件
stat = fs.statSync(downloadPath);
}catch(error) {
// 不存在该文件
return res.status(404).end();
}
// 获取文件的大小
let {size: total} = stat;
// 设置响应头信息，指示内容应该被下载
res.setHeader("Content-Disposition", "attachment; filename="+ encodeURIComponent(fileName));
// 说明了实体主体内对象的媒体类型，这是一个二进制文件类型
res.setHeader("Content-Type", "application/octet-stream");
// 响应状态为200
res.status(200);
// 通过fs模块创建二进制流，并将其二进制流推送到响应主体中
fs.createReadStream(downloadPath).pipe(res);
});
// 文件下载之断点续传
router.get("/transfer/:path", function(req, res, next) {
// 获取参数
let filePath = req.params.path;
// 拼接文件的绝对路径
let downloadPath = path.resolve(PUBLIC_PATH, filePath);
// 得到文件名
let {base: fileName} = path.parse(downloadPath);
// 文件的信息
let stat;
try{
// 通过fs模块获取文件的信息，报错就代表着不存在该文件
stat = fs.statSync(downloadPath);
}catch(error) {
// 不存在该文件
return res.status(404).end();
}
// 获取文件的大小
let {size: total} = stat;
// 获取请求头部信息
let range = req.get("range");
// 如果包含该头部
if(range) {
// 获取范围请求的开始和结束位置
let [, start, end] = range.match(/(\d*)-(\d*)/);
// 处理请求头中范围参数不传的问题
start = start ? parseInt(start) : 0;
end = end ? parseInt(end) : total - 1;
// 如果范围是合理的，服务器会返回所请求的部分内容，并带上 206 Partial Content 状态码. 当前内容的范围会在 Content-Range 消息头中申明。
res.status(206);
// 服务器告诉浏览器，该内容可以使用 Accept-Ranges 消息头进行分部分请求。
res.setHeader("Accept-Ranges", "bytes");
// 当前内容的范围会在 Content-Range 消息头中申明。
res.setHeader("Content-Range", `bytes ${start}-${end}/${total}`);
// 以二进制流进行文件的传输
res.setHeader("Content-Type", "application/octet-stream");
res.setHeader("Content-Disposition", 'attachment; filename=' + encodeURIComponent(fileName));
res.setHeader("Content-Length", total);
fs.createReadStream(downloadPath, { start, end }).pipe(res);
}else {
res.status(200);
res.setHeader("Content-Type", "application/octet-stream");
res.setHeader("Content-Disposition", 'attachment; filename=' + encodeURIComponent(fileName));
res.setHeader("Content-Length", total);
fs.createReadStream(downloadPath).pipe(res);
}
})
module.exports = router;
|
const chalk = require("chalk");
class Logger {
constructor(obj) {
this.showDebug = obj["showDebug"];
}
_log(prefix, message) {
(console._original && console._original.log
? console._original.log
: console.log)(`${prefix} ${message}`);
}
info(msg) {
this._log(chalk.green("[INFO]"), msg);
}
warn(msg) {
this._log(chalk.yellow("[WARN]"), msg);
}
severe(msg) {
this._log(chalk.red("[SEVERE]"), msg);
}
debug(msg) {
if (this.showDebug) {
this._log("[DEBUG] ", msg);
}
}
}
module.exports = Logger;
|
const config = {
url:'mongodb+srv://user1:user123@customerapp-vzzuo.mongodb.net/meanproject?retryWrites=true'
}
module.exports = config;
|
import { getAuth, signInWithPopup, GoogleAuthProvider, signOut, onAuthStateChanged, createUserWithEmailAndPassword, updateProfile, sendEmailVerification, signInWithEmailAndPassword } from "firebase/auth";
import { useEffect, useState } from "react";
import initializeAuthentication from "../Firebase/firebase.init";
initializeAuthentication();
const useFirebase = () => {
const auth = getAuth();
const googleProvider = new GoogleAuthProvider();
const [user, setUser] = useState({});
const [name, setName] = useState('');
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [passError, setPassError] = useState('');
const [isLoading, setIsLoading] = useState(true);
// name feild
const handleNameChange = e => {
setName(e.target.value)
}
// email feild
const handleEmailChnage = e => {
setEmail(e.target.value)
}
// password feild
const handlepasswordChnage = e => {
setPassError(" ")
setPassword(e.target.value);
}
// new register handle
const registerNewUser = (e) => {
e.preventDefault();
return createUserWithEmailAndPassword(auth, email, password)
}
// set user name
const setUserName = () => {
return updateProfile(auth.currentUser, { displayName: name })
}
// email verification
const verifyEmail = () => {
return sendEmailVerification(auth.currentUser)
}
// email pass log in
const processLogin = (e) => {
setIsLoading(true)
return signInWithEmailAndPassword(auth, email, password)
}
// google sign in
const signInWithgoogle = () => {
setIsLoading(true);
return signInWithPopup(auth, googleProvider)
}
// user log out
const logOut = () => {
const auth = getAuth();
signOut(auth).then(() => {
// Sign-out successful.
}).catch((error) => {
// An error happened.
});
}
// observe user state change
useEffect(() => {
const unsubscribed = onAuthStateChanged(auth, user => {
if (user) {
setUser(user);
}
else {
setUser({})
}
setIsLoading(false);
});
return () => unsubscribed;
}, [])
return {
user, signInWithgoogle, setIsLoading, logOut, handleNameChange, handleEmailChnage, handlepasswordChnage, registerNewUser, password, setUserName, verifyEmail, setPassError, passError, processLogin, isLoading, name, email
}
}
export default useFirebase;
|
import clownface from 'clownface'
import RDF from '@rdfjs/dataset'
import ParsingClient from 'sparql-http-client/ParsingClient'
import TermSet from '@rdfjs/term-set'
import { shrink } from '@zazuko/rdf-vocabularies/shrink'
import { tablesFromSHACL } from '@/shacl'
import { rdf, schema, spex, prefixes as _prefixes } from './namespace'
const SCHEMA_URI = '.well-known/void'
const initialPrefixes = [...Object.keys(_prefixes)]
const displayLanguage = ['en', '*']
export class Endpoint {
constructor ({ url, user = null, password = null, prefixes = [], graph = '', forceIntrospection = false }) {
this.url = url
this.user = user
this.password = password
this.prefixes = prefixes
this.graph = graph
this.client = new ParsingClient({ endpointUrl: url, user, password })
this.forceIntrospection = forceIntrospection
// Reinitialize prefixes
Object.keys(_prefixes).forEach((prefix) => {
if (!initialPrefixes.includes(prefix)) {
delete _prefixes[prefix]
}
})
// Apply custom prefixes
prefixes.forEach(({ prefix, url }) => {
_prefixes[prefix] = url
})
}
shrink (uri) {
return shrink(uri) || uri
}
/**
* Fetch a list of graphs in the endpoint
*/
async fetchGraphs (opts = {}) {
const offset = opts.offset || 0
const limit = opts.limit || null
const query = `
SELECT DISTINCT ?g
WHERE {
GRAPH ?g { ?s ?p ?o }
}
ORDER BY ?g
OFFSET ${offset}
LIMIT ${limit}
`
const graphs = await this.client.query.select(query)
return graphs.map(({ g: { value } }) => value)
}
/**
* Fetch data model, either by introspecting it or by querying the
* pre-defined SHACL definition
*/
async fetchDatamodel () {
if (this.forceIntrospection) {
return this.fetchIntrospectDatamodel()
}
const datamodel = await this.fetchPredefinedDatamodel()
return datamodel.tables
? datamodel
: this.fetchIntrospectDatamodel()
}
/**
* Fetch data model from pre-defined SHACL definition
*/
async fetchPredefinedDatamodel () {
const schemaURI = this.url.replace(/query\/?$/, SCHEMA_URI)
const fromClause = this.graph ? `FROM <${this.graph}>` : ''
const query = `
#pragma describe.strategy cbd
DESCRIBE <${schemaURI}>
${fromClause}
`
const quads = await this.client.query.construct(query)
const dataset = clownface({
dataset: RDF.dataset(quads),
term: RDF.namedNode(schemaURI),
})
const defaultShapes = dataset.out(spex.shape).has(rdf.type, spex.DefaultShapes)
const tables = defaultShapes.term
? tablesFromSHACL(defaultShapes.out(schema.hasPart), this)
: null
const viewports = dataset.out(spex.viewport).map(viewport => ({
name: viewport.out(schema.name, { language: displayLanguage }).value,
tables: new Set(viewport.out(spex.includes).terms.map(({ value }) => value)),
}))
return {
tables,
viewports,
isIntrospected: false,
}
}
/**
* Fetch data model by introspecting the endpoint
*/
async fetchIntrospectDatamodel () {
const structure = await this._fetchStructure()
const tablesMap = structure.reduce((tables, { cls, property, linktype, datatype }) => {
const table = tables.get(cls.value) || { id: cls.value, name: this.shrink(cls.value), properties: new Map(), isShown: true }
const typeURI = (linktype && linktype.value) || (datatype && datatype.value) || null
const typeTermType = linktype ? 'NamedNode' : (datatype ? 'Literal' : null)
const type = typeURI && { id: typeURI, name: this.shrink(typeURI), termType: typeTermType }
if (table.properties.has(property.value)) {
if (type) {
table.properties.get(property.value).values.push(type)
}
} else {
table.properties.set(property.value, {
id: property.value,
name: this.shrink(property.value),
values: type ? [type] : []
})
}
tables.set(cls.value, table)
return tables
}, new Map())
const tables = [...tablesMap.values()].map((table) => ({ ...table, properties: [...table.properties.values()] }))
return {
tables,
viewports: [],
isIntrospected: true,
}
}
async _fetchStructure () {
const fromClause = this.graph ? `FROM <${this.graph}>` : ''
const query = `
SELECT DISTINCT ?cls ?property ?linktype ?datatype
${fromClause}
WHERE {
?subject a ?cls .
?subject ?property ?object .
OPTIONAL {
?object a ?linktype .
}
BIND(DATATYPE(?object) AS ?datatype)
}
`
return this.client.query.select(query)
}
/**
* Fetch a sample of the data of a given table
*/
async fetchTableData (table, opts = {}) {
const limit = opts.limit || 100
const graphClause = this.graph ? `GRAPH <${this.graph}>` : ''
const query = `
DESCRIBE ?subject {
{
SELECT ?subject
WHERE {
${graphClause} {
?subject a <${table.id}>
}
}
LIMIT ${limit}
}
}
`
const results = await this.client.query.construct(query)
const rows = results.reduce((acc, { subject, predicate: { value: predicate }, object }) => {
const row = acc.get(subject.value) || { id: subject.value, term: subject }
if (!row[predicate]) {
row[predicate] = new TermSet()
}
row[predicate].add(object)
acc.set(subject.value, row)
return acc
}, new Map())
return [...rows.values()]
}
/**
* Fetch triples related to a given resource.
*/
async fetchResource (uri) {
const query = `
DESCRIBE <${uri}> {}
`
const quads = await this.client.query.construct(query)
const properties = quads.reduce((acc, { predicate, object }) => {
if (!acc.has(predicate.value)) {
const property = {
id: predicate.value,
term: predicate,
name: this.shrink(predicate.value),
values: [],
}
acc.set(predicate.value, property)
}
acc.get(predicate.value).values.push(object)
return acc
}, new Map())
const term = { value: uri, termType: 'NamedNode' }
return {
id: uri,
term,
name: this.shrink(term.value),
properties: [...properties.values()],
}
}
}
|
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var express_1 = require("express");
var ProductController_1 = __importDefault(require("../controllers/ProductController"));
var productRoutes = express_1.Router();
var productController = new ProductController_1.default();
productRoutes.get("/", productController.index);
productRoutes.get("/search", productController.search);
productRoutes.get("/:id", productController.indexById);
productRoutes.post("/", productController.create);
productRoutes.put("/:id", productController.update);
exports.default = productRoutes;
|
(function($) {
$.cukeTree
.attachMethod("updateReport", function(cukeTree) {
return function($report) {
this.trigger("cukeTree.reportUpdating", $report);
};
})
.attachMethod("reportRendered", function(cukeTree) {
return function($report) {
this.trigger("cukeTree.reportRendered", $report);
};
})
.attachMethod("reportNodeSelected", function(cukeTree) {
return function(options) {
this.trigger("cukeTree.report.nodeSelected", options);
};
});
var $cukeTree = $(window.document);
$cukeTree.on("cukeTree.initialising", function() {
initialiseReports($(".report-tree"));
});
function initialiseReports($reports) {
$reports.each(function() {
var $report = $(this);
$cukeTree.on("cukeTree.reportUpdating", function(e, $updatingReport) {
if ($report[0] == $updatingReport) {
updateReport();
}
});
$report.on("dblclick", function(e, t) {
e.preventDefault();
var $target = $(e.srcElement).parents("li").eq(0);
$(this).jstree('toggle_node', $target)
});
/* Private Methods */
function updateReport() {
var treeOptions = {
"plugins" : [ "themes", "html_data", "ui", "cookies", "contextmenu" ],
"cookies" : {
"save_opened" : $report.attr("id")+"_opened"
},
"contextmenu" : {
"select_node" : true,
"items" : contextMenuHandler
}
};
$report.jstree(treeOptions)
.on("loaded.jstree", function(event, data) {
$cukeTree.cukeTree().reportRendered($report);
})
.on("select_node.jstree", function(event, data) {
var $node = $(data.args[0]);
$cukeTree.cukeTree().reportNodeSelected({ $report : $report, selected : $node });
});
}
function contextMenuHandler(node) {
var type = $(node).data("type"), menu = {};
if (type == "step") {
menu.gotoStepDef = {
"label" : "Goto Step Definition",
"action" : function ($node) { $report.trigger("report.goto_step_def", { stepName : $node.children("a").text().trim() }); }
};
}
return menu;
}
});
}
})(jQuery);
|
//Section 1
function nearestSun(){
var now = new Date();
//Loop through every year in between 2020 to 2100
for (var year = 2020; year <= 2100; year++){
//Declare 1/1/year as Date in now variable
var now = new Date(year, 0, 1);
//Checking Sunday
if (now.getDay() === 0){
alert(now.getFullYear() + " is true.");
}
}
}
//Section 2
var output1 = document.getElementById("output1");
function multiply(){
var num1 = document.getElementById("num1").value;
var num2 = document.getElementById("num2").value;
output1.innerHTML = num1 * num2;
}
function divide(){
var num1 = document.getElementById("num1").value;
var num2 = document.getElementById("num2").value;
output1.innerHTML = num1 / num2;
}
//Section 3
var output2 = document.getElementById("output2");
function urlGen(){
output2.innerHTML = document.URL;
}
|
const express = require('express');
const server = express();
server.get('/', (req, res) => {
var value1 = req.query.sensor1;
var value2 = req.query.sensor2;
const responsestr = `sensor1: ${value1}, sensor2: ${value2}`;
res.status(200).send(responsestr);
console.log(responsestr);
});
server.listen(3000, () => {
console.log('server started on port 3000');
});
|
(function () {
var app = angular.module('techRecycleApp', ['ngRoute', 'ngAnimate', 'ui.bootstrap']);
app.service('modalService', ['$modal', '$http',
function ($modal, $http) {
var modalDefaults = {
backdrop: true,
keyboard: true,
modalFade: true,
templateUrl: '/app/partials/modal.html'
};
var modalOptions = {
okButtonText: 'OK',
closeButtonText: 'Cancel',
actionButtonText: 'Submit',
headerText: 'Proceed?',
bodyText: 'Perform this action?',
showHeader: false
};
this.showModal = function (customModalDefaults, customModalOptions) {
if (!customModalDefaults) customModalDefaults = {};
//customModalDefaults.backdrop = 'static';
return this.show(customModalDefaults, customModalOptions);
};
this.show = function (customModalDefaults, customModalOptions) {
//Create temp objects to work with since we're in a singleton service
var tempModalDefaults = {};
var tempModalOptions = {};
//Map angular-ui modal custom defaults to modal defaults defined in service
angular.extend(tempModalDefaults, modalDefaults, customModalDefaults);
//Map modal.html $scope custom properties to defaults defined in service
angular.extend(tempModalOptions, modalOptions, customModalOptions);
if (!tempModalDefaults.controller) {
tempModalDefaults.controller = function ($scope, $modalInstance) {
$scope.months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
$scope.modalOptions = tempModalOptions;
$scope.modalOptions.ok = function (result) {
$modalInstance.close(result);
};
$scope.modalOptions.close = function (result) {
$modalInstance.dismiss('cancel');
};
$scope.modalOptions.schedule = function (ticket, datetime, currentUser) {
var scheduleInfo = {
ticketNumber: ticket.TicketNumber,
datetime: datetime,
alias: currentUser
}
$http({
method: "post",
url: "/Manager/SchedulePickup",
data: scheduleInfo
}).success(function (data) {
location.reload(true);
}).error(function (data) {
var modalOptions = {
bodyText: "Error scheduling pickup - please contact support."
};
modalService.showModal({}, modalOptions).then(function () {
location.reload(true);
});
});
};
$scope.modalOptions.cancel = function (result) {
$modalInstance.close(result);
};
}
}
return $modal.open(tempModalDefaults).result;
};
}]);
app.controller('MainCtrl', ['$scope', function ($scope) {
//$scope.modalShown = false;
//$scope.toggleModal = function () {
// $scope.modalShown = !$scope.modalShown;
//};
}]);
app.controller('ManagerCtrl', ['$scope', '$http', 'modalService', function ($scope, $http, modalService) {
//$scope.getMyCtrlScope = function () {
// return $scope;
//}
$scope.selectedTicket = {};
$scope.tickets = {};
$scope.currentUser = "v-altiet";
$http.get('/Manager/GetAll').
success(function (data) {
$scope.tickets = JSON.parse(data);
}).
error(function (data) {
});
$scope.selectTicket = function (ticket) {
$scope.selectedTicket = ticket;
}
$scope.schedulePickup = function (ticket) {
var modalOptions = {
bodyText: "When would you like to schedule the pickup for ticket " + ticket.TicketNumber + "?",
ticket: ticket,
currentUser: $scope.currentUser,
showScheduler: true
};
modalService.showModal({
}, modalOptions).then(function () {
});
}
$scope.isActive = function (ticket) {
return ticket.TicketNumber == $scope.selectedTicket.TicketNumber;
}
}]);
app.controller('DatepickerCtrl', function ($scope) {
$scope.today = function () {
$scope.dt = new Date();
};
$scope.today();
$scope.clear = function () {
$scope.dt = null;
};
// Disable weekend selection
$scope.disabled = function (date, mode) {
return (mode === 'day' && (date.getDay() === 0 || date.getDay() === 6));
};
$scope.toggleMin = function () {
$scope.minDate = $scope.minDate ? null : new Date();
};
$scope.toggleMin();
$scope.open = function ($event) {
$event.preventDefault();
$event.stopPropagation();
$scope.opened = true;
};
$scope.dateOptions = {
formatYear: 'yy',
startingDay: 1
};
$scope.formats = ['dd-MMMM-yyyy', 'yyyy/MM/dd', 'dd.MM.yyyy', 'shortDate'];
$scope.format = $scope.formats[0];
});
// directive to highlight on hover
app.directive('highlightOnHover', function () {
return {
restrict: 'A',
link: function ($scope, element, attrs) {
if (/accordion/.test(element[0].outerHTML)) {
element.bind('mouseenter', function () {
element.removeClass('inactive-box');
element.addClass('hover-box');
});
element.bind('mouseleave', function () {
element.removeClass('hover-box');
element.addClass('inactive-box');
});
} else if (/tile/.test(element[0].outerHTML)) {
element.bind('mouseenter', function () {
element.addClass('hover-box');
});
element.bind('mouseleave', function () {
element.removeClass('hover-box');
});
} else {
element.bind('mouseenter', function () {
element.addClass('hover-link');
});
element.bind('mouseleave', function () {
element.removeClass('hover-link');
});
}
}
}
});
// directive to adapt header width
app.directive('hdrAdaptWidth', function () {
return {
restrict: 'A',
scope: {},
link: function ($scope, element, attrs) {
window.onload = function () {
var width = document.getElementsByTagName('header')[0].offsetWidth - 160;
element.css('width', width + 'px');
}
window.onresize = function () {
var width = document.getElementsByTagName('header')[0].offsetWidth - 160;
element.css('width', width + 'px');
}
}
}
});
app.directive('fixedHeader', ['$timeout', function ($timeout) {
return {
restrict: 'A',
scope: {
tableHeight: '@'
},
link: function ($scope, $elem, $attrs, $ctrl) {
// wait for content to load into table and the tbody to be visible
$scope.$watch(function () { return $elem.find("tbody").is(':visible') },
function (newValue, oldValue) {
if (newValue === true) {
// reset display styles so column widths are correct when measured below
$elem.find('thead, tbody, tfoot').css('display', '');
// wrap in $timeout to give table a chance to finish rendering
$timeout(function () {
// set widths of columns
$elem.find('th').each(function (i, thElem) {
thElem = $(thElem);
var tdElems = $elem.find('tbody tr:first td:nth-child(' + (i + 1) + ')');
var tfElems = $elem.find('tfoot tr:first td:nth-child(' + (i + 1) + ')');
var columnWidth = tdElems.width();
thElem.width(columnWidth);
tdElems.width(columnWidth);
tfElems.width(columnWidth);
});
// set css styles on thead and tbody
$elem.find('thead, tfoot').css({
'display': 'block',
});
$elem.find('tbody').css({
'display': 'block',
'height': $scope.tableHeight || '400px',
'overflow': 'auto'
});
// reduce width of last column by width of scrollbar
var scrollBarWidth = $elem.find('thead').width() - $elem.find('tbody')[0].clientWidth;
if (scrollBarWidth > 0) {
// for some reason trimming the width by 2px lines everything up better
scrollBarWidth -= 2;
$elem.find('tbody tr:first td:last-child').each(function (i, elem) {
$(elem).width($(elem).width() - scrollBarWidth);
});
}
});
}
});
}
}
}]);
// directive that only allows digits to be entered into a text field
app.directive('onlyDigits', function () {
return {
restrict: 'A',
require: '?ngModel',
link: function (scope, element, attrs, ngModel) {
if (!ngModel) return;
ngModel.$parsers.unshift(function (inputValue) {
var digits = inputValue.split('').filter(function (s) { return (!isNaN(s) && s != ' '); }).join('');
ngModel.$viewValue = digits;
ngModel.$render();
return digits;
});
}
}
});
// fix this
app.directive('widthAdapter', function () {
return {
restrict: 'A',
link: function (scope, element, attrs) {
element.css("width", 70 * element.children("input").length + 20 * (element.children("input").length - 1));
scope.stuff = element[0];
}
}
});
})();
|
import red from '@material-ui/core/colors/red';
import { createMuiTheme } from '@material-ui/core';
const theme = createMuiTheme({
palette: {
primary: {
main: '#607d8b',
dark: '#546e7a',
light: '#eceff1',
contrastText: '#fff',
},
secondary: {
main: '#009688',
light: '#e0f2f1',
dark: '#004d40',
contrastText: '#000',
},
info: {
main: '#f44336',
},
error: {
main: red.A400,
},
background: {
default: 'rgba(255, 255, 255, 0.75)',
},
},
});
export default theme;
|
//TODO: MAKE TITLES FOR PAGES
let loginButton = document.getElementById('loginButton');
loginButton.addEventListener("click",(evt)=>{
window.location.href="login.php";
console.log("clicked");
});
|
import React from 'react';
import { Image, StatusBar, View, Text, TouchableWithoutFeedback } from 'react-native';
import { Actions } from 'react-native-router-flux';
import { CardSection, Button } from './common';
const InitialScreen = () => {
const { backgroundImage } = styles;
return (
<View style={{ flex:1 }}>
<StatusBar backgroundColor='#F04E45' barStyle='light-content' />
<TouchableWithoutFeedback onPress={() => Actions.login()}>
<Image
source={require('../../images/InitialScreen.png')}
style={backgroundImage}
/>
</TouchableWithoutFeedback>
</View>
);
};
const styles = {
backgroundImage: {
flex: 1,
resizeMode: 'cover',
justifyContent: 'center',
alignItems: 'center',
width: null,
backgroundColor: 'transparent'
}
};
export default InitialScreen;
|
function explorationStrategy(maze, mouse, initPosition, initDirection){
memorizedMaze = [
[1,0],
[2,0],
[3,0],
[4,0],
[5,0],
[6,0],
[7,0],
[8,0],
[9,0],
[10,0],
[11,0],
[12,0],
[13,0],
[14,0],
[15,0],
[16,0],
[17,0],
[18,0],
[19,0],
[20,0],
[21,0],
[22,0],
[23,0],
[24,0],
[25,0],
];
goal = false;
// useless mais plus clair pour le moment
position = initPosition;
direction = initDirection;
while(!goal){
alert(position);
square = maze[position-1];
// init square exploration
yieldArray = explorationDispatch(maze, memorizedMaze, mouse, position, direction);
// retour de la nouvelle position et de la nouvelle direction et du goalMarker
position = yieldArray[0];
direction = yieldArray[1];
// add last direction taken by the mouse to its memorizerd maze
memorizedMaze[position -1][1] = direction;
// check for Goal
if(maze[position -1][2] == true){
goal = true;
alert('GOAL REACHED !!');
}
}
mazeToDisplay = '';
for (var i = 0; i < memorizedMaze.length; i++) {
mazeToDisplay += 'square : ' + memorizedMaze[i][0] + ' // direction : ' + memorizedMaze[i][1] + '----- ';
};
alert(mazeToDisplay);
// switch to goalStrategy
}
function explorationDispatch(maze, memorizedMaze, mouse, mousePosition, mouseDirection){
fwd = false;
mouseState = [];
while(!fwd){
switch(mouseDirection){
case 1:
mouseState = squareExploration(maze, memorizedMaze, mouse, mousePosition, 4, 1, 2);
break;
case 2:
mouseState = squareExploration(maze, memorizedMaze, mouse, mousePosition, 1, 3, 2);
break;
case 3:
mouseState = squareExploration(maze, memorizedMaze, mouse, mousePosition, 3, 4, 2);
break;
case 4:
mouseState = squareExploration(maze, memorizedMaze, mouse, mousePosition, 3, 4, 1);
break;
default:
alert('explorationDispatch ERROR');
}
fwd = true;
mousePosition = mouseState[0];
mouseDirection = mouseState[1];
}
// return new mousePosition & new mouseDirection
return [newPosition, newDirection];
}
function squareExploration(maze, memorizedMaze, mouse, mousePosition, direction1, direction2, direction3){
firstAttempt = true;
exit = false;
// first loop checks for any obstacle free path leeding to a anti-direction free square
while(firstAttempt && !exit){
alert('trying to go ' + convertDirection(direction1));
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction1);
if(!obstacleYield[0] && !obstacleYield[1]){
memorizedMaze[mousePosition-1][1] = direction1;
newPosition = addDirection(mousePosition, direction1);
newDirection = direction1;
exit = true;
}
else{
alert('Now trying to go ' + convertDirection(direction2));
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction2);
if(!obstacleYield[0] && !obstacleYield[1]){
memorizedMaze[mousePosition-1][1] = direction2;
newPosition = addDirection(mousePosition, direction2);
newDirection = direction2;
exit = true;
}
else{
alert('Now trying to go ' + convertDirection(direction3));
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction3);
if(!obstacleYield[0] && !obstacleYield[1]){
memorizedMaze[mousePosition-1][1] = direction3;
newPosition = addDirection(mousePosition, direction3);
newDirection = direction3;
exit = true;
}
else{
firstAttempt = false;
}
}
}
}
// second loop only checks for an obstacle free path
while(!exit){
alert('second loop starting');
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction1);
if(!obstacleYield[0]){
memorizedMaze[mousePosition-1][1] = direction1;
newPosition = addDirection(mousePosition, direction1);
newDirection = direction1;
exit = true;
}
else{
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction2);
if(!obstacleYield[0]){
memorizedMaze[mousePosition-1][1] = direction2;
newPosition = addDirection(mousePosition, direction2);
newDirection = direction2;
exit = true;
}
else{
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, direction3);
if(!obstacleYield[0]){
memorizedMaze[mousePosition-1][1] = direction3;
newPosition = addDirection(mousePosition, direction3);
newDirection = direction3;
exit = true;
}
else{
reverseDirection = quadrant(direction + 2);
obstacleYield = tryDirection(maze, memorizedMaze, mouse, mousePosition, reverseDirection);
if(!obstacleYield[0]){
memorizedMaze[mousePosition-1][1] = reverseDirection;
newPosition = addDirection(mousePosition, reverseDirection);
newDirection = reverseDirection;
exit = true;
}
else{
alert('Mouse must be blocked !!!');
}
}
}
}
}
// return newPosition
return [newPosition, newDirection];
}
function tryDirection(maze, memorizedMaze, mouse, mousePosition, mouseDirection){
obstacle = false;
previousVector = false;
if(maze[mousePosition-1][1].indexOf(mouseDirection) != -1){
alert('obstacle in the ' + convertDirection(mouseDirection) + ' in square #' + mousePosition);
obstacle = true;
}
nextPosition = addDirection(mousePosition, mouseDirection);
if(memorizedMaze[nextPosition-1] >= 0 && memorizedMaze[nextPosition-1] < 26){
if(memorizedMaze[nextPosition-1].indexOf(quadrant(mouseDirection)) != -1){
alert('wrong vector in square #' + nextPosition + ' by ' + convertDirection(mouseDirection) + ' direction');
previousVector = true;
}
}
return [obstacle, previousVector];
}
function addDirection(position, direction){
switch(direction){
case 1:
position = position + 5;
break;
case 2:
position = position + 1;
break;
case 3:
position = position - 5;
break;
case 4:
position = position - 1;
break;
default:
alert('"addDirection" Direction ERROR');
}
return position;
}
function convertDirection(direction){
switch(direction){
case 1:
return 'North';
break;
case 2:
return 'East';
break;
case 3:
return 'South';
break;
case 4:
return 'West';
break
default:
return 'Direction Error';
}
}
function quadrant(direction){
if(direction > 4){
direction -= 4;
}
return direction;
}
|
/**
* Created by titi on 2017/8/31.
*/
$("#loginbtn").click(function(){
var user=document.getElementById("user").value;
var password=document.getElementById("password").value;
if(user===""||password==="")
{alert("请输入用户名和密码")}
else{
$.post("/carrots-admin-ajax/a/login",{
"name":user,
"pwd":password
},
function(data){
var jsons=JSON.parse(data);
console.log(jsons.message);
if(jsons.message==="success"){
window.location.href=('js6-background.html');
}
else{
document.getElementById("txt").innerHTML=jsons.message;
}
});
}
});
|
function enterPress(e){ //传入 event
var e = e || window.event;
if(e.keyCode === 13){
document.getElementById("send-btn").click();
}
}
|
import * as types from "../Actions/actionConstant";
const initialState = [];
const companyReducer = (state = initialState, action) => {
switch (action.type) {
case types.GET_COMPANIES:
return action.payload;
case types.CREATE_COMPANY:
return [...state, action.payload];
case types.UPDATE_COMPANY:
const company = action.payload;
const index = state.findIndex(com => com._id === company._id);
state[index] = company;
return [...state];
default:
return state;
}
};
export default companyReducer;
|
/**
* search all type model
*/
window.NewsCategroyData=Backbone.Model.extend({
urlRoot:'/rest/news/searchAllType',
fetch:function(options){
digitnexus.ajaxRequest(this.urlRoot,
null,
function(response) {
options.success.call(options.callBackContext,response);
},
function(xhr, status, exception) {
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* search news data by newsType
* */
window.NewsListData=Backbone.Model.extend({
urlRoot:'/rest/news/searchByType/',
fetch:function(options){
digitnexus.ajaxRequest(this.urlRoot+options.newsType,
null,
function(response) {
options.success.call(options.callBackContext,response);
},
function(xhr, status, exception) {
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* delete news by newsId
* */
window.NewsListDeleteData=Backbone.Model.extend({
urlRoot:'/rest/news/delNews?',
fetch:function(options){
digitnexus.syncDelete(this.urlRoot+options.newsId,
null,
function(response){
options.success.call(options.callBackContext,response);
},
function(xhr,status,exception){
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* add news model
* */
window.NewsListAddData=Backbone.Model.extend({
urlRoot:'/rest/news/addNews',
fetch:function(options){
digitnexus.ajaxPostByContentType(this.urlRoot,
options.data,
options.contentType,
function(response){
options.success.call(options.callBackContext,response);
},
function(xhr,status,exception){
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* edit news model
* */
window.NewsListEditData=Backbone.Model.extend({
urlRoot:'/rest/news/editNews',
fetch:function(options){
digitnexus.ajaxWithDataTypeAndType(this.urlRoot,
options.data,
options.contentType,
options.type,
function(response){
options.success.call(options.callBackContext,response);
},
function(xhr,status,exception){
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* search news by newsId model
* */
window.NewsListQuerySingleData=Backbone.Model.extend({
urlRoot:'/rest/news/searchNewsById/',
fetch:function(options){
digitnexus.ajaxRequest(this.urlRoot+options.newsId,
null,
function(response) {
options.success.call(options.callBackContext,response);
},
function(xhr, status, exception) {
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
/**
* search news by create time and newsType
* */
window.NewsQueryLatestData=Backbone.Model.extend({
urlRoot:'/rest/news/searchNewsByIdAndType?',
fetch:function(options){
digitnexus.ajaxRequest(this.urlRoot+options.data,
null,
function(response){
options.success.call(options.callBackContext,response);
},
function(xhr, status, exception){
options.failure.call(options.callBackContext,xhr, status, exception);
}
);
}
});
|
// Brain.js
var Brain = function() {
console.log('braaaains')
}
module.exports = Brain;
|
class UrlValidator {
constructor() { }
validate(value) {
return {
isValid: validator.isURL(value),
message: 'Must consist of a valid URL.'
};
}
}
export default (new UrlValidator());
|
import CryptoJS from "crypto-js";
export default {
encryptData: data => {
var encrypted = CryptoJS.AES.encrypt(data, process.env.CRYPT_KEY);
return encrypted.toString();
},
decryptData: data => {
var decryptedBytes = CryptoJS.AES.decrypt(data, process.env.CRYPT_KEY);
var decrypted = decryptedBytes.toString(CryptoJS.enc.Utf8);
return decrypted;
}
};
|
"use strict";
exports.LockStore = function()
{
var that = this;
that.SHARED_LOCK = 0;
that.EXCLUSIVE_LOCK = 1;
var m_lockMap = { };
that.lock = function(resource, lockType, lifeTimeSeconds)
{
// create a unique lock token
var lockToken = "urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6";
return lockToken;
};
that.unlock = function(lockToken)
{
};
};
|
var win = $(window);
var DEFAULT_EDM_BACKGROUND = '#fafafa';
var DEFAULT_EDM_PADDING_TOP = '20';
var DEFAULT_EDM_PADDING_BOTTOM = '20';
var DEFAULT_EDM_PADDING_LEFT = '20';
var DEFAULT_EDM_PADDING_RIGHT = '20';
var DEFAULT_EDM_BODY_WIDTH = '600';
var DEFAULT_EDM_BODY_BACKGROUND = '#ffffff';
var DEFAULT_EDM_BODY_PADDING_TOP = '10';
var DEFAULT_EDM_BODY_PADDING_BOTTOM = '10';
var DEFAULT_EDM_BODY_PADDING_LEFT = '10';
var DEFAULT_EDM_BODY_PADDING_RIGHT = '10';
var DEFAULT_TEXT_COLOR = '#333333';
var DEFAULT_LINK_COLOR = '#337ab7';
var DEFAULT_FONT_FAMILY = 'Arial, Helvetica, san-serif';
var DEFAULT_FONT_SIZE = '14px';
var DEFAULT_LINE_HEIGHT = '1.42857143';
var keditor;
var body;
function initEdmEditorPage(fileName) {
flog('initEdmEditorPage', fileName);
body = $(document.body);
Msg.iconMode = 'fa';
keditor = initKEditor(fileName, processFileBody()).data('keditor');
initSaveFile(fileName);
}
function applyInlineCssForTextWrapper(target) {
target.find('.text-wrapper').each(function () {
var textWrapper = $(this);
setStyle(textWrapper, 'font-family', $('#edm-font-family').val());
setStyle(textWrapper, 'font-size', $('#edm-font-size').val());
setStyle(textWrapper, 'line-height', $('#edm-line-height').val());
setStyle(textWrapper, 'color', $('#edm-text-color').val());
});
}
function applyInlineCssForLink(target) {
target.find('td.text-wrapper a').each(function () {
var link = $(this);
setStyle(link, 'text-decoration', 'none');
setStyle(link, 'color', $('#edm-link-color').val());
});
}
function processFileBody() {
var edmHeader = $('#edm-header');
var edmBody = $('#edm-body');
var edmFooter = $('#edm-footer');
var edmHtml = $('<div />').html($('#edm-html').html());
// Handle styles
var edmStyle = $('#edm-style');
var defaultStyle = edmStyle.html();
var savedStyle = edmHtml.find('style').html();
if (savedStyle && savedStyle.length > 0 && savedStyle !== defaultStyle) {
edmStyle.html(savedStyle);
}
// Fulfill header, body and footer data
edmHeader.html(edmHtml.find('td#edm-header-td').html());
edmBody.html(edmHtml.find('td#edm-body-td').html());
edmFooter.html(edmHtml.find('td#edm-footer-td').html());
// Getting styles
var edmWidth = edmHtml.find('#edm-container').attr('width') || DEFAULT_EDM_BODY_WIDTH;
var tdWrapper = edmHtml.find('td#edm-wrapper-td');
var edmBg = tdWrapper.css('background-color') || DEFAULT_EDM_BACKGROUND;
var paddingTop = tdWrapper.css('padding-top') || '';
paddingTop = paddingTop.replace('px', '') || DEFAULT_EDM_PADDING_TOP;
var paddingBottom = tdWrapper.css('padding-bottom') || '';
paddingBottom = paddingBottom.replace('px', '') || DEFAULT_EDM_PADDING_BOTTOM;
var paddingLeft = tdWrapper.css('padding-left') || '';
paddingLeft = paddingLeft.replace('px', '') || DEFAULT_EDM_PADDING_LEFT;
var paddingRight = tdWrapper.css('padding-right') || '';
paddingRight = paddingRight.replace('px', '') || DEFAULT_EDM_PADDING_RIGHT;
var tdBody = edmHtml.find('td#edm-body-td');
var bodyBg = tdBody.css('background-color') || DEFAULT_EDM_BODY_BACKGROUND;
var paddingBodyTop = tdBody.css('padding-top') || '';
paddingBodyTop = paddingBodyTop.replace('px', '') || DEFAULT_EDM_BODY_PADDING_TOP;
var paddingBodyBottom = tdBody.css('padding-bottom') || '';
paddingBodyBottom = paddingBodyBottom.replace('px', '') || DEFAULT_EDM_BODY_PADDING_BOTTOM;
var paddingBodyLeft = tdBody.css('padding-left') || '';
paddingBodyLeft = paddingBodyLeft.replace('px', '') || DEFAULT_EDM_BODY_PADDING_LEFT;
var paddingBodyRight = tdBody.css('padding-right') || '';
paddingBodyRight = paddingBodyRight.replace('px', '') || DEFAULT_EDM_BODY_PADDING_RIGHT;
var tableContainer = edmHtml.find('table#edm-container');
var fontFamily = tableContainer.attr('data-font-family') || DEFAULT_FONT_FAMILY;
var fontSize = tableContainer.attr('data-font-size') || DEFAULT_FONT_SIZE;
var lineHeight = tableContainer.attr('data-line-height') || DEFAULT_LINE_HEIGHT;
var textColor = tableContainer.attr('data-text-color') || DEFAULT_TEXT_COLOR;
var linkColor = tableContainer.attr('data-link-color') || DEFAULT_LINK_COLOR;
return {
edmWidth: edmWidth,
edmBg: edmBg,
paddingTop: paddingTop,
paddingBottom: paddingBottom,
paddingLeft: paddingLeft,
paddingRight: paddingRight,
bodyBg: bodyBg,
paddingBodyTop: paddingBodyTop,
paddingBodyBottom: paddingBodyBottom,
paddingBodyLeft: paddingBodyLeft,
paddingBodyRight: paddingBodyRight,
fontFamily: fontFamily,
fontSize: fontSize,
lineHeight: lineHeight,
textColor: textColor,
linkColor: linkColor
};
}
function initKEditor(fileName, stylesData) {
flog('initKEditor', fileName, stylesData);
return $('#edm-area').keditor({
basePath: '',
tabContainersText: '<i class="fa fa-columns"></i>',
tabComponentsText: '<i class="fa fa-files-o"></i>',
tabTooltipEnabled: false,
snippetsTooltipEnabled: false,
contentAreasSelector: '#edm-header, #edm-body, #edm-footer',
contentAreasWrapper: '<div id="edm-area"></div>',
snippetsUrl: '_components?fileName=' + fileName,
extraTabs: {
setting: {
text: '<i class="fa fa-cog"></i>',
title: 'Settings',
content: '<div id="edm-setting" class="form-horizontal">' +
' <div class="panel panel-default">' +
' <div class="panel-heading">EDM Page</div>' +
' <div class="panel-body">' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-background">Background</label>' +
' <div class="input-group color-picker">' +
' <span class="input-group-addon"><i></i></span>' +
' <input type="text" value="' + stylesData.edmBg + '" id="edm-background" class="form-control" />' +
' </div>' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label>Padding (in px)</label>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingTop + '" id="edm-padding-top" class="form-control" />' +
' <small>top</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4">' +
' <input type="number" value="' + stylesData.paddingLeft + '" id="edm-padding-left" class="form-control" />' +
' <small>left</small>' +
' </div>' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingRight + '" id="edm-padding-right" class="form-control" />' +
' <small>right</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingBottom + '" id="edm-padding-bottom" class="form-control" />' +
' <small>bottom</small>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' <div class="panel panel-default">' +
' <div class="panel-heading">EDM Body</div>' +
' <div class="panel-body">' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-body-background">Width (in px)</label>' +
' <input type="number" value="' + stylesData.edmWidth + '" id="edm-body-width" class="form-control" />' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-body-background">Background</label>' +
' <div class="input-group color-picker">' +
' <span class="input-group-addon"><i></i></span>' +
' <input type="text" value="' + stylesData.bodyBg + '" id="edm-body-background" class="form-control" />' +
' </div>' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label>Padding (in px)</label>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingBodyTop + '" id="edm-body-padding-top" class="form-control" />' +
' <small>top</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4">' +
' <input type="number" value="' + stylesData.paddingBodyLeft + '" id="edm-body-padding-left" class="form-control" />' +
' <small>left</small>' +
' </div>' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingBodyRight + '" id="edm-body-padding-right" class="form-control" />' +
' <small>right</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="' + stylesData.paddingBodyBottom + '" id="edm-body-padding-bottom" class="form-control" />' +
' <small>bottom</small>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
' <div class="panel panel-default">' +
' <div class="panel-heading">EDM Default Styles</div>' +
' <div class="panel-body">' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-text-color">Text color</label>' +
' <div class="input-group color-picker">' +
' <span class="input-group-addon"><i></i></span>' +
' <input type="text" value="' + stylesData.textColor + '" id="edm-text-color" class="form-control" />' +
' </div>' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-text-color">Link color</label>' +
' <div class="input-group color-picker">' +
' <span class="input-group-addon"><i></i></span>' +
' <input type="text" value="' + stylesData.linkColor + '" id="edm-link-color" class="form-control" />' +
' </div>' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-font-family">Font family</label>' +
' <input type="text" value="' + stylesData.fontFamily + '" id="edm-font-family" class="form-control" />' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-font-size">Font size</label>' +
' <input type="text" value="' + stylesData.fontSize + '" id="edm-font-size" class="form-control" />' +
' </div>' +
' </div>' +
' <div class="form-group form-group-sm">' +
' <div class="col-md-12">' +
' <label for="edm-line-height">Line height</label>' +
' <input type="text" value="' + stylesData.lineHeight + '" id="edm-line-height" class="form-control" />' +
' </div>' +
' </div>' +
' </div>' +
' </div>' +
'</div>'
}
},
onBeforeDynamicContentLoad: function (dynamicElement, component) {
var width = dynamicElement.closest('.keditor-container-inner').width();
component.attr({
'data-width': width
});
},
onInitContentArea: function (contentArea) {
contentArea[contentArea.children().length === 0 ? 'addClass' : 'removeClass']('empty');
return contentArea.find('> table');
},
onComponentReady: function (component, editor) {
if (editor) {
applyInlineCssForTextWrapper(component);
applyInlineCssForLink(component);
editor.on('change', function () {
applyInlineCssForLink(component);
});
}
var img = component.find('img');
if (img && img.length > 0) {
$.keditor.components['photo'].adjustWidthForImg(img, img.hasClass('full-width'));
}
},
onContentChanged: function () {
if (!body.hasClass('content-changed')) {
body.addClass('content-changed');
}
var contentArea = $(this);
contentArea[contentArea.children().length === 0 ? 'addClass' : 'removeClass']('empty');
},
onContainerChanged: function (e, changedContainer) {
changedContainer.find('[data-dynamic-href]').each(function () {
keditor.initDynamicContent($(this));
});
},
onReady: function () {
initSettingPanel();
$('[data-dynamic-href]').each(function () {
keditor.initDynamicContent($(this));
});
adjustColWidth($('.keditor-container'));
hideLoadingIcon();
},
onContainerSnippetDropped: function (event, newContainer, droppedContainer) {
adjustColWidth(newContainer);
},
containerSettingEnabled: true,
containerSettingInitFunction: function (form, keditor) {
form.append(
'<form class="form-horizontal">' +
' <div class="form-group">' +
' <div class="col-sm-12">' +
' <label>Available for groups</label>' +
' <select class="form-control select-groups selectpicker" multiple="multiple" title=" - Select Groups - ">' +
' </select>' +
' </div>' +
' </div>' +
'</form>'
);
var groupsOptions = '';
for (var name in allGroups) {
groupsOptions += '<option value="' + name + '">' + allGroups[name] + '</option>';
}
form.find('.select-groups').html(groupsOptions).selectpicker().on('changed.bs.select', function () {
var container = keditor.getSettingContainer();
var table = container.find('.keditor-container-inner > table');
table.attr('data-groups', $(this).selectpicker('val').join(','));
});
},
containerSettingShowFunction: function (form, container, keditor) {
var table = container.find('.keditor-container-inner > table');
form.find('.select-groups').selectpicker('val', (table.attr('data-groups') || '').split(','));
}
});
}
function adjustColWidth(target) {
flog('adjustColWidth', target);
target.find('.keditor-container-inner').each(function () {
var cols = $(this).find('table.col');
var isDynamicContent = cols.closest('[data-dynamic-href]').length > 0;
if (!isDynamicContent) {
var colsNumber = cols.length;
var td = cols.closest('td');
var width = td.width();
var adjustedWidth = 0;
flog('Cols number: ' + colsNumber + ', width: ' + width);
cols.each(function (i) {
var col = $(this);
var dataWidth = col.attr('data-width');
if (dataWidth) {
var colWidth = 0;
if (i === colsNumber - 1) {
colWidth = width - adjustedWidth;
} else {
colWidth = Math.round(eval(width + '*' + dataWidth));
adjustedWidth += colWidth;
}
col.attr('width', colWidth);
}
});
} else {
flog('Is dynamic content. Ignored!');
}
});
}
function initSettingPanel() {
flog('initSettingPanel');
var settingPanel = body.find('#edm-setting');
// Init colorpicker
settingPanel.find('.color-picker').each(function () {
var input = $(this);
input.colorpicker({
format: 'hex',
container: input.parent(),
component: '.add-on, .input-group-addon'
}).trigger('changeColor.colorpicker');
input.on('changeColor.colorpicker', function (e) {
input.val(e.color.toHex());
applySetting();
});
});
settingPanel.find('input').not('.colorpicker').on('change', function () {
applySetting($(this));
});
applySetting();
}
function applySetting(sender) {
var edmBackground = body.find('#edm-background').val();
var edmPaddingTop = body.find('#edm-padding-top').val();
var edmPaddingBottom = body.find('#edm-padding-bottom').val();
var edmPaddingLeft = body.find('#edm-padding-left').val();
var edmPaddingRight = body.find('#edm-padding-right').val();
setStyle(body, 'background-color', edmBackground);
var edmArea = body.find('#edm-area');
setStyle(edmArea, 'padding-top', edmPaddingTop + 'px');
setStyle(edmArea, 'padding-bottom', edmPaddingBottom + 'px');
setStyle(edmArea, 'padding-left', edmPaddingLeft + 'px');
setStyle(edmArea, 'padding-right', edmPaddingRight + 'px');
var edmHeader = body.find('#edm-header');
var edmBody = body.find('#edm-body');
var edmFooter = body.find('#edm-footer');
var edmBodyBackground = body.find('#edm-body-background').val();
var edmBodyPaddingTop = body.find('#edm-body-padding-top').val();
var edmBodyPaddingBottom = body.find('#edm-body-padding-bottom').val();
var edmBodyPaddingLeft = body.find('#edm-body-padding-left').val();
var edmBodyPaddingRight = body.find('#edm-body-padding-right').val();
setStyle(edmBody, 'background-color', edmBodyBackground);
setStyle(edmBody, 'padding-top', edmBodyPaddingTop + 'px');
setStyle(edmBody, 'padding-bottom', edmBodyPaddingBottom + 'px');
setStyle(edmBody, 'padding-left', edmBodyPaddingLeft + 'px');
setStyle(edmBody, 'padding-right', edmBodyPaddingRight + 'px');
applyInlineCssForTextWrapper(edmHeader);
applyInlineCssForTextWrapper(edmBody);
applyInlineCssForTextWrapper(edmFooter);
var edmBodyWidth = body.find('#edm-body-width').val();
edmHeader.innerWidth(edmBodyWidth);
edmBody.innerWidth(edmBodyWidth);
edmFooter.innerWidth(edmBodyWidth);
if (sender && sender.length > 0 && sender.is('#edm-body-width')) {
adjustColWidth(edmHeader);
adjustColWidth(edmBody);
adjustColWidth(edmFooter);
edmHeader.add(edmBody).add(edmFooter).find('img.full-width').each(function () {
$.keditor.components['photo'].adjustWidthForImg($(this), true);
});
edmHeader.add(edmBody).add(edmFooter).find('[data-dynamic-href]').each(function () {
keditor.initDynamicContent($(this));
});
}
}
function initColorPicker(target, onChangeHandle) {
target.each(function () {
var colorPicker = $(this);
var input = colorPicker.find('input');
var previewer = colorPicker.find('.input-group-addon i');
colorPicker.colorpicker({
format: 'hex',
container: colorPicker.parent(),
component: '.input-group-addon',
align: 'left',
colorSelectors: {
'transparent': 'transparent'
}
}).on('changeColor.colorpicker', function (e) {
var colorHex = e.color.toHex();
if (!input.val() || input.val().trim().length === 0) {
colorHex = '';
previewer.css('background-color', '');
}
if (typeof onChangeHandle === 'function') {
onChangeHandle(colorHex);
}
});
});
}
function setStyle(target, name, value) {
flog('setStyle', name, value);
target.each(function () {
var self = $(this);
var styles = self.attr('style');
styles = styles ? styles.split(';') : [];
var isExisting = false;
for (var i = 0; i < styles.length; i++) {
var style = styles[i];
if (style && style.trim().length > 0 && style.indexOf(':') !== -1) {
style = style.split(':');
if (style[0].trim() === name) {
if (value) {
styles[i] = name + ':' + value;
} else {
styles.splice(i, 1);
}
isExisting = true;
} else {
if (style[1].trim() === '') {
styles.splice(i, 1);
}
}
}
}
if (!isExisting && value) {
styles.push(name + ':' + value);
}
self.attr('style', styles.join(';'));
});
}
function getEdmContent() {
var body = $(document.body);
var edmHtml = $('#edm-area').keditor('getContent', true);
var edmHeader = edmHtml[0];
var edmBody = edmHtml[1];
var edmFooter = edmHtml[2];
// EDM Page
var edmBackground = body.find('#edm-background').val();
var edmPaddingTop = body.find('#edm-padding-top').val();
var edmPaddingBottom = body.find('#edm-padding-bottom').val();
var edmPaddingLeft = body.find('#edm-padding-left').val();
var edmPaddingRight = body.find('#edm-padding-right').val();
var styleTDWrapper = '';
var attributeTableWrapper = '';
if (edmBackground) {
styleTDWrapper += 'background-color: ' + edmBackground + ';';
attributeTableWrapper += ' bgcolor="' + edmBackground + '" ';
}
if (edmPaddingTop) {
styleTDWrapper += 'padding-top: ' + edmPaddingTop + 'px;';
}
if (edmPaddingBottom) {
styleTDWrapper += 'padding-bottom: ' + edmPaddingBottom + 'px;';
}
if (edmPaddingLeft) {
styleTDWrapper += 'padding-left: ' + edmPaddingLeft + 'px;';
}
if (edmPaddingRight) {
styleTDWrapper += 'padding-right: ' + edmPaddingRight + 'px;';
}
// EDM Body
var edmBodyWidth = body.find('#edm-body-width').val();
var edmBodyBackground = body.find('#edm-body-background').val();
var edmBodyPaddingTop = body.find('#edm-body-padding-top').val();
var edmBodyPaddingBottom = body.find('#edm-body-padding-bottom').val();
var edmBodyPaddingLeft = body.find('#edm-body-padding-left').val();
var edmBodyPaddingRight = body.find('#edm-body-padding-right').val();
var styleTDBody = '';
var attributeTableBody = '';
if (edmBodyBackground) {
styleTDBody += 'background-color: ' + edmBodyBackground + ';';
attributeTableBody += ' bgcolor="' + edmBodyBackground + '" ';
}
if (edmBodyPaddingTop) {
styleTDBody += 'padding-top: ' + edmBodyPaddingTop + 'px;';
}
if (edmBodyPaddingBottom) {
styleTDBody += 'padding-bottom: ' + edmBodyPaddingBottom + 'px;';
}
if (edmBodyPaddingLeft) {
styleTDBody += 'padding-left: ' + edmBodyPaddingLeft + 'px;';
}
if (edmBodyPaddingRight) {
styleTDBody += 'padding-right: ' + edmBodyPaddingRight + 'px;';
}
// EDM Default styles
var edmFontFamily = body.find('#edm-font-family').val();
var edmFontSize = body.find('#edm-font-size').val();
var edmLineHeight = body.find('#edm-line-height').val();
var edmTextColor = body.find('#edm-text-color').val();
var edmLinkColor = body.find('#edm-link-color').val();
var dataEdmStyles = '';
if (edmFontFamily) {
dataEdmStyles += ' data-font-family="' + edmFontFamily + '" ';
}
if (edmFontSize) {
dataEdmStyles += ' data-font-size="' + edmFontSize + '" ';
}
if (edmLineHeight) {
dataEdmStyles += ' data-line-height="' + edmLineHeight + '" ';
}
if (edmTextColor) {
dataEdmStyles += ' data-text-color="' + edmTextColor + '" ';
}
if (edmLinkColor) {
dataEdmStyles += ' data-link-color="' + edmLinkColor + '" ';
}
return (
'<!DOCTYPE HTML>\n' +
'<html>\n' +
' <head>\n' +
' <title>Kademi EDM Title</title>\n' +
' <style type="text/css">\n' +
' ' + $('#edm-style').html().trim() + '\n' +
' </style>\n' +
' </head>\n' +
' <body>\n' +
' <center>\n' +
' <table cellpadding="0" cellspacing="0" border="0" width="100%" id="edm-wrapper" ' + attributeTableWrapper + '>\n' +
' <tbody>\n' +
' <tr>\n' +
' <td id="edm-wrapper-td" style="' + styleTDWrapper + '" align="center">\n' +
' <table cellpadding="0" cellspacing="0" border="0" width="' + edmBodyWidth + '" id="edm-container" ' + dataEdmStyles + '>\n' +
' <tbody>\n' +
' <tr>\n' +
' <td>\n' +
' <table cellpadding="0" cellspacing="0" border="0" width="100%" id="edm-header" align="center">\n' +
' <tbody>\n' +
' <tr>\n' +
' <td id="edm-header-td">\n' +
edmHeader +
' </td>\n' +
' </tr>\n' +
' </tbody>\n' +
' </table>\n' +
' <table cellpadding="0" cellspacing="0" border="0" width="100%" id="edm-body" ' + attributeTableBody + ' align="center">\n' +
' <tbody>\n' +
' <tr>\n' +
' <td id="edm-body-td" style="' + styleTDBody + '" >\n' +
edmBody +
' </td>\n' +
' </tr>\n' +
' </tbody>\n' +
' </table>\n' +
' <table cellpadding="0" cellspacing="0" border="0" width="100%" id="edm-footer" align="center">\n' +
' <tbody>\n' +
' <tr>\n' +
' <td id="edm-footer-td">\n' +
edmFooter +
' </td>\n' +
' </tr>\n' +
' </tbody>\n' +
' </table>\n' +
' </td>\n' +
' </tr>\n' +
' </tbody>\n' +
' </table>\n' +
' </td>\n' +
' </tr>\n' +
' </tbody>\n' +
' </table>\n' +
' </center>\n' +
' </body>\n' +
'</html>'
);
}
function initSaveFile(fileName) {
flog('initSaveFile', fileName);
var btnSave = $('.btn-save-file');
btnSave.on('click', function (e) {
e.preventDefault();
showLoadingIcon();
$.ajax({
url: fileName,
type: 'POST',
data: {
body: getEdmContent()
},
success: function () {
Msg.success('File is saved!');
hideLoadingIcon();
body.removeClass('content-changed');
},
error: function (e) {
Msg.error(e.status + ': ' + e.statusText);
hideLoadingIcon();
}
})
});
win.on({
keydown: function (e) {
if (e.ctrlKey && e.keyCode === keymap.S) {
e.preventDefault();
btnSave.trigger('click');
}
},
beforeunload: function () {
if (body.hasClass('content-changed')) {
return '\n\nAre you sure you would like to leave the editor? You will lose any unsaved changes\n\n';
}
}
});
}
function hideLoadingIcon() {
$('#editor-loading').addClass('hide');
}
function showLoadingIcon() {
$('#editor-loading').removeClass('hide');
}
$.keditor.initPaddingControls = function (keditor, form, addMethod, neighbor) {
var controlsHtml =
'<div class="form-group">' +
' <div class="col-md-12">' +
' <label>Padding (in px)</label>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="" class="txt-padding-top form-control" />' +
' <small>top</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4">' +
' <input type="number" value="" class="txt-padding-left form-control" />' +
' <small>left</small>' +
' </div>' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="" class="txt-padding-right form-control" />' +
' <small>right</small>' +
' </div>' +
' </div>' +
' <div class="row row-sm text-center">' +
' <div class="col-xs-4 col-xs-offset-4">' +
' <input type="number" value="" class="txt-padding-bottom form-control" />' +
' <small>bottom</small>' +
' </div>' +
' </div>' +
' </div>' +
'</div>';
if (neighbor) {
form.find(neighbor)[addMethod](controlsHtml);
} else {
form[addMethod](controlsHtml);
}
var txtPaddingTop = form.find('.txt-padding-top');
var txtPaddingBottom = form.find('.txt-padding-bottom');
var txtPaddingLeft = form.find('.txt-padding-left');
var txtPaddingRight = form.find('.txt-padding-right');
txtPaddingTop.on('change', function () {
setStyle(keditor.getSettingComponent().find('.wrapper'), 'padding-top', (this.value > 0 ? this.value : 0) + 'px');
});
txtPaddingBottom.on('change', function () {
setStyle(keditor.getSettingComponent().find('.wrapper'), 'padding-bottom', (this.value > 0 ? this.value : 0) + 'px');
});
txtPaddingLeft.on('change', function () {
setStyle(keditor.getSettingComponent().find('.wrapper'), 'padding-left', (this.value > 0 ? this.value : 0) + 'px');
});
txtPaddingRight.on('change', function () {
setStyle(keditor.getSettingComponent().find('.wrapper'), 'padding-right', (this.value > 0 ? this.value : 0) + 'px');
});
};
$.keditor.showPaddingControls = function (keditor, form, component) {
var wrapper = component.find('.wrapper');
var txtPaddingTop = form.find('.txt-padding-top');
var paddingTop = wrapper.css('padding-top');
txtPaddingTop.val(paddingTop ? paddingTop.replace('px', '') : '0');
var txtPaddingBottom = form.find('.txt-padding-bottom');
var paddingBottom = wrapper.css('padding-bottom');
txtPaddingBottom.val(paddingBottom ? paddingBottom.replace('px', '') : '0');
var txtPaddingLeft = form.find('.txt-padding-left');
var paddingLeft = wrapper.css('padding-left');
txtPaddingLeft.val(paddingLeft ? paddingLeft.replace('px', '') : '0');
var txtPaddingRight = form.find('.txt-padding-right');
var paddingRight = wrapper.css('padding-right');
txtPaddingRight.val(paddingRight ? paddingRight.replace('px', '') : '0');
};
$.keditor.initBgColorControl = function (keditor, form, addMethod, neighbor) {
var controlHtml =
'<div class="form-group">' +
' <div class="col-md-12">' +
' <label>Background</label>' +
' <div class="input-group color-picker">' +
' <span class="input-group-addon"><i></i></span>' +
' <input type="text" value="" class="txt-bg-color form-control" />' +
' </div>' +
' </div>' +
'</div>';
if (neighbor) {
form.find(neighbor)[addMethod](controlHtml);
} else {
form[addMethod](controlHtml);
}
var colorPicker = form.find('.color-picker');
initColorPicker(colorPicker, function (color) {
var wrapper = keditor.getSettingComponent().find('.wrapper');
var table = wrapper.closest('table');
if (color && color !== 'transparent') {
setStyle(wrapper, 'background-color', color);
table.attr('bgcolor', color);
} else {
setStyle(wrapper, 'background-color', '');
table.removeAttr('bgcolor');
form.find('.txt-bg-color').val('');
}
});
};
$.keditor.showBgColorControl = function (keditor, form, component) {
var wrapper = component.find('.wrapper');
var colorPicker = form.find('.color-picker');
colorPicker.colorpicker('setValue', wrapper.css('background-color') || '');
};
|
module.exports = function (str) {
// TODO
var reg = new RegExp(/^(0x[A-F, a-f, 0-9]{2}\s*){8}$/, "g");
return reg.test(str);
}
|
'use strict';
angular.module('navbar').
component('navbar', {
templateUrl: 'navbar/navbar.template.html',
controller: function($scope){
$scope.data = new Date();
//pegar do serviço
$scope.farms = ['Farm 1', 'Farm 2', 'Farm 3'];
$scope.portais = [
'Portal Boas Práticas',
'Agenda CEO',
'GRT & Duplicates',
'Portal da Receita Federal',
'Capital Projects',
'Global Exploration',
'Vale Informar',
'Sistema de Diagnóstico VPS',
'Mapa Fantasma de Oportunidades'
]
}
});
|
import React from 'react';
class Search extends React.Component {
constructor(props) {
super(props);
this.state = {
title: '',
artist: '',
showPrev: false
};
this.handleTitleChange = this.handleTitleChange.bind(this);
this.handleArtistChange = this.handleArtistChange.bind(this);
this.handleSubmit = this.handleSubmit.bind(this);
this.prevResults = this.prevResults.bind(this);
}
handleTitleChange(e) { this.setState({ title: e.target.value }); }
handleArtistChange(e) { this.setState({ artist: e.target.value }); }
handleSubmit(e) {
e.preventDefault();
this.props.search(this.state.title, this.state.artist);
this.setState({ title: '', artist: '', showPrev: true});
}
prevResults(e) {
e.preventDefault();
this.props.prev();
this.props.runUpDown();
}
render() {
return (
<div>
<div className="search">
<form onSubmit={this.handleSubmit}>
<input type="text" name="title" value={this.state.title} placeholder="title" onChange={this.handleTitleChange} className="textbox"/>
<input type="text" name="artist" value={this.state.artist} placeholder="artist" onChange={this.handleArtistChange} className="textbox"/>
<input type="submit" value="Search" className="submitbutton"/>
</form>
<form>
{this.props.showPrev ?
<div className="resultsBar" onClick={this.prevResults} >
<div className="searchHeadline">Search Results</div>
{this.props.upDown ?
<img className="searchPrevUp" src="./img/ic_down.svg" width="18" height="18"/>
: <img className="searchPrevDown" src="./img/ic_up.svg" width="18" height="18"/>}
</div>
: null}
</form>
</div>
</div>
);
}
}
export default Search;
|
/**
* @author Henrik
*/
$(document).bind('pageinit', function(){
$('#zoom-slider').slider();
});
|
/* @flow */
import React, { Component } from 'react';
import { Text, View, StyleSheet } from 'react-native';
import { material } from 'react-native-typography';
import withWeb3 from '../withWeb3';
class Container extends Component<{
children: *,
web3: *,
}> {
render() {
const { web3 } = this.props;
return (
<View style={styles.Container}>
<View style={styles.Header}>
<Text style={material.body1White}>
Tokens in the ethereum ecosystem can represent any fungible tradable
good: coins, loyalty points, gold certificates, IOUs, in game items,
etc...
</Text>
<Text style={material.captionWhite}>
Since all tokens implement some basic features in a standard way,
this also means that it will be instantly compatible with the
ethereum wallet and any other client or contract that uses the same
standards.
</Text>
</View>
<Text style={[styles.title, material.captionWhite]}>
react-ethereum-metacoin
</Text>
{this.props.children}
</View>
);
}
}
export default withWeb3(Container);
const styles = StyleSheet.create({
Container: {
flex: 1,
},
Header: {
paddingVertical: 20,
paddingHorizontal: 12,
backgroundColor: '#336699',
},
title: {
paddingHorizontal: 12,
paddingVertical: 9,
backgroundColor: '#777',
},
});
|
import Component from './SliderTemplate.component'
export default Component
|
define([
'client/views/graph/line-set',
'client/views/graph/line',
'client/views/graph/component',
'common/collections/grouped_timeseries'
], function (LineSet, Line, Component, Collection) {
describe('Line Set', function () {
var lineset, graph, collection;
beforeEach(function () {
collection = new Collection([
{ foo: 1, bar: 2 },
{ foo: 2, bar: 4 },
{ foo: 3, bar: 6 },
{ foo: 4, bar: 8 }
]);
graph = {
getXPos: _.identity,
getYPos: function (index, attr) {
return collection.at(index).get(attr);
},
getLines: function () {
return [
{
key: 'foo',
x: _.identity,
y: _.identity
},
{
key: 'bar',
x: _.identity,
y: _.identity
}
];
},
getDefaultComponentOptions: function () {
return {
graph: graph,
collection: collection,
scales: {
x: _.identity,
y: _.identity
}
};
}
};
});
describe('initialize', function () {
it('calls up to component initialize', function () {
spyOn(Component.prototype, 'initialize').and.callThrough();
lineset = new LineSet({
graph: graph,
collection: collection
});
/*
Note:
because of variable hoisting, we have to include the `el: undefined`
argument in the expectation.
The base Backbone.View object adds an "el" key to the passed-in 'options'
argument at the very end of the View::initialize method, which jasmine
then sees as part of the initial argument passed to the View object.
So we have to "expect" that an `el: undefined` argument was passed,
whether it was or not
*/
expect(Component.prototype.initialize).toHaveBeenCalledWith({
graph: graph,
collection: collection,
el: undefined
});
});
it('creates a line component for each line', function () {
lineset = new LineSet({
graph: graph,
collection: collection
});
expect(lineset.lines.length).toEqual(2);
_.each(lineset.lines, function (line) {
expect(line instanceof Line).toBe(true);
});
});
it('sets classNames and valueAttrs on lines', function () {
lineset = new LineSet({
graph: graph,
collection: collection
});
var lines = graph.getLines();
_.each(lineset.lines, function (line, i) {
expect(line.valueAttr).toEqual(lines[i].key);
expect(line.className).toEqual('group' + i);
});
});
it('passes a "grouped" property to lines', function () {
lineset = new LineSet({
graph: graph,
collection: collection
});
_.each(lineset.lines, function (line) {
expect(line.grouped).toEqual(true);
});
});
});
describe('onHover', function () {
var e;
beforeEach(function () {
spyOn(Line.prototype, 'x').and.callFake(_.identity);
e = {
slice: 4,
x: 1,
y: 1
};
lineset = new LineSet({
graph: graph,
collection: collection
});
spyOn(collection, 'selectItem');
});
it('calls collection selectItem method with the closest model index', function () {
lineset.onHover(e);
expect(collection.selectItem).toHaveBeenCalledWith(1, jasmine.any(Object));
e.x = 3;
lineset.onHover(e);
expect(collection.selectItem).toHaveBeenCalledWith(3, jasmine.any(Object));
});
it('does not select item if cursor is over linelabel area', function () {
e.slice = 5; // 5 represents line labels section
lineset.onHover(e);
expect(collection.selectItem).not.toHaveBeenCalled();
});
it('passes the valueAttr of the closest line as an option', function () {
e.y = 1;
lineset.onHover(e);
expect(collection.selectItem).toHaveBeenCalledWith(1, { valueAttr: 'foo', force: true });
e.y = 5;
lineset.onHover(e);
expect(collection.selectItem).toHaveBeenCalledWith(1, { valueAttr: 'bar', force: true });
});
it('passes a null valueAttr if no line has a value at the closest index', function () {
collection.at(3).set({ foo: null, bar: null });
e.x = 3;
lineset.onHover(e);
expect(collection.selectItem).toHaveBeenCalledWith(3, { valueAttr: null, force: true });
});
it('interpolates between lines if x value is between two points', function () {
collection.at(3).set('bar', 34);
e.x = 2.4;
e.y = 10;
lineset.onHover(e);
/* if we used purely "closest point" then this would return the
* "bar" line at (2, 6) but because it slopes up so sharply then
* the closest line at x=2.4 is the "foo" line
* the interpolated mid-point between the lines at x=2.4 is y=15
*/
expect(collection.selectItem).toHaveBeenCalledWith(2, { valueAttr: 'foo', force: true });
});
});
});
});
|
import Page from './page';
import taNotFoundPaths from '../ElementsData/taNotFoundPaths.page'
import CommonMethods from '../CommonMethods/CommonMethods.page';
import TextData from '../ElementsData/TextData.page';
class NotFound extends Page {
open() {
super.open(TextData.taNotFoundURL); // this will append `features` to the baseUrl to form complete URL
expect(CommonMethods.getTextOfDesiredElement(taNotFoundPaths.pageTextXpath)).toContain(TextData.textToVerify);
browser.setTimeout({ 'implicit': 5000 });
}
}
export default new NotFound();
|
function injectFonts(typography) {
const fontsStr = getFontsStr(typography)
if (fontsStr) {
const link = getFontsLink(fontsStr)
injectLink(link)
} else {
// dunno if this is ideal behavior
throw new Error('no fonts str')
}
}
function injectLink(link) {
const typoElt = document.getElementById("typography.js")
if (typoElt) {
typoElt.insertAdjacentHTML('afterend', link)
} else {
// i don't feel like handling this case right now
throw new Error('no typo elt')
}
}
function getFontsStr(typography) {
let fontsStr = ""
if (typography.options.googleFonts) {
const fonts = typography.options.googleFonts.map(font => {
let str = ""
str += font.name.split(" ").join("+")
str += ":"
str += font.styles.join(",")
return str
})
fontsStr = fonts.join("|")
}
return fontsStr
}
function getFontsLink(str) {
const link = `<link href="//fonts.googleapis.com/css?family=${str}" rel="stylesheet" type="text/css" />`
return link
}
export default injectFonts
|
/*-----------------------------------pagination-----------------------------*/
//method for creating Pagination in tables it takes 2 params table and nav ID and creates pagination for sent table data
function createPagination(tableID, navID) {
$('#' + tableID).after('<div id=' + navID + '></div>');
var rowsShown = 10;
var rowsTotal = $('#' + tableID + ' tbody tr').length;
var numPages = rowsTotal / rowsShown;
for (i = 0; i < numPages; i++) {
var pageNum = i + 1;
$('#' + navID).append('<a class="navNumb" href="#" rel="' + i + '">' + pageNum + '</a> ');
}
$('#' + tableID + ' tbody tr').hide();
$('#' + tableID + ' tbody tr').slice(0, rowsShown).show();
$('#' + navID + ' a:first').addClass('active');
$('#' + navID + ' a').bind('click', function () {
$('#' + navID + ' a').removeClass('active');
$(this).addClass('active');
var currPage = $(this).attr('rel');
var startItem = currPage * rowsShown;
var endItem = startItem + rowsShown;
$('#' + tableID + ' tbody tr').css('opacity', '0.0').hide().slice(startItem, endItem).
css('display', 'table-row').animate({
opacity: 1
}, 300);
});
}
/*--------------------------------popup dodaj novi-------------------------------------*/
function popup() {
document.getElementById("Država").value = "";
document.getElementById("PoštanskiBroj").value = "";
document.getElementById("NazivDržave").value = "";
// Get the modal
var modal = document.getElementById("myModal");
// Get the <span> element that closes the modal
var span = document.getElementsByClassName("close")[0];
// When the user clicks the button, open the modal
modal.style.display = "block";
// When the user clicks on <span> (x), close the modal
span.onclick = function () {
modal.style.display = "none";
}
// When the user clicks anywhere outside of the modal, close it
window.onclick = function (event) {
if (event.target == modal) {
modal.style.display = "none";
}
}
}
/*----------------------------Popup edit------------------------------------*/
function popupEdit(ID) {
var drzava = document.getElementById("Država " + ID).innerHTML;
var postanski = document.getElementById("Poštanski " + ID).innerHTML;
var naziv = document.getElementById("Naziv " + ID).innerHTML;
document.getElementById("Država").value = drzava;
document.getElementById("PoštanskiBroj").value = postanski;
document.getElementById("NazivDržave").value = naziv;
document.getElementById("IDnaselja").value = ID;
// Get the modal
var modal = document.getElementById("myModal");
// Get the <span> element that closes the modal
var span = document.getElementsByClassName("close")[0];
// When the user clicks the button, open the modal
modal.style.display = "block";
// When the user clicks on <span> (x), close the modal
span.onclick = function () {
modal.style.display = "none";
}
// When the user clicks anywhere outside of the modal, close it
window.onclick = function (event) {
if (event.target == modal) {
modal.style.display = "none";
}
}
}
/*------------------------------Stvaranje popup forme-------------------------*/
function loadForm() {
var div = document.createElement("div");
div.innerHTML = document.getElementById("dodaj/edit").innerHTML;
document.getElementById("mod-content").appendChild(div);
}
/*------------------------------Load on demand--------------------------------*/
|
/**
* 类型检测
* Created by Dreamzhu on 2017/3/25.
*/
let class2type = {};
"Boolean Number String Function Array Date RegExp Object Error".split(" ").forEach(function (name) {
class2type["[object " + name + "]"] = name.toLowerCase()
});
export function type(obj) {
return obj == null ? String(obj) :
class2type[Object.prototype.toString.call(obj)] || "object"
}
export function isArray(value) {
return value instanceof Array
}
function isObject(obj) {
return type(obj) == "object"
}
function isWindow(obj) {
return obj != null && obj == obj.window
}
export function isFunction(value) {
return type(value) == "function"
}
export function isPlainObject(obj) {
return isObject(obj) && !isWindow(obj) && Object.getPrototypeOf(obj) == Object.prototype
}
export default {
isArray: isArray,
type: type,
isPlainObject: isPlainObject,
isFunction: isFunction
}
|
let animation =bodymovin.loadAnimation({
container: document.getElementById('landingPageAnimation'),
path: 'assets/json/data.json',
renderer: 'svg',
loop: true,
autoplay: true,
name: "Landing Animation"
})
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.