text stringlengths 7 3.69M |
|---|
const siteConfig = {
title: 'Capacita.dev',
tagline: 'Aprenda programação online de graça através de desafios práticos',
url: 'https://www.capacita.dev',
baseUrl: '/',
projectName: 'capacita-dev',
organizationName: 'woliveiras',
headerLinks: [],
headerIcon: 'img/favicon/favicon-96x96.png',
footerIcon: 'img/favicon/favicon-96x96.png',
favicon: 'img/favicon/favicon.ico',
colors: {
primaryColor: '#20232a',
secondaryColor: '#5E2A85'
},
copyright: `Copyright © ${new Date().getFullYear()} William Oliveira`,
highlight: {
theme: 'default'
},
scripts: ['https://buttons.github.io/buttons.js'],
onPageNav: 'separate',
cleanUrl: true,
ogImage: 'img/undraw_online.svg',
twitterImage: 'img/undraw_tweetstorm.svg',
repoUrl: 'https://github.com/woliveiras/capacita.dev',
twitterUsername: '@etc_william'
}
module.exports = siteConfig
|
// What is Sorting?
// Sorting is the process of rearranging the items in a collection
// (e.g. an array) so that the items are in some kind of order.
// Examples
// -- Sorting numbers from smallest to largest
// -- Sorting names alphabetically
// -- Sorting movies based on a release year
// -- Sorting movies based on revenue
// ** Why do we need to learn this? **//
// Sorting is an incredibly common task,
// so it's good to know how it works
// There are many different ways to sort
// Things, and different techniques
// have their own advantages and disadvantages
//** JavaScript has a sort method **//
// The built-in sort method accepts an optional comparator function
// You can use this comparator function to tell JavaScript how you want it to sort
// If it returns a negative number, a should come after b
// If it returns a positive number, a should come after b
// If it returns 0, a and b are the same as far as the sort is concerned
//** Examples **//
const numberCompare = (num1, num2) => {
return num1 - num2;
}
[6,4,15,10].sort(numberCompare)
// [4,6,10,15]
const compareByLen = (str1, str2) => {
return str1.length - str2.length;
}
[ "Steele", "Colt", "Data Structures", "Algorithms"].sort(compareByLen) |
import React, { Component } from 'react';
import './Logo.scss';
export default class Logo extends Component {
render() {
const styles = {
color: '#ff1313',
fontSize: '1.63em',
textShadow: 'none',
fontWeight: 'bold'
}
return (
<div style={styles} className='logo'>
<span>F</span>
<span>A</span>
<span>K</span>
<span>E</span>
<span>F</span>
<span>L</span>
<span>I</span>
<span>X</span>
</div>
)
}
}
|
const request = require("request");
class Zendesk {
constructor(opts) {
this.host = opts.host;
this.token = opts.token;
this.email = opts.email;
this.debug = opts.debug;
};
get(endpoint, agent, callback) {
var _self = this;
if (endpoint && agent) {
request.get(_self.host + endpoint, {
json: true,
headers: {
Authorization: 'Basic ' + new Buffer.from(agent + _self.email + '/token:' + _self.token).toString('base64')
}
}, function (error, response, body) {
if (error) callback(error);
else if (!error && body) callback(body);
});
}
};
put(endpoint, data, agent, callback) {
var _self = this;
if (endpoint && data && agent) {
request.put(_self.host + endpoint, {
json: true,
body: data,
headers: {
Authorization: 'Basic ' + new Buffer.from(agent + _self.email + '/token:' + _self.token).toString('base64')
},
}, function (error, body, response) {
if (error) callback(error);
else if (!error && body) callback(body);
});
}
};
post(endpoint, data, agent, callback) {
var _self = this;
if (endpoint && data && agent) {
request.post(_self.host + endpoint, {
json: true,
body: data,
headers: {
Authorization: 'Basic ' + new Buffer.from(agent + _self.email + '/token:' + _self.token).toString('base64')
},
}, function (error, body, response) {
if (error) callback(error);
else if (!error && body) callback(body);
});
}
};
}
module.exports = Zendesk; |
import React, { Component } from 'react'
import {
ActivityIndicator,
StyleSheet,
Text,
View, Modal
} from 'react-native'
import { colors } from '../theme'
import { CirclesLoader, PulseLoader, TextLoader, DotsLoader, ColorDotsLoader,
NineCubesLoader,BubblesLoader } from 'react-native-indicator';
export default class Loader extends Component {
render() {
const { loader } = this.props
return (
<Modal
visible={loader}
//animationType={'slide'}
style={{ borderWidth: 3, borderColor: 'red' }}
transparent={true}
>
<View style={{
width: '100%', height: "100%",
justifyContent: 'center',
alignItems: 'center',
alignContent: 'center',
backgroundColor:colors.blackTransparent_bG
}}>
<BubblesLoader
size={40}
dotRadius={10}
color={colors.color_primary}
/>
</View>
</Modal>
)
}
}
const styles = StyleSheet.create({
container: {
position: 'absolute',
justifyContent: 'center',
alignItems: 'center',
alignContent: 'center',
zIndex: 0,
width: '100%',
height: '100%',
backgroundColor: colors.TRANSPARENT_LIGHT,
},
horizontal: {
flexDirection: 'row',
justifyContent: 'center',
padding: 10
}
}) |
angular.module('skills').controller('users_show_controller',function($scope,$http,$routeParams){
$http.get('/models/skills.json').success(function(skills){
$scope.skills = skills;
$http.get('/models/users/'+$routeParams.user_id+'.json').success(function(user){
$scope.user = user;
}).error(function(){
$scope.user = null;
})
})
}); |
const { v4 } = require('uuid');
class NodeApp{
getUserDetails_oidc(){
return {
"canShareCases": false,
"roleAssignmentInfo": [
{
...this.getUserDetailsLocationInfo(),
caseId:'',
caseType:'',
roleType:'ORGANISATION'
}
],
"sessionTimeout": {
"idleModalDisplayTime": 10,
"pattern": ".",
"totalIdleTime": 480
},
"userInfo": {
"uid": v4(),
"given_name": "XUI test",
"family_name": "auto",
"name": "test name",
"sub": "juser8@mailinator.com",
"roles": [
"caseworker",
"caseworker-ia",
"caseworker-ia-iacjudge"
],
"token": "Bearer eyJ0eXAiOiJKV1Q",
"roleCategory":"LEGAL_OPS"
}
}
}
getUserDetails_oauth(){
return {
"canShareCases": false,
"roleAssignmentInfo": [
this.getUserDetailsLocationInfo()
],
"sessionTimeout": {
"idleModalDisplayTime": 10,
"pattern": ".",
"totalIdleTime": 480
},
"userInfo": {
"id": v4(),
"forename": "XUI test",
"surname": "Judge",
"email": "juser8@mailinator.com",
"active": true,
"roles": [
"caseworker",
"caseworker-ia",
"caseworker-ia-iacjudge"
],
"token": "Bearer eyJ0eXAiOiJKV1Q",
"roleCategory": "LEGAL_OPS"
}
}
}
getUserDetailsLocationInfo(){
const location = Math.floor((Math.random() * 100009) + 10001);
const isCaseAllocator = Math.floor((Math.random() * 1) + 0) === 0 ? false : true;
return {
// "primaryLocation": location,
"jurisdiction": "IA",
"isCaseAllocator": true,
"substantive" : true
}
}
}
module.exports = new NodeApp();
|
import { Conference } from './Conference';
describe('Conference', () => {
describe('Conference.attendeeCollection', () => {
describe('iterate(callback)', () => {
let collection, callbackSpy;
function addAttendeesToCollection(attendees) {
attendees.forEach((attendee) => {
collection.add(attendee);
});
}
function verifyCallbackWasExecutedForEachAttendee(attendees) {
expect(callbackSpy).toHaveBeenCalledTimes(attendees.length);
attendees.forEach((attendee, index) => {
expect(callbackSpy).toHaveBeenNthCalledWith(index + 1, attendee);
});
}
beforeEach(() => {
collection = Conference.attendeeCollection();
callbackSpy = jest.fn();
});
it('빈 컬렉션에서는 콜백을 실행하지 않는다.', () => {
collection.iterate(callbackSpy);
expect(callbackSpy).not.toHaveBeenCalled();
});
it('원소가 하나뿐인 컬렉션은 콜백을 한 번만 실행한다.', () => {
const attendees = [Conference.attendee('윤지', '김')];
addAttendeesToCollection(attendees);
collection.iterate(callbackSpy);
verifyCallbackWasExecutedForEachAttendee(attendees);
});
it('컬렉션 원소마다 한 번씩 콜백을 실행한다.', () => {
const attendees = [
Conference.attendee('Tom', 'Kazansky'),
Conference.attendee('Charlotte', 'Blackwood'),
Conference.attendee('태영', '김'),
];
addAttendeesToCollection(attendees);
collection.iterate(callbackSpy);
verifyCallbackWasExecutedForEachAttendee(attendees);
});
});
});
describe('Conference.checkInService', () => {
let checkInService;
let checkInRecorder;
let attendee;
beforeEach(() => {
checkInRecorder = Conference.checkInRecorder();
jest.spyOn(checkInRecorder, 'recordCheckIn');
checkInService = Conference.checkInService(checkInRecorder);
attendee = Conference.attendee('형철', '서');
});
describe('checkInService.checkIn(attendee)', function () {
it('참가자를 체크인 처리한 것으로 표시한다', () => {
checkInService.checkIn(attendee);
expect(attendee.isCheckedIn()).toBe(true);
});
it('체크인을 등록한다', () => {
checkInService.checkIn(attendee);
expect(checkInRecorder.recordCheckIn).toHaveBeenCalledWith(attendee);
});
});
});
describe('Conference.checkedInAttendeeCounter', () => {
let counter;
beforeEach(() => {
counter = Conference.checkedInAttendeeCounter();
});
describe('countIfCheckedIn(attendee)', () => {
let attendee;
beforeEach(() => {
attendee = Conference.attendee('태영', '김');
});
it('참가자가 체크인하지 않으면 인원수를 세지 않는다.', () => {
counter.countIfCheckedIn(attendee);
expect(counter.getCount()).toBe(0);
});
it('참가자가 체크인하면 인원수를 센다', () => {
attendee.checkIn();
counter.countIfCheckedIn(attendee);
expect(counter.getCount()).toBe(1);
});
it('this가 꼭 checkedInAttendeeCounter 인스턴스를 가리키는 것은 아니다', () => {
attendee.checkIn();
counter.countIfCheckedIn.call({}, attendee);
expect(counter.getCount()).toBe(1);
});
});
});
});
|
(function(){
function Contorller(){
var zeroPhone = new Android("001", {color:"white", price:100});
var onePhone = new IPhone("002", {color:"black", price:150});
var zero = new Person("영희", zeroPhone);
var one = new Person("철수", onePhone);
zero.sendSMS(one, "안녕? 철수야.");
one.sendSMS(zero, "반가워. 영희야!");
zero.sendSMS(one, "철수야 뭐하니?");
one.sendSMS(zero, "레포트 하고 있어");
zero.phone.call();
one.phone.call();
zero.phone.useNotepad();
one.phone.startFaceTime();
};
window.Contorller = Contorller;
})();
|
import { GraphQLID, GraphQLNonNull } from 'graphql'
import objType from '../types/obj'
import resolve from '../resolvers/editObj'
import { OrganizationInput, ObjInput } from '../types/inputs'
const editObj = {
name: 'editObj',
type: objType,
args: {
obj: {
type: new GraphQLNonNull(ObjInput)
}
},
resolve
}
export default editObj
|
import {Socket} from "phoenix"
import store from '../store'
import Peer from 'peerjs';
const SOCKET_URL = process.NODE_ENV === "production" ?
"/socket" :
"ws://localhost:4000/socket"
let peer = new Peer({
config: {'iceServers': [
{ url: 'stun:stun.l.google.com:19302' },
]}
});
let socket = new Socket(SOCKET_URL, {params: {}})
socket.connect()
let call_setter = null;
let call = []
let channel = null
let local_stream = null;
let me = {}
function remove_caller(user) {
call = call.filter(c => c.user !== user)
call_setter(call)
}
function add_caller(stream, user) {
let caller = {user: user, stream: stream}
call = call.filter(c => c.user !== user)
call.push(caller)
call_setter(call)
}
export function join(room_id, stream, setCall) {
let state = store.getState()
if (state.user == null) return;
local_stream = stream
call = []
call_setter = setCall
call_setter(call)
channel = socket.channel("room:" + room_id, {token: state.user.access_token , peer_id: peer.id})
channel.join()
.receive("ok", (x) => {
let role =
x.collaborators.find(({user}) => state.user.login === user) ?
"collaborator" : "user"
me = {role, user: state.user.login, peer_id: peer.id}
store.dispatch({type: "room/set", data: x})
})
.receive("error", resp => console.log("Unable to join", resp));
channel.on('leave', ({user}) => {
store.dispatch({type: "room/leave", data: user})
remove_caller(user)
})
channel.on('user', (caller) => setTimeout(() => {
const {peer_id} = caller
// Only collaborators have to connect to users
if(me.role === "collaborator") {
// we just want to send them our stream and not wait for their stream
peer.call(peer_id, local_stream, {metadata: me})
}
store.dispatch({type: "room/user", data: caller})
}, 1000))
channel.on('collaborator', (caller) => setTimeout(() => {
const {peer_id} = caller
// Everyone wants to connect to a collaborator
let c = peer.call(peer_id, local_stream, {metadata: me})
c.on('stream', (remote_stream) => {
console.log("answered call from ", JSON.stringify(caller))
add_caller(remote_stream, caller.user)
})
store.dispatch({type: "room/collaborator", data: caller})
}, 1000))
channel.onClose(() => {
call_setter(null)
call = null
local_stream = null
channel = null
store.dispatch({type: "room/clear"})
})
}
// If someone calls you answer appropriately
peer.on('call', (c) => {
if(channel === null) return;
console.log("received call from ", JSON.stringify(c.metadata))
if(me.role === "collaborator" && c.metadata.role === "user") {
// I just respond with my own stream but the users stream is useless
c.answer(local_stream)
}
else if(me.role === "collaborator" && c.metadata.role === "collaborator") {
// I want to send my data and also get their stream
c.answer(local_stream)
c.on('stream', (remote_stream) => {
add_caller(remote_stream, c.metadata.user)
})
} else if(me.role === "user" && c.metadata.role === "collaborator") {
c.answer()
c.on('stream', (remote_stream) => {
add_caller(remote_stream, c.metadata.user)
})
} else {
console.log("ERROR UNEXPECTED CALL", JSON.stringify(c))
}
})
export function leave() {
channel && channel.leave()
}
|
import React, {forwardRef, useImperativeHandle, useState} from 'react';
import './UploadMaket.scss';
import Modal from "react-bootstrap-modal";
const UploadMaketModal = forwardRef((props, ref) => {
const [show, setShow] = useState(false);
const handleClose = () => setShow(false);
const handleShow = () => setShow(true);
useImperativeHandle(ref, () => ({
showModal() {
handleShow();
}
}));
return (
<Modal show={show} onHide={handleClose} className="add-modal">
<div className="modal-cross" onClick={handleClose}>
<svg width="15" height="14" viewBox="0 0 15 14" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M14.733 1.42188L9.15485 7L14.733 12.5781L13.3267 13.9844L7.7486 8.40625L2.17048 13.9844L0.764225 12.5781L6.34235 7L0.764225 1.42188L2.17048 0.015625L7.7486 5.59375L13.3267 0.015625L14.733 1.42188Z" fill="black"/>
</svg>
</div>
<div className="add-address-content">
<h1>Загрузка макета Availability</h1>
<div className='input-and-buttons app-input wide-input'>
<button className='primary-button download' type='button'>Выбрать файл</button>
<div className='app-button-group'>
<button className='primary-button'>Загрузить</button>
<button className='secondary-button' onClick={handleClose}>Отмена</button>
</div>
</div>
</div>
</Modal>
);
});
export default UploadMaketModal;
|
var keystone = require('keystone');
//var formidable = require('formidable');
var fs = require('fs');
var path = require('path');
var jsonfile = require('jsonfile');
var _ = require("underscore");
// Public Method
exports.list = function(req, res) {
var view = new keystone.View(req, res);
var locals = res.locals;
initLocals(locals,'project','list',req.body);
if (req.user._id)
view.query('projects', keystone.list('Project').model.find({"author":req.user._id}).sort('sortOrder'));
// Render the view
view.render('project');
}
exports.create = function(req, res) {
var view = new keystone.View(req, res);
var PrjModel = keystone.list('Project').model;
var locals = res.locals;
initLocals(locals,'project','create',req.body);
//Load Category Data
view.on('init', function (next) {
loadCategories(next,locals.option_list);
});
//Load Status List
view.on('init', function (next) {
loadStatusList(next,locals.status_list);
});
//Create Init Project Folder
view.on('init', function (next) {
createUserFolder(req.user._id);
createUploadFolder(req.user._id,"create");
next();
});
view.on('post', { action: 'project' }, function(next) {
var prjitem = new PrjModel;
req= prepareParam(req);
updatePrjItem(next,req,locals,prjitem,res);
});
// Render the view
view.render('project');
}
exports.edit = function(req, res) {
var view = new keystone.View(req, res);
var PrjModel = keystone.list('Project').model;
var locals = res.locals;
initLocals(locals,'project','edit',req.body);
//Load Category Data
view.on('init', function (next) {
loadCategories(next,locals.option_list);
});
//Load Status List
view.on('init', function (next) {
loadStatusList(next,locals.status_list);
});
view.on('get', function(next) {
if (req.params && req.params.prjid ) {
PrjModel.findOne({_id:req.params.prjid}).exec(function(err, prjitem) {
if (err) {
req.flash('error', "This Item is not existing");
return res.redirect('/project');
} else {
showItem(next,locals,prjitem);
}
});
}
});
view.on('post', { action: 'project' }, function(next) {
if (req.params && req.params.prjid ) {
PrjModel.findOne({_id:req.params.prjid}).exec(function(err, prjitem) {
if (err) {
req.flash('error', "This Item is not existing");
return res.redirect('/project');
} else {
req= prepareParam(req);
updatePrjItem(next,req,locals,prjitem,res);
}
});
}
});
// Render the view
view.render('project');
}
exports.delete = function(req, res) {
//var view = new keystone.View(req, res);
var PrjModel = keystone.list('Project').model;
var locals = res.locals;
initLocals(locals,'project','delete',req.body);
PrjModel.remove({_id:req.params.prjid}).exec(function(err) {
if (err) {
req.flash('error', err.errors);
}
return res.redirect('/project');
});
//TODO remove project folder
// Render the view
}
exports.status = function(req, res) {
var PrjModel = keystone.list('Project').model;
var locals = res.locals;
var reqType = req.url.split("/");
initLocals(locals,'project','status',req.body);
if (reqType.length >2 && (reqType[2] =="published"||reqType[2] =="draft")) {
PrjModel.update(
{_id:req.params.prjid },
{ $set: { "status": reqType[2] } }
).exec(function(err) {
if (err) {
req.flash('error', err.errors);
}
return res.redirect('/project');
});
} else {
return res.redirect('/project');
}
}
// AJAX Server JS
exports.deletefile = function(req, res) {
//removeUploadFile(req.params.fileid);
var prjId = getUrlLastField(req.headers.referer);
var folder = getUploadFolder(req.user._id,prjId);
var fileList = folder+"filelist.json";
var file = folder+req.params.fileid;
if(!req.params.fileid || !req.user || !prjId) {
res.status(400);
res.end("Request URL Error");
return;
}
removeUploadFile(res,file,fileList);
}
exports.uploadfile = function(req, res) {
var uploadFolder;
var fileList;
if(!req.user || !req.params.prjid || !req.files || !req.files.myFile) {
res.status(400);
res.end("Request URL Error");
return;
}
uploadFolder = getUploadFolder(req.user._id,req.params.prjid);
fileList = uploadFolder + "filelist.json";
if(req.files && req.files.myFile) {
oldPath = req.files.myFile.path;
newPath = uploadFolder+"upload_"+req.files.myFile.name;
} else {
res.status(400);
res.end("Transfer File Error");
return;
}
saveUploadFile(oldPath,newPath,res,req.files.myFile,fileList);
}
exports.listfile = function(req, res) {
if(!req.user || !req.params.prjid){
res.status(400);
res.end("URL File Error");
return;
}
var url = "/doc/user_"+req.user._id+"/prj_"+req.params.prjid+"/filelist.json";
res.redirect(url);
}
// Private Method
function prepareParam(req){
if(req.user){
req.body.author=req.user._id;
}
if(req.displayAttach){
if(req.body.displayAttach == 'on') {
req.body.displayAttach = true;
} else {
req.body.displayAttach = false;
}
}
//if(req.files.fselect) {
//req.body.docsPath=req.files.fselect.path;
//prepareImage(req.body.docsPath);
//}
return req;
}
// currently not used
function prepareImage(pdfFile){
var PDFImage = require("pdf-image").PDFImage;
var pdfImage = new PDFImage(pdfFile);
console.log(pdfFile);
pdfImage.convertPage(0).then(function (imagePath) {
// 0-th page (first page) of the slide.pdf is available as slide-0.png
console.log(imagePath);
//fs.existsSync("/tmp/slide-0.png") // => true
});
}
function loadCategories(next, option_list){
var PrjCategory = keystone.list('ProjectCategory').model;
PrjCategory.find().exec(function(err,results){
if(err) {
return next(err);
}else {
results.forEach(function(item,index,array){
option_list.push({value:item._id,label:item.name});
});
next();
}
});
}
function loadStatusList(next, status_list){
var results = keystone.list('Project').schema.path('status').enumValues;
results.forEach(function(item,index,array){
status_list.push(item);
});
next();
}
function updatePrjItem(next,req,locals,prjitem,res){
// queryType:status,edit,create
var updateField = 'name, author, description,category,displayAttach';
if (locals.queryType == 'status') {
updateField = 'status';
}
updater = prjitem.getUpdateHandler(req);
updater.process(req.body, {
flashErrors: true,
fields: updateField,
errorMessage: 'There was a problem submitting your project:'
}, function(err) {
if (err) {
locals.validationErrors = err.errors;
} else {
locals.userSubmitted = true;
req.flash('success', (locals.queryType == 'create')?'Create Success':'Update Success');
if (locals.queryType == 'create' && prjitem.id && req.user) {
createUploadFolder(req.user._id,prjitem.id);
}
if( (locals.queryType == 'create') || (locals.queryType == 'edit')){
return res.redirect('/project');
}
}
next();
});
}
function showItem(next,locals,prjitem){
locals.formData.name = prjitem.name;
locals.formData.author = prjitem.author;
locals.formData.description = prjitem.description;
locals.formData.category = prjitem.category;
locals.formData.displayAttach = prjitem.displayAttach;
//locals.formData.reviewDocs = prjitem.reviewDocs;
//locals.formData.docsPath = prjitem.docsPath;
locals.formData.status = prjitem.status;
next();
}
function initLocals(locals,section,queryType,formData){
locals.section = section;
locals.queryType = queryType;
locals.formData = formData || {};
// default initial data
locals.validationErrors = {};
//locals.option_list=[ {value:0,label:"(Select One)"}];
locals.option_list=[ ];
locals.userSubmitted = false;
locals.status_list=[];
}
function createUserFolder(userId) {
var usrDir = getUserFolder(userId);
try {
if(!fs.existsSync(usrDir)) {
fs.mkdirSync(usrDir);
}
}catch(err){
console.log(err);
}
}
function createUploadFolder(userId,prjId){
var prjDir = getUploadFolder(userId,prjId);
var oldDir =getUploadFolder(userId,"create");
//TODO condition user folder exist > Done
//user folder should be existing
try {
if (prjId == "create") {
if(!fs.existsSync(prjDir)) {
fs.mkdirSync(prjDir);
fs.writeFileSync(prjDir+"filelist.json","[]");
}
} else if (prjId.length > 0 ) {
fs.renameSync(oldDir, prjDir);
}
}catch(err){
console.log(err);
}
}
function getUploadFolder(userId,prjId){
return getUserFolder(userId) + "prj_" + prjId + "/";
}
function getUserFolder(userId) {
return path.join(__dirname, '../../public/doc/user_') + userId + "/";
}
function saveFile2Json(file,jsonFile) {
var fileListObj;
var userId="";
try {
fileListObj=jsonfile.readFileSync(jsonFile);
}catch(err){
fileListObj=[];
console.log(err);
}
var tmparray = jsonFile.split("/");
if(tmparray.length > 3) {
userId = tmparray[tmparray.length-3].substring(5);
}
fileListObj.push({'originalName':file.originalname,'saveName':"upload_"+file.name,'userId':userId});
try {
jsonfile.writeFileSync(jsonFile, fileListObj,{spaces: 2});
}catch(err){
console.log(err);
}
}
function removeFileFromJson(fileName,jsonFile) {
var fileListObj;
var index = 0;
if(!fileName || !jsonFile) {
return;
}
try {
fileListObj=jsonfile.readFileSync(jsonFile);
}catch(err){
fileListObj=[];
console.log(err);
}
for(index=0;index < fileListObj.length; index++){
if(fileListObj[index].saveName ==fileName){
break;
}
}
if(index < fileListObj.length) {
fileListObj.splice(index,1);
}
try {
jsonfile.writeFileSync(jsonFile, fileListObj,{spaces: 2});
}catch(err){
console.log(err);
}
}
function removeUploadFile(res,file,fileList){
fs.unlink(file, function(err) {
if(err) {
console.log(err);
}
var fileName =getUrlLastField(file);
if(fileName && fileList) {
removeFileFromJson(fileName,fileList);
}
res.status(200);
res.end();
return;
});
}
function saveUploadFile(oldPath,newPath,res,myFile,fileList){
fs.readFile(oldPath, function(err, data) {
if(err) {
res.status(500);
res.end("Server File Reading Error");
return;
}
fs.writeFile(newPath, data, function(err) {
if(err) {
res.status(500);
res.end("Server File Save Error");
return;
}
fs.unlink(oldPath, function(err) {
saveFile2Json(myFile,fileList);
res.status(200);
res.end();
return;
});
});
});
}
function getUrlLastField(url) {
var result = "";
var tmparray = url.split("/");
if( tmparray.length > 0) {
result = tmparray[tmparray.length-1];
}
return result;
} |
#!/usr/bin/env node
const fs = require('fs');
const shell = require('shelljs');
const argv = require('yargs')
.demandCommand(2)
.argv;
const dir = process.cwd();
const existingDir = dir + "/" + argv._[0];
const newDir = dir + "/" + argv._[1];
fs.readdir(dir, function(err, files) {
if (!fs.existsSync(newDir)){
shell.cp('-R', existingDir, newDir);
console.log(`New directory \"${newDir}\" created`);
} else {
console.log(`The directory \"${argv._[1]}\" already exists`);
}
if (err) {
throw err;
}
});
|
let btn1 = document.querySelectorAll(".btnmax")
let btn2 = document.querySelectorAll('.btnmin')
for (let i of btn1 ){
i.addEventListener('click', () => {
let num=i.nextElementSibling
if (num.value<7){
num.value++
total()}})}
for (let i of btn2 ){
i.addEventListener('click', () => {
let num=i.previousElementSibling
if (num.value>0)
{num.value--
total()}
else
num.value=0})}
function total(){
let father=document.querySelectorAll(".media")
let sum=0
for (let el of father){
let quantity=el.querySelector(".btn").value
let price=el.querySelector(".price").value
sum=sum+price*quantity}
document.querySelector("#tot").innerHTML=sum}
let close = document.querySelector('#delete')
close.addEventListener('click',(e) => {
e.target.parentElement.parentElement.parentElement.remove();})
|
// JavaScript Document
$(document).ready(function() {
// begin Ready
//...................................................
// When the form changes
$('#mapForm').change(function() {
var selectedContinent = $('#mapForm option:selected').val();
if (selectedContinent == 'ALL'){
$('a.dot').slideDown(1000);
}else{
$('a.dot[continent = "'+selectedContinent+'"]').slideDown(1000);
$('a.dot[continent != "'+selectedContinent+'"]').slideUp(1000);
}
});
//...................................................
// When a dot is mouseover-ed
$('a.dot').mouseover(function(){
//$('a.dot').removeClass('selected');
//$(this).addClass('selected');
var city = '.cancercenter_detail#' + $(this).attr('cancercenter');
var htmlCode = $(city).html();
$('.detail_container').fadeOut(500, function(){
$('.detail_container .cancercenter_detail').html(htmlCode);
$('.detail_container').fadeIn(500);
});
});
// end Ready
}); |
import Component from '@glimmer/component';
import debugLogger from 'ember-debug-logger';
import { action } from '@ember/object';
import { inject as service } from '@ember/service';
import { isPresent } from '@ember/utils';
export default class TwyrRadioGroupComponent extends Component {
// #region Services
@service constants;
// #endregion
// #region Private Attributes
debug = debugLogger('twyr-radio-group');
_childElements = [];
_element = null;
// #endregion
// #region Yielded Sub-components
subComponents = {
'label': 'twyr-radio-group/label',
'button': 'twyr-radio'
};
// #endregion
// #region Constructor
constructor() {
super(...arguments);
this.debug(`constructor`);
}
// #endregion
// #region Lifecycle Hooks
@action
didInsert(element) {
this.debug(`didInsert`);
this._element = element;
if(this.args.registerWithParent && (typeof this.args.registerWithParent === 'function'))
this.args.registerWithParent(this, true);
}
willDestroy() {
this.debug(`willDestroy`);
if(this.args.registerWithParent && (typeof this.args.registerWithParent === 'function'))
this.args.registerWithParent(this, false);
super.willDestroy(...arguments);
}
// #endregion
// #region DOM Event Handlers
@action
handleKeydown(event) {
switch (event.which) {
case this.constants.KEYCODE.LEFT_ARROW:
case this.constants.KEYCODE.UP_ARROW:
event.preventDefault();
this.debug(`handleKeydown: Left / Up`);
this._select(-1);
break;
case this.constants.KEYCODE.RIGHT_ARROW:
case this.constants.KEYCODE.DOWN_ARROW:
event.preventDefault();
this.debug(`handleKeydown: Right / Down`);
this._select(1);
break;
default:
this.debug(`handleKeydown: Unwanted Keycode`);
break;
}
}
// #endregion
// #region Computed Properties
get childValues() {
const childValues = this.enabledChildRadios.map((childRadio) => {
return childRadio.radioValue;
});
this.debug(`childValues: `, childValues);
return childValues;
}
get enabledChildRadios() {
const enabledRadios = this._childElements.filter((childRadio) => {
return !childRadio._element.hasAttribute('disabled');
});
this.debug(`enabledChildRadios: `, enabledRadios);
return enabledRadios;
}
get focusOnlyOnKey() {
this.debug(`focusOnlyOnKey: ${isPresent(this.args.focusOnlyOnKey) ? this.args.focusOnlyOnKey : true}`);
return isPresent(this.args.focusOnlyOnKey) ? this.args.focusOnlyOnKey : true;
}
get role() {
this.debug(`role: ${this.args.role || 'radiogroup'}`);
return this.args.role || 'radiogroup';
}
// #endregion
// #region Private Methods
_select(increment) {
this.debug(`_select::increment: `, increment);
const groupValue = this.args.groupValue;
let index = 0;
if(isPresent(groupValue)) {
index = this.childValues.indexOf(groupValue);
index += increment;
const length = this.childValues.length;
index = ((index % length) + length) % length;
}
const childRadio = this.enabledChildRadios[index];
this.debug(`_select::childRadio::value: `, childRadio.radioValue);
this.onChange(childRadio.radioValue);
}
// #endregion
// #region Actions
@action
registerChild(child, register) {
this.debug(`registerChild::child: `, child, `, register: ${register}`);
if(register) {
if(!this._childElements.includes(child))
this._childElements.push(child);
}
else {
if(this._childElements.includes(child))
this._childElements.splice(this._childElements.indexOf(child), 1);
}
}
@action
onChange(value) {
if(!this.args.onChange)
return;
if(typeof this.args.onChange !== 'function')
return;
this.debug(`onChange: `, value);
this.args.onChange(value);
}
// #endregion
}
|
import utils from './utils';
/**
* Base class for imitation ajax requests.
*/
export default class Api {
request(url, data) {
return new Promise(function(resolve, reject) {
setTimeout(function() {
resolve();
}, utils.random(500, 1700));
});
}
get(url) {
return this.request(url);
}
post(url, data) {
return this.request(url, data);
}
}
|
import {h} from 'hyperapp'
import humanize from 'string-humanize'
import {Box} from '../../theme/Box'
import {Row} from './Row'
import {ChevronDown, Edit, Cross} from '../../theme/Icons'
import {RemoveField, AddRepeaterRow, OpenFieldForm} from '../../actions'
export const Repeater = ({repeater, path, key}) => {
const opened = window.location.hash.replace('#/admin/' , '').replace('/', '.').startsWith(path)
return (
<Box
top={[
<h3><a href={'#/admin/' + path.replace('.', '/')}>{humanize(key)}</a></h3>,
<a class="round-btn" href={'#/admin/' + path.replace('.' + key, '').replace(key, '').replace('.', '/')}><ChevronDown /></a>,
<div class="round-btn edit-btn" onclick={[OpenFieldForm, path]}><Edit /></div>,
<div class="round-btn delete-btn" onclick={[RemoveField, path]}><Cross /></div>
]}
bottom={opened && [
<button colored onclick={[AddRepeaterRow, path]}>New row</button>,
repeater[0] && <button colored onclick={[OpenFieldForm, path + '.0.field_' + Object.keys(repeater[0]).length]}>Add subfield</button>
]}
>
{opened && repeater.map((row, id) => <Row row={row} path={`${path}.${id}`} index={id} />)}
</Box>
)
}
|
const mongoose = require('mongoose')
const autoIncrement = require('mongoose-auto-increment')
const connection = mongoose.createConnection(process.env.MONGO_URI)
autoIncrement.initialize(connection);
const CoverSchema = new mongoose.Schema({
customID: String,
archive: {
type: String
// reference to other
},
createdAtMo:{
type: Date,
default: Date.now
},
createdAtYear: {
type: Date,
default: Date.now
},
place: {
type: String,
enum: ['FRA']
}
});
CoverSchema.plugin(autoIncrement.plugin, {model: 'Cover', startAt: 1});
module.exports = mongoose.model('Cover', CoverSchema); |
import Ember from 'ember';
import { moduleFor, test } from 'ember-qunit';
import { defineFixture } from 'ic-ajax';
import startApp from '../helpers/start-app';
moduleFor('service:sync', 'Integration | Service | sync', {
integration: true,
beforeEach: function (assert) {
var adapter = null,
done = assert.async();
this.app = startApp();
adapter = this.app.__container__.lookup('adapter:application');
adapter.get('cache').clear();
window.localforage.clear(function () {
done();
});
},
afterEach: function () {
Ember.run(this.app, 'destroy');
}
});
test('updateAccountStore creates a new record and save it to the store if the record is new', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(7);
Ember.run(function () {
service.get('store').findAll('account').then(function (results) {
assert.equal(results.get('length'), 0, 'The store should be empty initially');
return service.updateAccountStore({
'id': '123',
'email': 'test@example.com',
'firstName': 'John',
'lastName': 'Doe',
'screenName': 'Johnny'
});
}).then(function (record) {
assert.equal(record.get('id'), '123', 'The id attribute should match');
assert.equal(record.get('email'), 'test@example.com', 'The email attribute should match');
assert.equal(record.get('firstName'), 'John', 'The firstName attribute should match');
assert.equal(record.get('lastName'), 'Doe', 'The lastName attribute should match');
assert.equal(record.get('screenName'), 'Johnny', 'The screenName attribute should match');
return service.get('store').findAll('account');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to updateAccountStore the store should contain one account');
done();
});
});
});
test('updateAccountStore updates an existing record and save it to the store if the record is not new', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(7);
Ember.run(function () {
var account = service.get('store').createRecord('account', {
'id': '123',
'email': 'test@example.com',
'firstName': 'John',
'lastName': 'Doe',
'screenName': 'Johnny'
});
account.save().then(function () {
return service.get('store').findAll('account');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'The store should contain one account initially');
return service.updateAccountStore({
'id': '123',
'email': 'test2@example.com',
'firstName': 'John2',
'lastName': 'Doe2',
'screenName': 'Johnny2'
});
}).then(function (record) {
assert.equal(record.get('id'), '123', 'The id attribute should match');
assert.equal(record.get('email'), 'test2@example.com', 'The email attribute should match');
assert.equal(record.get('firstName'), 'John2', 'The firstName attribute should match');
assert.equal(record.get('lastName'), 'Doe2', 'The lastName attribute should match');
assert.equal(record.get('screenName'), 'Johnny2', 'The screenName attribute should match');
return service.get('store').findAll('account');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to updateAccountStore the store should still contain one account');
done();
});
});
});
test('fetchUserInfo get user info and update the account store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(5);
defineFixture('/user?client_id=123', {
response: {
'id': '123',
'email': 'test@example.com',
'first_name': 'John',
'last_name': 'Doe',
'screen_name': 'Johnny'
},
jqXHR: {},
textStatus: 'success'
});
Ember.run(function () {
service.fetchUserInfo('token', '', 123).then(function (record) {
assert.equal(record.get('id'), '123', 'The id attribute should match');
assert.equal(record.get('email'), 'test@example.com', 'The email attribute should match');
assert.equal(record.get('firstName'), 'John', 'The firstName attribute should match');
assert.equal(record.get('lastName'), 'Doe', 'The lastName attribute should match');
assert.equal(record.get('screenName'), 'Johnny', 'The screenName attribute should match');
done();
});
});
});
test('createSecret creates a new secret', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(8);
Ember.run(function () {
service.get('store').findAll('secret').then(function (results) {
assert.equal(results.get('length'), 0, 'The store should be empty initially');
return service.createSecret({
id: '1',
service: 'example.com',
account: 'john',
secret: 's3cr3t',
notes: 'example notes',
tags: ['tag1', 'tag2']
});
}).then(function (record) {
assert.equal(record.get('id'), '1', 'The id attribute should match');
assert.equal(record.get('service'), 'example.com', 'The service attribute should match');
assert.equal(record.get('account'), 'john', 'The account attribute should match');
assert.equal(record.get('secret'), 's3cr3t', 'The secret attribute should match');
assert.equal(record.get('notes'), 'example notes', 'The notes attribute should match');
assert.equal(record.get('tags'), 'tag1 tag2', 'The notes attribute should match a serialized string of the original list');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to createSecret the store should contains one secret');
done();
});
});
});
test('updateSecret updates an existing secret without creating another one', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(8);
Ember.run(function () {
var secret = service.get('store').createRecord('secret', {
id: '1',
service: 'example.com',
account: 'john',
secret: 's3cr3t',
notes: 'example notes',
tags: ['tag1', 'tag2']
});
secret.save().then(function () {
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'The store should contain one secret initially');
return service.updateSecret(secret, {
service: 'mail.example.com',
account: 'john2',
secret: 's3cr3t',
notes: 'example notes2',
tags: ['tag3', 'tag4']
});
}).then(function (record) {
assert.equal(record.get('id'), '1', 'The id attribute should match');
assert.equal(record.get('service'), 'mail.example.com', 'The service attribute should match');
assert.equal(record.get('account'), 'john2', 'The account attribute should match');
assert.equal(record.get('secret'), 's3cr3t', 'The secret attribute should match');
assert.equal(record.get('notes'), 'example notes2', 'The notes attribute should match');
assert.equal(record.get('tags'), 'tag3 tag4', 'The notes attribute should match a serialized string of the original list');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to updateSecret the store should still contains one secret');
done();
});
});
});
test('updateSecrets creates secrets if they do not exists in the store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(15);
Ember.run(function () {
service.get('store').findAll('secret').then(function (existingRecords) {
assert.equal(existingRecords.get('length'), 0, 'The store should be empty initially');
return Ember.RSVP.all(service.updateSecrets(existingRecords, [{
id: '10',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '11',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: []
}]));
}).then(function (newRecords) {
assert.equal(newRecords.length, 2, "After the promises are resolved the result contain 2 new records");
assert.equal(newRecords[0].get('id'), '10', 'The id attribute of the first record should match');
assert.equal(newRecords[0].get('service'), '1.example.com', 'The service attribute of the first record should match');
assert.equal(newRecords[0].get('account'), 'john', 'The account attribute of the first record should match');
assert.equal(newRecords[0].get('secret'), 's3cr3t1', 'The secret attribute of the first record should match');
assert.equal(newRecords[0].get('notes'), 'example notes', 'The notes attribute of the first record should match');
assert.equal(newRecords[0].get('tags'), 'tag1 tag2', 'The tags attribute of the first record should match');
assert.equal(newRecords[1].get('id'), '11', 'The id attribute of the second record should match');
assert.equal(newRecords[1].get('service'), '2.example.com', 'The service attribute of the second record should match');
assert.equal(newRecords[1].get('account'), 'john', 'The account attribute of the second record should match');
assert.equal(newRecords[1].get('secret'), 's3cr3t2', 'The secret attribute of the second record should match');
assert.equal(newRecords[1].get('notes'), '', 'The notes attribute of the second record should match');
assert.equal(newRecords[1].get('tags'), '', 'The tags attribute of the second record should match');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecrets the store should contains two secrets');
done();
});
});
});
test('updateSecrets updates secrets if they already exists in the store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(15);
Ember.run(function () {
var secret = service.get('store').createRecord('secret', {
id: '10',
service: 'example.com',
account: 'johnny',
secret: '0lds3cr3t',
notes: 'old example notes',
tags: ['old-tag1', 'old-tag2']
});
secret.save().then(function () {
return service.get('store').findAll('secret');
}).then(function (existingRecords) {
assert.equal(existingRecords.get('length'), 1, 'The store should contain one secret initially');
return Ember.RSVP.all(service.updateSecrets(existingRecords, [{
id: '10',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '11',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: []
}]));
}).then(function (newRecords) {
assert.equal(newRecords.length, 2, "After the promises are resolved the result contain 2 records, one updated, one new");
assert.equal(newRecords[0].get('id'), '10', 'The id attribute of the first record should match');
assert.equal(newRecords[0].get('service'), '1.example.com', 'The service attribute of the first record should match');
assert.equal(newRecords[0].get('account'), 'john', 'The account attribute of the first record should match');
assert.equal(newRecords[0].get('secret'), 's3cr3t1', 'The secret attribute of the first record should match');
assert.equal(newRecords[0].get('notes'), 'example notes', 'The notes attribute of the first record should match');
assert.equal(newRecords[0].get('tags'), 'tag1 tag2', 'The tags attribute of the first record should match');
assert.equal(newRecords[1].get('id'), '11', 'The id attribute of the second record should match');
assert.equal(newRecords[1].get('service'), '2.example.com', 'The service attribute of the second record should match');
assert.equal(newRecords[1].get('account'), 'john', 'The account attribute of the second record should match');
assert.equal(newRecords[1].get('secret'), 's3cr3t2', 'The secret attribute of the second record should match');
assert.equal(newRecords[1].get('notes'), '', 'The notes attribute of the second record should match');
assert.equal(newRecords[1].get('tags'), '', 'The tags attribute of the second record should match');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecrets the store should contains two secrets');
done();
});
});
});
test('createTag creates a new tag', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(4);
Ember.run(function () {
service.get('store').findAll('tag').then(function (results) {
assert.equal(results.get('length'), 0, 'The store should be empty initially');
return service.createTag({
name: 'tag1',
count: 10
});
}).then(function (record) {
assert.equal(record.get('name'), 'tag1', 'The name attribute should match');
assert.equal(record.get('count'), 10, 'The count attribute should match');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to createTag the store should contains one tag');
done();
});
});
});
test('updateTag updates an existing tag without creating another one', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(4);
Ember.run(function () {
var tag = service.get('store').createRecord('tag', {
name: 'tag1',
count: 10
});
tag.save().then(function () {
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'The store should contain one tag initially');
return service.updateTag(tag, {name: 'tag1', count: 20});
}).then(function (record) {
assert.equal(record.get('name'), 'tag1', 'The name attribute should match');
assert.equal(record.get('count'), 20, 'The count attribute should match');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 1, 'After the call to updateTag the store should still contains one tag');
done();
});
});
});
test('updateTags creates tags if they do not exists in the store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(7);
Ember.run(function () {
service.get('store').findAll('tag').then(function (existingRecords) {
assert.equal(existingRecords.get('length'), 0, 'The store should be empty initially');
return Ember.RSVP.all(service.updateTags(existingRecords, [{
id: '10',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '11',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: ['tag1']
}]));
}).then(function (newRecords) {
assert.equal(newRecords.length, 2, "After the promises are resolved the result contain 2 new records");
assert.equal(newRecords[0].get('name'), 'tag1', 'The name attribute of the first record should match');
assert.equal(newRecords[0].get('count'), 2, 'The count attribute of the first record should match');
assert.equal(newRecords[1].get('name'), 'tag2', 'The name attribute of the second record should match');
assert.equal(newRecords[1].get('count'), 1, 'The count attribute of the second record should match');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecrets the store should contains two tags');
done();
});
});
});
test('updateTags updates tags if they exist in the store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(7);
Ember.run(function () {
var tag = service.get('store').createRecord('tag', {
name: 'tag1',
count: 10
});
tag.save().then(function () {
return service.get('store').findAll('tag');
}).then(function (existingRecords) {
assert.equal(existingRecords.get('length'), 1, 'The store should contain one tag initially');
return Ember.RSVP.all(service.updateTags(existingRecords, [{
id: '10',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '11',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: ['tag1']
}]));
}).then(function (newRecords) {
assert.equal(newRecords.length, 2, "After the promises are resolved the result contain 2 new records");
assert.equal(newRecords[0].get('name'), 'tag1', 'The name attribute of the first record should match');
assert.equal(newRecords[0].get('count'), 2, 'The count attribute of the first record should match');
assert.equal(newRecords[1].get('name'), 'tag2', 'The name attribute of the second record should match');
assert.equal(newRecords[1].get('count'), 1, 'The count attribute of the second record should match');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecrets the store should contains two tags');
done();
});
});
});
test('updateSecretsStore updates the secrets store with incoming data from the server', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(22);
Ember.run(function () {
service.get('store').findAll('tag').then(function (results) {
assert.equal(results.get('length'), 0, 'The tag store should be empty initially');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 0, 'The secret store should be empty initially');
return service.updateSecretsStore({
passwords: [{
id: '1',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '2',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: ['tag1']
}]
});
}).then(function (result) {
assert.equal(result.secrets.length, 2, 'There should be two secrets in the results');
assert.equal(result.secrets[0].get('id'), '1', 'The id attribute of the first secret should match');
assert.equal(result.secrets[0].get('service'), '1.example.com', 'The service attribute of the first secret should match');
assert.equal(result.secrets[0].get('account'), 'john', 'The account attribute of the first secret should match');
assert.equal(result.secrets[0].get('secret'), 's3cr3t1', 'The secret attribute of the first secret should match');
assert.equal(result.secrets[0].get('notes'), 'example notes', 'The notes attribute of the first secret should match');
assert.equal(result.secrets[0].get('tags'), 'tag1 tag2', 'The tags attribute of the first secret should match');
assert.equal(result.secrets[1].get('id'), '2', 'The id attribute of the second secret should match');
assert.equal(result.secrets[1].get('service'), '2.example.com', 'The service attribute of the second secret should match');
assert.equal(result.secrets[1].get('account'), 'john', 'The account attribute of the second secret should match');
assert.equal(result.secrets[1].get('secret'), 's3cr3t2', 'The secret attribute of the second secret should match');
assert.equal(result.secrets[1].get('notes'), '', 'The notes attribute of the second secret should match');
assert.equal(result.secrets[1].get('tags'), 'tag1', 'The tags attribute of the second secret should match');
assert.equal(result.tags.length, 2, 'There should be two tags in the results');
assert.equal(result.tags[0].get('name'), 'tag1', 'The name attribute of the first tag should match');
assert.equal(result.tags[0].get('count'), 2, 'The count attribute of the first tag should match');
assert.equal(result.tags[1].get('name'), 'tag2', 'The name attribute of the second tag should match');
assert.equal(result.tags[1].get('count'), 1, 'The count attribute of the second tag should match');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecretsStore the store should contain two secrets');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecretsStore the store should contain two tags');
done();
});
});
});
test('fetchSecrets get the secrets and update the account store', function (assert) {
var service = this.subject(),
done = assert.async();
assert.expect(22);
defineFixture('/passwords?client_id=123', {
response: {
passwords: [{
id: '1',
service: '1.example.com',
account: 'john',
secret: 's3cr3t1',
notes: 'example notes',
tags: ['tag1', 'tag2']
}, {
id: '2',
service: '2.example.com',
account: 'john',
secret: 's3cr3t2',
notes: '',
tags: ['tag1']
}]
},
jqXHR: {},
textStatus: 'success'
});
Ember.run(function () {
service.get('store').findAll('tag').then(function (results) {
assert.equal(results.get('length'), 0, 'The tag store should be empty initially');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 0, 'The secret store should be empty initially');
return service.fetchSecrets('token', '', 123);
}).then(function (result) {
assert.equal(result.secrets.length, 2, 'There should be two secrets in the results');
assert.equal(result.secrets[0].get('id'), '1', 'The id attribute of the first secret should match');
assert.equal(result.secrets[0].get('service'), '1.example.com', 'The service attribute of the first secret should match');
assert.equal(result.secrets[0].get('account'), 'john', 'The account attribute of the first secret should match');
assert.equal(result.secrets[0].get('secret'), 's3cr3t1', 'The secret attribute of the first secret should match');
assert.equal(result.secrets[0].get('notes'), 'example notes', 'The notes attribute of the first secret should match');
assert.equal(result.secrets[0].get('tags'), 'tag1 tag2', 'The tags attribute of the first secret should match');
assert.equal(result.secrets[1].get('id'), '2', 'The id attribute of the second secret should match');
assert.equal(result.secrets[1].get('service'), '2.example.com', 'The service attribute of the second secret should match');
assert.equal(result.secrets[1].get('account'), 'john', 'The account attribute of the second secret should match');
assert.equal(result.secrets[1].get('secret'), 's3cr3t2', 'The secret attribute of the second secret should match');
assert.equal(result.secrets[1].get('notes'), '', 'The notes attribute of the second secret should match');
assert.equal(result.secrets[1].get('tags'), 'tag1', 'The tags attribute of the second secret should match');
assert.equal(result.tags.length, 2, 'There should be two tags in the results');
assert.equal(result.tags[0].get('name'), 'tag1', 'The name attribute of the first tag should match');
assert.equal(result.tags[0].get('count'), 2, 'The count attribute of the first tag should match');
assert.equal(result.tags[1].get('name'), 'tag2', 'The name attribute of the second tag should match');
assert.equal(result.tags[1].get('count'), 1, 'The count attribute of the second tag should match');
return service.get('store').findAll('secret');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecretsStore the store should contain two secrets');
return service.get('store').findAll('tag');
}).then(function (results) {
assert.equal(results.get('length'), 2, 'After the call to updateSecretsStore the store should contain two tags');
done();
});
});
});
|
import React, { useState,useRef } from 'react';
import DatePicker from 'react-datepicker';
import 'react-datepicker/dist/react-datepicker.css'
import FetchCenters from './FetchCenters';
import { AiOutlineHome } from 'react-icons/ai';
import { GiLoveInjection } from 'react-icons/gi';
const url = "https://cdn-api.co-vin.in/api/v2/appointment/sessions/public/findByPin"
export default function SearchByPIN(props) {
const [pin, setPin] = useState('');
const [items, setItems] = useState(null);
const [selectedDate,setSelectedDate] = useState(null)
const [pinerror,setPinError] = useState('')
const [invalidPin,setInvalidPin] = useState('')
const [dateError,setDateError] = useState('')
const focusRef = useRef()
const handlePINChange = e => {
let p = e.target.value;
if(p)
{
setPin(p)
setPinError('')
}
else
{
setPin('')
setPinError('Pincode cannot be empty')
}
setInvalidPin('')
}
const handleDateChange = date => {
setSelectedDate(date)
setDateError('')
}
const search = (e) => {
e.preventDefault();
if(pin && selectedDate)
{
const date = selectedDate;
const today = `${date.getDate()}-${(date.getMonth()+1).toString().padStart(2,0)}-${date.getUTCFullYear()}`
fetch(url+`?pincode=${pin}&date=${today}`)
.then(res => res.json())
.then(result => {
if(result.error){
setInvalidPin(result.error);
setItems(null)
}
else
{
let res = result.sessions?result.sessions.filter(item => item.available_capacity>0):[];
setItems(res)
}
focusRef.current?.scrollIntoView({ behavior: 'smooth', block: 'start' })
});
}
if(!pin){
setPinError('Pincode cannot be empty')
}
if(!selectedDate)
setDateError('Date is not selected')
}
return (
<div>
<div className='App'>
<form onSubmit={search}>
<div>
<p><label>Pincode:</label></p>
<input
className='input'
type="number"
name="PIN"
placeholder="Enter PIN Code..."
onChange={handlePINChange}
value={pin}
/>
</div>
{invalidPin?<p className='error'>{invalidPin}</p>:<></>}
<p className='error'>{pinerror}</p>
<div>
<p><label>Date:</label></p>
<DatePicker
placeholderText="Enter date..."
className='input'
selected={selectedDate}
onChange={date => handleDateChange(date)}
dateFormat='dd/MM/yyyy'
withPortal
minDate={new Date()}
isClearable
showYearDropdown
scrollableMonthYearDropdown/>
</div>
<p className='error'>{dateError}</p>
<div>
<div><button type='submit' className='button btn2' ><span><GiLoveInjection style={{marginBottom: '4px'}}/> Find Slots</span></button></div>
<div><button className='button btn2' onClick={() => props.onChange('0')}><span><AiOutlineHome style={{marginBottom: '4px'}}/> Home</span></button>{' '}</div>
</div>
</form>
</div>
<div ref={focusRef}><FetchCenters items={items}/></div>
</div>
)
}
|
/**
* allSessions.js
*
* Controls the simple initialization and creation of a DataTable that hold
* all sessions and their associated information.
*/
$(document).ready(function() {
let ajaxSessionUrl = "/sessions";
let instanceSelector = $("#sessionsInstanceSelect");
function reloadDataTable() {
$("#allSessionsTable").DataTable({
responsive: true,
pageLength: 25,
order: [[1, "desc"]],
columnDefs: [
{targets: [0], orderable: false},
]
});
}
/**
* Generate change listener to modify the sessions data table.
*/
instanceSelector.off("change").change(function() {
$.ajax({
url: ajaxSessionUrl,
dataType: "json",
data: {
instance: $(this).val(),
context: true
},
beforeSend: function() {
$("#sessionsCardBody").empty().append(loaderTemplate);
$(".loader-template").fadeIn();
},
success: function(data) {
let body = $("#sessionsCardBody");
body.find(".loader-template").fadeOut(100, function() {
$(this).remove();
body.empty().append(data["table"]);
reloadDataTable();
});
}
});
});
/**
* Generate DataTable Instance...
*/
reloadDataTable();
/**
* Allow users to export their sessions data to a JSON file.
*/
$("#exportSessionsJson").off("click").click(function() {
exportToJsonFile($("#jsonData").data("json"), "sessions")
});
}); |
import { createNativeStackNavigator } from "@react-navigation/native-stack";
import React from "react";
import { View, Text, FlatList, ScrollView, TouchableOpacity, StyleSheet, Image } from 'react-native';
import { multimedia_data } from "../../data/multimedia_data";
const MultimediaItemCard = ({ route }) => {
const { title } = route.params
return (
<Text>{title}</Text>
)
}
const Multimedia = ({ navigation }) => {
const renderItem = ({ item }) => {
return (
<View style={styles.container}>
<Text style={styles.mediaTitle}>{item.title}</Text>
<ScrollView horizontal>
{item.options.map(x => {
return (
<View style={styles.mediaBox}>
<TouchableOpacity onPress={() => navigation.navigate('media-item-card', {
title: x.title
})}>
<Text style={styles.x_title}>{x.title}</Text>
</TouchableOpacity>
</View>
)
})}
</ScrollView>
</View>
)
}
return (
<View>
<View style={styles.header}>
<View style={styles.headerOne}>
<Image source={require('../../assets/news/Logo.jpg')} style={styles.logoHeader}/>
</View>
<View style={styles.headerTwo}>
<Text style={styles.textHeader}>Мультимедиа</Text>
</View>
</View>
<FlatList
data={multimedia_data}
renderItem={renderItem}
keyExtractor={x => x.id}
/>
</View>
)
}
const MediaStack = createNativeStackNavigator()
export const MultimediaStack = () => {
return (
<MediaStack.Navigator screenOptions={{headerShown: false}}>
<MediaStack.Screen name='multimedia' component={Multimedia} />
<MediaStack.Screen name='media-item-card' component={MultimediaItemCard} />
</MediaStack.Navigator>
)
}
const styles = StyleSheet.create({
header: {
display: 'flex',
position: 'absolute',
top: 0,
start: 0,
flexDirection: "row"
},
headerOne: {
flex: 1,
alignItems: 'center',
},
headerTwo: {
flex: 5,
alignItems: 'flex-start'
},
logoHeader: {
width: 30,
height: 30,
marginTop: '74%',
},
textHeader: {
fontFamily: 'GothamPro-Medium',
fontSize: 19,
marginTop: '16%',
},
//----------------------------------------------------
container: {
marginTop: '20%'
},
mediaTitle: {
fontSize: 20,
fontFamily: 'GothamPro-Medium',
textAlign:'center',
marginTop: '7%'
},
mediaBox: {
fontSize: 25
},
x_title: {
fontSize: 25,
padding: 10,
fontFamily: 'GothamPro-Medium'
}
}) |
'use strict';
import { request, catcher } from 'RatesEx/js/common/websocketConnector';
import { STORE_BANKS_DATA } from './actionTypes';
function storeData(data) {
return {
type: STORE_BANKS_DATA,
payload: data
}
};
export function getBanks() {
return (dispatch, getState) => {
request('/ratesex/banks', 'get', {countryCode: getState().appSettings.countryCode}).then((result) => {
if (result.status === 'ok') {
return dispatch(storeData({
banksList: getState().banks.banksList.cloneWithRows(result.data)
}));
}
});
};
};
|
const UrlPrettifier = require( 'next-url-prettifier' ).default;
const routes = [
{
page: 'index',
prettyUrl: '/',
priority: '1.0',
},
{
page: 'platform',
prettyUrl: '/platform',
prettyUrlPatterns: [
{
pattern: '/platform',
defaultParams: {
apiRoute: 'page',
slug: 'platform',
},
},
],
priority: '.09',
},
{
page: 'company',
prettyUrl: '/company',
prettyUrlPatterns: [
{
pattern: '/company',
defaultParams: {
apiRoute: 'page',
slug: 'company',
},
},
],
priority: '.08',
},
{
page: 'media',
prettyUrl: '/media',
prettyUrlPatterns: [
{
pattern: '/media',
defaultParams: {
activeSection: 0,
apiRoute: 'page',
slug: 'media',
},
},
],
priority: '.07',
},
{
page: 'media',
prettyUrl: '/media/posts',
prettyUrlPatterns: [
{
pattern: '/media/posts',
defaultParams: {
activeSection: 1,
apiRoute: 'page',
slug: 'media',
},
},
],
priority: '.07',
},
{
page: 'contact',
prettyUrl: '/contact',
prettyUrlPatterns: [
{
pattern: '/contact',
defaultParams: {
apiRoute: 'page',
slug: 'contact',
},
},
],
priority: '.07',
},
{
page: 'request-demo',
prettyUrl: '/request-demo',
prettyUrlPatterns: [
{
pattern: '/request-demo',
defaultParams: {
apiRoute: 'page',
slug: 'request-demo',
},
},
],
priority: '.06',
},
{
page: 'post',
prettyUrl: ( { slug = '' } ) => `/media/${ slug }`,
prettyUrlPatterns: [
{
pattern: '/media/:slug',
defaultParams: {
apiRoute: 'post',
},
},
],
priority: '.06',
},
{
page: 'team',
prettyUrl: ( { slug = '' } ) => `/team/${ slug }`,
prettyUrlPatterns: [
{
pattern: '/team/:slug',
defaultParams: {
apiRoute: 'team',
},
},
],
priority: '.05',
},
{
page: 'page',
prettyUrl: ( { slug = '' } ) => `/${ slug }`,
prettyUrlPatterns: [
{
pattern: '/:slug',
defaultParams: {
apiRoute: 'page',
},
},
{
pattern: '/page/:slug',
defaultParams: {
apiRoute: 'page',
},
},
],
priority: '.04',
},
{
page: 'preview',
prettyUrl: ( { id = '', wpnonce = '' } ) =>
`/_preview/${ id }/${ wpnonce }`,
prettyUrlPatterns: [ { pattern: '/_preview/:id/:wpnonce' } ],
priority: '.01',
},
];
const urlPrettifier = new UrlPrettifier( routes );
exports.default = routes;
exports.Router = urlPrettifier;
|
$(document).ready(function() {
function log() {
if (console)
console.log.apply(console, arguments);
}
function timing(point) {
if (!Date.now)
return;
var timestamp = Date.now();
if (state.lastTimestamp) {
var delta = (timestamp-state.lastTimestamp)/1000;
log("("+state.lastPoint+") -> ("+point+"): "+delta);
}
state.lastPoint = point;
state.lastTimestamp = timestamp;
}
function makeConfig() {
var $body = $('body');
return {
databaseName: $body.attr('data-database-name') || "",
htsqlVersion: $body.attr('data-htsql-version') || "",
htsqlLegal: $body.attr('data-htsql-legal') || "",
serverRoot: $body.attr('data-server-root') || "",
queryOnStart: $body.attr('data-query-on-start') || "/",
evaluateOnStart: ($body.attr('data-evaluate-on-start') == 'true'),
canReadOnStart: ($body.attr('data-can-read-on-start') == 'true'),
canWriteOnStart: ($body.attr('data-can-write-on-start') == 'true'),
implicitShell: ($body.attr('data-implicit-shell') == 'true')
};
}
function makeEnviron() {
var $outer = $("<div></div>").prependTo($('body'))
.css({ position: 'absolute',
left: 0, top: -1000,
width: 100, height: 100,
overflow: 'auto' });
var $inner = $("<div></div>").prependTo($outer)
.css({ width: '100%', height: 1000 });
var scrollbarWidth = 100-$inner.width();
$outer.remove();
return {
scrollbarWidth: scrollbarWidth || 20,
screenWidth: window.screen.width || 2000,
}
}
function makeState() {
return {
$panel: null,
waiting: false,
lastQuery: null,
lastAction: null,
lastPage: null,
lastOffset: null,
marker: null,
expansion: 0,
lastPoint: null,
lastTimestamp: null,
completions: {}
}
}
function makeEditor() {
var $editor = $('#editor');
var editor = CodeMirror.fromTextArea($editor[0], {
mode: 'htsql',
onKeyEvent: function(i, e) {
// Ctrl-Enter
if ((e.ctrlKey || e.metaKey) && !e.altKey && e.keyCode == 13) {
if (e.type == 'keydown') {
$('#run').click();
}
return true;
}
// Ctrl-Up
if ((e.ctrlKey || e.metaKey) && !e.altKey && e.keyCode == 38) {
if (e.type == 'keydown') {
$('#shrink').click();
}
return true;
}
// Ctrl-Down
if ((e.ctrlKey || e.metaKey) && !e.altKey && e.keyCode == 40) {
if (e.type == 'keydown') {
$('#expand').click();
}
return true;
}
// Ctrl-Space
if ((e.ctrlKey || e.metaKey) && !e.altKey && e.keyCode == 32) {
if (e.type == 'keydown') {
startComplete();
}
return true;
}
}
});
return editor;
}
function updateTitle(message) {
if (!message) {
message = '['+config.databaseName+']';
}
else {
message = message+' ['+config.databaseName+']';
}
document.title = message;
}
function setQuery(query) {
editor.setValue(query);
editor.setCursor(editor.lineCount(), 0);
}
function getQuery() {
var orig_query = editor.getValue();
var query = orig_query.replace(/^\s+|\s+$/g, "");
if (query != orig_query) {
editor.setValue(query);
}
if (!/^\//.test(query)) {
return;
}
return query;
}
function clickSchema() {
}
function clickHelp() {
$('#version').text(config.htsqlVersion);
$('#legal').text(config.htsqlLegal);
$popups.show();
$helpPopup.show();
}
function clickRun() {
var query = getQuery();
pushHistory(query)
run(query);
}
function clickExpand(dir) {
var expansion = state.expansion+dir;
if (expansion < -1 || expansion > 3)
return;
if (state.expansion == -1)
$shrink.css({ visibility: 'visible' });
if (expansion == -1)
$shrink.css({ visibility: 'hidden' });
if (state.expansion == 3)
$expand.css({ visibility: 'visible' });
if (expansion == 3)
$expand.css({ visibility: 'hidden' });
var height = null;
if (expansion < 0)
height = 4;
else
height = 8*(expansion+1);
$('.input-area').css({ height: height+'em' });
$('.output-area').css({ top: (height+2)+'em' });
if (expansion == -1) {
$('#run').css({ height: '2em',
'margin-bottom': '1px'});
$('#more').css({ 'margin-bottom': '1px'});
}
else {
$('#run').removeAttr('style');
$('#more').removeAttr('style');
}
state.expansion += dir;
}
function clickPopups() {
$popups.hide();
$popups.children('.popup').hide();
}
function clickMore() {
var $more = $('#more');
var offset = $more.offset();
$morePopup.css({ top: offset.top+$more.outerHeight(),
right: $viewport.width()-offset.left-$more.outerWidth() });
$popups.show();
$morePopup.show();
}
function clickExport(format) {
$popups.hide();
$popups.children('.popup').hide();
var query = getQuery();
if (query && query != '/') {
if (/\n|#/.test(query)) {
query += '\n';
}
query += '/:'+format;
run(query);
}
}
function clickShowSql() {
$popups.hide();
$popups.children('.popup').hide();
var query = getQuery();
if (query && query != '/') {
run(query, 'analyze');
}
}
function clickLoad() {
var query = state.lastQuery
var page = state.lastPage || 1;
state.lastOffset = $gridBody.scrollTop();
run(query, 'produce', page+1);
}
function clickClose() {
if (state.$panel) {
state.$panel.hide();
state.$panel = null;
}
}
function scrollGrid() {
$gridHead.scrollLeft($gridBody.scrollLeft());
}
function popstateWindow(event) {
var data = event.originalEvent.state;
if (!data) {
return;
}
var query = data.query;
if (query == getQuery()) {
return;
}
if (state.waiting) {
return
}
setQuery(query);
if (state.$panel)
state.$panel.hide();
state.$panel = null;
updateTitle();
}
function pushHistory(query, replace) {
if (!history.pushState || !history.replaceState)
return;
if (!query || !config.serverRoot || state.waiting)
return;
var data = { query: query };
var title = 'HTSQL';
if (!config.implicitShell) {
if (query == '/')
query = "/shell()";
else
query = "/shell('" + query.replace(/'/g,"''") + "')";
}
var url = config.serverRoot+encodeURI(query).replace(/#/g, '%23');
try {
if (replace)
history.replaceState(data, title, url);
else
history.pushState(data, title, url);
}
catch (e) {
log(e);
}
}
function run(query, action, page, with_permissions) {
if (!query)
return;
if (!config.serverRoot)
return;
if (state.waiting)
return;
if (state.marker) {
state.marker();
state.marker = null;
}
state.lastQuery = query;
state.lastAction = action;
state.lastPage = page;
var success = handleSuccess;
var failure = handleFailure;
if (!action)
action = 'produce';
if (page) {
query = "/" + action + "('" + query.replace(/'/g,"''") + "',"
+ page + ")";
}
else {
query = "/" + action + "('" + query.replace(/'/g,"''") + "')";
}
if (with_permissions && (!config.canReadOnStart || !config.canWriteOnStart)) {
query = "/with_permissions(" + query + ",'" + config.canReadOnStart
+ "','" + config.canWriteOnStart + "')";
success = handleSuccessWithPermissions;
}
var url = config.serverRoot+encodeURI(query).replace(/#/g, '%23');
$.ajax({
url: url,
dataType: 'json',
success: success,
error: failure,
});
state.waiting = true;
setTimeout(showWaiting, 1000);
}
function handleFailure() {
state.waiting = false;
if (state.$panel)
state.$panel.hide();
state.$panel = $failurePanel.show();
updateTitle();
}
function handleSuccess(output) {
state.waiting = false;
switch (output.type) {
case "product":
handleProduct(output);
break;
case "empty":
handleEmpty(output);
break;
case "sql":
handleSql(output);
break;
case "error":
handleError(output);
break;
case "permissions":
handleError(output);
break;
case "unsupported":
handleUnsupported(output);
}
}
function handleSuccessWithPermissions(output) {
if (output.type == "permissions") {
output.type = "empty";
}
handleSuccess(output);
}
function handleError(output) {
if (state.$panel)
state.$panel.hide();
state.$panel = $errorPanel.show();
$error.text(output.detail);
if (output.hint) {
$errorHint.text("("+output.hint+")");
}
else {
$errorHint.text("");
}
if (state.marker) {
state.marker();
state.marker = null;
}
if (output.first_line !== null && output.first_column !== null &&
output.last_line !== null && output.last_column !== null) {
editor.setCursor({ line: output.first_line,
ch: output.first_column });
state.marker = editor.markText({ line: output.first_line,
ch: output.first_column },
{ line: output.last_line,
ch: output.last_column },
'marker');
}
updateTitle($error.text());
}
function handleUnsupported(output) {
if (state.$panel)
state.$panel.hide();
state.$panel = null;
if (!state.lastAction) {
var url = config.serverRoot+encodeURI(state.lastQuery).replace(/#/g, '%23');
window.open(url, "_blank");
}
updateTitle();
}
function handleEmpty(output) {
if (state.$panel)
state.$panel.hide();
state.$panel = null;
updateTitle();
}
function handleSql(output) {
if (state.$panel)
state.$panel.hide();
state.$panel = $sqlPanel.show();
$sql.text(output.sql);
updateTitle();
}
function handleProduct(output) {
// timing("rendering table");
if (state.$panel)
state.$panel.hide();
state.$panel = null;
var width = $viewport.width();
var build = makeBuild(output.meta, output.data, output.more);
// log("build.head():");
var head = build.head();
// log(head);
// log("build.body():");
var body = build.body();
// log(body);
// log("build.foot():");
var foot = build.foot();
// log(foot);
var constraint = null;
if (width < 640)
constraint = 'w640';
else if (width < 800)
constraint = 'w800';
else if (width < 1024)
constraint = 'w1024';
else if (width < 1280)
constraint = 'w1280';
else if (width < 1600)
constraint = 'w1600';
var table = '';
table += '<table'+(constraint ? ' class="'+constraint+'"' : '')+'>';
table += '<colgroup>';
for (var i = 0; i < build.size; i ++) {
table += '<col' + (i == build.size-1 ? (' style="width: '+width+'px">') : '>');
}
table += '</colgroup>';
table += '<thead>';
for (var k = 0; k < head.length; k ++) {
var row = head[k];
table += '<tr>';
for (var i = 0; i < row.length; i ++) {
var cell = row[i];
var attrs = '';
attrs += (cell.colspan || 1) > 1 ? ' colspan="'+cell.colspan+'"' : '';
attrs += (cell.rowspan || 1) > 1 ? ' rowspan="'+cell.rowspan+'"' : '';
attrs += (cell.classes && cell.classes.length > 0) ?
' class="'+cell.classes.join(' ')+'"' : '';
table += '<th'+attrs+'>'+(cell.content || '')+'</th>';
}
table += '</tr>';
}
table += '</thead>';
table += '<tbody>';
for (var k = 0; k < body.length; k ++) {
var row = body[k];
table += '<tr' + (k % 2 == 1 ? ' class="alt">' : '>');
for (var i = 0; i < row.length; i ++) {
var cell = row[i];
var attrs = '';
attrs += (cell.colspan || 1) > 1 ? ' colspan="'+cell.colspan+'"' : '';
attrs += (cell.rowspan || 1) > 1 ? ' rowspan="'+cell.rowspan+'"' : '';
attrs += (cell.classes && cell.classes.length > 0) ?
' class="'+cell.classes.join(' ')+'"' : '';
table += '<td'+attrs+'>'+(cell.content || '')+'</td>';
}
table += '</tr>';
}
for (var k = 0; k < foot.length; k ++) {
var row = foot[k];
table += '<tr class="foot">';
for (var i = 0; i < row.length; i ++) {
var cell = row[i];
var attrs = '';
attrs += (cell.colspan || 1) > 1 ? ' colspan="'+cell.colspan+'"' : '';
attrs += (cell.rowspan || 1) > 1 ? ' rowspan="'+cell.rowspan+'"' : '';
attrs += (cell.classes && cell.classes.length > 0) ?
' class="'+cell.classes.join(' ')+'"' : '';
table += '<td'+attrs+'>'+(cell.content || '')+'</td>';
}
table += '</tr>';
}
table += '</tbody>';
table += '</table>';
if (output.more) {
table += '<button id="load">Load More Data</button>';
}
$gridHead.empty();
$gridBody.empty()
.css({ top: 0,
width: build.size*width+"px",
right: "auto",
"overflow-y": "hidden",
"overflow-x": "hidden" });
state.$panel = $productPanel.show();
var title = '';
if (output.meta.header) {
title = output.meta.header;
}
updateTitle(title);
$gridBody.html(table);
$gridBody.scrollLeft(0).scrollTop(0);
if (state.lastPage && state.lastOffset) {
$gridBody.scrollTop(state.lastOffset);
state.lastOffset = 0;
}
$('#load').click(clickLoad);
setTimeout(configureGrid, 0);
}
function makeBuild(meta, data, more) {
var profileBuild = buildForProfile(meta);
var headHeight = profileBuild.headHeight();
if (headHeight < 1) {
headHeight = 1;
}
return {
size: profileBuild.size+1,
bounded: profileBuild.bounded,
head: function () {
var height = profileBuild.headHeight();
if (height < 1) {
height = 1;
}
var rows = profileBuild.head(height);
while (rows.length < height) {
rows.push([]);
}
rows[0].push({ colspan: profileBuild.size+1,
rowspan: height, classes: ['dummy'] });
return rows;
},
body: function () {
var height = profileBuild.bodyHeight(data);
var rows = profileBuild.body(data, height);
for (var k = 0; k < rows.length; k ++) {
rows[k].push({ classes: ['dummy'] });
}
return rows;
},
foot: function () {
var height = profileBuild.footHeight(more);
var rows = profileBuild.foot(more, height);
for (var k = 0; k < rows.length; k ++) {
rows[k].push({ classes: ['dummy'] });
}
return rows;
}
};
}
function buildForProfile(meta) {
var domainBuild = buildForDomain(meta.domain);
if (!meta.header || domainBuild.size == 0) {
return domainBuild;
}
return {
size: domainBuild.size,
bounded: domainBuild.bounded,
headHeight: function () {
return domainBuild.headHeight()+1;
},
head: function(height) {
var rows = [];
if (domainBuild.headHeight() > 0) {
rows = domainBuild.head(height-1);
rows.unshift([]);
}
else {
for (var k = 0; k < height; k ++) {
rows.push([]);
}
}
var rowspan = (height > 1 && domainBuild.headHeight() == 0) ? height : 1,
colspan = domainBuild.size,
content = meta.header.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>');
rows[0].push({ rowspan: rowspan, colspan: colspan, content: content });
return rows;
},
bodyHeight: function (data) {
return domainBuild.bodyHeight(data);
},
body: function (data, height) {
return domainBuild.body(data, height);
},
footHeight: function (more) {
return domainBuild.footHeight(more);
},
foot: function (more, height) {
return domainBuild.foot(more, height);
}
};
}
function buildForDomain(meta) {
if (meta.type == "record") {
return buildForRecord(meta);
}
else if (meta.type == "list") {
return buildForList(meta);
}
else if (meta.type == "void") {
return buildForVoid(meta);
}
return {
size: 1,
bounded: true,
headHeight: function () {
return 0;
},
head: function(height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
if (height > 0) {
rows[0].push({ rowspan: height, classes: ['dummy'] });
}
return rows;
},
bodyHeight: function (data) {
return 1;
},
body: function (data, height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
var classes = [];
if (meta.type) {
classes.push(meta.type);
}
var content = data;
if (content === null) {
content = '';
classes.push('null-val');
}
else if (content === true) {
content = 'true';
classes.push('true-val');
}
else if (content === false) {
content = 'false';
classes.push('false-val');
}
else {
content = ''+content;
if (content === '') {
classes.push('empty-val');
}
}
content = content.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>');
rows[0].push({ rowspan: height, classes: classes, content: content });
return rows;
},
footHeight: function (more) {
return 1;
},
foot: function (more, height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
var classes = [];
if (meta.type) {
classes.push(meta.type);
}
if (more) {
classes.push('more');
}
else {
classes.push('dummy');
}
rows[0].push({ rowspan: height, classes: classes });
return rows;
}
};
}
function buildForRecord(meta) {
var fieldBuilds = [];
var size = 0;
var bounded = true;
for (var k = 0; k < meta.fields.length; k ++) {
var fieldBuild = buildForProfile(meta.fields[k]);
fieldBuilds.push(fieldBuild);
size += fieldBuild.size;
bounded = bounded && fieldBuild.bounded;
}
return {
size: size,
bounded: bounded,
headHeight: function () {
if (!size) {
return 0;
}
var height = 0;
for (var k = 0; k < fieldBuilds.length; k ++) {
var fieldHeight = fieldBuilds[k].headHeight();
height = fieldHeight > height ? fieldHeight : height;
}
return height;
},
head: function(height) {
var rows = [];
if (!height) {
return rows;
}
for (var k = 0; k < height; k ++) {
rows.push([]);
}
for (var k = 0; k < fieldBuilds.length; k ++) {
var fieldHead = fieldBuilds[k].head(height);
for (var i = 0; i < height; i ++) {
for (var j = 0; j < fieldHead[i].length; j ++) {
rows[i].push(fieldHead[i][j]);
}
}
}
return rows;
},
bodyHeight: function (data) {
if (data === null || !size) {
return 0;
}
var height = 0;
for (var k = 0; k < fieldBuilds.length; k ++) {
var fieldHeight = fieldBuilds[k].bodyHeight(data[k]);
height = fieldHeight > height ? fieldHeight : height;
}
return height;
},
body: function (data, height) {
var rows = [];
if (!height) {
return rows;
}
for (var k = 0; k < height; k ++) {
rows.push([]);
}
if (data === null) {
for (var k = 0; k < fieldBuilds.length; k ++) {
rows[0].push({ rowspan: height, classes: ['null-rec-val'] });
}
}
else {
for (var k = 0; k < fieldBuilds.length; k ++) {
var fieldBody = fieldBuilds[k].body(data[k], height);
for (var i = 0; i < height; i ++) {
for (var j = 0; j < fieldBody[i].length; j ++) {
rows[i].push(fieldBody[i][j]);
}
}
}
}
return rows;
},
footHeight: function (more) {
if (!size) {
return 0;
}
return 1;
},
foot: function (more, height) {
var rows = [];
if (height == 0) {
return rows;
}
for (var k = 0; k < height; k ++) {
rows.push([]);
}
for (var k = 0; k < fieldBuilds.length; k ++) {
var fieldFoot = fieldBuilds[k].foot(more, height);
for (var i = 0; i < height; i ++) {
for (var j = 0; j < fieldFoot[i].length; j ++) {
rows[i].push(fieldFoot[i][j]);
}
}
}
return rows;
}
};
}
function buildForList(meta) {
var itemBuild = buildForDomain(meta.item.domain);
return {
size: itemBuild.size+1,
bounded: false,
headHeight: function () {
return itemBuild.headHeight();
},
head: function(height) {
var rows = itemBuild.head(height);
if (height > 0) {
rows[0].unshift({ rowspan: height, classes: ['dummy'] });
}
return rows;
},
bodyHeight: function (data) {
if (data === null) {
return 0;
}
var height = 0;
for (var k = 0; k < data.length; k ++) {
var itemHeight = itemBuild.bodyHeight(data[k]);
if (itemHeight == 0) {
itemHeight = 1;
}
height += itemHeight;
}
return height;
},
body: function (data, height) {
var rows = [];
if (!height) {
return rows;
}
if (data === null || data.length == 0) {
for (var k = 0; k < height; k ++) {
rows.push([]);
}
rows[0].push({ rowspan: height, classes: ['index', 'null-rec-val'] });
for (var k = 0; k < itemBuild.size; k ++) {
rows[0].push({ rowspan: height, classes: ['null-rec-val']});
}
}
else {
for (var k = 0; k < data.length; k ++) {
var itemHeight = itemBuild.bodyHeight(data[k]);
if (itemHeight == 0) {
itemHeight = 1;
}
if (k == data.length-1) {
itemHeight = height;
}
height -= itemHeight;
var itemRows = itemBuild.body(data[k], itemHeight);
itemRows[0].unshift({ rowspan: itemHeight, classes: ['index'],
content: ''+(k+1) });
if (!itemBuild.bounded) {
var row = itemRows[0];
for (var i = 0; i < row.length; i ++) {
var classes = row[i].classes || [];
if (classes[0] != 'section') {
classes.unshift('section');
}
row[i].classes = classes;
}
}
for (var i = 0; i < itemRows.length; i ++) {
rows.push(itemRows[i]);
}
}
}
return rows;
},
footHeight: function (more) {
var height = itemBuild.footHeight(more);
if (height == 0) {
height = 1;
}
return height;
},
foot: function (more, height) {
var rows = itemBuild.foot(more, height);
if (height > 0) {
var classes = [];
classes.push('index');
if (more) {
classes.push('more');
}
else {
classes.push('dummy');
}
rows[0].unshift({ rowspan: height, classes: classes });
}
return rows;
}
};
}
function buildForVoid(meta) {
return {
size: 0,
bounded: true,
headHeight: function () {
return 0;
},
head: function(height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
return rows;
},
bodyHeight: function (data) {
return 0;
},
body: function (data, height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
return rows;
},
footHeight: function (more) {
return 0;
},
foot: function (more, height) {
var rows = [];
for (var k = 0; k < height; k ++) {
rows.push([]);
}
return rows;
}
};
}
function configureGrid() {
var $bodyTable = $gridBody.children('table');
var gridWidth = $grid.width();
var colWidths = [];
$bodyTable.find('tbody tr:first-child').children().each(function(idx) {
colWidths[idx] = $(this).outerWidth()+1;
});
colWidths[colWidths.length-1] = 1;
var tableWidth = 0;
for (var i = 0; i < colWidths.length; i ++) {
tableWidth += colWidths[i];
}
var overflow = 'auto';
if (tableWidth < gridWidth) {
var diff = gridWidth-tableWidth-1;
colWidths[colWidths.length-1] += diff;
tableWidth += diff;
if (diff >= 2*environ.scrollbarWidth)
overflow = 'hidden';
}
var $bodyGroup = $("<colgroup></colgroup>");
var $headGroup = $("<colgroup></colgroup>");
for (var i = 0; i < colWidths.length; i ++) {
var width = colWidths[i];
$bodyGroup.append("<col style=\"width: "+width+"px\">");
$headGroup.append("<col style=\"width: "+width+"px\">");
}
var $headTable = $("<table></table>")
.appendTo($gridHead)
.css('table-layout', 'fixed')
.width(tableWidth)
.append($headGroup)
.append($bodyTable.children('thead').clone());
$gridHead.scrollLeft(0);
var headHeight = $gridHead.height();
$("<div></div>").appendTo($gridHead)
.width(tableWidth+environ.screenWidth)
.height(1);
$bodyTable.children('colgroup').remove();
$bodyTable.children('thead').remove();
$bodyTable.removeClass();
$bodyTable.css('table-layout', 'fixed')
.width(tableWidth)
.prepend($bodyGroup);
$gridBody.css({ right: 0,
top: headHeight,
width: 'auto',
'overflow-y': 'auto',
'overflow-x': overflow });
setTimeout(reportTime, 0);
}
function reportTime() {
// timing("!rendering table");
}
function showWaiting() {
if (!state.waiting)
return;
if (state.$panel)
state.$panel.hide();
state.$panel = $requestPanel.show();
}
function startComplete() {
if (editor.somethingSelected()) {
return;
}
var cursor = editor.getCursor();
var token = editor.getTokenAt(cursor);
var line = cursor.line;
var start = token.start;
var end = token.end;
var prefix = token.string;
if (!/^(?![0-9])[_0-9a-zA-Z\u0080-\uFFFF]+$/.test(token.string)) {
start = cursor.ch;
end = cursor.ch;
prefix = '';
}
var query = editor.getRange({line: 0, ch: 0}, {line: line, ch: start});
var names = scanQuery(query);
if (!names) return;
var completions = state.completions;
for (var k = 0; k < names.length; k ++) {
if (completions && completions.hasOwnProperty(names[k]))
completions = completions[names[k]];
else
completions = null;
}
if (completions && completions.hasOwnProperty(''))
completions = completions[''];
else
completions = null;
if (!completions) {
requestCompletions(names);
return;
}
var matches = [];
for (var k = 0; k < completions.length; k ++) {
var name = completions[k];
if (name.substr(0, prefix.length) == prefix) {
matches.push(name);
}
}
//log(matches);
if (matches.length == 0)
return;
if (matches.length == 1) {
var match = matches[0];
editor.replaceRange(match, {line: line, ch: start}, {line: line, ch: end});
return;
};
var common = matches[0];
for (var k = 0; k < matches.length; k ++) {
var match = matches[k];
var l = common.length < match.length ? common.length : match.length;
while (common.substr(0, l) != match.substr(0, l))
l --;
common = common.substr(0, l);
if (common == prefix)
break;
}
if (common != prefix) {
editor.replaceRange(common, {line: line, ch: start}, {line: line, ch: end});
setTimeout(startComplete);
return;
}
$complete.empty();
for (var k = 0; k < matches.length; k ++)
$complete.append($('<option></option>').text(matches[k]));
var coords = editor.charCoords({line: line, ch: start});
$completePopup.css({ top: coords.yBot+"px", left: coords.x+"px" });
$complete.attr('size', matches.length < 10 ? matches.length : 10);
$complete.val(matches[0]);
$complete.blur(function () {
clickPopups();
$complete.unbind();
$completePopup.unbind().removeAttr('style');
});
$complete.keydown(function (e) {
/* Esc */
if (e.keyCode == 27) {
setTimeout(function() { editor.focus(); });
return false;
}
/* Enter, Space */
else if (e.keyCode == 13 || e.keyCode == 32) {
var choice = $complete.val();
editor.replaceRange(choice, {line: line, ch: start}, {line: line, ch: end});
setTimeout(function() { editor.focus(); });
return false;
}
/* Up, Down, PageUp, PageDown, Home, End */
else if (e.keyCode == 38 || e.keyCode == 40 ||
e.keyCode == 33 || e.keyCode == 34 ||
e.keyCode == 35 || e.keyCode == 36) {
return;
}
else {
editor.focus();
var ch = String.fromCharCode(e.keyCode);
if (/^[_0-9a-zA-Z\u0080-\uFFFF]+$/.test(ch))
setTimeout(startComplete, 100);
return;
}
});
$completePopup.click(function() {
var choice = $complete.val();
editor.replaceRange(choice, {line: line, ch: start}, {line: line, ch: end});
setTimeout(function() { editor.focus(); });
return false;
});
$completePopup.show();
$popups.show();
if (matches.length <= 10) {
$completePopup.css({width: ($complete[0].clientWidth-1)+"px", overflow: 'hidden'});
}
$complete.focus();
}
function requestCompletions(names) {
var query = "";
for (var k = 0; k < names.length; k ++) {
var name = names[k];
if (k > 0)
query += ",";
query += "'"+name.replace(/'/g, "''")+"'";
}
query = "/complete(" + query + ")";
var url = config.serverRoot+encodeURI(query).replace(/#/, '%23');
$.ajax({
url: url,
dataType: 'json',
success: function (output) {
if (output.type != 'complete')
return;
var completions = state.completions;
for (var k = 0; k < names.length; k ++) {
var name = names[k];
if (!completions.hasOwnProperty(name))
completions[name] = {}
completions = completions[name];
}
completions[''] = output.names;
setTimeout(startComplete);
}
});
}
function ScanState() {
this.indicator = '/';
this.identifiers = [];
this.stack = [];
}
ScanState.prototype.push = function (indicator, identifiers) {
this.stack.push({indicator: this.indicator, identifiers: this.identifiers});
this.indicator = indicator;
if (identifiers) {
this.identifiers = identifiers;
}
}
ScanState.prototype.drop = function (indicators) {
if (indicators.test(this.indicator)) {
var item = this.stack.pop();
this.indicator = item.indicator;
this.identifiers = item.identifiers;
return true;
}
return false;
}
ScanState.prototype.drop_all = function (indicators) {
if (indicators.test(this.indicator)) {
while (indicators.test(this.indicator)) {
var item = this.stack.pop();
this.indicator = item.indicator;
this.identifiers = item.identifiers;
}
return true;
}
return false;
}
ScanState.prototype.clone = function () {
var copy = new ScanState();
copy.indicator = this.indicator;
copy.identifiers = this.identifiers;
copy.stack = this.stack.concat();
return copy;
}
function scanQuery(query) {
var regexp = /#[^\r\n]*|->|:=|\[|\]|[~<>=!&|.,?(){}:$@^/*+-]|'(?:[^']|'')*'|\d+[.eE]?|(?!\d)[_0-9a-zA-Z\u0080-\uFFFF]+/g;
var tokens = [];
var match;
while ((match = regexp.exec(query))) {
if (/^#/.test(match[0])) {
continue;
}
tokens.push(match[0]);
}
var state = new ScanState();
for (var i = 0; i < tokens.length; i ++) {
var token = tokens[i];
var prev_token = (i > 0) ? tokens[i-1] : '';
var next_token = (i < tokens.length-1) ? tokens[i+1] : '';
if (state.indicator == '[') {
if (token == '[' || token == '(') {
state.push('[', []);
}
else if (token == ']' || token == ')') {
state.drop(/[[]/);
}
continue;
}
if (/^(?![0-9])[_0-9a-zA-Z\u0080-\uFFFF]+$/.test(token)) {
if (!/[:$]/.test(prev_token) && !/[(]/.test(next_token)) {
state.push('_', state.identifiers.concat([token]));
}
}
else if (token == '.') {
}
else if (token == '->' || token == '@') {
state.push('_', []);
}
else if (token == '?' || token == '^') {
var copy = state.clone();
state.drop_all(/[_]/);
if (!state.drop(/[?^]/))
state = copy;
state.push(token);
}
else if (token == '(') {
state.push(token);
}
else if (token == ')') {
var copy = state.clone();
state.drop_all(/[_?^]/);
if (!state.drop(/[(]/))
state = copy;
}
else if (token == '{') {
var copy = state.clone();
state.drop_all(/[_]/);
if (!state.drop(/[?^]/))
state = copy;
state.push(token);
}
else if (token == '}') {
var copy = state.clone();
state.drop_all(/[_?^]/);
if (!state.drop(/[{]/))
state = copy;
}
else if (token == ':=') {
state.drop(/[_]/);
}
else if (token == ':') {
state.drop_all(/[_?^]/);
}
else if (token == '$') {
state.push('_', []);
}
else if (token == '[') {
state.push('[', []);
}
else {
state.drop_all(/[_]/);
}
}
if (state.indicator == '[') {
return null;
}
return state.identifiers;
}
function ajaxSend(evt, xhr, settings) {
var name = 'htsql-csrf-token';
var token = null;
if (document.cookie && document.cookie != '') {
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i++) {
var cookie = $.trim(cookies[i]);
if (cookie.substring(0, name.length+1) == (name+'=')) {
token = decodeURIComponent(cookie.substring(name.length+1));
break;
}
}
}
if (token) {
xhr.setRequestHeader('X-HTSQL-CSRF-Token', token);
}
}
var config = makeConfig();
var environ = makeEnviron();
var state = makeState();
var $viewport = $('#viewport');
var $database = $('#database');
var $productPanel = $('#product-panel');
var $grid = $('#grid');
var $gridHead = $('#grid-head');
var $gridBody = $('#grid-body');
var $requestPanel = $('#request-panel');
var $errorPanel = $('#error-panel');
var $error = $('#error');
var $errorHint = $('#error-hint');
var $failurePanel = $('#failure-panel');
var $sqlPanel = $('#sql-panel');
var $sql = $('#sql');
var $popups = $('#popups');
var $morePopup = $('#more-popup');
var $completePopup = $('#complete-popup');
var $complete = $('#complete');
var $helpPopup = $('#help-popup');
var $shrink = $('#shrink');
var $expand = $('#expand');
var editor = makeEditor();
setQuery(config.queryOnStart);
editor.focus();
$('#schema').click(clickSchema);
$('#help').click(clickHelp);
$('#run').click(clickRun);
$('#more').click(clickMore);
$('#export-html').click(function() { return clickExport('html'); });
$('#export-json').click(function() { return clickExport('json'); });
$('#export-xml').click(function() { return clickExport('xml'); });
$('#export-csv').click(function() { return clickExport('csv'); });
$('#export-tsv').click(function() { return clickExport('tsv'); });
$('#show-sql').click(clickShowSql);
$('#close-error').click(clickClose);
$('#close-failure').click(clickClose);
$('#close-sql').click(clickClose);
$('#grid-body').scroll(scrollGrid);
$('#popups').click(clickPopups);
$('#shrink').click(function() { return clickExpand(-1); });
$('#expand').click(function() { return clickExpand(+1); });
$(window).bind('popstate', popstateWindow);
$('#help-popup').click(function (e) { e.stopPropagation(); });
$(document).ajaxSend(ajaxSend);
$('#schema').hide();
$('#close-sql').hide();
$database.text(config.databaseName);
updateTitle();
pushHistory(config.queryOnStart, true);
if (config.evaluateOnStart) {
run(config.queryOnStart, null, null, true);
}
if (typeof window.addEventListener === 'function') {
var allowedOrigin = window.location.origin;
function handleMessage(evt) {
if (evt.origin !== allowedOrigin) {
return;
}
switch (evt.data.type) {
case 'getQuery':
evt.source.postMessage({
id: evt.data.id,
data: getQuery(),
}, allowedOrigin);
break;
default:
break;
}
}
window.addEventListener('message', handleMessage);
}
});
|
import React from 'react';
import {
BrowserRouter as Router,
Route,
} from 'react-router-dom';
import Login from './auth/login';
import Reminders from './reminders/index';
const BasicExample = () => (
<Router>
<div>
<Route exact path="/" component={Login}/>
<Route exact path="/reminders" component={Reminders}/>
</div>
</Router>
)
export default BasicExample;
|
import React from 'react';
import { Card, Image, Col, Row, Container, Button } from 'react-bootstrap';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import Comment from '../ContentCards/Comments';
import NewsCard from '../ContentCards/NewsCard';
import BreakingNews from '../ContentCards/BreakingNewsCard';
import VerticalCard from '../ContentCards/VerticalCard';
import GlobalButton from '../GlobalButton';
const ColoredLine = ({ color }) => (
<div>
<Row>
<Col
md={2}
style={{ fontWeight: 'bold', fontFamily: 'Calibri', fontSize: '20px' }}
>
Top Stories
</Col>
<Col md={10}>
<hr
style={{
backgroundColor: '#491542',
height: 10,
}}
/>
</Col>
</Row>
</div>
);
function News() {
return (
<div>
<Container>
<ColoredLine />
<Row>
<Col>
<VerticalCard />
</Col>
<Col>
<VerticalCard />
</Col>
<Col>
<BreakingNews />
</Col>
</Row>
<Row>
{/**fix this later */}
<Col></Col>
<br />
<GlobalButton label={'See More News'} />
<Col></Col>
</Row>
</Container>
</div>
);
}
export default News;
|
/**
* Created by nicholas on 5/1/17.
*/
import React, { Component } from 'react';
class GoogleMap extends Component {
}
export default GoogleMap; |
/**
* Author: Iancu George-Alexandru
* Created: 02.11.2019
*
* (c) Copyright by Iancu George-Alexandru.
**/
var gameName = "cine-pe-cine";
async function getKidName() {
return localStorage.getItem('name');
}
window.onload = async () => {
var kidName = await getKidName();
$("[data-name='kidName']").html(kidName);
}
$("#checkAnswer").on("click", function() {
var answer = 0;
$(".js-input").each(function(index, item) {
if($(item).val() == $(item).attr("data-good")) {
answer = 1;
}else {
answer = 0;
}
});
if(answer == 1) {
showModal("Felicitari, ai gasit raspunsul corect !")
} else {
showModal("Ups, nu ai reusit, mai incearca !")
}
})
|
import React from 'react';
import '../../CSS/Results.css';
class Positive extends React.Component {
render() {
return (
<div id="positiveDiv" className="slantRight slantDiv">
<div id="posTitle" className="sectionTitle">
<h2>Most Positive Comment</h2>
</div>
<div id="mostPositiveParent" className="dataDiv">
<p>John Doe</p>
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse bibendum enim ac
lectus consequat finibus. Ut lacus ipsum, varius mollis placerat et, finibus vel lectus.</p>
</div>
</div>
);
}
}
export default Positive; |
$(document).ready(function() {
addItem();
function addItem(){
$('#add-item').keydown(function(enter){
if(enter.keyCode == 13){
postItem();
}
});
}
function postItem() {
var itemVal = $('#add-item').val();
var done = '<span class="done">done</span>';
var empty = '<span class="empty">delete</span>'
var place = $('<li>' + empty + itemVal + done + '</li>');
$('.list').prepend(place);
$('#add-item').val('');
}
$('button').click(function(){
$('li').remove();
});
$(document).on('click', '.done', function(){
$(this).closest('li').toggleClass('stroked');
});
$(document).on('click','.empty',function(){
$(this).closest('li').fadeOut(300);
});
});
|
import React, { PropTypes, PureComponent } from 'react';
import { connect } from 'react-redux';
import LocationDot from './LocationDot';
import { locationIdSelector } from 'store/selectors';
export class LocationDots extends PureComponent {
static propTypes = {
ids: PropTypes.array.isRequired,
projection: PropTypes.func // Map projection
};
get dots () {
const { ids, projection } = this.props;
return ids.map(id => (
<LocationDot id={id} key={id} projection={projection} />
));
}
render () {
return (
<g>
{this.dots}
</g>
);
}
}
/**
*
* Redux
*
*/
const select = state => ({
ids: locationIdSelector(state)
});
export default connect(select)(LocationDots);
|
const express = require('express')
const session = require('express-session')
const path = require('path')
const bodyParser = require('body-parser')
const flash = require('express-flash')
const app = express()
const port = 3000;
require('./server/db')
app.use(session({
key: 'user_sid',
secret: 'keyboard cat',
resave: false,
saveUninitialized: false,
cookie: {
expires: 600000
}
}))
app.use(flash())
app.use(express.static(path.join(process.cwd(), '/dist')))
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())
app.use('/', require('./server/routes/'))
app.use((req, res, next) => {
let err = new Error('Not Found')
err.status = 404
next(err)
})
app.use((err, req, res, next) => {
res.status(err.status || 500)
res.send(`${res.statusCode} - ${err.message}`)
})
app.listen(port, () => {
console.log(`Running on port ${port}`)
})
|
var self;
function objectPanelBodyComponent(params) {
this.title = params.data.key;
this.data = this.data || ko.observable(params.data.value);
this.cardIndex = this.cardIndex || ko.utils.unwrapObservable(params.index);
this.cardGroup = params.cardGroup;
this.getMore = this.cardGroup.getMore;
this.pageParam = params.pageParam;
self = this;
}
objectPanelBodyComponent.prototype.onEnterKeyDown = function (model, event) {
var pageNumber = ~~model.value < 0 ? 0 : ~~model.value;
self.pageParam(pageNumber < ko.utils.unwrapObservable(self.data).totalPages ? pageNumber : ko.utils.unwrapObservable(self.data).totalPages - 1);
if (event.keyCode === 13) {
$('#api-exp-get-btn').trigger('click');
} else {
return true;
}
};
module.exports = ko.components.register('object-panel-body', {
viewModel: objectPanelBodyComponent,
template:`
<ul data-bind="foreachprop: data">
<li class="clearfix">
<!-- ko if: $component.title === 'images' -->
<img data-bind="attr: {src: url, alt: 'image-' + ratio}" alt="img" class="img img-thumbnail">
<!-- /ko -->
<b class="key">
<span data-bind="text: typeof value === 'object' ? key: key + ':'"></span>
</b>
<!-- ko ifnot: typeof value === 'object' || $component.title === 'page' && key === 'number' -->
<span data-bind="text: value" class="value"></span>
<!-- /ko -->
<!-- ko if: $component.title === 'page' && key === 'number'-->
<div class="form-inline">
<input id="pagination-input" data-bind="textInput: value, event: {keydown: $component.onEnterKeyDown}" type="text" pattern="[0-9]+" class="form-control">
</div>
<!-- /ko -->
<!-- ko if: typeof value === 'object' -->
<button data-bind="click: $component.getMore.bind($component.cardGroup, value, $component.cardIndex)" type="button" class="btn btn-icon blue-shevron-right pull-right"></button>
<!-- /ko -->
</li>
</ul>
`});
|
import API from 'src/util/api';
import elnPlugin from '../libs/elnPlugin';
import Roc from '../../rest-on-couch/Roc';
import Color from './color';
export async function load(uuid) {
const couchUrl = API.cache('couchUrl');
const database = API.cache('database');
const roc = new Roc({
url: couchUrl,
database: database,
kind: 'reaction',
processor: elnPlugin,
});
API.cache('roc', roc);
roc.getGroupMembership().then((groups) => API.cache('allGroups', groups));
let userInfo = await roc.getUserInfo();
userInfo.username = userInfo.username || userInfo.userId || userInfo.email;
await API.createData('userInfo', userInfo);
const emitter = roc.getDocumentEventEmitter(uuid);
emitter.on('sync', () => API.createData('dataSynced', true));
emitter.on('unsync', () => API.createData('dataSynced', false));
API.cache('rocReaction', roc);
const reaction = await roc.document(uuid, {
varName: 'reaction',
track: true,
});
console.log({ reaction });
// small fix for missing seq in reagents
updateEntry(reaction);
if (reaction.$content.reagents) {
var maxID =
Math.max(...reaction.$content.reagents.map((r) => r.seq || 0)) + 1;
reaction.$content.reagents.forEach((r) => {
if (!r.seq) r.seq = maxID++;
});
}
// for compatibility reason we need to upgrade old status
Color.updateStatuses(reaction.$content.status);
var reactionVar = API.getVar('reaction');
API.setVariable('reactionContent', reactionVar, ['$content']);
API.setVariable('reagents', reactionVar, ['$content', 'reagents']);
API.setVariable('reactionRXN', reactionVar, ['$content', 'reactionRXN']);
API.setVariable('products', reactionVar, ['$content', 'products']);
API.setVariable('title', reactionVar, ['$content', 'title']);
API.setVariable('procedure', reactionVar, ['$content', 'procedure']);
API.setVariable('conditions', reactionVar, ['$content', 'conditions']);
API.setVariable('remarks', reactionVar, ['$content', 'remarks']);
API.setVariable('code', reactionVar, ['$id']);
API.setVariable('date', reactionVar, ['$content', 'date']);
API.setVariable('status', reactionVar, ['$content', 'status']);
API.setVariable('currentStatus', reactionVar, [
'$content',
'status',
'0',
'code',
]);
API.setVariable('meta', reactionVar, ['$content', 'meta']);
API.setVariable('attachments', reactionVar, ['attachmentList']);
API.doAction('refreshSamples');
if (API.getData('metaTemplate')) API.getData('metaTemplate').triggerChange();
const overview = reaction._attachments
? reaction._attachments['overview.svg'] ||
reaction._attachments['overview.png']
: undefined;
if (overview) {
API.createData('overviewImage', overview.url);
}
}
function updateEntry(entry) {
// update all reaction format
if (entry.$content.procedure) {
let value = entry.$content.procedure;
if (value && value.type === 'html') {
value = value.value;
entry.$content.procedure = value;
}
if (value && value.includes('id="reagent_')) {
value = value.replace(
/<span id="reagent_([0-9]+)">([^<]*)<\/span>/g,
'<a href="#reagent_$1">$2</a>',
);
entry.$content.procedure = value;
}
}
if (entry.$content.keywords && !entry.$content.meta) {
entry.$content.meta = {};
for (let keyword of entry.$content.keywords) {
entry.$content.meta[keyword.kind] = keyword.value;
}
delete entry.$content.keywords;
}
if (!entry.$content.meta) {
entry.$content.meta = {};
}
}
export async function loadViewPreferences() {
const roc = API.cache('roc');
if (!roc) return;
let userInfo = API.getData('userInfo');
if (!userInfo || !userInfo.email || !userInfo.email.includes('@')) return;
console.log({ userInfo });
let userViewPrefs = await roc.UserViewPrefs.get();
if (!userViewPrefs) {
userViewPrefs = {};
let cookie = localStorage.getItem('eln-procedure-snipets');
if (cookie) {
userViewPrefs.snipets = JSON.parse(cookie);
} else {
userViewPrefs.snipets = [
{
key: 'wus',
html: 'The reaction was quenched with a diluted solution of sodium hydroxide. The organic phase was separated, dried of magnesium sulfate and concentrated under reduced pressure. ',
},
{
key: 'fla',
html: 'The crude sample was purified by flash chromatography. ',
},
];
}
roc.UserViewPrefs.set(userViewPrefs);
}
if (userViewPrefs.autoupdate === undefined) {
userViewPrefs.autoupdate = false;
}
if (userViewPrefs.defaultMetas === undefined) {
userViewPrefs.defaultMetas = [];
}
await API.createData('userViewPrefs', userViewPrefs);
let userViewPrefsVar = API.getVar('userViewPrefs');
API.setVariable('snipets', userViewPrefsVar, ['snipets']);
API.setVariable('defaultMetas', userViewPrefsVar, ['defaultMetas']);
}
|
export const GET_CART = 'GET_CART';
export const STORE_MINICART_ID = 'STORE_MINICART_ID';
export const GET_CART_ITEMS = 'GET_CART_ITEMS';
export const STORE_CART_ITEMS = 'STORE_CART_ITEMS';
export const GET_CART_INFO = 'GET_CART_INFO';
export const STORE_CART_INFO = 'STORE_CART_INFO';
export const ADD_TO_CART = 'ADD_TO_CART';
export const STORE_TO_CART = 'STORE_TO_CART';
export const REMOVE_FROM_CART = 'REMOVE_FROM_CART';
export const STORE_FROM_CART = 'STORE_FROM_CART';
export const COMPONENT_RERENDER = 'COMPONENT_RERENDER';
/*
GET CARD ID
*/
export const storeMinicartId = (res) => {
return {
type: GET_CART,
result: res
};
};
export const getCart = (data) => {
return dispatch => {
fetch('http://magento2.inchoo4u.net/rest/V1/guest-carts', {
method: 'POST'
})
.then(response => response.json())
.then(data => dispatch(storeMinicartId(data)))
};
};
/*
GET ITEMS
*/
export const storeCartItems = (res) => {
return {
type: GET_CART_ITEMS,
result: res
};
};
export const getCartItems = (minicartId,item,sku) => {
return dispatch => {
fetch('http://magento2.inchoo4u.net/rest/V1/guest-carts/' + minicartId + '/items')
.then(response => response.json())
.then(data => dispatch(storeCartItems(data)))
}
};
/*
GET CART INFO
*/
export const storeCartInfo = (res) => {
return {
type: GET_CART_INFO,
result: res
};
};
export const getCartInfo = (minicartId) => {
return dispatch => {
fetch('http://magento2.inchoo4u.net/rest/V1/guest-carts/' + minicartId + '/totals')
.then(response => response.json())
.then(data => dispatch(storeCartInfo(data)))
}
};
/*
ADD TO CART
*/
export const storeToCart = (res) => {
return {
type: addToCart,
result: res
};
};
export const addToCart = (minicartId,itemid,sku) => {
return dispatch => {
fetch('http://magento2.inchoo4u.net/rest/V1/guest-carts/' + minicartId + '/items', {
method: 'POST',
body: JSON.stringify({cartItem: {quoteId: minicartId,sku: sku, qty:1}}),
headers: new Headers({
'Content-Type': 'application/json'
})
})
.then(response => response.json())
.then(data => {
dispatch(getCartItems(minicartId,itemid,sku));
dispatch(getCartInfo(minicartId));
});
}
};
/*
REMOVE FROM CART
*/
export const storeFromCart = (res) => {
return {
type: removeFromCart,
result: res
};
};
export const removeFromCart = (minicartId,itemid,sku) => {
return dispatch => {
fetch('http://magento2.inchoo4u.net/rest/V1/guest-carts/' + minicartId + '/items/' + itemid, {
method: 'DELETE'
})
.then(response => response.json())
.then(data => {
dispatch(getCartItems(minicartId,itemid,sku));
dispatch(getCartInfo(minicartId));
});
}
};
|
class Point{
//CONSTRUCTOR
constructor(x, y, size, name){
this.x = x;
this.y = height - y;//CHANGE THE COORDINATE ORIENTATION TO LEFT BOTTOM SIDE OF THE SCREEN
this.size = size;
this.name = name;
}
drawPoint(){
//MAKE THE POINT DRAGGABLE
if(dist(this.x, this.y, mouseX, mouseY)<this.size/2){
fill(255, 255, 255);
if(mouseIsPressed){
this.x = mouseX;
this.y = mouseY;
}
}
else{
fill(101, 188, 119);
}
//DRAW A CIRCLE
stroke(255);
ellipse(this.x, this.y, this.size, this.size);
//CAPTION
fill(153, 255, 241);
textSize(16);
noStroke();
//height is always subtracted by Y just for captioning reason
text(this.name + " : (" + parseInt(this.x-(width/2)) + ", " + parseInt((height - this.y)-(height/2)) + ")" ,this.x+this.size ,this.y);
}
} |
/* eslint-env jest */
const Qs = require('qs')
const Path = require('path')
const Sequelize = require('sequelize')
const Portfinder = require('portfinder')
const { Server } = require('@hapi/hapi')
const modelsPath = Path.join(__dirname, 'fixtures', 'models')
const modelsGlob = Path.join(modelsPath, '**', '*.js')
const dbName = 'db'
// these are what's in the fixtures dir
const modelNames = [
{ Singular: 'City', singular: 'city', Plural: 'Cities', plural: 'cities' },
{ Singular: 'Team', singular: 'team', Plural: 'Teams', plural: 'teams' },
{ Singular: 'Player', singular: 'player', Plural: 'Players', plural: 'players' }
]
module.exports = () => {
const setupServer = async () => {
const sequelize = new Sequelize({ dialect: 'sqlite', logging: false })
const server = new Server({
host: '0.0.0.0',
port: await Portfinder.getPortPromise(),
query: {
parser: (query) => Qs.parse(query)
}
})
await server.register([
{
plugin: require('hapi-sequelizejs'),
options: {
name: dbName,
models: [modelsGlob],
sequelize,
sync: true,
forceSync: true
}
},
{
plugin: require('../src/index.js'),
options: {
name: dbName
}
}
])
return { server, sequelize }
}
const setupModels = async (sequelize) => {
const { Player, Team, City } = sequelize.models
const city1 = await City.create({ name: 'Healdsburg' })
const team1 = await Team.create({ name: 'Baseballs', cityId: city1.id })
const team2 = await Team.create({ name: 'Footballs', cityId: city1.id })
const player1 = await Player.create({ name: 'Cat', teamId: team1.id, active: true })
const player2 = await Player.create({ name: 'Pinot', teamId: team1.id })
const player3 = await Player.create({ name: 'Syrah', teamId: team2.id })
return { city1, team1, team2, player1, player2, player3 }
}
// kill the server so that we can exit and don't leak memory
const stopServer = (server) => server.stop()
return { setupServer, setupModels, stopServer, modelNames }
}
|
import React, { Component } from 'react'
import axios from 'axios'
import {signup} from '../../actions/constante'
class Registro extends Component{
constructor(){
super()
this.state = {
nombre:'',
apellidos:'',
carrera:'',
correo:'',
password:''
}
this.inputChange = this.inputChange.bind(this)
this.registro = this.inputChange.bind(this)
}
inputChange(e){
const { value, name } = e.target;
console.log(value, name);
this.setState({
[name]: value
});
}
registro(e){
e.preventDefault();
const username = this.state.username
const password = this.state.password
const data = {
username,
password
}
axios.post(signup,data)
.then(res=>{
console.log(res);
}).
catch(err=>{
console.log(err);
})
}
render(){
return(
<div>
<form onSubmit={this.registro}>
<input type="text" name="nombre" value={this.state.nombre} onChange={this.inputChange}/>
<input type="text" name="apellidos" value={this.state.apellidos} onChange={this.inputChange}/>
<input type="text" name="carrera" value={this.state.carrera} onChange={this.inputChange}/>
<input type="text" name="correo" value={this.state.correo} onChange={this.inputChange}/>
<input type="text" name="password" value={this.state.password} onChange={this.inputChange}/>
<button>aceptar</button>
</form>
</div>
)
}
}
export default Registro |
// 转换日期对象为可读的字符串
export const formatDateToPast = (date) => {
const sec = Math.floor((new Date().valueOf() - date.valueOf()) / 1000)
if (sec < 10) {
return ('刚刚')
}
if (sec < 60) {
return (`${sec}秒前`)
}
if (sec < 60 * 60) {
const _min = Math.floor(sec / 60)
return (`${_min}分钟前`)
}
if (sec < 60 * 60 * 24) {
const _hou = Math.floor(sec / (60 * 60))
const restSeconds = Math.floor(sec % (60 * 60))
const _min = Math.floor(restSeconds / 60)
return (`${_hou}小时${_min}分钟前`)
}
if (sec < 60 * 60 * 24 * 30) {
const _day = Math.floor(sec / (60 * 60 * 24))
return (`${_day}天前`)
}
const _mon = Math.floor(sec / (60 * 60 * 24 * 30))
return (`${_mon}月前`)
}
// 格式化日期: YYYY-MM-DD HH:MM:SS
export const formatDateToString = (date, toSeconds) => {
if (!(date instanceof Date)) {
date = new Date(date)
}
const addZero = (str) => {
return str.toString().length === 1 ? `0${str}` : str
}
const y = addZero(date.getFullYear())
const m = addZero(date.getMonth() + 1)
const d = addZero(date.getDate())
let res = `${y}-${m}-${d}`
if (toSeconds === true) {
const ho = addZero(date.getHours())
const mi = addZero(date.getMinutes())
const se = addZero(date.getSeconds())
res += ` ${ho}:${mi}:${se}`
}
return res
} |
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var routes = require('./routes/index');
var api = require('./routes/api');
var users_route = require('./routes/users');
var about_route = require('./routes/about');
var url_route = require('./routes/url');
var game_route = require('./routes/game');
var test_route = require('./routes/test');
var demo_route = require('./routes/demo');
var web_lession_route = require('./routes/web_lession');
var zuowen_lession_route = require('./routes/zuowen_lession');
var h5_lession_route = require('./routes/h5_lession');
var nodejs_lession_route = require('./routes/nodejs_lession');
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
var db=require('./package/db.js');
app.use(function(req, res,next){
//get ip
var time=Date.parse(new Date());
//var ip=req.ip;
//black ip here ?
var ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
db.conn(function(){
next();
},function(){
res.send('mongodb err');
});
});
app.use('/', routes);
app.use('/api', api);
app.use('/users', users_route);
app.use('/about', about_route);
app.use('/url', url_route);
app.use('/demo', demo_route);
app.use('/test', test_route);
app.use('/game', game_route);
/* lessions */
app.use('/web', web_lession_route);
app.use('/h5', h5_lession_route);
app.use('/zuowen', zuowen_lession_route);
app.use('/nodejs', nodejs_lession_route);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
module.exports = app;
|
'use strict';
angular.module('demoApp')
.factory("manageVolumeSvc",['$http',function($http){
var manageVolumeSvc = {};
manageVolumeSvc.getManageVolumes = function(){
return $http.get(servicePath.getManageVolume)
.then(function(res){
return res.data;
})
.catch(function(err){
throw err;
});
};
manageVolumeSvc.getCategory = function(){
return $http.get(servicePath.getCategory)
.then(function(res){
return res.data;
})
.catch(function(err){
throw err;
});
};
manageVolumeSvc.deleteManageVol = function(id){
var url = servicePath.deleteManageVol + id;
return $http.post(url)
.then(function(res){
return res.data;
})
.catch(function(err){
throw err;
});
}
manageVolumeSvc.addDictionaryWord = function(manageVol){
return $http.post(servicePath.addDictionaryWord, manageVol)
.then(function(res){
return res.data;
})
.catch(function(err){
throw err;
});
};
/*manageVolumeSvc.addManageVolumes = function(manageVol){
return $http.post(path,product);
};*/
manageVolumeSvc.updateManageVolumes = function(manageVol){
return $http.post(servicePath.updateManageVol, manageVol)
.then(function(res){
return res.data;
})
.catch(function(err){
throw err;
});
};
return manageVolumeSvc;
}]) |
const url ='https://fortniteapi.io/v2/items/list?lang=en'
//const API_Key='edc47162-9716dc98-c724884c-58bb9cb9'
const API_Key='361618b4-f348534e-6616046c-7e87897f'
fetch(url, {method:'GET',
headers: {'Authorization': API_Key}})
.then((result)=>{
result.json().then(function(result){
document.getElementById('loding').style.visibility='hidden'
//const types=['backpack','bannertoken','bundle','contrail','cosmeticvariant','emoji','emote','glider','loadingscreen','music','outfit','pet','pickaxe','spray','toy','wrap']
//console.log(result.items)
var container = document.getElementById("items-container");
const addItems=(i)=>{
var border= result.items[i].rarity.name.toLocaleLowerCase()==='uncommon'?'handmade': result.items[i].rarity.name.toLocaleLowerCase();
var html=`<a class="fortnite-db-item fortnite-db-item--large-text fortnite-db-item--%rarity% " style="grid-column: span 1;" href="/details?id=%id%" id="%id%"><img loading="lazy" class="fortnite-db-item__image" src="%img%" alt="fortnite shop item" /><div class="fortnite-db-item__details"><div class="fortnite-db-item__name" >%name%</div><div class="fortnite-db-item__price"><img loading="lazy" src="https://cdn.thetrackernetwork.com/cdn/trackernetwork/3C7Avbucks.png" alt="2000 v-bucks" /> <span>%price%</span></div></div><div class="fortnite-db-item__rating"><i class="ion ion-star"></i> %star%</div></a>`;
//console.log(result.items[i])
nwHtml=html.replace('%id%', result.items[i].id);
// src of the image
if(result.items[i].images)
nwHtml=nwHtml.replace('%img%', result.items[i].images.icon);
//change border style
nwHtml=nwHtml.replace('%rarity%',border)
nwHtml=nwHtml.replace('%name%', result.items[i].name)
nwHtml=nwHtml.replace('%title%', result.items[i].name)
nwHtml=nwHtml.replace('%price%', result.items[i].price)
//if(result.items[i].interest)
nwHtml=nwHtml.replace('%star%', result.items[i].interest.toFixed(2)<=0?0:result.items[i].interest.toFixed(2))
container.innerHTML+=nwHtml;
}
const showItems=(start,n,type,rarity)=>{
if(rarity&&type)
{
for(let i=start;i<=n;i++)
if(type==result.items[i].type.id)
{
if (result.items[i].rarity){
if(rarity==result.items[i].rarity.id.toLocaleLowerCase())
addItems(i)
}
}
}
else if(type)
{//console.log(type)
for(let i=start;i<=n;i++)
if(type==result.items[i].type.id)
addItems(i)
}
else if(rarity)
{
//console.log(rarity)
for(let i=start;i<=n;i++)
{
if (result.items[i].rarity){
if(rarity==result.items[i].rarity.id.toLocaleLowerCase())
addItems(i)
}
}
}
else
for(let i=start;i<=n;i++)
addItems(i)
}
showItems(0,101)
var nItems=100,start,type,rarity;
document.getElementById('LoadMore').addEventListener('click',()=>{
if(rarity&&type)
{
start=nItems+1
nItems=start+200;
showItems(start,nItems,type,rarity)
}
start=nItems+1
nItems=start+200;
showItems(start,nItems,type,rarity)
})
document.getElementById('filter-category-type').addEventListener('change',()=>{
type =document.getElementById('filter-category-type').value
start=0
nItems=start+200;
// clear the page for the new type only
if(type)
container.innerHTML=" "
showItems(start,nItems,type,rarity)
})
document.getElementById('filter-category-rarity').addEventListener('change',()=>{
rarity =document.getElementById('filter-category-rarity').value
start=0
nItems=start+200;
// clear the page for the new type only
if(rarity)
container.innerHTML=" "
showItems(start,nItems,type,rarity)
})
document.getElementById('itemName').addEventListener('change',()=>{
const searchig=document.getElementById('searhing')
itemName =document.getElementById('itemName').value
searchig.style.visibility='visible'
var index=0
var item = result.items.find(item=>{
index++;
return item.name==itemName
})
document.getElementById('itemName').value=""
if(item)
{
searchig.style.visibility='hidden'
container.innerHTML=" "
addItems(index-1)
return
}
searchig.textContent=" Not Found !!!"
})
}).catch((e)=>{
console.log(e)
})
})
|
import 'bootstrap/dist/css/bootstrap.css';
import 'bootstrap/dist/css/bootstrap-theme.css';
import './index.css';
import './TodoList/style/base.css';
// React
import React, { PropTypes } from 'react';
import TodoList from './TodoList/TodoListContainer';
const RootComponent = (router)=><TodoList router={router} />;
import { Provider } from 'react-redux';
import { browserHistory, BrowserRouter as Router, Route } from 'react-router-dom';
const Root = ({store}) => (
<Provider store={store}>
<Router history={browserHistory}>
<Route path='/' component={RootComponent} />
</Router>
</Provider>
);
Root.propTypes = {
store: PropTypes.object.isRequired,
};
import { createStore } from 'redux';
import reducers from './reducers';
const store = createStore(reducers, {},
window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__());
import ReactDOM from 'react-dom';
ReactDOM.render(<Root store={store} />,document.getElementById('app'));
|
/**
* The MIT License (MIT)
* Copyright (c) 2016, Jeff Jenkins.
*/
const AppDispatcher = require('../dispatcher/AppDispatcher');
const Constants = require('../constants/Constants');
const SearchApi = require('../api/SearchApi');
const Actions = {
/**
* @param {number} start
* @param {number} skip
*/
getList: function(count, skip, q, clearStore) {
SearchApi.getEntityListData(count, skip, q);
if (clearStore){
AppDispatcher.dispatch({actionType: Constants.CLEAR_SEARCH_DATA})
}
},
};
module.exports = Actions;
|
// function listen() {
// var element = document.getElementById("viewkey");
// var xhr = new XMLHttpRequest();
// xhr.open("GET", "http://localhost:12909/?viewKey=" + element.value, true);
// xhr.responseType = 'arraybuffer';
// xhr.onload = function () {
// playAudio(xhr.response);
// }
// xhr.send();
// }
function search(){
var element = document.getElementById('search');
var url = getSearchUrl(element.value, 'video');
console.log(url);
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.onload = function(){
var result = JSON.parse(xhr.response);
console.log(result);
var audioInfo = result.items[0];
var audioPath = 'https://www.youtube.com/watch?v=' + audioInfo.id.videoId;
document.getElementById('viewkey').value = audioPath;
listen();
}
xhr.send();
}
function playAudio(buffer) {
console.log(buffer);
var audioCtx = new (window.AudioContext || window.webkitAudioContext)();
audioCtx.decodeAudioData(buffer, function (data) {
var src = audioCtx.createBufferSource();
src.buffer = data;
src.connect(audioCtx.destination);
src.start(0);
});
return audioCtx;
}
function listen(){
var element = document.getElementById("viewkey");
var connection = new WebSocket('ws://localhost:12909');
connection.onopen = function(){
connection.send("http://localhost:12909/?viewKey=" + element.value);
}
connection.onerror = function (error) {
// just in there were some problems with connection...
alert(error);
};
var sum = 0;
var audioCtx = new AudioContext();
connection.binaryType = 'arraybuffer';
connection.onmessage = function (message) {
//TO DO - Handle chunks
sum+=message.data.byteLength;
//playAudio(message.data);
console.log(sum);
};
}
|
export * from './dom.functions.js';
export * from './html.function.js';
export * from './new-guid.function.js'; |
import React, { PureComponent } from 'react';
import PropTypes from "prop-types"
export default class TestMessageMarkup extends PureComponent {
render() {
const {message, title} = this.props;
return (
<div>
<div className="title">{title}</div>
{message && <div className="error">{message}</div>}
</div>
)
}
}
TestMessageMarkup.propTypes = {
message: PropTypes.string,
title: PropTypes.string.isRequired
}; |
function solve(args) {
args = args.map(Number);
for(let i = 0; i < args.length; i++){
let currentNumber = args[i];
let number = Math.log2(currentNumber);
console.log(number);
}
} |
const router = require("express").Router();
const withAuth = require("../../middleware/authentication");
const {
getAllImgPost,
getAllPostImg,
newImgPost
} = require("../../controllers/imgpost")
router
.route("/")
.post(withAuth, newImgPost);
router
.route("/post/:postid")
.get(withAuth, getAllImgPost)
router
.route("/Img/:imgid")
.get(withAuth, getAllPostImg);
module.exports = router; |
const { RichEmbed } = require("discord.js");
var { guild, createNewGuildEntry } = require("database.js");
module.exports = (client, banGuild, user) => {
guild.findById(banGuild.id, "eventlog", async (error, guildTable) => {
if (error) return 1;
if (!guildTable) {
createNewGuildEntry(banGuild.id);
return 0;
}
if (!guildTable.eventlog.ban) return 0;
let channel = banGuild.channels.get(guildTable.eventlog._id);
if (!channel) return 0;
let embed = new RichEmbed()
.setAuthor(user.username, user.displayAvatarURL)
.setTitle("Ban | Banido")
.addField("Usuário:", user, true)
.addField("Tag:", user.tag, true)
.setColor("C50404")
.setThumbnail(user.displayAvatarURL)
.setFooter(`ID: ${user.id}`, banGuild.iconURL)
.setTimestamp();
channel.send(embed).catch(()=>{});
});
}; |
var cuarto= new Array();
var contador=0;
/*------------variables globales---------*/
function habitacion(numero,entrada,salida,status)
{
this.numero=numero;
this.entrada=entrada;
this.salida=salida;
this.status=status;
}
/*----------creacion de objeto--------*/
$(document).on('ready',inicia);
function inicia()
{
$("select.status").on('change',status);
$("div.mostrar p").on('click',oculta);
}
function status()
{
var entrada=$(this).parent().parent().children('div.fechas').children('input#entrada').val();
var salida=$(this).parent().parent().children('div.fechas').children('input#salida').val();
var numeroCuarto=$(this).parent().parent().children('div.fechas').children('p.numero').text();
var estado=$(this).val();
cuarto[contador]= new habitacion(numeroCuarto,entrada,salida,estado);
contador++;
}
function oculta()
{
var opcion=$(this).data('opcion');
for(x in cuarto)
{
//console.log(cuarto[x]);
if(cuarto[x].status==opcion)
{
var y=(cuarto[x].numero)-1;
console.log($('section.habitaciones article')[y].style.display="none");
//var room=$('section.habitaciones article')[y];
//console.log(room);
}
//console.log($('section.habitaciones article'));
}
} |
import React, {Component} from 'react';
import {
StyleSheet,
TouchableOpacity,
TextInput,
View
} from 'react-native';
import {
Button,
Container,
Content,
Card,
CardItem,
Left,
Right,
Center,
Body,
Thumbnail,
Spinner,
Icon,
Header,
Text,
Form,
Item,
Label,
Input
} from 'native-base';
import {
compose,
defaultProps,
setPropTypes,
withState,
withProps,
withHandlers,
lifecycle
} from 'recompose';
import { bindActionCreators } from 'redux';
import {connect} from 'react-redux';
import { addMacAddres as addMacAddresAction } from '../login.action';
console.log();
const mapStateToProps = ({ loginReducers }) => ({ loginReducers });
const mapDispatchToProps = dispatch => bindActionCreators({ addMacAddres: addMacAddresAction }, dispatch);
const styles = StyleSheet.create({
bigblue: {
color: 'blue',
fontWeight: 'bold',
fontSize: 30,
},
red: {
color: 'red',
},
button: {
width: 150,
height: 100,
alignItems: 'center',
justifyContent: 'center'
}
});
const enhance = compose(
connect(mapStateToProps, mapDispatchToProps),
withState('password', 'setPassword', ''),
withState('login', 'setLogin', ''),
withHandlers({
_onPressButton: (params) => () => {
console.log(params);
console.log(this.state);
// const fileContents = await FileSystem.readFile('my-directory/test.txt');
// console.log(`read from file: ${fileContents}`);
const { navigate } = this.props.navigation;
this.props.selectMacAddres('eeeeee');
navigate('Home');
console.log("Post");
},
onLogin: ({ navigation, login, password, addMacAddres }) => () => {
console.log('navigation, login, password ', navigation, login, password );
fetch(`http://192.168.0.107:3000/user`, {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
login: login,
password: password,
})
}).then((response) => {
if(response._bodyInit) {
const jsonData = JSON.parse(response._bodyInit);
const mac = jsonData[0].mac;
addMacAddres(mac);
const { navigate } = navigation;
navigate('Home');
// getParams
// const { navigate } = navigation;
// navigate('Home');
}
}).catch((error) => {
console.log('navigation, login, password ', navigation, login, password );
console.error(error);
});
}
})
);
const Login = ({
navigation,
setLogin,
setPassword,
onLogin,
_onPressButton
}) => (
<Container>
<Content>
<Item style={{ alignSelf: "center", width: 300, marginTop: 10}}>
<Input
placeholder="Login"
onChangeText={(login) => setLogin({login})}
/>
</Item>
<Item style={{ alignSelf: "center", width: 300, margin: 10}}>
<Input
style={{ alignSelf: "center", width: 300, margin: 2}}
placeholder="Password"
onChangeText={(password) => setPassword({password})}
/>
</Item>
<View>
<Button style={{ alignSelf: "center", width: 300, margin: 10}} onPress={() =>_onPressButton()} block info>
<Text>Login</Text>
</Button>
</View>
<View>
<Button style={{ alignSelf: "center", width: 300, margin: 10}} onPress={() => onLogin()} block info>
<Text>Login</Text>
</Button>
</View>
</Content>
</Container>
);
export default enhance(Login);
|
DB.message_all.deny(
{'insert' :
function(userID, doc) {
if (doc.type === 'dice') {
var amount = doc.amount
, face = doc.face
, result = []
;
while ((amount -= 1) >= 0) {
result.push( Math.floor( ( Math.random() * face ) + 1 ) );
}
delete doc.amount;
doc.result = result;
}
return false;
}
}
);
/*
Meteor.methods(
{'rollDice' :
function(data) {
var user = this.userId;
if (data && Array.isArray(data.dices)) {
data.dices.forEach(function(v, k, a) {
var dice =
{'_id' : Date.now()
,'room' : data.room
,'user' : user
,'type' : 'dice'
,'chapter' : data.chapter
,'section' : data.section
,'who' : data.who
,'isHide' : data.isHide
}
, dices = v.dice
, face = v.face
, result = []
;
dice.name = v.name;
dice.note = v.note;
dice.face = face;
dice.addEach = v.addEach;
while ((dices -= 1) >= 0) {
result.push( Math.floor( ( Math.random() * face ) + 1 ) );
}
dice.result = result;
dice.add = v.add;
dice.extra = v.extra;
DB.message.insert(dice);
});
return true;
}
return false;
}
}
)
*/ |
module.exports = {
parser: 'babel-eslint',
extends: ['airbnb', 'prettier', 'prettier/react'],
plugins: ['prettier', 'react-hooks'],
env: {
browser: true,
mocha: true,
},
rules: {
'react/prop-types': 'off',
'consistent-return': 'off',
'import/named': 'off',
'no-plusplus': 'off',
'no-console': 'off',
'comma-dangle': 'off',
'import/prefer-default-export': 'off',
'import/no-extraneous-dependencies': 'off',
'jsx-a11y/click-events-have-key-events': 'off',
'jsx-a11y/no-static-element-interactions': 'off',
'jsx-a11y/no-noninteractive-element-interactions': 'off',
'jsx-a11y/anchor-is-valid': 'off',
'jsx-a11y/label-has-associated-control': 'off',
'no-prototype-builtins': 'off',
'react/no-danger': 'off',
'react/state-in-constructor': 'off',
'no-unused-vars': 'off',
'react/no-unused-state': 'off',
'react/display-name': [
1,
{
ignoreTranspilerName: true,
},
],
'react/jsx-props-no-spreading': 'off',
'react/no-unescaped-entities': 'off',
'react/no-multi-comp': [
2,
{
ignoreStateless: true,
},
],
'react/jsx-fragments': 'off',
'react/forbid-prop-types': 'off',
'react/require-default-props': 'off',
'react/prefer-stateless-function': 0,
'react/no-array-index-key': 0,
'react/jsx-filename-extension': [
1,
{
extensions: ['.js', '.jsx'],
},
],
'prettier/prettier': [
'error',
{
trailingComma: 'es5',
singleQuote: true,
printWidth: 120,
},
],
},
parserOptions: {
ecmaVersion: 6,
sourceType: 'module',
ecmaFeatures: {
experimentalObjectRestSpread: true,
jsx: true,
},
},
}; |
import React from "react";
import { useHistory } from "react-router-dom";
import ClientModalComponent from "../../components/modal_clients_admin/index";
import EmpresasModalComponent from "../../components/modal_empresas_admin/index";
import { logout } from "../../service/auth";
import "./admsidebar.css";
import logo from "../../assets/logo.svg";
export default function AdmSideBar() {
const history = useHistory();
async function exitLogout() {
logout();
history.push("/");
}
return (
<aside className="app-sidebar">
<p>
<img src={logo} alt="logo rdp" />
<div className="buttonCadastro">
<ClientModalComponent />
<div className="buttonCadastro">
<EmpresasModalComponent />
</div>
</div>
</p>
<footer>
<button type="button" onClick={exitLogout}>
Logout
</button>
</footer>
</aside>
);
}
|
import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import GridItem from "components/Grid/GridItem.js";
import GridContainer from "components/Grid/GridContainer.js";
import Button from "@material-ui/core/Button";
import Card from "components/Card/Card.js";
import CardHeader from "components/Card/CardHeader.js";
import CardAvatar from "components/Card/CardAvatar.js";
import CardBody from "components/Card/CardBody.js";
import { observer, inject } from "mobx-react";
import { CircularProgress } from "@material-ui/core";
import Table from "components/Table/Table.js";
import ReportsTable from "../ReportsTable/ReportsTable"
import DeleteUserDialog from "views/Dialog/DeleteUserDialog";
import UserDetail from './AdminUserDetail'
import boyAvatar from "assets/img/boy.png";
import girlAvatar from "assets/img/girl.png"
const AdminUsersPage = inject("store")(
observer((props) => {
const classes = useStyles();
const handleUserDetailOpen = (targetUserId) => (e) => {
const targetUser = props.store.users.find((user) => {
return user.id == targetUserId
})
props.store.set(
"targetUserForDetails",
targetUser
)
props.store.set(
"isUserDetailsOpen",
true
)
}
const handleUserDelete = () => {
props.store.set(
"isDeleteUserOpen",
true
)
}
const getUserImage = (id) => {
if (id % 2 == 0){
return boyAvatar
} else {
return girlAvatar
}
}
return (
<div>
<GridContainer>
<GridItem xs={12} sm={12} md={12}>
<Card>
<CardHeader color="warning">
<h4 className={classes.cardTitleWhite}>
{cardTitle}
</h4>
<p className={classes.cardCategoryWhite}>
{`업데이트 - ${new Date().toLocaleDateString()}`}
</p>
</CardHeader>
<CardBody>
{props.store.loadingUsers ?
<CircularProgress />
:
<Table
openDetail={handleUserDetailOpen}
tableHeaderColor="warning"
tableHead={usersTableHeadColumns}
tableData={props.store.users.map((user) => {
return [
user.id,
user.name,
user.email,
user.reports.length,
new Date(user.created_time).toLocaleDateString(),
]
})}
/>
}
</CardBody>
</Card>
</GridItem>
{props.store.isUserDetailsOpen &&
<UserDetail></UserDetail>}
</GridContainer>
</div>
);
}))
export default AdminUsersPage;
const usersTableHeadColumns = [
"이름",
"email",
"신고 횟수",
"가입 시각"
]
const cardTitle = "전체 사용자"
const styles = {
cardCategoryWhite: {
color: "rgba(255,255,255,.62)",
margin: "0",
fontSize: "14px",
marginTop: "0",
marginBottom: "0"
},
cardTitleWhite: {
color: "#FFFFFF",
marginTop: "0px",
minHeight: "auto",
fontWeight: "300",
fontFamily: "'Roboto', 'Helvetica', 'Arial', sans-serif",
marginBottom: "3px",
textDecoration: "none"
}
};
const useStyles = makeStyles(styles);
|
import _ from 'lodash';
import { connect } from 'react-redux';
import Tasks from './TasksComponent';
const filterTasks = ({ tasks, searchFilter }) => {
const { query, showDone } = searchFilter;
const re = new RegExp(query, "i");
const customFilter = (task) => {
const matchDescription = !!query ? task.description.match(re) : true;
const matchDone = showDone || showDone === task.done;
const hasPassed = matchDescription && matchDone;
return hasPassed;
}
return _.filter(tasks, customFilter);
}
// State of the Aplication
const mapStateToProps = (state, props) => {
const { searchFilter, selectedCategory } = props;
let tasksListData = [];
if (selectedCategory) {
const tasks = props.tasks.getByCategoryId(selectedCategory.id);
tasksListData = filterTasks({ searchFilter, tasks });
}
return { tasksListData };
}
// Actions of the application
const mapDispatchToProps = (dispatch) => ({})
const TasksContainer = connect(mapStateToProps,mapDispatchToProps)(Tasks);
export default TasksContainer;
|
angular.module('gamificationEngine.home', [])
.controller('HomeCtrl', function ($scope, $rootScope, $window, $uibModal, gamesFactory, utilsFactory) {
$rootScope.currentNav = 'home';
$rootScope.currentGameId = 1;
// Error alerts object
$scope.alerts = {
'loadGameError': false,
'error': false
};
// Load games
gamesFactory.getGamesByDomain().then(function () {
$rootScope.games.forEach(function (g) {
g.terminated = g.expiration && g.expiration <= new Date().getTime();
});
}, function () {
// Reject: show error alert
$scope.alerts.loadGameError = true;
});
$scope.deleteGame = function (game) {
// Delete a game
var modalInstance = $uibModal.open({
templateUrl: 'modals/modal_delete_confirm.html',
controller: 'DeleteGameConfirmModalInstanceCtrl',
backdrop: "static",
resolve: {
game: function () {
return game;
}
}
});
};
$scope.cloneGame = function (game) {
var g = angular.copy(game);
g.id = null;
var fields = {};
fields.name = game.name + '_cloned';
fields.expiration = game.expiration && game.neverending ? game.expiration.getTime() : undefined;
// Edit game
gamesFactory.editGame(g, fields).then(
function (data) {
g.name = data.name;
g.id = data.id;
gamesFactory.saveGame(g).then(function () {
$rootScope.games[0] = g;
$scope.alerts.error = false;
}, function () {
$scope.alerts.error = true;
});
},
function (message) {
$scope.alerts.error = true;
});
};
$scope.updateStatus = function (game) {
var g = angular.copy(game);
g.active = !g.active;
gamesFactory.saveGame(g).then(function () {
game.active = !game.active;
$scope.alerts.error = false;
}, function () {
$scope.alerts.error = true;
});
};
$scope.stopGame = function (game) {
var modalInstance = $uibModal.open({
templateUrl: 'home/modal_stop_confirm.html',
controller: 'StopGameConfirmModalInstanceCtrl',
backdrop: "static",
resolve: {
game: function () {
return game;
}
}
});
};
$scope.goto = function (path) {
$window.location.href = path;
};
});
modals.controller('StopGameConfirmModalInstanceCtrl', function ($scope, $uibModalInstance, game, gamesFactory) {
$scope.argument = game.name;
$scope.error = false;
// DELETE button click event-handler
$scope.stop = function () {
var g = angular.copy(game);
g.stopped = true;
gamesFactory.saveGame(g).then(function () {
game.stopped = true;
$uibModalInstance.close();
}, function () {
$scope.error = true;
});
};
// CANCEL button click event-handler
$scope.cancel = function () {
$uibModalInstance.dismiss('cancel');
}
});
|
var formeg = Ext.define('Layouts.view.Forms', {
extend: 'Ext.form.Panel',
xtype: 'form',
requires: [
'Ext.field.Email',
'Ext.form.FieldSet',
'Ext.field.Password',
'Layouts.store.Taxonomy',
],
config: {
title: 'Form',
iconCls: 'user',
padding: 0,
refs: {
// start: 'getstarted',
main: 'main',
},
control: {
'button[action=button_get]': {
tap: 'response_get'
},
'button[action=button_clear]': {
tap: 'response_clear'
},
'button[action=button_set]': {
tap: 'response_set'
},
'button[action=button_change]': {
tap: 'change_view'
}
},
items: [
{
xtype: 'toolbar',
title: 'Form Example'
},
{
xtype: 'fieldset',
title: 'A Form Example ...',
items: [
{
xtype: 'textfield',
label: 'Name:',
name: 'name',
// value: 'Dr Fraiser Crane'
},
{
xtype: 'emailfield',
label: 'Email:',
name: 'email',
// value: 'fcrane@kacl.org'
},
{
xtype: 'passwordfield',
label: 'Password:',
name: 'password',
// value: 'imlistening'
},
{
items: [
{
xtype: 'toolbar',
items: [
{
xtype: 'button',
text: 'Set Data',
action: 'button_set',
},
{
xtype: 'button',
text: 'Get Data',
action: 'button_get',
},
{
xtype: 'button',
text: 'Clear Data',
action: 'button_clear',
},
{
xtype: 'button',
text: 'Change View',
action: 'button_change',
}
]
}
]
}//buttons
]
}//fieldset
]
},//config
response_get: function(event){
// var values = formeg.getValues();
var values = this.getValues();
Ext.Msg.alert('Name: ' + values.name + '<br>' +
'Email: ' + values.email + '<br>' +
'Password: ' + values.password + '<br>');
// console.log('Testing GET button response: ' + values.name);
},
response_clear: function(){
console.log('Clear button responding');
this.reset();
},
response_set: function(){
var cp = Ext.create('Layouts.model.User', {
name: 'Jean-Luc Picard',
email: 'picard@enterprise@starfleet',
password: 'picard-alpha-delta-aplha',
});
this.setRecord(cp);
},
change_view: function(event){
// Ext.Viewport.push({
// xtype: 'getstarted'
// });
/*this.getMain().push({
xtype: 'getstarted'
});*/
Ext.Viewport.add(Ext.create('Layouts.store.Taxonomy'));
console.log('Change-View button responding!');
}
}); |
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");
var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers .start;
handle["/upload"] = requestHandlers .upload;
handle["/test.js"] = requestHandlers.testJS;
handle["/jquery-2.1.0.min.js"] = requestHandlers.jquery;
handle["/ajaxServer.js"] = requestHandlers.ajaxServer;
handle["/test.json"] = requestHandlers.testjson;
server.start(router.route, handle);
|
import React, { Component } from 'react'
import { Segment, Input, List, Checkbox, Radio, Icon } from 'semantic-ui-react'
import { QuestionsTypes } from './../../services/questionTypes'
class ChoiseQuestion extends Component {
constructor() {
super();
this.state = {
title: '',
isRequired: false,
answers: [],
}
}
componentWillMount() {
this.setState({
title: this.props.question.title,
isRequired: this.props.question.isRequired,
answers: this.props.question.answers,
})
}
titleHandler = (e) => {
this.setState({ title: e.target.value });
this.props.questionInfoHandler(this.props.index, 'title', e.target.value);
}
// requiredHandler = (e) => {
// this.setState({ isRequired: e.target.checked });
// this.props.questionInfoHandler(this.props.index, e.target.checked);
// }
answersHandler = (index) => (e) => {
let answers = this.state.answers;
answers[index] = e.target.value;
this.setState({ answers: answers });
this.props.questionInfoHandler(this.props.index, 'answers', answers)
}
addAnswer = () => {
let answers = this.state.answers;
answers.push('');
this.setState({ answers: answers });
this.props.questionInfoHandler(this.props.index, 'answers', answers)
}
removeAnswer = (index) => (e) => {
let answers = this.state.answers;
answers.splice(index, 1);
this.setState({ answers: answers });
}
render() {
return (
<Segment>
<Input fluid
placeholder='Question title'
value={this.state.title}
onChange={this.titleHandler}
/>
<List>
{this.state.answers.map((answer, index) =>
(<List.Item key={index} className='value-list-item'>
{
this.props.question.type === QuestionsTypes.SINGLE
? (<Radio disabled />)
: (<Checkbox disabled />)
}
<Input
value={answer}
placeholder='Value'
onChange={this.answersHandler(index)}
/>
<Icon name='minus' onClick={this.removeAnswer(index)} />
</List.Item>)
)}
<Icon name='plus' onClick={this.addAnswer} />
</List>
</Segment>
)
}
}
export default ChoiseQuestion;
|
import * as React from 'react';
import Src from './src';
export default Src; |
import React from 'react';
import EachUserSkills from './eachuserskills'
class RenderUsers extends React.Component {
state={
profile: false
}
renderSkills = () => {
return this.props.user.skills.map((skill, index) => <EachUserSkills
skillInfo={this.skillInfo}
key={index}
skill={skill}
user_id={this.props.user.id} />)
}
skillInfo = (info) => {
console.log(info)
}
render() {
const {username,first_name,last_name, avalability} = this.props.user
return (
<div className="eachPersonOnHomePage">
<h1>{username} </h1>
<p>Name: {first_name} {last_name}</p>
<p>Avalability : {avalability}</p>
{this.renderSkills()}
<button className="glow-on-hover" type="button" onClick={()=> this.props.profile(this.props.user)}>view profile </button>
</div>
)
}
}
export default RenderUsers;
|
/**
* JSON转换为图片
* @param {object, string} json 需要转转为图片的字符串
*/
function jsonToImg(json) {
var strData = JSON.stringify(json)
// 编码
var uint8array = (new TextEncoder('utf-8')).encode(strData);
// 计算存储数据需要的图片尺寸
var dataSize = Math.ceil(Math.sqrt(uint8array.length / 3));
if(dataSize > 255){
console.warn('数据长度超出范围')
return
}
// 创建类型数组
var paddedData = new Uint8ClampedArray(dataSize * dataSize * 4);
var idx = 0;
for (var i = 0; i < uint8array.length; i += 3) {
// 返回给定的起始和结束索引之间的元素组成的新的类型化数组
var subArray = uint8array.subarray(i, i + 3);
// 读取一个指定数组中的元素保存到格式化数组中
paddedData.set(subArray, idx);
// alpha 通道
paddedData.set([255], idx + 3);
idx += 4;
}
// 创建图片
var imageData = new ImageData(paddedData, dataSize, dataSize);
var imgSize = 256;
var canvas = document.createElement('canvas');
canvas.width = canvas.height = imgSize;
var ctx = canvas.getContext('2d');
ctx.fillStyle = '#AA0000';
ctx.fillRect(0, 0, imgSize, imgSize);
// 保存数据大小
// todo 可以把偏移量也设置进去
ctx.fillStyle = 'rgb(' + dataSize + ',0,0)';
ctx.fillRect(0, 0, 1, 1);
ctx.putImageData(imageData, 0, 1);
// 下载图片
let aLink = document.createElement('a')
aLink.style.display = 'none'
aLink.setAttribute('id', 'hiddenLink')
aLink.setAttribute('href', canvas.toDataURL())
aLink.setAttribute('download', 'image.png')
let body = document.querySelector('body')
body.append(aLink)
var link = document.querySelector('#hiddenLink');
link.click();
link.remove();
}
/**
* 讲图片转换为JSON
* @param {object, string} src 图片的地址或者arrayBuffer
*/
function imgToJson(src) {
var img = new Image();
if (typeof src === 'object') {
let base64string = arrayBufferToBase64(src);
img.src = 'data:image/png;base64,' + base64string
} else {
img.src = src
}
return new Promise(function (resolve, reject) {
img.onload = function () {
var imgSize = img.width;
var canvas = document.createElement('canvas');
canvas.width = canvas.height = imgSize;
var ctx = canvas.getContext('2d');
ctx.drawImage(img, 0, 0);
var headerData = ctx.getImageData(0, 0, 1, 1);
var dataSize = headerData.data[0];
var imageData = ctx.getImageData(0, 1, dataSize, dataSize);
var paddedData = imageData.data;
var uint8array = new Uint8Array(paddedData.length / 4 * 3);
// 取出保存的数据
var idx = 0;
for (var i = 0; i < paddedData.length - 1; i += 4) {
var subArray = paddedData.subarray(i, i + 3);
uint8array.set(subArray, idx);
idx += 3;
}
var includeBytes = uint8array.length;
for (var i = uint8array.length - 1; i > 0; i--) {
if (uint8array[i] == 0) {
includeBytes--;
} else {
break;
}
}
var data = uint8array.subarray(0, includeBytes);
var strData = (new TextDecoder('utf-8')).decode(data);
resolve(JSON.parse(strData))
};
})
}
// 计算字符串的大小
const byteSize = str => new Blob([str]).size;
/**
* ArrayBuffer To Base64
* @param {buffer} buffer ArrayBuffer
*/
function arrayBufferToBase64(buffer) {
var binary = '';
var bytes = new Uint8Array(buffer);
var len = bytes.byteLength;
for (var i = 0; i < len; i++) {
binary += String.fromCharCode(bytes[i]);
}
return window.btoa(binary);
}
/**
* Base64 To ArrayBuffer
* @param {string} base64 Base64 string
*/
function base64ToArrayBuffer(base64) {
var binary_string = window.atob(base64);
var len = binary_string.length;
var bytes = new Uint8Array(len);
for (var i = 0; i < len; i++) {
bytes[i] = binary_string.charCodeAt(i);
}
return bytes.buffer;
}
export {
imgToJson
}
export default jsonToImg |
import { combineReducers } from 'redux';
import mainReducers from '../apps/main/reducers';
const RESET_STATE = 'RESET_STATE';
const appReducers = combineReducers({
...mainReducers,
});
/**
* Reset all state of all reducers.
* */
const rootReducer = (state, action) => {
if (action.type === RESET_STATE) {
state = undefined;
}
return appReducers(state, action);
};
export default rootReducer;
|
'use strict';
import express from 'express';
import debug from 'debug';
import parser from 'body-parser';
import * as config from './config';
import {api, logger, error, notfound} from './routes';
import db from './db';
const log = debug('server');
const app = express();
const port = config.port;
// module wide properties
app.locals.db = db(config);
// middleware
app.use(parser.json());
// server routes
app.use(logger);
app.use(express.static(config.ui));
app.use('/api', api);
app.use(notfound);
app.use(error);
// engage and export the server
const server = app.listen(port, () => log(`listening on port ${port}`));
export default server; |
const Text = function(s) {
this.value = s;
};
Text.prototype.line = function(a) {
this.value += "\n" + a;
return this;
};
Text.prototype.toString = function() {
return this.value;
};
const phrase = new Text("Черепашка")
.line("по имени")
.line("Наташка");
console.log(`*${phrase}*`);
|
// Import express
const express = require("express");
// Import upload-controller
const tracingRoutes = require("./../controllers/tracing-controller");
// Create router
const router = express.Router();
router.get('/:ssn/search',tracingRoutes.searchBySsn);
router.get('/:studentId/report',tracingRoutes.getContactTracingReport);
// Export router
module.exports = router;
|
const INPUT_CHANGED = 'red1/INPUT_CHANGED';
const initialState = {
oldInput: 'ORIGINAL TEXT'
}
export default function reducer(state=initialState, action) {
console.log('action: ', action);
switch(action.type) {
case INPUT_CHANGED:
return {
oldInput: action.payload
}
default:
return state;
}
}
export function sendToStore(red1) {
console.log('red1: ', red1);
return {
type: INPUT_CHANGED,
payload: red1
}
}
|
var init_8h =
[
[ "init_config", "init_8h.html#a010347bb26a5857fdac5430b85cfaab0", null ],
[ "mutt_command_complete", "init_8h.html#ad41f1b6fbd5aeeee1bfc56f620ff0f44", null ],
[ "mutt_extract_token", "init_8h.html#a0c8965a76cc79c02268a42a859968bcb", null ],
[ "mutt_get_hook_type", "init_8h.html#a2b5a9a2f2f93e047f07ee4d095e39b3e", null ],
[ "mutt_init", "init_8h.html#aadc99134446d4162844e0a8d103df18b", null ],
[ "mutt_label_complete", "init_8h.html#a5a8b0c83a6dcb7d57edae458041869ad", null ],
[ "mutt_nm_query_complete", "init_8h.html#a17d5ac51e166d61b729ebdd66cd25c88", null ],
[ "mutt_nm_tag_complete", "init_8h.html#a8f739fa0c68ded6e209f2ceccd9bcfdf", null ],
[ "mutt_opts_free", "init_8h.html#aa49c5a3aa046da11a3df8924443c1732", null ],
[ "mutt_parse_rc_buffer", "init_8h.html#a2a463ed3c7fe921eb96c06d32c4ba0bc", null ],
[ "mutt_parse_rc_line", "init_8h.html#a136d8ba552e1a6f982e8349e0629ee8d", null ],
[ "mutt_query_variables", "init_8h.html#a77ec94a99800475c38871a7b67a43ecb", null ],
[ "mutt_var_value_complete", "init_8h.html#a173ae67a86a1c7bfc88e98a0edbe514f", null ]
]; |
import React,{createContext, useReducer} from 'react'
import dataReducer from './dataReducer'
import axios from 'axios'
import { v4 as uuidv4 } from 'uuid';
const initialState = {
datas:[],
singleData:{},
loading:true,
message:null,
alert:[],
error:{}
}
export const dataApi = createContext(initialState)
export const GlobalData = ({children}) =>{
const [state, dispatch] = useReducer( dataReducer , initialState)
function setAlert(msg, alertType, timeout = 3000){
const id = uuidv4();
dispatch({
type:'SET_ALERT',
payload:{ msg , alertType,id}
})
setTimeout(()=> dispatch({
type: 'REMOVE_ALERT',
payload:id
}), timeout)
}
async function getData(){
try {
const {data} = await axios.get('/data')
dispatch({
type:'GET_DATA',
payload:data.rows
})
} catch (error) {
dispatch({
type:'DATA_ERROR',
payload:error
})
}
}
async function getSingleData(id){
try {
const {data} = await axios.get('/data/single/'+id)
dispatch({
type:'SINGLE_DATA',
payload:data
})
} catch (error) {
dispatch({
type:'DATA_ERROR',
payload:error
})
}
}
async function editData(newdata){
const config = {
headers:{
'Content-Type':'application/json'
}
}
try {
const {data} = await axios.post('/data/edit',newdata, config)
dispatch({
type:'EDIT_DATA',
payload:data
})
setAlert('Data Updated', 'success')
} catch (error) {
dispatch({
type:'DATA_ERROR',
payload:error
})
}
}
async function postData(newdata){
const config = {
headers:{
'Content-Type':'application/json'
}
}
try {
const {data} = await axios.post('/data',newdata, config)
dispatch({
type:'POST_DATA',
payload:data
})
setAlert('New Data Inserted', 'success')
} catch (error) {
dispatch({
type:'DATA_ERROR',
payload:error
})
}
}
async function deletelData(id){
try {
await axios.delete('/data/delete/'+id)
dispatch({
type:'DEL_DATA',
payload:id
})
setAlert('Data Deleted', 'danger')
} catch (error) {
dispatch({
type:'STUDENT_ERROR',
payload:error
})
}
}
return (
<dataApi.Provider value={{
getData,
datas:state.datas,
getSingleData,
singleData: state.singleData,
editData,
loading:state.loading,
postData, deletelData, setAlert,
alerts: state.alert
}}>
{children}
</dataApi.Provider>
)
} |
module.exports = function (pages) {
pages.declare('index-page', function (params) {
var options = params.options;
return {
block: 'page',
title: 'Index page',
styles: [
{url: options.assetsPath + '.css'}
],
scripts: [
{url: options.assetsPath + '.' + params.lang + '.js'}
],
body: []
};
});
};
|
import React, {Component} from "react";
import "./style.css";
import { Form, FormGroup, Label, Input, FormText, Button } from "reactstrap";
class PetFormMedical extends Component {
continue = e => {
e.preventDefault();
this.props.nextStep();
};
back = e => {
e.preventDefault();
this.props.prevStep();
}
render() {
const { values, handleChange } = this.props;
return (
<React.Fragment>
<FormGroup>
<Label for="insurance">Insurance: </Label>
<Input type="text" name="insurance" id="insurance" onChange={handleChange('insurance')} defaultValue={values.insurance} placeholder="What company or plan do you have?" />
</FormGroup>
<FormGroup>
<Label for="medication">Medication: </Label>
<Input type="text" name="medication" id="medication" onChange={handleChange('medication')} defaultValue={values.medication} placeholder="Be sure to list all medications!" />
</FormGroup>
<FormGroup>
<Label for="rabiesTagNumber">Rabies Tag Number: </Label>
<Input type="number" name="rabiesTagNumber" id="rabiesTagNumber" onChange={handleChange('rabiesTagNumber')} defaultValue={values.rabiesTagNumber} />
</FormGroup>
<Button className="formBtn" onClick={this.back}>Back</Button>{" "}
<Button className="formBtn" onClick={this.continue}>Continue</Button>
</React.Fragment>
)
}
}
export default PetFormMedical; |
import React, { useRef, useEffect } from 'react'
import * as d3 from "d3";
// data manipulation function takes raw data from csv and converts it into an array of node objects
// each node will store data and visualisation values to draw a bubble
// rawData is expected to be an array of data objects, read in d3.csv
// function returns the new node array, with a node for each element in the rawData input
function createNodes(rawData) {
// use max size in the data as the max in the scale's domain
// note we have to ensure that size is a number
const maxSize = d3.max(rawData, d => +d.value);
// size bubbles based on area
const radiusScale = d3.scaleSqrt()
.domain([0, maxSize])
.range([0, 50])
// use map() to convert raw data into node data
const myNodes = rawData.map(d => ({
...d,
radius: radiusScale(+d.value),
size: +d.value,
imageWidth: radiusScale(+d.value) * 2,
imageHeight: radiusScale(+d.value) * 2,
x: Math.random() * 900,
y: Math.random() * 800
}))
return myNodes;
}
const ticked = (bubbles, labels, images) => {
bubbles
.attr('cx', d => d.x)
.attr('cy', d => d.y)
labels
.attr('x', d => d.x)
.attr('y', d => d.y)
images
.attr('x', d => d.x - (d.imageWidth / 2))
.attr('y', d => d.y - (d.imageHeight / 2))
}
const charge = (d) => {
return Math.pow(d.radius, 2.0) * 0.01
}
const BubbleGraph = (props) => {
const container = useRef(null);
let { width, height, padding, clusterPadding, maxRadius, data } = props;
useEffect(() => {
// location to centre the bubbles
const centre = { x: width / 2, y: height / 2 };
// strength to apply to the position forces
const forceStrength = 0.03;
// these will be set in createNodes and chart functions
let containerSel = null;
let svg = null;
let bubbles = null;
let labels = null;
let images = null;
let nodes = [];
// create a force simulation and add forces to it
const simulation = d3.forceSimulation()
.force('charge', d3.forceManyBody().strength(charge))
.force('center', d3.forceCenter(centre.x, centre.y))
.force('x', d3.forceX().strength(forceStrength).x(centre.x))
.force('y', d3.forceY().strength(forceStrength).y(centre.y))
.force('collision', d3.forceCollide().radius(d => d.radius + 1));
// force simulation starts up automatically, which we don't want as there aren't any nodes yet
simulation.stop();
nodes = createNodes(data);
// Get container
containerSel = d3.select(container.current);
// Remove previous svg
containerSel.select('svg').remove();
// create svg element inside provided selector
svg = containerSel
.append('svg')
.attr('width', width)
.attr('height', height)
// bind nodes data to circle elements
const elements = svg.selectAll('.bubble')
.data(nodes, d => d.id)
.enter()
.append('g');
bubbles = elements
.append('circle')
.classed('bubble', true)
.attr('r', d => d.radius)
.attr('fill', 'transparent');
// labels
labels = elements
.append('text')
.attr('dy', '.3em')
.style('text-anchor', 'middle')
.style('font-size', 10)
.attr('fill', '#fff')
.text(d => d.id)
images = elements
// .attr("transform", function(d) { return "translate(" + arc.centroid(d) + ")"; })
.append("svg:image")
.attr("xlink:href", function (d) {
if (d.image) {
return require('../../../assets/images/' + d.image);
}
return require('../../../assets/images/js.png');
})
.attr("width", d => d.imageWidth)
.attr("height", d => d.imageHeight)
.attr("x", d => d.x - d.imageWidth / 2)
.attr("y", d => d.y - d.imageHeight / 2);
const dragstarted = (d) => {
d3.event.sourceEvent.stopPropagation();
if (!d3.event.active) simulation.alphaTarget(0.3).restart();
d.fx = d.x;
d.fy = d.y;
}
const dragged = (d) => {
d.fx = d3.event.x;
d.fy = d3.event.y;
}
const dragended = (d) => {
if (!d3.event.active) simulation.alphaTarget(0);
d.fx = null;
d.fy = null;
}
bubbles.call(
d3.drag()
.on("start", dragstarted)
.on("drag", dragged)
.on("end", dragended)
);
images.call(
d3.drag()
.on("start", dragstarted)
.on("drag", dragged)
.on("end", dragended)
)
// set simulation's nodes to our newly created nodes array
// simulation starts running automatically once nodes are set
simulation.nodes(nodes)
.on('tick', () => ticked(bubbles, labels, images))
.restart();
}, [data, height, width, maxRadius, clusterPadding, padding])
return (
<div ref={container} >
</div>
)
}
export default BubbleGraph
|
// 引入express框架
const express = require('express');
// 路径处理模块
const path = require('path');
// 向其他服务器端请求数据的模块
const request = require('request');
// 创建web服务器
const app = express();
// 静态资源访问服务功能
app.use(express.static(path.join(__dirname, 'public')));
app.get('/server', (req, res) => {
request('http://localhost:3001/cross', (err, response, body) => {
res.send(body);
})
});
// 监听端口
app.listen(3000);
// 控制台提示输出
console.log('服务器启动成功'); |
/* eslint-disable linebreak-style */
const villageKeys = [
/VILLAGE_[0-9a-f\\-]+_DWELLERS/,
/VILLAGE_[0-9a-f\\-]+_INFO/,
/VILLAGE_[0-9a-f\\-]+_PLAYERS/,
/VILLAGE_[0-9a-f\\-]+_POI/,
/map_\\-[0-9]+/,
];
const BLOCK_BLACKLIST = [
'minecraft:netherrack',
'minecraft:lava',
'minecraft:soul_soil',
'minecraft:soul_sand',
'minecraft:basalt',
'minecraft:nether_gold_ore',
'minecraft:quartz_ore',
'minecraft:magma',
'minecraft:blackstone',
'minecraft:stone',
'minecraft:gravel',
'minecraft:bedrock',
'minecraft:air',
'minecraft:water',
'minecraft:dirt',
'minecraft:grass',
'minecraft:sand',
'minecraft:sandstone',
];
const BLOCK_WHITELIST = [
'minecraft:ancient_debris',
// 'minecraft:diamond_ore',
// 'minecraft:lapis_ore'
];
export { villageKeys, BLOCK_WHITELIST, BLOCK_BLACKLIST };
|
import React from 'react';
import NavBar from './components/NavBar/NavBar.js';
import LandingPage from './components/LandingPage/landingPage.js';
import {Router} from '@reach/router'
import ClothesContextProvider from './components/contexts/ClothesContext.js';
import ItemsPage from './components/Pages/ItemsPage.js';
import CartContextProvider from './components/contexts/CartContext.js';
import CheckOutPage from './components/Pages/CheckOutPage.js';
import SuccessPage from './components/Pages/SuccessPage.js';
function App() {
return (
<div>
<NavBar/>
<CartContextProvider>
<ClothesContextProvider>
<Router>
<LandingPage path="/"/>
<ItemsPage path="/itemspage"/>
<CheckOutPage path="/check-out"/>
<SuccessPage path="/order-placed"/>
</Router>
</ClothesContextProvider>
</CartContextProvider>
</div>
);
}
export default App;
|
var app = angular.module('imageApp', []);
app.controller('GetController', function($scope, $http, $location) {
$scope.errMessage = "";
$scope.download = function($files) {
var url = $location.absUrl() + "download";
var fd = new FormData();
angular.forEach($scope.files,function(file)
{
console.log("i am here"+file);
fd.append('file', file);
});
/*$http({
method: 'POST',
url: url,
headers: {'Content-Type': undefined},
data: fd,
transformRequest: angular.identity
})*/
$http.post(url,
fd,
{
transformRequest: angular.identity,
headers: {'Content-Type': undefined}
})
.success(function(data, status) {
alert("success");
});
}
})
.directive('fileInput', ['$parse', function($parse){
return {
restrict: 'A',
link: function(scope, elm, attrs){
elm.bind('change',
function(){
$parse(attrs.fileInput).assign(scope, elm[0].files);
var input = document.getElementById ("fileUploader");
$parse(attrs.filePath).assign(scope, input.value);
scope.$apply();
}
);
}
}
}]);
|
import accounting from "accounting";
const duration = document.getElementById("order_duration");
duration.addEventListener('change', (event) => {
if (!(duration.value === "")) {
if (!isNaN(duration.value)) {
const total_price = document.getElementById("total_price")
const price = total_price.dataset.price;
const total = parseInt(price) * parseInt(duration.value/28);
total_price.innerHTML = `${accounting.formatMoney(total/100, "R$ ", 2, ".", ",")}`;
}
}
})
|
const { getGreatestTidyNumberSmallerThan } = require('./main')
describe('getGreatestTidyNumberSmallerThan', () => {
it('should return no digit, if none given', () => {
expect(getGreatestTidyNumberSmallerThan('')).toEqual('')
})
it('should return one digit', () => {
expect(getGreatestTidyNumberSmallerThan('0')).toEqual('0')
expect(getGreatestTidyNumberSmallerThan('7')).toEqual('7')
})
it('should return tidy, if one given', () => {
expect(getGreatestTidyNumberSmallerThan('1123')).toEqual('1123')
})
it('should return the greatest tidy stricty smaller than the input', () => {
// given as example
expect(getGreatestTidyNumberSmallerThan('132')).toEqual('129')
expect(getGreatestTidyNumberSmallerThan('1000')).toEqual('999')
expect(getGreatestTidyNumberSmallerThan('111111111111111110')).toEqual('99999999999999999')
// mine
expect(getGreatestTidyNumberSmallerThan('11002')).toEqual('9999')
})
})
|
import React from 'react';
import { useSelector } from 'react-redux';
import { Typography } from '@material-ui/core';
import { makeStyles } from '@material-ui/styles';
const useStyles = makeStyles(theme => ({
homeContainer: {
display: 'flex',
justifyContent: 'center',
alignContent: 'center',
marginTop: '10rem'
},
homeContent: {
display: 'flex',
flexFlow: 'column wrap',
textAlign: 'center'
}
}));
export const Profile = () => {
const classes = useStyles();
const currentUser = useSelector(state => state.currentUser);
return (
<div className={classes.homeContainer}>
<Typography
className={classes.homeContent}
variant="h6"
>
<span>Email: {currentUser.email}</span>
<span>Username: {currentUser.username}</span>
</Typography>
</div>
);
};
|
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io').listen(server);
var socket = require('./socket.js');
var port = process.env.PORT || 8000;
server.listen(port);
app.use("/", express.static(__dirname + '/app'));
// assuming io is the Socket.IO server object
if (process.env.NO_WEBSOCKETS) {
console.log("Configuring socket.io server for Heroku (No true websockets, replace with xhr-longpolling");
// See https://devcenter.heroku.com/articles/using-socket-io-with-node-js-on-heroku
io.configure(function () {
io.set("transports", ["xhr-polling"]);
io.set("polling duration", 10);
});
}
io.sockets.on('connection', socket);
|
import Vue from 'vue'
import Vuex from 'vuex'
import moduloAutenticacion from './modules/autenticacion/store-autenticacion'
import moduloPeliculas from './modules/peliculas/store-peliculas'
import moduloUsuario from './modules/usuario/store-usuario'
Vue.use(Vuex)
const store = new Vuex.Store({
modules: {
moduloAutenticacion,
moduloPeliculas,
moduloUsuario,
}
})
export default store |
import React from 'react'
import styles from './styles.css'
export const JSONToHTMLTable = (props) => {
const { data, wrapperClassName, tableClassName } = props
return (
<div className={wrapperClassName}>
<table className={tableClassName}>
<tbody>
{Object.keys(data).map((k) => (
<tr key={k}>
{!Array.isArray(data)
&& <td>{k.replace(/_/g, ' ')}</td>}
{(() => {
if (data[k] && typeof data[k] === 'object') {
return (
<td>
<JSONToHTMLTable data={data[k]} tableClassName={tableClassName} />
</td>
)
}
return (
<td>
<span dangerouslySetInnerHTML={{ __html: data[k] }} />
</td>
)
})()}
</tr>
))}
</tbody>
</table>
</div>
)
}
|
class ChatController {
constructor() {
this.userList = new UserList(arrUsers, arrActiveUsers);
this.msgList = new MessageList();
this.headerView = new HeaderView('authorized-user');
this.messagesView = new MessagesView('msg-chat');
this.activeUsersView = new ActiveUsersView('sidebar-online-user');
}
setCurrentUser() {
this.headerView.display(this.msgList.user);
this.messagesView.display(this.msgList.getPage(), this.msgList.user);
}
addMessage(msg) {
this.msgList.add(msg);
this.messagesView.display(this.msgList.getPage(0, 10), this.msgList.user);
}
editMessage(id, element) {
document.querySelector(`.${messagesView.id}`).innerHTML = '';
msgList.edit(id, element);
messagesView.display(this.msgList.getPage(0, 10), this.msgList.user);
}
removeMessage(id) {
document.querySelector(`.${messagesView.id}`).innerHTML = '';
msgList.remove(id);
messagesView.display(msgList.getPage(), msgList.user);
}
showMessages(skip = 0, top = 10, filterConfig = {}) {
document.querySelector(`.${this.messagesView.id}`).innerHTML = '';
const i = this.msgList.getPage(skip, top, filterConfig);
this.messagesView.display(i, this.msgList.user);
}
showActiveUsers() {
this.activeUsersView.display(this.userList.activeUsers);
}
login() {
const login = document.querySelector('.login');
login.style.display = 'block';
}
registr() {
const regist = document.querySelector('.registr');
regist.style.display = 'block';
}
}
function sendLocalStor() {
// if(JSON.parse(localStorage.msgStorage === undefined)){
// localStorage.setItem('msgStorage', JSON.stringify(arr.map((item) => new Messages(item))));
// }
if (JSON.parse(localStorage.user === undefined)) {
localStorage.setItem('user', JSON.stringify(''));
}
if (JSON.parse(localStorage.token === undefined)) {
localStorage.setItem('token', JSON.stringify(''));
}
// if(JSON.parse(localStorage.allUser === undefined)){
// localStorage.setItem('allUser', JSON.stringify(arrUsers))
// }
// if(JSON.parse(localStorage.arrActiveUsers === undefined)){
// localStorage.setItem('arrActiveUsers', JSON.stringify(arrActiveUsers))
// }
}
class ChatApiService {
constructor() {
this.token = JSON.parse(localStorage.getItem('token'));
this.user = JSON.parse(localStorage.getItem('user'));
this.headerView = new HeaderView('authorized-user');
this.messagesView = new MessagesView('msg-chat');
this.activeUsersView = new ActiveUsersView('sidebar-online-user');
this.privatMsgView = new PrivatMsgView('select-privat-user');
this.to = null;
this.isPersonal = false;
this.top = 10;
}
messages(skip = 0, elseTop = 0) {
let { top } = this;
top += elseTop;
const url = `https://jslabdb.datamola.com/messages?skip=${skip}&top=${top}`;
if (this.msgScreen) {
clearTimeout(this.msgScreen);
}
return fetch(url, {
method: 'GET',
headers: { Authorization: `Bearer ${JSON.parse(localStorage.getItem('token'))}` },
})
.then((result) => result.json()).then((data) => {
for (let i = 0; i < data.length; i++) {
data[i].createdAt = new Date(data[i].createdAt);
}
return data.sort((a, b) => a.createdAt - b.createdAt);
}).then((data) => {
this.top = data.length;
this.messagesView.display(data.map((item) => new Messages(item)), this.user, skip, top);
this.msgScreen = setTimeout(() => {
this.messages();
}, 45000);
});
}
users() {
const url = 'https://jslabdb.datamola.com/users';
return fetch(url)
.then((result) => result.json()).then((data) => {
this.activeUsersView.display(data, this.user);
this.privatMsgView.display(data);
});
}
register(name, pass) {
const url = 'https://jslabdb.datamola.com/auth/register';
const formData = new FormData();
formData.set('name', name);
formData.set('pass', pass);
const obj = {};
formData.forEach((value, key) => {
obj[key] = value;
});
localStorage.setItem('user', JSON.stringify(name));
this.user = JSON.parse(localStorage.getItem('user'));
const json = JSON.stringify(obj);
return fetch(url, {
method: 'POST',
body: formData,
});
}
login(name, pass) {
const url = 'https://jslabdb.datamola.com/auth/login';
const formData = new FormData();
formData.set('name', name);
formData.set('pass', pass);
return fetch(url, {
method: 'POST',
body: formData,
})
.then((result) => {
if (result.ok) {
localStorage.setItem('user', JSON.stringify(name));
this.user = JSON.parse(localStorage.getItem('user'));
}
const resJson = result.json();
return resJson;
})
.then(((result) => result.token))
.then((res) => {
this.token = res;
return this.token;
})
.then((res) => {
localStorage.setItem('token', JSON.stringify(res));
this.token = JSON.parse(localStorage.getItem('token'));
return this.token;
})
.then((res) => {
this.headerView.display(this.user);
this.activeUsersView.display(this.users(), this.user);
this.messages();
});
}
logout() {
const url = 'https://jslabdb.datamola.com/auth/logout';
return fetch(url, {
method: 'POST',
headers: { Authorization: `Bearer ${JSON.parse(localStorage.getItem('token'))}` },
})
.then((result) => {
this.user = localStorage.setItem('user', JSON.stringify(''));
localStorage.setItem('token', JSON.stringify(''));
return this.user;
})
.then((res) => {
this.headerView.display(res);
});
}
messagesSend(data) {
const url = 'https://jslabdb.datamola.com/messages';
this.token = JSON.parse(localStorage.getItem('token'));
return fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json;charset=utf-8',
Authorization: `Bearer ${this.token}`,
},
body: JSON.stringify(data),
}).then((res) => res.json()).then((res) => {
this.messages();
});
}
delete(id) {
const url = `https://jslabdb.datamola.com/messages/${id}`;
this.token = JSON.parse(localStorage.getItem('token'));
return fetch(url, {
method: 'DELETE',
headers: {
'Content-Type': 'application/json;charset=utf-8',
Authorization: `Bearer ${this.token}`,
},
}).then((res) => {
return res.json();
});
}
}
document.addEventListener('DOMContentLoaded', () => {
const chatApiService = new ChatApiService();
sendLocalStor();
chatApiService.headerView.display(chatApiService.user);
chatApiService.messages();
chatApiService.users();
const linkRegistr = document.querySelector('.regisrt-button');
linkRegistr.onclick = function () {
const registr = document.querySelector('.registr');
registr.style.display = 'block';
const formRegistr = document.getElementById('form-registr');
formRegistr.addEventListener('submit', (event) => {
event.preventDefault();
registr.style.display = 'none';
const name = formRegistr[1].value;
const pass = formRegistr[2].value;
chatApiService.register(name, pass);
registr.style.display = 'none';
const login = document.querySelector('.login');
login.style.display = 'block';
const formLogin = document.getElementById('form-login');
formLogin.addEventListener('submit', (event) => {
event.preventDefault();
login.style.display = 'none';
const name = formLogin[0].value;
const pass = formLogin[1].value;
chatApiService.login(name, pass);
chatApiService.headerView.display(chatApiService.user);
chatApiService.messages();
});
});
};
const linkLogin = document.querySelector('.login-button');
linkLogin.addEventListener('click', () => {
const login = document.querySelector('.login');
login.style.display = 'block';
const formLogin = document.getElementById('form-login');
formLogin.addEventListener('submit', (event) => {
event.preventDefault();
login.style.display = 'none';
const name = formLogin[0].value;
const pass = formLogin[1].value;
chatApiService.login(name, pass);
chatApiService.messages();
});
});
const exit = document.querySelector('.authorized-user');
exit.onclick = function () {
const windowExit = document.querySelector('.exit');
if (windowExit.style.display !== 'block') {
windowExit.style.display = 'block';
} else {
windowExit.style.display = 'none';
}
};
const windowExit = document.querySelector('.exit');
windowExit.addEventListener('click', () => {
windowExit.style.display = 'none';
chatApiService.logout();
});
const btnSendMsg = document.querySelector('.msg-send-btn');
btnSendMsg.addEventListener('click', () => {
const inputSendMsg = document.getElementById('write-msg');
const select = document.querySelector('.select-privat-user');
if (select.value === 'Публичное') {
chatApiService.isPersonal = false;
chatApiService.to = null;
}
if (select.value !== 'Публичное') {
chatApiService.isPersonal = true;
chatApiService.to = select.value;
}
chatApiService.messagesSend({
text: inputSendMsg.value, author: chatApiService.user, isPersonal: chatApiService.isPersonal, to: chatApiService.to,
});
inputSendMsg.value = '';
});
const possibleMsg = document.querySelector('.msg-chat');
possibleMsg.addEventListener('click', (event) => {
let target = event.target;
if (target.className === 'possible-msg') {
document.getElementById(`${event.target.parentNode.parentNode.parentNode.parentNode.id}1`).style.display = 'block';
}
if (target.className !== 'delete' && target.className !== 'possible-msg') {
document.getElementById(`${event.target.parentNode.parentNode.parentNode.id}1`).style.display = 'none';
}
if (target.className === 'delete') {
chatApiService.delete(event.target.parentNode.parentNode.parentNode.id);
}
});
const elseMsgBtn = document.getElementById('else-msg-btn');
elseMsgBtn.addEventListener('click', () => {
chatApiService.messages(0, 10);
});
});
|
const category = document.querySelector('#categories');
console.log(`Всього: ${category.childElementCount} категорії`);
const itemsAll = document.querySelectorAll('.item');
itemsAll.forEach((item) =>
console.log(
`Категорія: ${item.querySelector('h2').textContent}. Кількість елементів: ${item.lastElementChild.children
.length}`
)
);
|
var $ = require('jquery');
var React = require('react');
var LoginForm = require('./LoginForm.jsx');
var data = {};
var Login = React.createClass({
getInitialState: function() {
return {
email: '',
password: '',
response: ''
};
},
componentDidMount: function() {
// this.setState({ response: JSON.stringify(data) })
},
handleEmailChange: function(event) {
this.setState({ email: event.target.value });
},
handlePasswordChange: function(event) {
this.setState({ password: event.target.value });
},
handleSubmit: function() {
var state = this.state;
var that = this;
if (!this.props.clientId || !this.props.clientSecret) {
console.error('Cannot login without client id or client secret');
}
this.props.prepareAjax(this.props.clientId, this.props.clientSecret);
function handleSuccess(response) {
console.log('success:', response);
that.setState({ response: response });
that.props.updateAuthentication(response);
}
function handleError(xhr, response, status) {
console.log('error:', xhr, response, status);
that.setState({ response: xhr });
}
$.ajax({
url: '/oauth2/token/',
method: 'POST',
data: {
grant_type: 'password',
username: state.email,
password: state.password
},
success: handleSuccess,
error: handleError
});
},
render: function () {
return (
<div>
<hgroup>
<h1>Sign in</h1>
</hgroup>
<LoginForm
email={this.state.email}
handleEmailChange={this.handleEmailChange}
password={this.state.password}
handlePasswordChange={this.handlePasswordChange}
handleClickSubmit={this.handleSubmit} />
<div hidden={!this.state.response || !this.props.debug}>
<h3>Response</h3>
<pre>
{JSON.stringify(this.state.response, null, 2)}
</pre>
</div>
</div>
)
}
})
module.exports = Login; |
$(document).ready(function(){
$("form").submit(function(e){
e.preventDefault();
$("#errors").empty();
var url = $('form').attr('action');
var method = $('form').attr('method');
data = convertFormToJSON($('form'));
console.log(method);
$.ajax({
type: method,
url: url,
data: data,
success: checkError,
dataType: 'json'
});
});
});
var convertFormToJSON = function (form){
var array = jQuery(form).serializeArray();
var json = {};
jQuery.each(array, function() {
json[this.name] = this.value || '';
});
return json;
}
var checkError = function (response) {
if (response.errors) {
$.each(response.errors,function(index,value){
$("#errors").append("<li>"+value+"</li>");
});
}
else{
window.location.href = response.new_url;
}
}
|
// single event
const initialState = null;
export default function eventReducer(state = initialState, action) {
switch (action.type) {
case "EVENT_FETCHED":
return action.event;
case "EVENT_UPDATED":
return action.event;
default:
return state;
}
}
|
import React, { Component } from 'react'
import PropTypes from 'prop-types'
class Time extends Component {
constructor(props) {
super(props)
this.locale = props.locale || 'de-DE'
this.state = { time: this.getTime() }
}
getTime() {
return new Date().toLocaleTimeString(this.locale)
}
setTime() {
this.setState({ time: this.getTime() })
}
componentDidMount() {
this.timer = setInterval(this.setTime.bind(this), 1000)
}
componentWillUnmount() {
clearInterval(this.timer)
}
render() {
return (
<div>{this.state.time}</div>
)
}
}
Time.propTypes = {
locale: PropTypes.string
}
export default Time
|
export function addItem(name, id, unitPrice, setCart, quantity, cart) {
const itemToAdd = {
id,
name,
quantity,
unitPrice,
};
if (!cart.some((product) => product.id === id)) {
setCart(cart.concat(itemToAdd));
} else {
let indexElement = 0;
for (const item of cart) {
item.id === id && (indexElement = cart.indexOf(item));
}
itemToAdd.quantity = cart[indexElement].quantity + quantity;
cart.pop(indexElement);
setCart(cart.concat(itemToAdd));
}
}
|
"use strict";
var Tag = require('../Tag');
var utils = require('../support/utils');
/**
* Given an array of objects,
* Render <option> elements.
*/
Tag.extend('options', {
parse: utils.parseForEach,
evaluate: function(template)
{
var id = this.args.index;
var label = this.args.key;
this.setSource(`
__out += (function(){
return ${this.args.array}.map(function(obj){
return '<option value="'+ obj["${id}"] +'">'+obj["${label}"]+'</option>';
}).join("\\n");
})();
`);
}
}); |
var client = require('./../config/pg_db_client');
let projectConfig = require('../setup/initialize.config');
//postgres queries here
class PostgresOperations {
constructor() {
}
/* @function
* @param {object} params - Required params (Workflow, etc).
* @param {function} errback - Database error callback.
* @param {function} callback - Callback.
*/
createWorkflow(params, errback, callback) {
var query = client.query("INSERT INTO public.workflow" +
"(id, name, description, default_milestone, roles, actions, milestones, create_ts, create_user, update_ts, update_user) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) returning *",
[params.id,
params.name,
params.description || null,
params.defaultMilestone || 'new',
params.roles || {},
params.actions || {},
params.milestones || {},
'2017-06-24 00:00:00', 'workflow', '2017-06-24 00:00:00', 'pkulshrestha']);
//var query = client.query("SELECT firstname, lastname FROM emps ORDER BY lastname, firstname");
query.on('row', function (row, result) {
console.log('data' + JSON.stringify(row, null, " "));
result.addRow(row);
});
query.on('end', function (result) {
console.log(JSON.stringify(result.rows));
client.end();
callback(null,result.rows[0].workflow_skey);
});
}
createNewInstance(workflowId, errback, callback){
var workflowIdRetrieved;
const query = {
// give the query a unique name
name: 'fetch-workflow',
text: 'SELECT * FROM workflow WHERE workflow_skey= $1',
values: [workflowId]
}
// callback
client.query(query, (err, res) => {
if (err) {
console.log(err.stack)
} else {
console.log(res.rows[0])
const query = {
text: 'INSERT INTO public.workflow_instance' +
'(workflow_skey, create_ts, create_user, update_ts, update_user) VALUES ($1, $2, $3, $4, $5) returning *',
values: [workflowId, '2017-06-24 00:00:00', 'workflow', '2017-06-24 00:00:00', 'pkulshrestha']
}
// callback
client.query(query, (err, res) => {
if (err) {
console.log(err.stack)
} else {
if (res.rows[0].workflow_skey) {
console.log(' workflow instance id '+ res.rows[0].workflow_instance_skey)
callback(null,res.rows[0].workflow_instance_skey);
}
}
})
}
})
}
setInstance(documentId, errback, callback){
const query = {
// give the query a unique name
name: 'fetch-workflow-for-instance',
text: 'select * from workflow w, workflow_instance wi where w.workflow_skey = wi.workflow_instance_skey and wi.workflow_instance_skey= $1 ',
values: [documentId]
}
client.query(query, (err, res) => {
if (err) {
console.log(err.stack)
} else {
var wfModel = JSON.parse(JSON.stringify(res.rows[0]));
wfModel._id= wfModel.workflow_skey.toString() ;
delete wfModel.workflow_skey;
wfModel.updatedAt = wfModel.update_ts;
delete wfModel.update_ts;
wfModel.createdAt = wfModel.create_ts;
delete wfModel.create_ts;
wfModel.defaultMilestone = wfModel.default_milestone;
delete wfModel.default_milestone;
delete wfModel.create_user;
delete wfModel.update_user;
var documents = [wfModel.workflow_instance_skey.toString()];
wfModel.documents= documents;
delete wfModel.workflow_instance_skey;
console.log('***************** res.rows[0] after*****************' + JSON.stringify(wfModel));
if(!wfModel){
return errback({message: "Not found", statusCode: 404}, callback);
}
if(projectConfig.externalHistory){
this.fetchHistory(documentId, (err, document)=>{
if(err){
return errback(err, callback);
}
callback(null, {"wfModel": wfModel, "document": document});
});
} else {
console.log('Before external callback '+ "wfModel: "+ JSON.stringify(doc));
callback(null, {"wfModel": doc});
}
}
})
}
fetchHistory(documentId,callback){
const query = {
// give the query a unique name
name: 'fetch-history',
text: 'SELECT * FROM workflow_action_history WHERE workflow_instance_skey= $1',
values: [documentId]
}
// callback
client.query(query, (err, res) => {
if (err) {
return callback(err, null);
} else {
var docs = [];
console.log('$$$$$$$$$$$$ docs before ' + JSON.stringify(res.rows));
res.rows.forEach(function(record) {
var requiredRecord = record;
requiredRecord._id = requiredRecord.workflow_action_history_skey.toString() ;
delete requiredRecord.workflow_action_history_skey;
requiredRecord.workflowModelId = requiredRecord.workflow_skey;
delete requiredRecord.workflow_skey;
requiredRecord.documentId = requiredRecord.workflow_instance_skey;
delete requiredRecord.workflow_instance_skey;
requiredRecord.user = requiredRecord.user_acted;
delete requiredRecord.user_acted;
requiredRecord.action = requiredRecord.user_action;
delete requiredRecord.user_action;
requiredRecord.updatedAt = requiredRecord.update_ts;
delete requiredRecord.update_ts;
requiredRecord.createdAt = requiredRecord.create_ts;
delete requiredRecord.create_ts;
delete requiredRecord.create_user;
delete requiredRecord.update_user;
docs.push(requiredRecord)
})
let documentObj = {
history: docs
}
console.log('$$$$$$$$$$$$ docs after ' + JSON.stringify(docs));
callback(null, documentObj);
}
})
}
setHistory(params, errback, callback){
const query = {
// give the query a unique name
name: 'fetch-history',
text: 'SELECT * FROM workflow_action_history WHERE workflow_instance_skey= $1',
values: [params.documentId]
}
// callback
client.query(query, (err, res) => {
if (err) {
return callback(err, null);
} else {
var docs = [];
console.log('$$$$$$$$$$$$ docs before ' + JSON.stringify(res.rows));
res.rows.forEach(function(record) {
var requiredRecord = record;
requiredRecord._id = requiredRecord.workflow_action_history_skey.toString() ;
delete requiredRecord.workflow_action_history_skey;
requiredRecord.workflowModelId = requiredRecord.workflow_skey;
delete requiredRecord.workflow_skey;
requiredRecord.documentId = requiredRecord.workflow_instance_skey;
delete requiredRecord.workflow_instance_skey;
requiredRecord.user = requiredRecord.user_acted;
delete requiredRecord.user_acted;
requiredRecord.action = requiredRecord.user_action;
delete requiredRecord.user_action;
requiredRecord.updatedAt = requiredRecord.update_ts;
delete requiredRecord.update_ts;
requiredRecord.createdAt = requiredRecord.create_ts;
delete requiredRecord.create_ts;
delete requiredRecord.create_user;
delete requiredRecord.update_user;
docs.push(requiredRecord)
})
let documents = docs;
var document = params.history[params.history.length -1];
document.documentId = params.documentId;
document.workflowModelId = params.wfModelId;
const query = {
// give the query a unique name
name: 'set-history',
text: "INSERT INTO workflow_action_history(workflow_skey, workflow_instance_skey, user_acted, user_action, milestone, allowedroles, create_ts, create_user, update_ts, update_user)" +
" VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) returning *",
values: [document.workflowModelId, document.documentId, document.user, document.action, document.milestone, JSON.stringify(document.allowedroles),
'2017-06-24 00:00:00', 'workflow', '2017-06-24 00:00:00', 'pkulshrestha']
}
// callback
client.query(query, (err, res) => {
if (err) {
console.log('##################3 err ' +err);
return callback(err, null);
} else {
var requiredRecord = res.rows[0];
console.log('##################3 record ' +JSON.stringify(res));
requiredRecord._id = requiredRecord.workflow_action_history_skey.toString() ;
delete requiredRecord.workflow_action_history_skey;
requiredRecord.workflowModelId = requiredRecord.workflow_skey;
delete requiredRecord.workflow_skey;
requiredRecord.documentId = requiredRecord.workflow_instance_skey;
delete requiredRecord.workflow_instance_skey;
requiredRecord.user = requiredRecord.user_acted;
delete requiredRecord.user_acted;
requiredRecord.action = requiredRecord.user_action;
delete requiredRecord.user_action;
requiredRecord.updatedAt = requiredRecord.update_ts;
delete requiredRecord.update_ts;
requiredRecord.createdAt = requiredRecord.create_ts;
delete requiredRecord.create_ts;
delete requiredRecord.create_user;
delete requiredRecord.update_user;
documents.push(requiredRecord);
callback(null, documents);
}
})
}
});
}
}
module.exports = PostgresOperations; |
var app = require('express')();
var http = require('http');
http = http.Server(app);
var io = require('socket.io')(http);
app.get('/', (req, res) => {
res.sendFile(__dirname + "/views/index.html");
});
var generalInfo = io.of("/generalInfo");
var users = [];
var rooms = [];
generalInfo.on('connection', (socket) => {
console.log(socket.client.id + " connected");
users.push({ id: socket.client.id, name: socket.client.id });
generalInfo.emit("userInfo", users);
generalInfo.emit("roomInfo", rooms);
socket.on('disconnect', () => {
console.log(socket.client.id + " disconnected");
users.splice(getUser(socket.client.id), 1);
generalInfo.emit("userInfo", users);
});
});
io.on('connection', (socket) => {
socket.on('message', (msg) => {
var textSplitted = msg.split(" ");
if (textSplitted[0][0] == "/") {
var command = textSplitted[0].slice(1, textSplitted[0].length);
switch (command.toUpperCase()) {
case "newroom".toUpperCase():
var roomName = textSplitted[1];
addRoom(roomName);
break;
case "closeroom".toUpperCase():
var roomName = textSplitted[1];
closeRoom(roomName);
break;
case "nickname".toUpperCase():
users[getUser(socket.id)].name = textSplitted[1];
generalInfo.emit("userInfo", users);
break;
}
}
else if (textSplitted[0][0] == "@") {
var command = textSplitted[0].slice(1, textSplitted[0].length);
var restOfTheMessage = "";
var username = users[getUser(socket.id)].name;
for (var i = 1; i < textSplitted.length; i++) {
restOfTheMessage += textSplitted[i];
if (!(i == textSplitted.length - 1)) {
restOfTheMessage += " ";
}
}
io.to(command).emit("newMessage", { channel: command, messageText: restOfTheMessage, writtenBy: socket.id, userName: username, date: Date.now() });
}
else {
var username = users[getUser(socket.id)].name;
io.emit("newMessage", { channel: "Public", messageText: msg, writtenBy: socket.id, userName: username, date: Date.now() });
}
});
socket.on('joinRoom', (roomName) => {
socket.join(roomName);
});
socket.on('leaveRoom', (roomName) => {
socket.leave(roomName);
});
});
function addRoom(roomName) {
let roomFound = false;
for (let i = 0; i < rooms.length; i++) {
if (rooms[i].name == roomName) {
roomFound = true
}
}
if (!roomFound) {
rooms.push({ name: roomName });
generalInfo.emit("roomInfo", rooms);
return 1;
} else {
return null;
}
}
function closeRoom(roomName) {
let roomFound = false;
for (let i = 0; i < rooms.length; i++) {
if (rooms[i].name == roomName) {
roomFound = true
}
}
if (roomFound) {
rooms.splice(getRoom(roomName), 1);
generalInfo.emit("roomInfo", rooms);
return 1;
} else {
return null;
}
}
function getRoom(name) {
for (let i = 0; i < rooms.length; i++) {
if (rooms[i].name == name) {
return i;
}
}
return null;
}
function getUser(id) {
for (let i = 0; i < users.length; i++) {
if (users[i].id == id) {
return i;
}
}
return null;
}
// io.on('connection', function (socket) {
// console.log('Someone connected');
// });
/*var nsp = io.of('/burak');
nsp.on('connection', function (socket) {
console.log('someone connected to ' + socket.nsp.name);
socket.join('some room');
socket.join('some room2');
// synchronousSpam(socket, 111);
});*/
var synchronousSpam = (socket, length, i) => {
if (i === undefined) {
i = 0;
}
var promise1 = new Promise(function (resolve, reject) {
setTimeout(function () {
resolve('foo');
}, 30);
});
promise1.then(function (value) {
socket.emit('def', socket.nsp.name + ' ' + i);
if (i < length) {
synchronousSpam(socket, length, i + 1);
}
});
}
http.listen(827, () => {
}); |
import React,{Component} from 'react';
import { connect } from 'dva';
import { routerRedux } from 'dva/router';
class NotFound extends Component {
constructor(props){
super(props);
}
render(){
return (
<div>
<h1 style={{textAlign:'center',color:'#909090', marginTop: 200}}>抱歉，未找到相关信息</h1>
</div>
);
}
}
export default connect()(NotFound); |
import Rebase from 're-base'
import firebase from 'firebase/app'
import 'firebase/database'
import 'firebase/storage'
import dotenv from 'dotenv'
dotenv.config()
const firebaseApp = firebase.initializeApp({
apiKey: process.env.APIKEY,
authDomain: process.env.AUTHDOMAIN,
databaseURL: "https://image-contest-b2fdf.firebaseio.com",
storageBucket: 'gs://image-contest-b2fdf.appspot.com'
})
const base = Rebase.createClass(firebaseApp.database())
export { firebaseApp }
const storage = firebase.storage()
export { storage }
export default base
|
const User = require('../schema/user');
const store = (req, res) => {
const user = new User(req.body);
user.save((error, result) => {
if (error) {
res.json({status:false, message:'Unable to create account'});
} else {
res.json({status:true, message:'User account created successfully'});
}
})
}
const login = (req, res) => {
const user = User.findOne({ email: req.body.email})
if (user == undefined) {
res.json({status:false, message:'Invalid credentials'});
} else {
res.json({status:true, message:'Logged in successfully'});
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.