text
stringlengths 7
3.69M
|
|---|
import React, { Component } from 'react'
import { bindActionCreators } from 'redux'
import { connect } from 'react-redux'
import Radium from 'radium'
import * as actions from './actions'
import MessageList from './ui/messages/MessageList'
import UserList from './ui/userList/UserList'
import JoinForm from './ui/JoinForm'
import SendMessageForm from './ui/SendMessageForm'
const styles = {
row: {
margin: '0px',
padding: '0px',
display: 'flex',
flexFlow: 'row nowrap'
}
}
class App extends Component {
constructor (props) {
super(props)
this.join = this.join.bind(this)
this.sendMessage = this.sendMessage.bind(this)
this.typing = this.typing.bind(this)
}
componentWillMount () {
this.props.actions.startUp()
}
join (name) {
this.props.actions.join(name)
}
sendMessage (message) {
this.props.actions.sendMessage(message)
}
typing () {
this.props.actions.typing()
}
render () {
const { messages, users, currentUser, userIdsTyping } = this.props
let form = (<JoinForm
join={this.join}
/>)
if (currentUser.size > 0) {
form = (
<SendMessageForm
typing={this.typing}
sendMessage={this.sendMessage}
/>
)
}
return (
<div>
<div style={styles.row}>
<MessageList
messages={messages}
/>
<UserList
userIdsTyping={userIdsTyping}
users={users}
/>
</div>
<div style={styles.row}>
{form}
</div>
</div>
)
}
}
function mapStateToProps (state) {
return {
messages: state.get('messages'),
users: state.get('users'),
currentUser: state.get('currentUser'),
userIdsTyping: state.get('userIdsTyping')
}
}
function mapDispatchToProps (dispatch) {
return {
dispatch: dispatch,
actions: bindActionCreators(actions, dispatch)
}
}
export default Radium(connect(
mapStateToProps,
mapDispatchToProps
)(App))
|
// Copyright 2012 Dmitry Monin. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/**
* @fileoverview A component which is animated. Used together with InView
* Controller, to start / stop animations.
*/
goog.provide('morning.ui.AnimatedComponent');
goog.require('goog.dom.dataset');
goog.require('goog.math.Box');
goog.require('goog.ui.Component');
goog.require('morning.app.ModularApp');
/**
* @constructor
* @extends {goog.ui.Component}
* @implements {morning.controllers.InViewComponent}
*/
morning.ui.AnimatedComponent = function()
{
goog.base(this);
/**
* Name of the component.
* @type {string}
*/
this.name = '';
/**
* Defines whether component is inView
* @type {boolean}
*/
this.inView = false;
/**
* Defines whether component is currently animated.
* @type {boolean}
*/
this.isAnimated = false;
/**
* Changes bounds of the component in each direction.
*
* @type {goog.math.Box}
*/
this.changeBoundsBy = new goog.math.Box(0, 0, 0, 0);
};
goog.inherits(morning.ui.AnimatedComponent, goog.ui.Component);
/** @inheritDoc */
morning.ui.AnimatedComponent.prototype.decorateInternal = function(el)
{
goog.base(this, 'decorateInternal', el);
var reduceBounds = goog.dom.dataset.get(el, 'reduceBounds');
if (reduceBounds)
{
var numbers = reduceBounds.split(' ');
this.changeBoundsBy.top = Number(numbers[0]);
this.changeBoundsBy.right = Number(numbers[1]);
this.changeBoundsBy.bottom = Number(numbers[2]);
this.changeBoundsBy.left = Number(numbers[3]);
}
};
/** @inheritDoc */
morning.ui.AnimatedComponent.prototype.enterDocument = function()
{
goog.base(this, 'enterDocument');
var app = morning.app.ModularApp.getInstance();
if (app.getController('inview'))
{
app.getController('inview').register(this);
}
};
/** @inheritDoc */
morning.ui.AnimatedComponent.prototype.exitDocument = function()
{
goog.base(this, 'exitDocument');
var app = morning.app.ModularApp.getInstance();
if (app.getController('inview'))
{
app.getController('inview').unregister(this);
}
};
/**
* Returns bounds of the component.
*
* @return {goog.math.Rect}
*/
morning.ui.AnimatedComponent.prototype.getBounds = function()
{
var app = morning.app.ModularApp.getInstance();
var inViewController = app.getController('inview');
return inViewController ?
app.getController('inview').getBounds(this) : null;
};
/**
* Sets whether component is in visible in current browser view.
* @param {boolean} isInView
*/
morning.ui.AnimatedComponent.prototype.setInView = function(isInView)
{
this.forEachChild(function(child) {
if (child instanceof morning.ui.AnimatedComponent)
{
child.setInView(isInView);
}
}, this);
this.inView = isInView;
this.updateAnimated();
};
/**
* Sets animated status of the component.
*
* @param {boolean} isAnimated
*/
morning.ui.AnimatedComponent.prototype.setAnimated = function(isAnimated)
{
this.isAnimated = isAnimated;
this.forEachChild(function(child) {
if (child instanceof morning.ui.AnimatedComponent)
{
child.setAnimated(isAnimated);
}
}, this);
};
/**
* Updates animated after certain amount of time.
*
* @protected
*/
morning.ui.AnimatedComponent.prototype.updateAnimated = function()
{
var isAnimated = this.isInDocument() && this.inView;
if (isAnimated == this.isAnimated)
{
return;
}
this.setAnimated(isAnimated);
};
/**
* Events enum.
*
* @enum {string}
*/
morning.ui.AnimatedComponent.EventType = {
BOUNDS_UPDATE: 'bounds_update'
};
|
class Element {
constructor(el) {
this.el = el
}
getEl() {
return this.el
}
appendChild(el) {
this.el.appendChild(el.getEl())
}
removeChild(el) {
this.el.removeChild(el.getEl())
}
attr(options) {
this.setAttr(options)
}
setAttr(options) {
//el.setAttributeNS(null, 'transform', 'translate('+0+','+0+')')
Object.keys(options).forEach((key)=>{
this.el.setAttributeNS(null, key, options[key])
})
return this
}
setStyle(options) {
this.el.style = options
}
className(className) {
this.el.setAttributeNS(null, 'class', className)
}
transform(translate) {
this.el.setAttributeNS(null, 'transform', translate)
}
getTextContent(text) {
return this.el.textContent
}
setTextContent(text) {
this.el.textContent = text
}
setInnerHTML(html) {
this.el.innerHTML = html
}
click(onClick) {
this.el.addEventListener('click', (e) => {
onClick(e)
})
}
}
class DraggableElement extends Element {
mouseMoveHandler(onDragging, e) {
if(e.changedTouches && e.changedTouches.length > 0) {
e = e.changedTouches[0]
}
const x = e.clientX
const y = e.clientY
if(this.isDragging) {
const transform = this.el.getAttributeNS(null, 'transform')
onDragging(x - this.draggingX, y - this.draggingY, x, y, e)
}
}
mouseDownHandler(onDragging, onStart, onEnd, e) {
if(e.changedTouches && e.changedTouches.length > 0) {
e = e.changedTouches[0]
}
this.isDragging = true
this.draggingX = e.clientX
this.draggingY = e.clientY
onStart(this.draggingX, this.draggingY)
window.addEventListener('mousemove', this.mouseMoveHandler.bind(this, onDragging), false)
window.addEventListener('touchmove', this.mouseMoveHandler.bind(this, onDragging), false)
window.addEventListener('mouseup', this.mouseUpHandler.bind(this, onDragging, onEnd), false)
window.addEventListener('touchend', this.mouseUpHandler.bind(this, onDragging, onEnd), false)
}
mouseUpHandler(onDragging, onEnd, e) {
if(this.isDragging) {
this.isDragging = false
onEnd(e)
window.removeEventListener('mousemove', this.mouseMoveHandler.bind(this, onDragging), false)
window.removeEventListener('touchmove', this.mouseMoveHandler.bind(this, onDragging), false)
window.removeEventListener('mouseup', this.mouseUpHandler.bind(this, onEnd), false)
window.removeEventListener('touchend', this.mouseUpHandler.bind(this, onEnd), false)
}
}
drag(onDragging, onStart, onEnd) {
//dammy dragging elementが必要？
this.el.addEventListener('mousedown', this.mouseDownHandler.bind(this, onDragging, onStart, onEnd), false)
this.el.addEventListener('touchstart', this.mouseDownHandler.bind(this, onDragging, onStart, onEnd), false)
}
}
const createElement = function(type, _options, style) {
let options = _options || {}
const el = window.document.createElementNS('http://www.w3.org/2000/svg', type);
//el.setAttributeNS(null, 'transform', 'translate('+0+','+0+')')
Object.keys(options).forEach((key)=>{
el.setAttributeNS(null, key, options[key])
})
if(style) {
//el.style = style
}
return new Element(el)
}
const createDraggableElement = function(type, options, style) {
const el = window.document.createElementNS('http://www.w3.org/2000/svg', type);
//el.setAttributeNS(null, 'transform', 'translate('+0+','+0+')')
Object.keys(options).forEach((key)=>{
el.setAttributeNS(null, key, options[key])
})
if(style) {
el.style = style
}
return new DraggableElement(el)
}
const SVGUtil = {
Element,
DraggableElement,
createElement,
createDraggableElement
}
export default SVGUtil
|
import React from 'react'
import bcrypt from 'bcryptjs'
import { connect } from 'react-redux'
import { bindActionCreators, compose } from 'redux';
import Recaptcha from 'react-recaptcha'
import { Redirect } from 'react-router-dom'
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
import { NavLink } from 'react-router-dom';
import Navagation from '../Nav/navagation.js'
import { history, routes } from '../../history.js'
import { RECAPTCHA_SITE_KEY } from '../../constants'
import { RecaptchaAPI, RatePointWebSocket } from '../../api'
import * as Actions from '../../actions/actions.js'
import { caesarShift } from '../../security/security.js'
import { withAuthentication } from '../../hoc'
import Logo from '../../images/logo.png'
import { Button } from '../../util'
import './createAccount.scss'
let recaptchaInstance;
class CreateAccount extends React.Component {
state = {
username: '',
name: '',
email: '',
pass1: '',
pass2: '',
error: []
}
validatePassword = (pass, passCon) => {
if (pass !== passCon) {
return 'Passwords do not match'
}
if (pass.length < 8) {
return 'password must be atleast 8 characters';
}
let symbol = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/.test(pass);
if (!symbol) {
return 'password must include at least one symbol';
}
let symbol2 = /[a-z]/.test(pass);
if (!symbol2) {
return 'password must include at least one lower case character';
}
let symbol3 = /[A-Z]/.test(pass);
if (!symbol3) {
return 'password must include at least one upper case character';
}
let symbol4 = /[0-9]/.test(pass);
if (!symbol4) {
return 'password must include at least one number';
}
return null;
//Check email valid format
//Check username for foul language
};
validateForm = () => {
let errors = []
if(this.state.username.length === 0) {
errors.push("Please Enter Username")
}
if(this.state.email.length === 0) {
errors.push("Please Enter Email")
}
if(this.state.pass1.length === 0) {
errors.push("Please Enter Password")
}
if(this.state.pass2.length === 0) {
errors.push("Please Repeat Password")
}
/*
let passError = this.validatePassword(this.state.pass1,this.state.pass2)
if(passError)
errors.push(passError)
*/
this.setState({
error: errors
})
return errors.length === 0;//Return true valid if 0 errors
}
createRequest = async(e) => {
e.preventDefault();
if(!this.validateForm()) {
console.error("Invalid Form");
return;
}
if(recaptchaInstance)
recaptchaInstance.execute(RECAPTCHA_SITE_KEY, {action: 'create_account'})//will then call verifyCallback
else
console.error("No reCAPTCHA!");
};
verifyCallback = async(response) => {
//DO NOT CHANGE ABOVE LINE, IT STOPS WORKING IF YOU DO
let serverResponse = await RecaptchaAPI.DoVerifyRecaptcha(response)
/*
serverResponse
{
"success": true|false, // whether this request was a valid reCAPTCHA token for your site
"score": number // the score for this request (0.0 - 1.0)
"action": string // the action name for this request (important to verify)
"challenge_ts": timestamp, // timestamp of the challenge load (ISO format yyyy-MM-dd'T'HH:mm:ssZZ)
"hostname": string, // the hostname of the site where the reCAPTCHA was solved
"error-codes": [...] // optional
}
*/
if(serverResponse.success) {
this.attemptCreateUser();
}
else {
this.setState({
error: ["Failed reCAPTCHA"]
})
}
}
attemptCreateUser = () => {
bcrypt.hash(this.state.pass1, 10,(err, hashedPassword) => {
let personProps = {
username: this.state.username,
email: this.state.email,
name: this.state.name,
password: caesarShift(this.state.pass1),// TODO: Remove this trash
biography: ''
};
this.props.Actions.createUser(personProps.username,personProps.email,personProps.name,personProps.biography,personProps.password)
.then(person => {
//Suscessful Login
RatePointWebSocket.connect(person.username)
//this.setState({username:'',email:'', pass1:'', pass2:''});
history.push(routes._HOME)
})
.catch(err => {
alert(err.error);
})
})
}
checkError = () => {
//Check for empty on blur
};
handleInputChange = (event) => {
const target = event.target;
const value = target.type === 'checkbox' ? target.checked : target.value;
const name = target.name;
this.setState({
[name]: value
});
}
render(){
if(this.props.user) {
//Already Logged in
return (
<Redirect to={routes._HOME}/>
)
}
if(history.location === routes._LOGIN || history.location === routes._CREATEACCOUNT) {
}
else {
}
return(
<div className="loginPage">
<div className='clickableContent'>
<div className='login__topBar'>
<a className='arrow' onClick={() => history.goBack()}><FontAwesomeIcon icon="arrow-left" /></a>
<NavLink to={routes._LOGIN}>Login</NavLink>
</div>
<div className="loginFormWrapper">
<div className="createAccountForm">
<div ><img className='login__logo' src={Logo} alt='Logo'/></div>
<form onSubmit={(e) => this.createRequest(e)} noValidate autoComplete="off">
<div className='createAccountFormItem'>
<b>name:</b>
<input type="text" maxLength="20" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='name' value={this.state.name}/>
</div>
<div className='createAccountFormItem'>
<b>email:</b>
<input type="email" maxLength="32" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='email' value={this.state.email}/>
</div>
<div className='createAccountFormItem'>
<b>username:</b>
<input type="text" maxLength="20" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='username' value={this.state.username}/>
</div>
<div className='createAccountFormItem'>
<b>password:</b>
<input type="password" maxLength="32" autoComplete="off" id="pass1"
onChange={this.handleInputChange} onBlur={this.checkError} name='pass1' value={this.state.pass1}/>
</div>
<div className='createAccountFormItem'>
<b>confirm password:</b>
<input type="password" maxLength="32" autoComplete="off" id="pass2"
onChange={this.handleInputChange} onBlur={this.checkError} name='pass2' value={this.state.pass2}/>
</div>
<div className='createAccountFormItem'>
<input type="submit" value="Submit" id="createSubmit"/>
</div>
</form>
{
/*
<form onSubmit={(e) => this.onSubmitLogin(e)}>
<label>Username</label>
<input
type="text"
maxLength="20"
value={this.state.username}
name='username'
onBlur={this.checkError}
onFocus={this.checkError}
onChange={this.handleInputChange}
/>
<label className='passLabel'>Password
<div className='passInput'>
<input
type="password"
type={this.state.inputType}
maxLength="32"
name='pass'
onChange={this.handleInputChange}
onBlur={this.checkError}
onFocus={this.checkError}
value={this.state.pass}
/>
<span className="password-trigger" onClick={() => this.setState({inputType: this.state.inputType === 'password' ? 'text' : 'password'})}>
<FontAwesomeIcon icon={this.state.inputType === 'password' ? 'eye' : 'eye-slash'} />
</span>
</div>
</label>
<div >
<div className='submitBtn'><Button name='Log In' size='medium' onClick={this.onSubmitLogin}/></div>
<hr/>
<div className='login__formFooter'>
{
this.state.error
&&
<div className='errorBox'>{this.state.error}</div>
}
</div>
</div>
</form>
*/
}
</div>
</div>
</div>
<div className="angles">
<svg className="angle bottom-angle" viewBox="0 0 1440 128">
<polygon className='angle' points="1440 957.884 0 894.563 0 1021.205 1440 1021.205" transform="translate(0 -894)"></polygon>
</svg>
<svg className="angle bottom-right-angle" viewBox="0 0 1056 215">
<polygon className='angle' points="1440 807.75 384.781 1021.205 1440 1021.205" transform="translate(-384 -807)"></polygon>
</svg>
<svg className="angle bottom-right-large-angle" viewBox="0 0 1440 425">
<polygon className='angle' points="0 1001.5 0 1024 1440 1024 1440 599.055" transform="translate(0 -599)"></polygon>
</svg>
<svg className="angle top-left-angle" viewBox="0 0 1440 254">
<polygon className='angle' points="0 253.305 0 0 1440 0 1440 58.969" opacity=".15"></polygon>
</svg>
<svg className="angle top-right-angle" viewBox="0 0 720 134">
<polygon className='angle' points="720 0 1439.938 0 1439.938 133.984" transform="translate(-720)" ></polygon>
</svg>
<Recaptcha
ref={e => recaptchaInstance = e}
sitekey={RECAPTCHA_SITE_KEY}
size="invisible"
verifyCallback={this.verifyCallback}
/>
{
this.state.error
&&
<div>
{this.state.error}
</div>
}
</div>
{
/*
<div id="containerCreate">
<div id="formCreate">
<b id="createHeader">Create Account</b>
<div id="positionForm">
<form onSubmit={(e) => this.createRequest(e)} noValidate autoComplete="off">
<br/>
<b>name:</b>
<input type="text" maxLength="20" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='name' value={this.state.name}/>
<br/><br/>
<b>email:</b>
<input type="email" maxLength="32" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='email' value={this.state.email}/>
<br/><br/>
<b>username:</b>
<input type="text" maxLength="20" autoComplete="off"
onChange={this.handleInputChange} required onBlur={this.checkError} name='username' value={this.state.username}/>
<br/><br/>
<b>password:</b>
<input type="password" maxLength="32" autoComplete="off" id="pass1"
onChange={this.handleInputChange} onBlur={this.checkError} name='pass1' value={this.state.pass1}/>
<br/><br/>
<b>confirm password:</b>
<input type="password" maxLength="32" autoComplete="off" id="pass2"
onChange={this.handleInputChange} onBlur={this.checkError} name='pass2' value={this.state.pass2}/>
<br/><br/>
<input type="submit" value="Submit" id="createSubmit"/>
</form>
</div>
</div>
{
this.state.error.length > 0
&&
<div className='formError'>
{this.state.error}
</div>
}
</div>
*/
}
</div>
);
}
}
function mapStateToProps(state) {
return {
user: state.user.currUser
}
}
function mapDispatchToProps(dispatch) {
return {
Actions: bindActionCreators(Actions, dispatch)
};
}
export default compose(
connect(mapStateToProps,mapDispatchToProps)
)(CreateAccount);
|
/**
* 화면 초기화 - 화면 로드시 자동 호출 됨
*/
function _Initialize() {
// 단위화면에서 사용될 일반 전역 변수 정의
// $NC.setGlobalVar({ });
// 그리드 초기화
grdMasterInitialize();
$("#btnClose").click(onCancel); // 닫기버튼
}
/**
* 화면 리사이즈 Offset 세팅
*/
function _SetResizeOffset() {
$NC.G_OFFSET.nonClientHeight = $("#divBottomView").outerHeight() + $NC.G_LAYOUT.nonClientHeight;
}
/**
* 등록팝업 Open 시 호출 됨
*/
function _OnPopupOpen() {
$NC.setValue("#edtQOwn_Brand_Nm", $NC.G_VAR.userData.P_BRAND_NM);
$NC.setValue("#edtQAdjust_Date", $NC.G_VAR.userData.P_ADJUST_DATE);
$NC.setValue("#edtQAdjust_Month", $NC.G_VAR.userData.P_ADJUST_MONTH);
$NC.setValue("#edtQAdjust_Period", $NC.G_VAR.userData.P_ADJUST_START_DATE + "~"
+ $NC.G_VAR.userData.P_ADJUST_END_DATE);
$NC.setValue("#edtQFee_Head_Cd", $NC.G_VAR.userData.P_FEE_HEAD_NM);
$NC.setValue("#edtQFee_Base_Cd", $NC.G_VAR.userData.P_FEE_BASE_NM);
$NC.setInitGridVar(G_GRDMASTER);
// 파라메터 세팅
G_GRDMASTER.queryParams = $NC.getParams({
P_BU_CD: $NC.G_VAR.userData.P_BU_CD,
P_BRAND_CD: $NC.G_VAR.userData.P_BRAND_CD,
P_ADJUST_MONTH: $NC.G_VAR.userData.P_ADJUST_MONTH,
P_ADJUST_DATE: $NC.G_VAR.userData.P_ADJUST_DATE,
P_ADJUST_NO: $NC.G_VAR.userData.P_ADJUST_NO,
P_ADJUST_START_DATE: $NC.G_VAR.userData.P_ADJUST_START_DATE,
P_ADJUST_END_DATE: $NC.G_VAR.userData.P_ADJUST_END_DATE,
P_FEE_HEAD_CD: $NC.G_VAR.userData.P_FEE_HEAD_CD,
P_FEE_BASE_CD: $NC.G_VAR.userData.P_FEE_BASE_CD
});
// 데이터 조회
$NC.serviceCall("/LF01130E/getDataSet.do", $NC.getGridParams(G_GRDMASTER), onGetMaster);
}
/**
* Window Resize Event - Window Size 조정시 호출 됨
*/
function _OnResize(parent) {
var clientWidth = parent.width() - $NC.G_LAYOUT.border1;
var clientHeight = parent.height() - $NC.G_OFFSET.nonClientHeight - 35;
$NC.resizeContainer("#divMasterView", clientWidth, clientHeight);
$NC.resizeGrid("#grdMaster", clientWidth, clientHeight - $NC.G_LAYOUT.header);
}
/**
* Inquiry Button Event - 메인 상단 조회 버튼 클릭시 호출 됨
*/
function _Inquiry() {
}
/**
* 신규
*/
function _New() {
}
/**
* 저장
*/
function _Save() {
}
/**
* 삭제
*/
function _Delete() {
}
/**
* 닫기,취소버튼 클릭 이벤트
*/
function onCancel() {
$NC.setPopupCloseAction("CANCEL");
$NC.onPopupClose();
}
/**
* 저장,확인버튼 클릭 이벤트
*/
function onClose() {
$NC.setPopupCloseAction("OK");
$NC.onPopupClose();
}
function grdMasterOnGetColumns() {
var columns = [ ];
$NC.setGridColumn(columns, {
id: "OWN_BRAND_NM",
field: "OWN_BRAND_NM",
name: "위탁사명",
minWidth: 120
});
$NC.setGridColumn(columns, {
id: "ORDERER_NM",
field: "ORDERER_NM",
name: "주문자명",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "SHIPPER_NM",
field: "SHIPPER_NM",
name: "수령자명",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "WB_NO",
field: "WB_NO",
name: "송장번호",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "DEAL_ID",
field: "DEAL_ID",
name: "딜ID",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "DEAL_NM",
field: "DEAL_NM",
name: "딞명",
minWidth: 120
});
$NC.setGridColumn(columns, {
id: "OPTION_ID",
field: "OPTION_ID",
name: "옵션ID",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "OPTION_VALUE",
field: "OPTION_VALUE",
name: "옵션명",
minWidth: 120
});
$NC.setGridColumn(columns, {
id: "ITEM_CD",
field: "ITEM_CD",
name: "상품코드",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "ITEM_NM",
field: "ITEM_NM",
name: "상품명",
minWidth: 120
});
$NC.setGridColumn(columns, {
id: "ITEM_SPEC",
field: "ITEM_SPEC",
name: "상품규격",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "ITEM_STATE",
field: "ITEM_STATE",
name: "상태",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "QTY_IN_BOX",
field: "QTY_IN_BOX",
name: "입수",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "ORDER_QTY",
field: "ORDER_QTY",
name: "예정수량",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "ENTRY_QTY",
field: "ENTRY_QTY",
name: "등록수량",
minWidth: 90,
cssClass: "align-right"
});
$NC.setGridColumn(columns, {
id: "CONFIRM_QTY",
field: "CONFIRM_QTY",
name: "확정수량",
minWidth: 90,
cssClass: "align-right"
});
$NC.setGridColumn(columns, {
id: "INSPECT_QTY",
field: "INSPECT_QTY",
name: "검수수량",
minWidth: 90,
cssClass: "align-right"
});
$NC.setGridColumn(columns, {
id: "INOUT_NM",
field: "INOUT_NM",
name: "입출고구분",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "OUTBOUND_DATE",
field: "OUTBOUND_DATE",
name: "출고일자",
minWidth: 90,
cssClass: "align-center"
});
$NC.setGridColumn(columns, {
id: "OUTBOUND_NO",
field: "OUTBOUND_NO",
name: "출고번호",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "MALL_NM",
field: "MALL_NM",
name: "몰명",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "INORDER_TYPE_NM",
field: "INORDER_TYPE_NM",
name: "매입형태",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "SHIP_TYPE_NM",
field: "SHIP_TYPE_NM",
name: "운송구분",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "SHIP_PRICE_TYPE_NM",
field: "SHIP_PRICE_TYPE_NM",
name: "운송비구분",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "UNIT_PRICE",
field: "UNIT_PRICE",
name: "운송비",
minWidth: 90,
cssClass: "align-right"
});
$NC.setGridColumn(columns, {
id: "DELIVERY_TYPE_NM",
field: "DELIVERY_TYPE_NM",
name: "배송유형",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "SHIPPER_HP",
field: "SHIPPER_HP",
name: "수령자핸드폰",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "SHIPPER_ADDR",
field: "SHIPPER_ADDR",
name: "수령자주소",
minWidth: 80
});
$NC.setGridColumn(columns, {
id: "CARD_MSG",
field: "CARD_MSG",
name: "배송메세지",
minWidth: 200
});
$NC.setGridColumn(columns, {
id: "BU_DATE",
field: "BU_DATE",
name: "주문일자",
minWidth: 80,
cssClass: "align-center"
});
$NC.setGridColumn(columns, {
id: "BU_NO",
field: "BU_NO",
name: "주문번호",
minWidth: 90
});
$NC.setGridColumn(columns, {
id: "BU_KEY",
field: "BU_KEY",
name: "결제번호",
minWidth: 150
});
return $NC.setGridColumnDefaultFormatter(columns);
}
function grdMasterInitialize() {
var options = {
frozenColumn: 2
};
// Grid Object, DataView 생성 및 초기화
$NC.setInitGridObject("#grdMaster", {
columns: grdMasterOnGetColumns(),
queryId: "LF01130E.RS_SUB2",
sortCol: "ADJUST_DATE",
gridOptions: options
});
G_GRDMASTER.view.onSelectedRowsChanged.subscribe(grdMasterOnAfterScroll);
}
function grdMasterOnAfterScroll(e, args) {
var row = args.rows[0];
if (G_GRDMASTER.lastRow != null) {
if (row == G_GRDMASTER.lastRow) {
e.stopImmediatePropagation();
return;
}
}
// 상단 현재로우/총건수 업데이트
$NC.setGridDisplayRows("#grdMaster", row + 1);
}
function onGetMaster(ajaxData) {
$NC.setInitGridData(G_GRDMASTER, ajaxData);
if (G_GRDMASTER.data.getLength() > 0) {
$NC.setGridSelectRow(G_GRDMASTER, 0);
} else {
$NC.setGridDisplayRows("#grdMaster", 0, 0);
}
}
|
import React, {Component} from 'react'
import ListNav from '../../shared/ListNav'
class LeftNav extends Component{
render(){
return(
<div className="list-group">
<ListNav to="/settings/company/profile" className="list-group-item">Profile</ListNav>
<ListNav to="/settings/company/setup" className="list-group-item">Setup</ListNav>
<ListNav to="/settings/company/jobtitle" className="list-group-item">Job Titles</ListNav>
</div>
)
}
}
export default LeftNav
|
export const ORDER_CREATE_REQUEST = 'ORDER_CREATE_REQUEST';
export const ORDER_CREATE_SUCCESS = 'ORDER_CREATE_SUCCESS';
export const ORDER_CREATE_FAIL = 'ORDER_CREATE_FAIL';
export const MY_ORDER_LIST_REQUEST = 'MY_ORDER_LIST_REQUEST';
export const MY_ORDER_LIST_SUCCESS = 'MY_ORDER_LIST_SUCCESS';
export const MY_ORDER_LIST_FAIL = 'MY_ORDER_LIST_FAIL';
export const ORDER_DELETE_REQUEST = 'ORDER_DELETE_REQUEST';
export const ORDER_DELETE_SUCCESS = 'ORDER_DELETE_SUCCESS';
export const ORDER_DELETE_FAIL = 'ORDER_DELETE_FAIL';
|
import {
xmini,
} from '../config/xmini';
import env from '../config/env';
import { MY_APPID } from '../config/index';
import { modelApis, commonParams, headers } from './api.config';
import request from './request';
import { compact } from '../utils/base/object';
import { storage } from '@xmini/x-mini/lib/index';
// console.log('============== api index.js:');
const version = '4.0.0';
let userInfo = storage.get('userInfo') || {};
// let uuid = storage.get('uuid') || '';
// console.log('userInfo:', userInfo);
// 公共参数
headers.init({
// token: getToken(),
// userId: userInfo.userId || '', // 用户唯一标志
});
// 9779dabbec4c9f30ee2f34e4e07b30cf 10860912
// 41f83388e388218fa1afe1ce5d841b4b 10742171
commonParams.init({
token: userInfo.token,
uid: userInfo.user_id,
zoneId: '857', // 当前收货省份
uuid: userInfo.user_id, // 用户唯一标志
udid: '', // 设备唯一标志
timestamp: '', // 时间
channel: 'wxapp', // 渠道
// cpsName: '', // 废弃
spm: 'hsq_wxapp',
v: version, // 系统版本，用于获取最新版数据
terminal: 'wxapp',// 系统版本，用于获取最新版数据
device: '', // 设备
swidth: '', // 屏幕宽度
sheight: '', // 屏幕高度
/* eslint appx/no-appx-globals: 0 */
location: '', // 地理位置
net: '', // 网络
appid: MY_APPID,
appId: MY_APPID,
});
const regHttp = /^https?/i;
const apiList = Object.keys(modelApis).reduce((api, key) => {
const val = modelApis[key];
const [url, methodType = 'GET'] = val.split(/\s+/).reverse();
const method = methodType.toUpperCase();
api[key] = function postRequest(params, success, fail) {
// url
const originUrl = regHttp.test(url)
? url
: `${env.apiBaseUrl}${url}`;
// weights 接口权重 0没有 1
const { isLoading = true, weights = 0, scope } = params;
delete params.isLoading;
delete params.weights;
delete params.scope;
const temp = compact(Object.assign({}, commonParams.get(), xmini.getChannel(), params));
// console.log(JSON.stringify(temp));
const header = headers.get();
return request.call((scope || null), {
weights,
isLoading,
url: originUrl,
method,
header,
options: temp,
success,
fail,
})
};
return api;
}, {});
apiList.setCommonParams = commonParams.set;
apiList.getCommonParams = commonParams.get;
apiList.setHeader = headers.set;
apiList.getHeader = headers.get;
console.log(apiList)
module.exports = apiList;
|
import components from '@/demo/locale/zh_CN/components';
import route from './route';
export default {
route,
components,
toolbar: {
appname: '我的应用',
settings: '设置',
profile: '资料',
logout: '退出'
},
settings: {
title: '主题设置',
default: '设为默认',
version: '版本',
position: '元素位置',
theme: '主题',
dark: '暗黑主题',
toolbarDense: '紧凑工具栏',
navbarDense: '紧凑导航栏',
navbarLogo: '导航栏Logo',
settingsBtn: '设置按钮',
footer: '页脚'
},
login: {
titleIn: '登录',
titleUn: '注册',
signIn: '登录',
signUp: '注册',
email: 'Email',
password: '密码',
confirm: '确认'
},
errors: {
whoops: '哦嚯~!',
back: '返回!',
301: 'Moved Permanently',
401: '未授权访问',
403: '禁止访问',
404: '页面未找到',
500: '内部服务器错误'
},
guide: {
description: '引导页对于第一次进入项目的人来说是很有用的. 你可以简单的介绍一下项目的特性. Demo是基于',
button: '显示引导信息'
},
ui: {
switch: '切换语言',
theme: '切换主题',
success: '成功',
error: '错误',
warning: '警告',
info: '提示',
primary: '主要',
secondary: '次要',
default: '默认',
accent: '强调',
firstName: '名',
lastName: '姓',
email: 'E-mail'
}
};
|
const express = require("express");
const router = express.Router();
const verifyToken = require("../authentication/verify");
const validation = require("../validation/category");
const bodyparser = require("body-parser");
const db = require("../database/query");
router.use(bodyparser.json());
router.use(bodyparser.urlencoded({ extended: false }));
router.get(`/:name/products`, async function(req, res, next) {
let categories = await db.categoriesQuery();
let result = await db.categoriesNameQuery(req.params.name);
if (result.length == 0) {
next(createError(404, "Url not found"));
} else {
if (req.params.name == "all") {
let products = await db.productsQueryAll();
if (req.headers["content-type"] === "application/json") {
res.json({
products: products,
categories: categories
});
} else {
res.render("cast", {
products: products,
categories: categories
});
}
} else {
for (let i = 1; i < categories.length; i++) {
if (req.params.name == categories[i].name) {
let products = await db.productsQuery(i + 1);
if (req.headers["content-type"] === "application/json") {
res.json({
products: products,
categories: categories
});
} else {
res.render("cast", {
products: products,
categories: categories
});
}
}
}
}
}
});
router.post("/", verifyToken, validation, async (req, res, next) => {
let query = await db.categoriesNameQuery(req.body.name);
if (query.length == 1) {
next(createError(400, "Category already exists"));
} else {
try {
let queryresult = await db.addCategory(req.body.name);
res.status(201).json({
data: {
id: queryresult.insertId,
name: req.body.name
},
message: "Category added"
});
} catch (err) {
next(createError(500, "Database error"));
}
}
});
router.put("/:id", verifyToken, validation, async (req, res, next) => {
let idquery = await db.categoriesId(req.params.id);
if (idquery.length == 1) {
let query = await db.categoriesNameQuery(req.body.name);
if (query.length == 1) {
next(createError(400, "Category name already exists can't be updated"));
} else {
try {
await db.updateCategory(req.body.name, req.params.id);
res.json({
data: {
id: req.params.id,
name: req.body.name
},
message: "Category updated"
});
} catch (err) {
next(createError(500, "Database error"));
}
}
} else {
next(createError(400, "Id doesn't exists"));
}
});
router.delete("/:id", verifyToken, async (req, res, next) => {
let id = req.params.id;
let query = await db.categoriesId(id);
let idquery = await db.categoriesId(req.params.id);
if (idquery.length == 1) {
try {
let queryresult = await db.deleteCategory(id);
res.status(204).json({
data: query,
message: "Deleted Successfully"
});
} catch (err) {
next(createError(500, "Database error"));
}
} else {
next(createError(400, "Category doesn't exists"));
}
});
function createError(status, errmessage) {
router.use((req, res) => {
res.status(status).send(errmessage);
});
}
module.exports = router;
|
/*
Each batch of link maps (of length batchSize) in a batchList will have a forked rssProcessor
*/
const FeedParser = require('feedparser')
const requestStream = require('./request.js')
const sqlConnect = require('./sql/connect.js')
const logLinkErr = require('../util/logLinkErrs.js')
const processAllSources = require('./logic/rss.js')
if (require('../config.json').logging.logDates === true) require('../util/logDates.js')()
let con
Object.defineProperty(Object.prototype, 'size', {
value: function () {
let c = 0
for (var x in this) if (this.hasOwnProperty(x)) c++
return c
},
enumerable: false,
writable: true
})
function getFeed (link, rssList, uniqueSettings, debugFeeds) {
const feedparser = new FeedParser()
const articleList = []
const cookies = (uniqueSettings && uniqueSettings.cookies) ? uniqueSettings.cookies : undefined
let requested = false
setTimeout(function () {
if (!requested) {
try {
process.send({status: 'failed', link: link, rssList: rssList})
console.log(`RSS Error: Unable to complete request for link ${link} during cycle, forcing status update to parent process`)
} catch (e) {}
}
}, 90000)
requestStream(link, cookies, feedparser, function (err) {
requested = true
if (!err) return
logLinkErr({link: link, content: err})
process.send({status: 'failed', link: link, rssList: rssList})
})
feedparser.on('error', function (err) {
logLinkErr({link: link, content: err})
process.send({status: 'failed', link: link, rssList: rssList})
feedparser.removeAllListeners('end')
})
feedparser.on('readable', function () {
let item
while (item = this.read()) {
articleList.push(item)
}
})
feedparser.on('end', function () {
if (articleList.length === 0) return process.send({status: 'success', link: link})
processAllSources(con, rssList, articleList, debugFeeds, link, function (err, results) {
if (err) console.log(err)
if (results) process.send(results)
})
})
}
process.on('message', function (m) {
if (!con) {
con = sqlConnect(function () {
getFeed(m.link, m.rssList, m.uniqueSettings, m.debugFeeds)
})
} else getFeed(m.link, m.rssList, m.uniqueSettings, m.debugFeeds)
})
|
function loadjscssfile(filename, filetype) {
if (filetype == "js") { //if filename is a external JavaScript file
var fileref = document.createElement('script')
fileref.setAttribute("type", "text/javascript")
fileref.setAttribute("src", filename)
document.getElementsByTagName("head")[0].appendChild(fileref)
}
else if (filetype == "css") { //if filename is an external CSS file
var fileref = document.createElement("link")
fileref.setAttribute("rel", "stylesheet")
fileref.setAttribute("type", "text/css")
fileref.setAttribute("href", filename)
document.getElementsByTagName("head")[0].appendChild(fileref)
}
}
const reqpath = document.location;
const data = {
reqpath,
projectSlug: "blogger-afe17daa4960"
}
fetch('http://localhost:3000/api/v1/projects/page-request', {
method: 'POST',
body: JSON.stringify(data),
headers: {
'Content-type': 'application/json; charset=UTF-8'
}
})
.then((resp) => resp.json())
.then(function (data) {
//console.log(data)
// data.filename = "https://pincop.s3.eu-west-1.amazonaws.com/pages/1614853392077.js"
data.filename = "https://pincop.s3.eu-west-1.amazonaws.com/pages/1614854311602.js"
const filename = data.filename;
const filetype = "js"
const resp = loadjscssfile(filename, filetype)
console.log(resp)
console.log(data)
return
})
.catch(function (error) {
console.log(error);
});
|
let memeModel = (function () {
let memeUrl = `appdata/${storage.appKey}/memes?query={}&sort={"_id":-1}`;
const getMemes = function () {
return requester.get(memeUrl);
};
const getAllforGivenUser = function() {
let currentUrl = `appdata/${storage.appKey}/memes?query={"creator":"${storage.getData('userInfo').username}"}&sort={"_id":-1}`;
return requester.get(currentUrl);
};
const create = function (creator, title, description, imageUrl) {
let memeUrl = `appdata/${storage.appKey}/memes`;
let data = {
creator,
title,
description,
imageUrl
};
let authString = btoa(`${storage.appKey}:${storage.appSecret}`);
let headers = { Authorization: 'Basic ' + authString};
return requester.post(memeUrl, data, headers);
};
return {
getAllforGivenUser,
getMemes,
create
}
})();
|
import Navigation from "./navigation";
import Head from "next/head";
import 'remixicon/fonts/remixicon.css'
const Container = (props) => (
<div>
<Head>
<title>{props.title}</title>
<link
rel="stylesheet"
href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap"
/>
<link rel="shortcut icon" href="https://library.kissclipart.com/20180901/ele/kissclipart-rubber-duck-png-clipart-rubber-duck-clip-art-6e4079de63415213.png" type="image/x-icon"/>
</Head>
<Navigation />
<div className="container p-4">{props.children}</div>
</div>
);
export default Container;
|
const express = require('express');
const router = express.Router();
const User = require('../models/User.model');
const bcrypt = require('bcryptjs');
router.get('/login', (req, res) => {
res.render('auth/login');
});
router.post('/login', async (req, res) => {
const { username, password } = req.body;
if (username === '' || password === '') {
res.render('auth/login',
{ errorMessage: 'Indicate username and password' })
return;
}
const user = await User.findOne({ username: username });
if (user === null) {
res.render('auth/login',
{ errorMessage: 'Invalid login' })
return;
}
//The user and password match
if (bcrypt.compareSync(password, user.password)) {
//Sucessful login
req.session.currentUser = user;
res.redirect('/');
// res.render('index', { user });
} else {
//Passwords don't match
res.render('auth/login',
{ errorMessage: 'Invalid login' })
return;
}
});
router.get('/signup', (req, res) => {
res.render('auth/signup');
});
router.post('/signup', async (req, res) => {
const { username, email, password } = req.body;
//Checking for username and password being filled out
if (username === '' || password === '') {
res.render('auth/signup',
{ errorMessage: 'Indicate username and password' })
return;
}
//Check for password strength - Regular Expression
const passwordRegex = /(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,}/
if (passwordRegex.test(password) === false) {
res.render('auth/signup',
{ errorMessage: 'Password is too weak' })
return;
}
//Check if the user already exists
let user = await User.findOne({ username: username });
console.log('user', user);
if (user !== null) {
res.render('auth/signup',
{ errorMessage: 'username already exists' })
return;
}
user = await User.findOne({ email: email });
console.log('user', user);
if (user !== null) {
res.render('auth/signup',
{ errorMessage: 'email already exists' })
return;
}
//Create the user in the database
const saltRounds = 10;
const salt = bcrypt.genSaltSync(saltRounds);
const hashedPassword = bcrypt.hashSync(password, salt);
try {
await User.create({
username,
email,
password: hashedPassword
});
res.redirect('/');
} catch (e) {
res.render('auth/signup',
{ errorMessage: 'Error occurred' })
return;
}
});
router.post('/logout', (req, res) => {
req.session.destroy();
res.redirect('/');
});
module.exports = router;
|
import React, {Component} from 'react';
import {View,Text,StyleSheet,Button,TabNavigator,FlatList,TouchableHighlight,ActivityIndicator} from 'react-native';
import { connect } from 'react-redux';
import { getChalList,setActiveChat } from '../actions/ChatActions';
export class ConversasList extends Component{
static navigationOptions = {
title:'Conversas',
tabBarlabel:'Conversas'
}
constructor(props){
super(props);
this.state = {
loading:true
};
console.disableYellowBox = true;
this.contatoClick = this.contatoClick.bind(this);
this.props.getChalList(this.props.uid , ()=>{
this.setState({loading:false});
}); //Pegando a lista de conversas do usuaruio logado
}
componentDidUpdate(){ //ou componentWillUpdate
if(this.props.activeChat != ''){
//existe uma conversa que tem que ser aberta
this.props.navigation.navigate('ConversaInterna', {title:this.props.activeChatTitle});
}
}
contatoClick(item){
//alert(item.key);
this.props.setActiveChat(item.key);
}
render(){
return(
<View style={styles.container}>
{this.state.loading && <ActivityIndicator size='large'/> /*CONDIÇÃO TERNÁRIA PARA APARECER O LOADING*/}
<FlatList
data={this.props.chats}
renderItem = {({item}) => (
<TouchableHighlight
underlayColor="#DDDDDD"
style={styles.buttonArea} onPress={() => this.contatoClick(item)}>
<View >
<Text>{item.title}</Text>
</View>
</TouchableHighlight>
)}
/>
</View>
);
}
}
const styles = StyleSheet.create({
container: {
margin:10
},
buttonArea:{
height:40,
flex:1,
justifyContent:'center',
paddingLeft:10,
borderBottomWidth:1,
borderBottomColor:'#CCCCCC'
}
});
//retorna user e senha por exemplo
const mapStateToProps = (state)=>{
return {
status:state.auth.status,
uid:state.auth.uid,
activeChat:state.chat.activeChat,
chats:state.chat.chats,
activeChatTitle:state.chat.activeChatTitle
};
};
//checklogin são as ações que podem ser executadas nessa tela, final a tela que vai abrir
const ConversasListConnect = connect(mapStateToProps,{getChalList,setActiveChat })(ConversasList);
export default ConversasListConnect;
|
import React, { Component } from 'react'
import {Text, View} from 'react-native'
import styles from '../style/style'
export default function Header() {
return(
<View style={styles.header}>
<Text style={styles.title}>
B A T T L E S H I P S
</Text>
</View>
)
}
|
import {ADD_ARTICLE, DEL_ARTICLE} from '../constants/action-types';
const initialState = {
articles: []
};
const rootReducer = (state=initialState, action) => {
switch(action.type){
case ADD_ARTICLE:
return {...state, articles: [...state.articles, action.payload]};
case DEL_ARTICLE:
const newArticles = state.articles.filter((article)=>{
if(article.id !== parseInt(action.payload.id))
return article;
});
return {...state, articles: newArticles}
default:
return state;
}
};
export default rootReducer;
|
var express = require('express');
var router = express.Router();
var SocialEventModel = require('../models/social-event');
router.get("/social", function(req,res){
SocialEventModel.find(function(err,socialevent){
res.json(socialevent)
});
});
router.post("/social",function(req,res){
var socialPost = new SocialEventModel();
socialPost.name = req.body.name;
socialPost.time = req.body.time;
socialPost.date = req.body.date;
socialPost.location = req.body.location;
socialPost.address = req.body.address;
socialPost.picture = req.body.picture;
socialPost.description = req.body.description;
socialPost.save(function(){
res.send();
});
});
router.get('/view/:id', function(req,res){
SocialEventModel.findById({_id: req.params.id}, function(err,post){
if(err){
console.log(err);
return res.status(500).send();
}
// console.log(req.params.id);
// return res.status(200).send();
res.json(post);
});
});
module.exports = router;
|
// This script will copy all `.d.ts` files from `lib/` into `dist/`
var fs = require('fs')
var path = require('path')
var rootDir = path.resolve(__dirname, '..')
var distDir = path.join(rootDir, 'dist')
var libDir = path.join(rootDir, 'lib')
function* walk(dir) {
for (var d of fs.readdirSync(dir)) {
var entry = path.join(dir, d)
var stat = fs.lstatSync(entry)
if (stat.isDirectory()) yield* walk(entry)
else if (stat.isFile()) yield entry
}
}
function copy(libFilePath) {
var distFilePath = path.join(distDir, path.relative(libDir, libFilePath))
var dir = path.dirname(distFilePath)
fs.mkdirSync(dir, {recursive: true}) // Need Node.js 10.12.0+
var inputLines = fs.readFileSync(libFilePath, 'utf-8').split('\n')
var outputLines = []
for (var line of inputLines) {
if (line === '// @for-script: REMOVE_ALL_THING_BELOW') {
break
}
outputLines.push(line)
}
fs.writeFileSync(distFilePath, outputLines.join('\n'))
}
function main() {
for (var filePath of walk(libDir)) {
if (filePath.endsWith('.d.ts')) {
copy(filePath)
}
}
}
main()
|
import { combineReducers } from "redux";
import fakeFirebaseReducer from "./reducers/FakeFirebaseReducer";
import fakeFireStoreReducer from "./reducers/FakeFireStoreReducer";
import textMessageVariantReducer from "./reducers/TextMessageVariantReducer";
import mediaMessageVariantReducer from "./reducers/MediaMessageVariantReducer";
import sideNavReducer from "./reducers/SideNavReducer";
const rootReducer = combineReducers({
firebase: fakeFirebaseReducer,
firestore: fakeFireStoreReducer,
sideNav: sideNavReducer,
textMessageVariants: textMessageVariantReducer,
mediaMessageVariants: mediaMessageVariantReducer,
});
export default rootReducer;
|
import Huesped from "./huesped.js"
export default class Reservacion {
constructor(numeroHabitacion, fechaLlegada, noches) {
this.numeroHabitacion = numeroHabitacion
this.fechaLlegada = fechaLlegada
this.noches = noches
this.huespedes = new Array()
}
getFechaFormatoCorto() {
return (`${this.fechaLlegada.getDate()}/${this.fechaLlegada.getMonth()}/${this.fechaLlegada.getFullYear()}`)
}
addHuesped(huesped) {
this.huespedes.push(huesped)
}
getNumHuespedes1() {
return this.huespedes.length
}
printReservacion() {
console.log(`Habitación: ${this.numeroHabitacion}`)
console.log(`Fecha Llegada: ${this.getFechaFormatoCorto()}`)
console.log(`${this.noches} noches reservadas`)
this.huespedes.forEach((huesped, i) => {
console.log(`${i+1}.- ${huesped.getDescripcion()}`)
})
}
}
|
var EventEmitter = require('events').EventEmitter;
var util = require('util');
module.exports = Drawable;
function Drawable() {
EventEmitter.call(this);
}
util.inherits(Drawable, EventEmitter);
Drawable.prototype.renderingContextFactory = {};
Drawable.prototype.getContext = function(name, arg1, arg2, arg3) {
var renderingContextFactory = this.renderingContextFactory[name];
if (!renderingContextFactory)
throw new Error('Unknown rendering context:', name);
return renderingContextFactory(this, arg1, arg2, arg3);
}
|
/**
* Created by DELL on 2017/11/14.
*/
console.log("add");
$ajax({
type:"post",
url:"/addaction",
data:"",
success:function(){
}
});
|
const mongoose = require('mongoose');
const uniqueValidator = require('mongoose-unique-validator');
const EventsModel = new mongoose.Schema({
startingDate: {
type: Date,
required: true
},
endingDate: {
type: Date,
required: true
},
title: {
type: String,
required:true
},
description:{
type:String,
required:true,
},
department: {
type: mongoose.Schema.Types.ObjectId ,
ref: "Product"
},
participants:[
{
name:{
type:String,
},
value:{
type:Number
}
}
]
});
EventsModel.plugin(uniqueValidator, { message: '{PATH} already exists!' });
module.exports = Events = mongoose.model('Events', EventsModel);
|
const algorithmia = require('algorithmia')
const algorithmiaApiKey = require('./credentials/algorithmia.json').apiKey
const sentenceBoundaryDetection = require('sbd')
const watsonApiKey = require('./credentials/watson-nlu.json').apikey
const NaturalLanguageUnderstandingV1 = require('watson-developer-cloud/natural-language-understanding/v1.js')
const state = require('./state.js')
const nlu = new NaturalLanguageUnderstandingV1({
iam_apikey: watsonApiKey,
version: '2018-04-05',
url: 'https://gateway.watsonplatform.net/natural-language-understanding/api/'
})
async function robot(){
const content = state.load()
await fetchContentFromWikipedia(content)
sanitizeContent(content)
breakContentIntoSentences(content)
limitMaximunSentences(content)
await keyWordOfAllSentences(content)
state.save(content)
async function fetchContentFromWikipedia (content){
const algorithmiaAuthenticated = algorithmia(algorithmiaApiKey)//Autenticação
const wikipediaAlgorithmia = algorithmiaAuthenticated.algo('web/WikipediaParser/0.1.2')
const wikipediaResponde = await wikipediaAlgorithmia.pipe(content.searchTerm) //Conteudo Referente pesquisa
const wikipediaContent = wikipediaResponde.get() //Conteudo (dentro a objetos(content) e arrays(imagens))
content.sourceContenOriginal = wikipediaContent.content // add ao objeto
}
function sanitizeContent(content){
const withoutBlanckLinesAndMarkDown = removeBlankLinesAndMarkDown(content.sourceContenOriginal)
const withoutDate = removeDate(withoutBlanckLinesAndMarkDown)
content.sourceContentSanitized = withoutDate
function removeBlankLinesAndMarkDown(text){
const allLines = text.split('\n')
const withoutBlanckLinesAndMarkDown= allLines.filter((line) => {
if(line.trim().length === 0 || line.trim().startsWith('=')){
return false
} else {
return true
}
})
return withoutBlanckLinesAndMarkDown.join(' ')
}
}
function removeDate(text){
return text.replace(/\((?:\([^()]*\)|[^()])*\)/gm, '').replace(/ /g, ' ')
}
function breakContentIntoSentences(content){
content.sentences = []
const sentences = sentenceBoundaryDetection.sentences(content.sourceContentSanitized)
sentences.forEach((sentence) => {
content.sentences.push({
text :sentence,
keywords : [],
images : []
})
})
}
function limitMaximunSentences(content){
content.sentences = content.sentences.slice(0 ,content.maximumSentences)
}
async function keyWordOfAllSentences(content){
for (let sentence of content.sentences){
sentence.keywords = await fetchWatsonAndReturnKeywords(sentence.text)
}
}
async function fetchWatsonAndReturnKeywords(sentence){
return new Promise((resolve, reject) => {
nlu.analyze({
text : sentence,
features : {
keywords : {}
}
}, (error,response) => {
if(error){
reject (error)
return
}
const keywords = response.keywords.map((keyword) => {
return keyword.text
})
resolve(keywords)
})
})
}
}
module.exports = robot
|
import React, { useEffect } from "react";
import ReactGA from "react-ga";
import ResponsiveTest from "./modules/ResponsiveTest";
import Header from "./components/Header";
import Footer from "./components/Footer";
function App() {
useEffect(() => {
ReactGA.initialize("UA-164384148-1");
ReactGA.pageview(window.location.pathname + window.location.search);
}, []);
return (
<div>
<Header />
<div className="container-fluid">
<ResponsiveTest />
</div>
<Footer />
</div>
);
}
export default App;
|
import _ from 'lodash'
import React, { Component } from 'react'
import { Button, Header, Loader } from 'stardust'
const containerStyle = {
position: 'absolute',
top: 0,
bottom: 0,
left: 0,
right: 0,
height: '100vh',
zIndex: 3000,
}
const textStyle = {
position: 'absolute',
padding: '1em',
top: 0,
left: 0,
right: 0,
backgroundImage: 'linear-gradient(180deg, rgba(0, 0, 0, 0.4), rgba(0, 0, 0, 0.2 ))',
zIndex: 4000,
}
const imageStyle = {
position: 'absolute',
backgroundSize: 'cover',
width: '100%',
height: '100%',
zIndex: 2000,
}
// we use slightly random image sizes to ensure we get a new image from unsplash.it
const getImageUrl = () => `url(//unsplash.it/${_.random(1500, 1600)}/${_.random(1100, 1200)}})`
class PageNotFound extends Component {
state = { backgroundImage: getImageUrl() }
getNewImage = () => this.setState({ backgroundImage: getImageUrl() })
render() {
const { backgroundImage } = this.state
return (
<div style={containerStyle}>
<div style={textStyle}>
<Header inverted>
Couldn't find that, but check this out:
</Header>
<Button basic inverted size='mini' onClick={this.getNewImage}>
See Another
</Button>
</div>
<div style={{ ...imageStyle, backgroundImage }} />
<Loader active />
</div>
)
}
}
export default PageNotFound
|
/*
Author: Jonathan Pardo-Cano
Date: 1.25.19
FileName: authenticator.js
*/
var OAuth = require('oauth').OAuth; // importing the authentication module
var config = require('./config.json'); // Loads in standard configurations such as port and tokens
// adding in new properties to the OAuth object in order according to documentation to gain access
var oauth = new OAuth(
config.request_token_url,
config.access_token_url,
config.consumer_key,
config.consumer_secret,
config.oauth_version,
config.oauth_callback,
config.oauth_signature
);
var twitterCredentials = {
oauth_token: "",
oauth_token_secret: "",
access_token: "",
access_token_secret: "",
twitter_id: ""
};
// an object to export the function that can be called by the index.js
module.exports = {
getCredentials: function() {
return twitterCredentials;
},
clearCredentials: function () {
twitterCredentials.oauth_token = "";
twitterCredentials.oauth_token_secret = "";
twitterCredentials.access_token = "";
twitterCredentials.access_token_secret = "";
twitterCredentials.twitter_id = "";
},
get: function(url,access_token, access_token_secret,callback) {
oauth.get.call(oauth, url, access_token, access_token_secret, callback);
},
post: function(url,access_token, access_token_secret, body, callback) {
oauth.post.call(oauth, url,access_token, access_token_secret, body, callback);
},
redirecToTwitterLoginPage: function(req, res){
oauth.getOAuthRequestToken(function(error, oauth_token, oauth_token_secret, results){ //uses the credentials from the oauth object we constructed
if (error) {
console.log(error);
res.send("Authentication failed!");
}
else {
twitterCredentials.oauth_token = oauth_token;
twitterCredentials.oauth_token_secret = oauth_token_secret;
res.redirect(config.authorize_url + '?oauth_token=' + oauth_token); // redirects to the authorize url which allows us to allow the connection to twitter
}
});
},
authenticator: function(req, res, callback) {
if (!(twitterCredentials.oauth_token && twitterCredentials.oauth_token_secret && req.query.oauth_verifier)) {
return callback("Request does not have all required keys");
}
// runs to get the access token using credentials if there is an error it returns it through the callback
oauth.getOAuthAccessToken(twitterCredentials.oauth_token, twitterCredentials.oauth_token_secret, req.query.oauth_verifier, function(error, oauth_access_token, oauth_access_token_secret, results){
if (error){
return callback(error);
}
// using the OAuth tokens it goes to twitter to test the credentials if successful it pulls account data parsing it into readable JSON
oauth.get('https://api.twitter.com/1.1/account/verify_credentials.json', oauth_access_token, oauth_access_token_secret, function(error, data) {
if (error) {
console.log(error);
return callback(error);
}
data = JSON.parse(data);
twitterCredentials.access_token = oauth_access_token;
twitterCredentials.access_token_secret = oauth_access_token_secret;
twitterCredentials.twitter_id = data.id_str;
// console.log(twitterCredentials);
callback();
});
});
}
}
|
import React, { useEffect } from "react";
import { useRouter } from "next/router";
import useAuth from "../../hooks/useAuth";
// For routes that can only be accessed by authenticated users
function GuestGuard({ children }) {
const { isAuthenticated, isInitialized } = useAuth();
const router = useRouter();
useEffect(() => {
if (isInitialized && isAuthenticated) {
router.push("/auth/sign-in");
}
}, [isInitialized, isAuthenticated, router]);
return isInitialized && !isAuthenticated ? (
<React.Fragment>{children}</React.Fragment>
) : (
<React.Fragment />
);
}
export default GuestGuard;
|
import Header from './Header';
import Main from './Main';
import Footer from './Footer';
import PopupWithForm from './PopupWithForm';
import ImagePopup from './ImagePopup';
import React from 'react';
import api from '../utils/api';
import EditProfilePopup from './EditProfilePopup';
import EditAvatarPopup from './EditAvatarPopup';
import AddPlacePopup from './AddPlacePopup';
import { CurrentUserContext } from '../contexts/CurrentUserContext.js';
function App() {
const [isEditAvatarPopupOpen, setIsEditAvatarPopupOpen] = React.useState(false);
const [isEditProfilePopupOpen, setIsEditProfilePopupOpen] = React.useState(false);
const [isAddPlacePopupOpen, setIsAddPlacePopupOpen] = React.useState(false);
const [selectedCard, setSelectedCard] = React.useState(null);
const [currentUser, setCurrentUser] = React.useState({});
const [cards, setCards] = React.useState([]);
React.useEffect(() => {
Promise.all([api.getInitialCards(), api.getUserInfo()])
.then(([cardsData, userData]) => {
setCards(cardsData);
setCurrentUser(userData);
}).catch(err => console.error(err));
}, []);
function handleCardLike(card) {
const isLiked = card.likes.some(i => i._id === currentUser._id);
api.changeLikeCardStatus(card._id, isLiked)
.then(newCard => {
setCards(state => state.map(c => c._id === card._id ? newCard : c));
})
.catch(err => console.error(err));
}
function handleCardDelete(card) {
api.deleteCard(card._id)
.then(_ => {
setCards(state => {
return state.filter(c => c._id !== card._id);
})
}).catch(err => console.error(err));
}
function handleEditAvatarClick() {
setIsEditAvatarPopupOpen(true);
}
function handleEditProfileClick() {
setIsEditProfilePopupOpen(true);
}
function handleAddPlaceClick() {
setIsAddPlacePopupOpen(true);
}
function handleCardClick(card) {
setSelectedCard(card);
}
function closeAllPopups() {
setIsEditAvatarPopupOpen(false);
setIsEditProfilePopupOpen(false);
setIsAddPlacePopupOpen(false);
setSelectedCard(null);
}
function handleUpdateUser(name, about) {
api.setUserInfo(name, about)
.then(userData => {
setCurrentUser(userData);
closeAllPopups();
}).catch(err => console.error(err));
}
function handleUpdateAvatar(avatar) {
api.setUserAvatar(avatar)
.then(userData => {
setCurrentUser(userData);
closeAllPopups();
}).catch(err => console.error(err));
}
function handleAddPlaceSubmit(name, link) {
api.addCard(name, link)
.then(card => {
closeAllPopups();
setCards([card, ...cards]);
}).catch(err => console.error(err));
}
return (
<CurrentUserContext.Provider value={currentUser}>
<div className="page">
<div className="page__container">
<Header />
<Main onEditAvatar={handleEditAvatarClick}
onEditProfile={handleEditProfileClick}
onAddPlace={handleAddPlaceClick}
onCardClick={handleCardClick}
cards={cards}
onCardLike={handleCardLike}
onCardDelete={handleCardDelete}
/>
<Footer />
{/* Попап редактировать профиль */}
<EditProfilePopup isOpen={isEditProfilePopupOpen} onClose={closeAllPopups}
onUpdateUser={handleUpdateUser} />
{/* <!-- Попап добавить карточку --> */}
<AddPlacePopup isOpen={isAddPlacePopupOpen} onClose={closeAllPopups} onAddPlace={handleAddPlaceSubmit} />
{/* <!-- Попап изменить аватар --> */}
<EditAvatarPopup isOpen={isEditAvatarPopupOpen} onClose={closeAllPopups} onUpdateAvatar={handleUpdateAvatar} />
{/* <!-- Попап удаления карточки --> */}
<PopupWithForm title="Вы уверены?"
name='confirm-delete-card'
onClose={closeAllPopups} />
{/* <!-- Попап полной картинки --> */}
<ImagePopup onClose={closeAllPopups} card={selectedCard}/>
</div>
</div>
</CurrentUserContext.Provider>
);
}
export default App;
|
import Image from "../../Image/Image";
import styles from "./featuredStories.module.scss";
import Button from "../../Button/Button";
import { useBreakpoints } from "../../../utils/breakpoints";
const FeaturedStories = ({ contentLeft, contentRight }) => {
const { isTabletCeil } = useBreakpoints();
const mediaView = isTabletCeil ? (
<div className={"container-fluid " + styles.featured_container}>
<div className={styles.overlay_wrapper}>
<Image url={contentLeft.image} />
<div className={styles.overlay}></div>
<div className={"row " + styles.wrapper}>
<div>
<div className={styles.overlay_text}>
<h2 className={styles.title}>Lorem Ipsum Dolor Sit Amet</h2>
<p>
At iam decimum annum in spelunca iacet. Cur tantas regiones
barbarorum pedibus obiit, tot maria transmisit.
</p>
<Button type="button" priority="high">
Contact
</Button>
</div>
</div>
</div>
</div>
<div
className={styles.right_stories_list + " " + styles.right_stories_media}
>
<div className={styles.stories_right}>
<h2 className={styles.title}>{contentRight.title}</h2>
<ul className={styles.list_item}>
{contentRight.items.map((item, key) => (
<li key={key}>
<div className={styles.list_image}>
<img src={item.image} alt={item.image} />
</div>
<div>
<h3 className={styles.list_title}>{item.title}</h3>
<span className={styles.date}>{item.date}</span>
</div>
</li>
))}
</ul>
</div>
</div>
</div>
) : (
<div className={"container-fluid " + styles.featured_container}>
<div className={styles.overlay_wrapper}>
<Image url={contentLeft.image} />
<div className={styles.overlay}></div>
<div className={"row " + styles.wrapper}>
<div>
<div className={styles.overlay_text}>
<h2 className={styles.title}>Lorem Ipsum Dolor Sit Amet</h2>
<p>
At iam decimum annum in spelunca iacet. Cur tantas regiones
barbarorum pedibus obiit, tot maria transmisit.
</p>
<Button type="button" priority="high">
Contact
</Button>
</div>
</div>
<div className={styles.right_stories_list}>
<div className={styles.stories_right}>
<h2 className={styles.title}>{contentRight.title}</h2>
<ul className={styles.list_item}>
{contentRight.items.map((item, key) => (
<li key={key}>
<div className={styles.list_image}>
<img src={item.image} alt={item.image} />
</div>
<div>
<h3 className={styles.list_title}>{item.title}</h3>
<span className={styles.date}>{item.date}</span>
</div>
</li>
))}
</ul>
</div>
</div>
</div>
</div>
</div>
);
return mediaView;
};
export default FeaturedStories;
|
import angular from 'angular';
export default angular.module('player', [])
.factory('player', function($timeout) {
//return {
'ngInject';
var sounf = null;
var current, data, direction, events, filter, lastPod, lastSound, pods, volume;
console.log("soundManager status: soundManager is", soundManager);
pods = [];
lastPod = {};
lastSound = null;
volume = 66;
data = {
feedSlug: ''
};
soundManager.setVolume(volume);
events = {
play: function() {
return $timeout(function() {
lastPod.paused = false;
return lastPod.playing = true;
});
},
stop: function() {
return $timeout(function() {
lastPod.paused = false;
return lastPod.playing = false;
});
},
pause: function() {
return $timeout(function() {
return lastPod.paused = true;
});
},
resume: function() {
return $timeout(function() {
lastPod.paused = false;
return lastPod.playing = true;
});
},
finish: function() {
return $timeout(function() {
lastPod.paused = false;
lastPod.playing = false;
lastPod.position = '';
return skip(lastPod);
});
},
whileplaying: function() {
return $timeout(function() {
lastPod.playPercent = lastSound.position / getDurationEstimate(lastSound) * 100;
lastPod.position = getTime(lastSound.position) + ' / ' + getTime(getDurationEstimate(lastSound));
// if (lastPod.playPercent > 10 && !lastPod.reportedListen) {
// //lastPod.reportedListen = true;
// //return $http.post('/api/report-listen', {
// // podId: lastPod._id
// self.addItem();
// //});
// }
});
},
whileloading: function() {
return $timeout(function() {
return lastPod.loadPercent = lastSound.bytesLoaded / lastSound.bytesTotal * 100;
});
},
error: function(err) {
return console.log(err);
}
};
getTime = function(nMSec) {
var min, nSec, sec;
nSec = Math.floor(nMSec / 1000);
min = Math.floor(nSec / 60);
sec = nSec - (min * 60);
return min + ':' + (sec < 10 ? '0' + sec : sec);
};
getDurationEstimate = function(oSound) {
if (oSound.instanceOptions.isMovieStar) {
return oSound.duration;
} else {
return oSound.durationEstimate || 0;
}
};
skip = function(pod) {
console.log("pod in skip is", pod);
var foundPod, j, len, mpod;
foundPod = false;
if (!pod) {
foundPod = true;
pod = {
url: ''
};
}
for (j = 0, len = pods.length; j < len; j++) {
mpod = pods[j];
if (mpod.url === pod.url) {
foundPod = true;
} else {
if (foundPod && mpod.displayed) {
return togglePlay(mpod);
}
}
}
};
togglePlay = function(item) {
if (lastSound && lastSound.id === item.url) {
if (lastSound.readyState !== 2) {
if (lastSound.playState !== 1) {
return lastSound.play();
} else {
return lastSound.togglePause();
}
}
} else {
if (lastSound) {
soundManager.stop(lastSound.id);
soundManager.unload(lastSound.id);
}
if (lastPod) {
lastPod.playing = false;
lastPod.position = '';
}
console.log('creating sound', item);
lastSound = soundManager.createSound({
id: item.url,
url: decodeURI(item.url),
onplay: events.play,
onstop: events.stop,
onpause: events.pause,
onresume: events.resume,
onfinish: events.finish,
whileplaying: events.whileplaying,
whileloading: events.whileloading,
onerror: events.error
});
lastPod = item;
lastSound.play();
return soundManager.setVolume(volume);
}
};
sortPods = function() {
if (direction && direction.value === 'ASC') {
return pods.sort(function(a, b) {
return a.pubDate - b.pubDate;
});
} else {
return pods.sort(function(a, b) {
return b.pubDate - a.pubDate;
});
}
};
scrollABit = function() {
return $timeout(function() {
return $window.scrollTo($window.scrollX, $window.scrollY + 1);
});
};
return {
getPods: function() {
return pods;
},
getPod: function() {
return lastPod;
},
podClick: function(pod) {
console.log('podClick');
if (!pod) {
return skip(null);
} else {
return togglePlay(pod);
}
},
setVolume: function(vol) {
volume = vol;
return soundManager.setVolume(volume);
},
getVolume: function() {
return volume;
},
setPosition: function(pos) {
console.log("setPosition called, pos is: ", pos);
var nMsecOffset;
nMsecOffset = Math.floor(pos * getDurationEstimate(lastSound));
console.log("nMsecOffset is: ", nMsecOffset);
if (!isNaN(nMsecOffset)) {
nMsecOffset = Math.min(nMsecOffset, lastSound.duration);
}
if (!isNaN(nMsecOffset)) {
console.log("lastSound.setPosition() called");
lastSound.setPosition(nMsecOffset);
}
console.log("returning lastSound.resume()");
return lastSound.resume();
},
setFeedSlug: function(slug) {
return data.feedSlug = slug;
},
setDirection: function(dir) {
database.setDirection({
value: dir
});
direction = database.getDirection();
sortPods();
return scrollABit();
},
getDirection: function() {
if (direction && direction.value) {
return direction.value;
}
return 'DESC';
},
setFilter: function(newFilter) {
database.setFilter({
value: newFilter
});
filter = database.getFilter();
return scrollABit();
},
getFilter: function() {
if (filter && filter.value) {
return filter.value;
}
return 'unlistened';
},
scrollABit: function() {
return scrollABit();
}
};
});
|
/**
*
* The main and only page for Strategy builder for uniswap v3
*
*/
import * as React from 'react';
import {
Col, Row, Card, Empty, Spin, Space, Button, Popover,
} from 'antd';
import { useEffect, useState } from 'react';
import './StrategyBuilder.less';
import '../../assets/Oswald-VariableFont_wght.ttf';
import { useDispatch, useSelector } from 'react-redux';
import { TranslationOutlined } from '@ant-design/icons';
import AddPosition from './AddPosition';
import Header from './Header';
import ChartProfitLoss from './ChartProfitLoss';
import { CHART_TYPE } from '../../utils/types';
import ChartLiquidityOnePct from './ChartLiquidityOnePct';
import ChartVolumeDay from './ChartVolumeDay';
import TablePositions from './TablePositions';
import { selectNow, selectPositions } from './selectors';
import LANGUAGE from '../../translations/types';
import sliceSettings from '../Settings/slice';
import { selectMessages } from '../Settings/selectors';
const { setLanguage } = sliceSettings.actions;
const StrategyBuilder = React.memo(() => {
const messages = useSelector(selectMessages);
const dispatch = useDispatch();
const positions = useSelector(selectPositions);
const now = useSelector(selectNow);
const [isUpdateTimeout, setIsUpdateTimeout] = useState(positions.length);
const [chart, setChart] = useState(CHART_TYPE.PROFIT_LOSS);
useEffect(() => {
setIsUpdateTimeout(true);
setTimeout(() => {
setIsUpdateTimeout(false);
}, 850);
}, [positions, now]);
return (
<Spin tip={messages['Loading...']} spinning={isUpdateTimeout}>
<Popover
className="popover-translation"
content={(
<Space direction="vertical">
<Button
type="text"
color="primary"
size="small"
className="button-language"
onClick={() => dispatch(setLanguage(LANGUAGE.EN))}
>
🍔 English
</Button>
<Button
type="text"
color="primary"
size="small"
className="button-language"
onClick={() => dispatch(setLanguage(LANGUAGE.FR))}
>
🥐 Français
</Button>
</Space>
)}
>
<Button type="primary" shape="circle" icon={<TranslationOutlined />} className="button-translation" />
</Popover>
<Row gutter={[16, 16]} className="w100p pl-22">
<Col span={24} lg={{ span: 8 }}>
<Card className="h100p w100p card-add-range">
<AddPosition />
</Card>
</Col>
<Col span={24} lg={{ span: 16 }}>
<Row gutter={[16, 16]} className="w100p">
<Col span={24}>
<Card className="w100p card-graph-header">
<Header onSelectChart={setChart} selectedChart={chart} />
</Card>
</Col>
<Col span={24}>
<Card className={`w100p card-graph ${chart === CHART_TYPE.PROFIT_LOSS && positions.filter((p) => !p.hide).length === 0 && 'flex-center card-add-range-no-position'}`}>
{chart !== CHART_TYPE.PROFIT_LOSS || positions.filter((p) => !p.hide).length === 0 ? '' : (<ChartProfitLoss />)}
{chart === CHART_TYPE.PROFIT_LOSS && positions.filter((p) => !p.hide).length === 0 ? (<Empty description={messages['No position']} />) : ''}
{chart !== CHART_TYPE.LIQUIDITY_1_PCT ? '' : (<ChartLiquidityOnePct />)}
{chart !== CHART_TYPE.VOLUME_DAY ? '' : (<ChartVolumeDay />)}
</Card>
</Col>
</Row>
</Col>
<Col span={24} className="pr-22">
<Card className="w100p card-position-list">
<TablePositions />
</Card>
</Col>
</Row>
</Spin>
);
});
export default StrategyBuilder;
|
// global variables go at the top
let POINTS = [1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10];
let Letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
let player1score = 0;
let player2score = 0;
// utility functions
// check if is upper
function isupper(str) {
return str === str.toUpperCase();
}
// check if is lower
function islower(str) {
return str === str.toLowerCase();
}
// accesses the index for letters and connects them to the array of POINTS
function getPoints(letter){
let index = Letters.indexOf(letter);
return POINTS[index];
}
// console commands to display functions
console.log("testing point function " + getPoints("x"));
// console commands to display functions
console.log("testing index " + Letters.indexOf("c"));
// demonstrates how to add two integers from a set of strings
function add(x,y){
let sum = x + y;
let string = '$(sum)';
console.log(string.length);
console.log("the sum is ", sum);
}
// example of the addition ^^
add(6,7);
// you can in JS perform an islower/isupper and strlen
function compute_score(word){
let score = 0;
let index = 0;
// calculates for lowercase letters
for (i = 0, n = word.length; i < n; i++){
if (islower(word[i])){
console.log(word[i] + "this is lower case");
// printf("accounting for lower case\n");
// index = word[i]-'a';
}
// same for uppercase letters
if (isupper(word[i])){
console.log(word[i] + " is upper case");
// printf("accounting for upper case\n");
// index = word[i]-'A';
}
console.log("testing word i " + (word[i]));
console.log("testing point function " + getPoints(word[i]));
// score += getPoints(word[i]);
console.log("testing the score " + score);
}
}
// example score
compute_score("Hello");
// calculates the value of each character
function getInputValue() {
// Selecting the input element and get its value
let inputVal = document.getElementById("inputId").value;
// Displaying the value
output();
}
// output the total score value
function output(){
document.getElementById("output").value = inputVal;
}
|
'use strict';
(function () {
var URL = 'https://js.dump.academy/kekstagram';
var SUCCESS = 200;
var TIMEOUT = 10000;
var load = function (url, form, method, onSuccess, onError) {
var xhr = new XMLHttpRequest();
xhr.responseType = 'json';
window.backend.xhr = xhr;
xhr.addEventListener('load', function () {
if (onSuccess) {
if (xhr.status === SUCCESS) {
onSuccess(xhr.response);
} else {
onError('Статус ответа: ' + xhr.status + ' ' + xhr.statusText);
}
}
});
xhr.addEventListener('error', function () {
onError('Произошла ошибка соединения');
});
xhr.addEventListener('timeout', function () {
onError('Запрос не успел выполниться за ' + TIMEOUT + 'мс');
});
xhr.timeout = TIMEOUT;
xhr.open(method, url);
xhr.send(form);
};
window.backend = {
loadPictures: function (onSuccess, onError) {
return load(URL + '/data', '', 'GET', onSuccess, onError);
},
uploadPictures: function (form, onError) {
return load(URL, form, 'POST', '', onError);
},
xhr: ''
};
})();
|
const getAccessUrl = () => {
const authEndpoint = 'https://accounts.spotify.com/authorize'
// Replace with your app's client ID, redirect URI and desired scopes
const clientId = '7a5bd131e8184ad78d98ce4ad2952e7d'
const scopes = [
'user-read-currently-playing',
'user-read-recently-played',
'user-read-playback-state',
'user-modify-playback-state',
'user-top-read',
'user-read-email',
'user-read-private',
'streaming'
]
const url = new URL(authEndpoint)
url.searchParams.set('client_id', clientId)
url.searchParams.set('redirect_uri', process.env.SPOTIFY_CALLBACK)
url.searchParams.set('scope', scopes.join(' '))
url.searchParams.set('response_type', 'token')
return url.href
}
export const accessUrl = getAccessUrl()
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _mongoose = require('mongoose');
var _mongoose2 = _interopRequireDefault(_mongoose);
var _joi = require('joi');
var _joi2 = _interopRequireDefault(_joi);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var Schema = _mongoose2.default.Schema;
var UserSchema = Schema({
_id: Schema.Types.ObjectId,
role: String,
active: Boolean,
firstname: String,
lastname: String,
email: String,
password: String
});
var UserModel = _mongoose2.default.model('users', UserSchema);
UserModel.getAll = function () {
return UserModel.find({});
};
UserModel.removeUser = function (userName) {
return UserModel.remove({ name: userName });
};
UserModel.findEmail = function (find) {
return UserModel.findOne(find);
};
UserModel.getUser = function (id) {
return UserModel.find({ '_id': id, active: true });
};
exports.default = UserModel;
|
import * as React from 'react';
import Exercise from './exercise';
import renderer from 'react-test-renderer';
const Props = {
transcript: '<p>Here is some html<p>',
infoToggle: () => { },
title: 'Pull up'
}
describe('Exercise component', () => {
it('renders correctly', () => {
const tree = renderer.create(<Exercise {...Props} />)
.toJSON();
expect(tree).toMatchSnapshot()
});
});
|
///////////////////////////////
// Author: Bora DAN
// Version: 2.0.4
// 13 March 2015
// http://dribbble.com/bqra
// http://themeforest.com/bqra
// http://twitter.com/bqra
// http://pikselmatik.com
///////////////////////////////
var rS = '.raxus-slider';
var number = 0;
function move(that, pixel) {
that.css({
'-webkit-transform': 'translate3d(' + pixel + ', 0)',
'-moz-transform': 'translate3d(' + pixel + ', 0)',
'-o-transform': 'translate3d(' + pixel + ', 0)',
'-ms-transform': 'translate3d(' + pixel + ', 0)',
'transform': 'translate(' + pixel + ')'
});
}
// slider actions
function raxusSliderGlobal(that,direction){
var e = jQuery(that).parents('.raxus-slider'), rel = e.find('.slider-relative'), action;
var dataShow = parseInt(e.attr('data-show'));
var slide = ( e.attr('data-direction') == 'vertical' ) ? e.find('.slide').eq(dataShow).outerHeight(true) : e.find('.slide').eq(dataShow).outerWidth(true);
var totalSize = e.find('.slide').size()-1;
var totalW = totalSize*slide;
var pixel = slide * dataShow;
var pixelH = slide * dataShow;
var loop = e.attr('data-loop') == 'false';
e.removeAttr('data-playing');
e.find('iframe').remove();
e.find('.play-button, img, .slide .text, .fullscreen').show(0);
jQuery(that).parents('.raxus-slider[data-dots]').find('ul.dots').show(0);
if ( totalW == pixel && direction == '-' ) {
if ( loop ) { return false; } else {
dataShow = 0;
e.attr('data-show', '0');
}
} else if ( dataShow == 0 && direction == '+' ) {
if ( loop ) { return false; } else {
dataShow = totalSize;
e.attr('data-show', totalSize);
}
} else if ( direction == 'dot' ) {
dataShow = jQuery(that).index();
e.attr('data-show', jQuery(that).index());
} else {
dataShow = (direction == '-') ? dataShow+1 : dataShow-1;
e.attr('data-show', dataShow);
}
pixel = slide * dataShow;
action = ( e.attr('data-direction') == 'vertical' ) ? '0, -' + pixel + 'px' : '-' + pixel + 'px, 0';
move(rel,action);
if ( dataShow == totalSize ) {
jQuery(that).parents('.raxus-slider[data-loop]').find('.arrow-r').css('opacity', '0.5');
} else if (dataShow == 0 ) {
jQuery(that).parents('.raxus-slider[data-loop]').find('.arrow-l').css('opacity', '0.5');
} else {
jQuery(that).parents('.raxus-slider[data-loop]').find('.arrow-r, .arrow-l').css('opacity', '1');
}
if ( e.find('.mini-images').length ) {
var miniImgs = e.find('.mini-images'),
miniImgsLi = e.find('.mini-images li');
//mini images selecting
miniImgsLi.removeClass('selected');
miniImgsLi.eq(e.attr('data-show')).addClass('selected');
// mini images direction auto actions
var thumbPixel,
ifDir = ( e.attr('data-thumbnail') == 'left' || e.attr('data-thumbnail') == 'right' ),
miniSlide = ifDir ? miniImgsLi.outerHeight(true) : miniImgsLi.outerWidth(true),
miniSize = miniImgsLi.size()-1,
miniDirSize = ifDir ? e.height() : e.width(),
miniShow = miniDirSize / miniSlide,
miniSelected = e.find('.mini-images li.selected').index(),
margin = ifDir ? 30 : 20,
firstDisplay = parseInt(miniImgsLi.eq(0+number).index());
miniShow = parseInt(miniShow-1);
if ( miniSize-1 >= miniShow ) {
if ( miniSelected == miniImgsLi.slice(-1).index() || miniSelected == miniImgsLi.slice(-2).index() ) {
thumbPixel = -( (miniSize - miniShow) * miniSlide) + margin, number = miniImgsLi.last().index() - miniShow;
} else if ( miniSelected == miniSize && miniShow <= miniSize ) {
thumbPixel = -miniSelected * miniSlide + miniSlide * miniShow, number = miniSelected - miniShow+1;
} else if ( miniSelected == 0 ) {
thumbPixel = 0, number = miniSelected;
} else if ( miniSelected >= firstDisplay + miniShow ) {
thumbPixel = -miniSelected * miniSlide + miniSlide * (miniShow-1), number = miniSelected - miniShow+1;
} else if ( miniSelected <= firstDisplay ) {
thumbPixel = -(miniSelected-1) * miniSlide, number = miniSelected-1;
} else {
thumbPixel = miniImgs.attr('data-thumbwidth');
}
miniImgs.attr('data-thumbwidth', thumbPixel);
thumbPixel = ifDir ? '0, ' + thumbPixel + 'px' : thumbPixel + 'px, 0';
move(miniImgs, thumbPixel);
}
}
dataEqSel();
// dots selecting
e.find('.dots li').removeClass('selected');
e.find('.dots li').eq(e.attr('data-show')).addClass('selected');
// close video
e.find('.close-video').click();
// text animation
rel.find('.slide .text').removeClass('left-animated');
rel.find('.slide:eq('+dataShow+') .text').addClass('left-animated');
}
// functions
function thumbNoSlide() {
jQuery(rS+'[data-thumbnail]').each(function() {
if ( jQuery(this).find('.mini-images li').size() * jQuery(this).find('.mini-images li').outerWidth(true) < jQuery(this).outerWidth() ) {
jQuery(this).find('.mini-images').addClass('no-slide');
}
});
}
function rePositioning() {
jQuery('.raxus-slider[data-thumbnail]').each(function() {
var thumb = jQuery(this).attr('data-thumbnail');
var way = thumb == 'left' || thumb == 'right' ? jQuery(this).find('.mini-images-relative').outerWidth() : jQuery(this).find('.mini-images-relative').outerHeight();
jQuery(this).find('.slider-area').animate({'left':0, 'right':0, 'top': 0, 'bottom':0},0);
jQuery(this).find('.slider-area').css(thumb, way);
});
thumbNoSlide();
jQuery('.raxus-slider').map(function(index, el) {
raxusSliderGlobal('.dots:eq('+index+') li.selected', 'dot');
return this;
});
}
function videoId(data) {
data.match(/http:\/\/(player.|www.)?(vimeo\.com|youtu(be\.com|\.be))\/(video\/|embed\/|watch\?v=)?([A-Za-z0-9._%-]*)(\&\S+)?/);
return {
url: RegExp.$2,
id: RegExp.$5,
site: RegExp.$2 == 'youtube.com' || RegExp.$2 == 'youtu.be' ? 'http://www.youtube-nocookie.com/embed/' : 'http://player.vimeo.com/video/'
}
}
//slides selecting
function dataEqSel() {
jQuery(rS).each(function(){
var t = jQuery(this);
t.find('.slide').removeClass('selected');
var dataEq = t.attr('data-show') == 0 ? null : (t.attr('data-show') - 1);
t.find('.slide:eq(' + dataEq + '), .slide:eq(' + t.attr('data-show') + '), .slide:eq(' + (parseInt(t.attr('data-show')) + 1) + ')').addClass('selected');
});
}
jQuery(function(){
/////////////////////////////
// appends
/////////////////////////////
jQuery(rS).attr('data-show', '0');
// wrap slider area
jQuery(rS+' .slider-relative').wrap('<div class="slider-area"></div>');
jQuery(rS+' .slider-relative .slide img').wrap('<span class="image"></span>');
// first text animation
jQuery(document).ready(function() {
jQuery(rS+' .slider-relative').find('.slide:eq(0) .text').addClass('left-animated');
});
jQuery(rS+' .slider-relative').find('.slide:eq(0)').addClass('selected');
// dots append
jQuery(rS+' .slider-area').append('<ul class="dots"></ul>');
jQuery(rS+' .slider-area').each(function() {
for (var i = jQuery(this).find('.slide').size() - 1; i >= 0; i--) {
jQuery(this).find('.dots').append('<li><span></span></li>')
};
jQuery(this).find('.dots').css('margin-top', -(jQuery(this).find('.dots').height()/2));
});
jQuery(rS+' .slider-area').find('.dots li:eq(0)').addClass('selected');
// arrows append
jQuery(rS+' .slider-area').append('<div class="arrow-l"></div><div class="arrow-r"></div>');
jQuery(rS+'[data-arrows=outer]').find('.arrow-l, .arrow-r').addClass('outer');
// mini images append
jQuery(rS+'[data-thumbnail]').append('<div class="mini-images-relative"><ul data-thumbwidth="0" class="mini-images"></ul></div>');
jQuery(rS+'[data-thumbnail]').each(function() {
var thumb = jQuery(this).attr('data-thumbnail');
for (var i = 0; i <= jQuery(this).find('.slide').size()-1; i++) {
var thumbUrl = jQuery(this).find(".slider-relative li").eq(i).find(".image img");
thumbUrl = thumbUrl.attr('data-thumbnailurl') == null ? thumbUrl.attr("src") : thumbUrl.attr("data-thumbnailurl");
jQuery(this).find('.mini-images').append('<li><span class="img-selected"></span><div class="image"><img src="' + thumbUrl + '" alt="" /></div></li>')
};
var miniCalc = ( thumb == 'bottom' || thumb == 'top' ) ? jQuery(this).find('.mini-images-relative').outerHeight() : jQuery(this).find('.mini-images-relative').outerWidth();
jQuery(this).find('.slider-area').css(thumb, miniCalc+'px');
});
thumbNoSlide();
jQuery(rS+'[data-thumbnail]').find('.mini-images li:eq(0)').addClass('selected');
// fullscreen icon append
jQuery(rS+'[data-fullscreen=show]').append('<span class="fullscreen"></span>');
// tabindex append
jQuery(rS).each(function(index){
jQuery(this).attr('tabindex', index);
});
// slides selecting
dataEqSel();
// auto-play
var autoPlaySelector = jQuery('.raxus-slider[data-autoplay]');
autoPlaySelector.each(function() {
jQuery(this).find('.arrow-r').addClass('autoPlayButton');
autoPlay(jQuery(this).attr('data-autoplay'), jQuery(this));
});
function autoPlay(time, that) {
var playIt = setInterval(function(){
raxusSliderGlobal(that.find('.arrow-r.autoPlayButton'), '-');
}, time);
function stopPlay() {
clearInterval(playIt);
that.find('.arrow-r').removeClass('autoPlayButton');
}
function startPlay(){
if (!( that.find('.close-video').length ))
that.find('.arrow-r').addClass('autoPlayButton');
playIt = setInterval(function(){
raxusSliderGlobal(that.find('.arrow-r'), '-');
}, time);
}
that.on('touchstart', function(){
stopPlay();
});
that.on('touchstart', function(){
startPlay();
});
that.hover(function() {
stopPlay();
}, function() {
if ( that.attr('data-playing') != 'true' ) {
startPlay();
}
});
jQuery(document).on('click touchstart', rS + ' .play-button', function(){
that.attr('data-playing', 'true');
stopPlay();
});
}
// video appends and settings
jQuery('[data-videoUrl]').after('<div class="play-button"></div>');
jQuery(document).on('click touchstart touch', rS + ' .play-button', function(){
var t = jQuery(this);
t.hide(0);
t.prev('img').hide(0);
t.parents('.slide').find('.text').hide(0);
t.parents('.slide').append('<div class="close-video"></div>');
t.parents('.raxus-slider').find('.fullscreen, ul.dots').hide(0);
t.parent().append('<iframe width="' + t.parents('.slide').outerWidth(true) + '" height="' + t.parents('.slide').outerHeight(true) + '" src="' + videoId(t.prev('img').attr('data-videoUrl')).site + videoId(t.prev('img').attr('data-videoUrl')).id + '?rel=0&autoplay=1&fullscreen=0" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe>');
});
jQuery(rS).on('mousedown', '.close-video', function(){
var t = jQuery(this);
t.parents('.raxus-slider').find('.play-button, img, .slide .text, .fullscreen').show(0);
t.parents('.raxus-slider[data-dots]').find('ul.dots').show(0);
t.parent().find('iframe').remove();
t.remove();
t.parents('.raxus-slider').removeAttr('data-playing');
});
// fix caption text
jQuery(rS+' .text strong').after('<div class="clear"></div>');
// other appends
jQuery(rS+' .slide .image').prepend('<div class="vertical-helper"></div>'); // vertical align middle
jQuery(rS+'[data-bgcolor]').each(function(){
jQuery(this).find('.slider-area .slider-relative .slide').css('background-color', jQuery(this).attr('data-bgcolor'));
});
jQuery(rS+'[data-thumbbgcolor]').each(function() {
jQuery(this).find('.mini-images').css('background-color', jQuery(this).attr('data-thumbbgcolor'));
});
// slide button actions
jQuery(document).on('click', '.arrow-r', function(){
raxusSliderGlobal(this, '-');
});
jQuery(document).on('click', '.arrow-l', function(){
raxusSliderGlobal(this, '+');
});
// dot button action
jQuery(document).on('mouseup touchend', '.dots li, .mini-images:not(.no-transition) li', function(){
raxusSliderGlobal(this, 'dot');
});
// touch moves actions
//////////////////////
var startX, thumb, direction, slideWhere, finishLeft, finishTop, finish = 0;
function dirAndThumb(that) {
var dataThumbnail = jQuery(that).parents('.raxus-slider').attr('data-thumbnail'),
dataDirection = jQuery(that).parents('.raxus-slider').attr('data-direction');
thumb = dataThumbnail == 'left' || dataThumbnail == 'right';
direction = dataDirection == 'vertical';
}
function touching(a) {
dirAndThumb(a);
if ( a.className == 'slider-relative' ) {
slideWhere = direction ? parseInt(jQuery(a).position().top) : parseInt(jQuery(a).position().left);
} else if ( a.className == 'mini-images' ) {
slideWhere = thumb ? parseInt(jQuery(a).position().top)-10 : parseInt(jQuery(a).position().left)-10;
}
startX = 0;
finishLeft = -(jQuery(a).find('li').outerWidth(true) * (jQuery(a).find('li').size()-1)) + ( jQuery(a).parents('.mini-images-relative').outerWidth(true) - jQuery(a).find('li').outerWidth(true) )-10;
finishTop = -(jQuery(a).find('li').outerHeight(true) * (jQuery(a).find('li').size()-1)) + ( jQuery(a).parents('.mini-images-relative').outerHeight(true) - jQuery(a).find('li').outerHeight(true) )-10;
finish = thumb ? finishTop : finishLeft;
}
function touchable(that, b, e, event) {
var ifA = parseInt(event.pageY) - parseInt(e.pageY), ifB = parseInt(event.pageX) - parseInt(e.pageX);
jQuery(that).addClass('no-transition');
if ( that.className == 'slider-relative no-transition' ) {
var endPoint = direction ? jQuery('.slide').outerHeight(true) : jQuery('.slide').outerWidth(true);
if ( -(startX - b) < -(endPoint * (jQuery('.slide').size()-1)) || -(startX - b) > 0 ) {
ifA = ifA/12, ifB = ifB/12;
}
startX = direction ? ifA : ifB;
var tWay = direction ? ('0, ' + (b + -(startX)) + 'px') : (b + -(startX) + 'px, 0');
} else if ( that.className == 'mini-images no-transition' ) {
var endPoint = direction ? $('.mini-images li').outerWidth(true) : $('.mini-images li').outerHeight(true);
if ( -(startX - b) > 0 ) {
var tWay = thumb ? ('0, 0') : ('0, 0');
} else if ( -(startX - b) < finish ) {
var tWay = thumb ? ('0,' + finish + 'px') : (finish + 'px, 0');
} else {
startX = thumb ? ifA : ifB;
var tWay = thumb ? ('0, ' + (b + -(startX)) + 'px') : (b + -(startX) + 'px, 0');
}
}
move(jQuery(that), tWay);
}
// mouse touching
jQuery(document).on('mousedown', rS + ' .slider-relative, ' + rS + ' .mini-images:not(.no-slide)', function(event) {
event.preventDefault();
touching(this);
jQuery(this).on('mousemove', function(e) { touchable(this, slideWhere, e, event) });
});
// mobile touching
jQuery(rS + ' .slider-relative, ' + rS + ' .mini-images:not(.no-slide)').map(function() {
this.addEventListener('touchstart', function(event) {
if ( jQuery(rS + ' .slider-relative, ' + rS).attr('data-direction') == 'vertical' ) { event.preventDefault(); }
touching(this);
this.addEventListener('touchmove', function(e) { touchable(this, slideWhere, e.touches[0], event) }, false);
}, false);
});
// big images mouse and mobile touchend
jQuery(document).on('mouseup touchend', rS + ' .slider-relative', function() {
jQuery(this).off('mousemove touchmove').removeClass('no-transition');
var thatR = jQuery(this).parents('.raxus-slider').find('.arrow-r'), thatL = jQuery(this).parents('.raxus-slider').find('.arrow-l');
if ( -(startX) < (-100) ) { raxusSliderGlobal(thatR, '-'); }
else if ( -(startX) > 100 ) { raxusSliderGlobal(thatL, '+'); }
rePositioning();
});
// mini images mouse and mobile touchend
jQuery(document).on('mouseup touchend', rS + ' .mini-images', function(event) {
jQuery(this).off('mousemove touchmove').removeClass('no-transition');
var endDir = thumb ? jQuery(this).position().top : jQuery(this).position().left;
if ( endDir > -10 ) {
move(jQuery(this), ('0, 0') );
} else if ( endDir <= finish ) {
finish = thumb ? ('0, ' + finish + 'px') : (finish + 'px, 0');
move(jQuery(this), finish )
}
});
// disable redirect links when slide
var link = true;
jQuery(rS + ' .slide a').on({
mousedown: function() {
link = true;
jQuery(window).mousemove(function(){ link = false });
},
click: function(e) {
if ( link == false )
e.preventDefault();
}
});
// slide with keyboard buttons action
jQuery('.raxus-slider').keydown(function(event) {
if ( event.which == 39 ) {
raxusSliderGlobal('[data-keypress=true]:focus .arrow-r', '-');
} else if ( event.which == 37 ) {
raxusSliderGlobal('[data-keypress=true]:focus .arrow-l', '+');
}
});
// fullscreen mode actions
jQuery(document).on('click touchstart', '.fullscreen', function(){
jQuery(this).parents('.raxus-slider').focus();
var id = jQuery(this).parents('.raxus-slider').attr('id');
var elem = document.getElementById(id);
if (!document.fullscreenElement && !document.mozFullScreenElement && !document.webkitFullscreenElement && !document.msFullscreenElement ) {
if (elem.requestFullscreen) {
elem.requestFullscreen();
} else if (elem.msRequestFullscreen) {
elem.msRequestFullscreen();
} else if (elem.mozRequestFullScreen) {
elem.mozRequestFullScreen();
} else if (elem.webkitRequestFullscreen) {
elem.webkitRequestFullscreen();
}
} else {
if (document.exitFullscreen) {
document.exitFullscreen();
} else if (document.msExitFullscreen) {
document.msExitFullscreen();
} else if (document.mozCancelFullScreen) {
document.mozCancelFullScreen();
} else if (document.webkitExitFullscreen) {
document.webkitExitFullscreen();
}
}
});
document.addEventListener("fullscreenchange", function () { if (document.fullscreenElement){ rePositioning() } else { rePositioning() } }, false);
document.addEventListener("msfullscreenchange", function () { if (document.msFullscreenElement){ rePositioning() } else { rePositioning() } }, false);
document.addEventListener("mozfullscreenchange", function () { if (document.mozFullScreen){ rePositioning() } else { rePositioning() } }, false);
document.addEventListener("webkitfullscreenchange", function () { if (document.webkitIsFullScreen){ rePositioning() } else { rePositioning() } }, false);
// when window resize
jQuery(window).resize(function(){
rePositioning();
});
});
|
const { ipcRenderer } = window.require('electron');
export function LoadPodcasts() {
return () => {
ipcRenderer.send("AllPodcasts")
}
}
export function LoadFeeds() {
return () => {
ipcRenderer.send("AllFeeds")
}
}
|
const User = require('../model/user');
exports.departmentReq = async (req, res, next) => {
req.check('name', 'Name is required').notEmpty().isString().withMessage('Name Value is in valid');
const errors = req.validationErrors();
if (errors) {
return res.status(400).json({
status: false,
error: errors
});
}
const { hods } = req.body;
if (hods) {
const hodData = await User.findOne({ _id: hods[0].hod });
if (!hodData) {
return res.status(400).json({
status: false,
msg: "HOD Not Found"
});
}
}
next();
}
|
(function () {
'use strict';
angular.module('events.admin')
.directive('defineAnEvent', addEventDirective)
.directive('defineEventDetails', defineEventDetailsDirective)
.directive('linkEventDetails', linkEventDetailsDirective);
function addEventDirective () {
AddEventDirectiveCtrl.$inject = ['$scope', '$log', '$timeout', 'DefineEventService', '$state'];
return {
restrict: 'A',
templateUrl: 'partials/admin/add-event/add-an-event.html',
controller: AddEventDirectiveCtrl,
controllerAs: 'event'
};
function AddEventDirectiveCtrl($scope, $log, $timeout, DefineEventService, $state) {
var event = this;
event.fieldsModel = loadMySavedEdaFieldsModel(); //="edaFieldsModel" - see easy form generator model -
event.dataModel = {}; //data Model: filling form will fill it (submit event will return updated data model)
event.submitButtonText = 'Create Event'; //button text
event.cancelButtonText = 'Cancel'; //button text
event.createEvent = submitFormEvent; //event called on form submit
event.cancelEvent = cancelFormEvent; //event called on form cancel
function loadMySavedEdaFieldsModel(){
return DefineEventService.getEventDefinition();
}
//submit will return updated dataModel in "dataModelSubmitted" parameter
function submitFormEvent(dataModelSubmitted){
DefineEventService.saveEvent(dataModelSubmitted).then(function (response) {
$state.go('addEvent.details', {'eventId': response.data._id, 'eventName': response.data.eventName});
});
}
function cancelFormEvent(){
console.info('Cancel event: you can manage this event in your controller');
}
}
}
function defineEventDetailsDirective () {
DefineEventDetailsDirectiveCtrl.$inject = ['$scope', '$log', '$timeout', 'easyFormSteWayConfig', 'DefineEventService', '$state'];
return {
restrict: 'A',
scope: {
eventId: '=',
eventName: '='
},
templateUrl: 'partials/admin/add-event/add-event-details.html',
controller: DefineEventDetailsDirectiveCtrl,
controllerAs: 'eventDetails'
};
function DefineEventDetailsDirectiveCtrl ($scope, $log, $timeout, easyFormSteWayConfig, DefineEventService, $state) {
var eventDetails = this;
eventDetails.eventName = $scope.eventName;
eventDetails.easyFormGeneratorModel = {};
eventDetails.saveForm = saveForm;
eventDetails.currentLangue = refreshCurrentLanguage();
eventDetails.switchLanguage = switchLanguage;
function switchLanguage(toLanguage){
if(angular.isString){
easyFormSteWayConfig.setLanguage(toLanguage);
refreshCurrentLanguage();
console.info('language changed to ' + eventDetails.currentLangue);
}
}
function refreshCurrentLanguage(){
return easyFormSteWayConfig.getCurrentLanguage();
}
function saveForm(easyFormGeneratorModel){
DefineEventService.saveEventDetails(easyFormGeneratorModel, $scope.eventId);
$state.go('addEvent.linkSubEvents', {'eventId': $scope.eventId, 'eventName': $scope.eventName});
}
}
}
function linkEventDetailsDirective () {
LinkEventDetailsDirectiveCtrl.$inject = ['$scope', '$log', '$timeout', 'easyFormSteWayConfig', 'UpdateEventService', '$state'];
return {
restrict: 'A',
scope: {
eventId: '=',
eventName: '='
},
templateUrl: 'partials/admin/add-event/add-event-linksubevent.html',
controller: LinkEventDetailsDirectiveCtrl,
controllerAs: 'linkEventDetails'
};
function LinkEventDetailsDirectiveCtrl ($scope, $log, $timeout, easyFormSteWayConfig, UpdateEventService, $state) {
var linkEventDetails = this;
linkEventDetails.eventId = $scope.eventId;
linkEventDetails.eventName = $scope.eventName;
linkEventDetails.links = {};
UpdateEventService.getEventDetails(linkEventDetails.eventId).then(function (response) {
linkEventDetails.fullEventDetails = response;
linkEventDetails.eventFields = response.eventDetails.edaFieldsModel;
});
linkEventDetails.saveLinks = function () {
for (var x in linkEventDetails.links) {
if (linkEventDetails.links[x].price) {
var priceObj = {};
priceObj[x] = linkEventDetails.links[x].price;
UpdateEventService.addPrice(linkEventDetails.fullEventDetails._id, priceObj);
}
var sourceFieldType = getType(x);
if (linkEventDetails.links.hasOwnProperty(x)) {
for (var a in linkEventDetails.eventFields) {
if (linkEventDetails.eventFields.hasOwnProperty(a)) {
for (var b in linkEventDetails.eventFields[a].columns) {
if (linkEventDetails.eventFields[a].columns.hasOwnProperty(b)) {
if (linkEventDetails.links[x].targetField && linkEventDetails.links[x].targetField.hasOwnProperty("control")) {
if (linkEventDetails.eventFields[a].columns[b].control.key === linkEventDetails.links[x].targetField.control.key) {
delete linkEventDetails.eventFields[a].columns[b].control.edited;
delete linkEventDetails.eventFields[a].columns[b].control.subtype;
delete linkEventDetails.eventFields[a].columns[b].control.selectedControl;
if (linkEventDetails.links[x].action === "disable" && sourceFieldType !== "select") {
linkEventDetails.eventFields[a].columns[b].control.formlyExpressionProperties = {
"templateOptions['disabled']": "!model['" + x + "']"
};
} else if (linkEventDetails.links[x].action === "enable" && sourceFieldType !== "select") {
linkEventDetails.eventFields[a].columns[b].control.formlyExpressionProperties = {
"templateOptions['disabled']": "model['" + x + "']"
};
} else if (linkEventDetails.links[x].action === "disable" && (sourceFieldType === "basicSelect" || sourceFieldType === "select")) {
linkEventDetails.eventFields[a].columns[b].control.formlyExpressionProperties = {
"templateOptions['disabled']": "model['" + x + "'] == '" + linkEventDetails.links[x].sourceValue.value + "'"
};
} else if (linkEventDetails.links[x].action === "enable" && (sourceFieldType === "basicSelect" || sourceFieldType === "select")) {
linkEventDetails.eventFields[a].columns[b].control.formlyExpressionProperties = {
"templateOptions['disabled']": "model['" + x + "'] != '" + linkEventDetails.links[x].sourceValue.value + "'"
};
}
}
}
}
}
}
}
}
}
function getType (property) {
for (var a in linkEventDetails.eventFields) {
if (linkEventDetails.eventFields.hasOwnProperty(a)) {
for (var b in linkEventDetails.eventFields[a].columns) {
if (linkEventDetails.eventFields[a].columns.hasOwnProperty(b)) {
if (linkEventDetails.eventFields[a].columns[b].control.key === property) {
if (linkEventDetails.eventFields[a].columns[b].control.type === 'basicSelect') {
linkEventDetails.eventFields[a].columns[b].control.type = "select";
}
delete linkEventDetails.eventFields[a].columns[b].control.edited;
delete linkEventDetails.eventFields[a].columns[b].control.subtype;
delete linkEventDetails.eventFields[a].columns[b].control.selectedControl;
return linkEventDetails.eventFields[a].columns[b].control.type;
}
}
}
}
}
}
linkEventDetails.fullEventDetails.eventDetails.edaFieldsModel = linkEventDetails.eventFields;
UpdateEventService.updateEvent(linkEventDetails.fullEventDetails).then(function () {
UpdateEventService.persistLinkDetails(linkEventDetails.links, linkEventDetails.eventId).then(function (response) {
$state.go('manageEvent');
});
}, function (error) {
$log.info('Failure');
});
};
}
}
})();
|
CISearch = function ()
{
// Private members
var that = this;
var _ajax = 0;
var base_url = window.location.origin;
var ajax_base_url = base_url + '/ajax';
var speciality = '#speciality';
var city = '#city';
var search_button = '#go';
var search_results_div = '.search_results';
var result_displayed = 0;
var search_results;
var original_search_results;
var sort_order = 'desc';
/**
* Constructor
*
* @access public
* @return null
*/
that.init = function ()
{
_bindEvents();
};
that.initFillDropdowns = function ()
{
_initGetSpeciality();
_initGetCity();
};
function _initGetSpeciality() {
$.ajax({
type: "GET",
url: ajax_base_url + '/specialities',
beforeSend: function () {
//do nothing
},
success: function (response) {
$(speciality).find(':first-child').remove();
$(speciality).prepend('<option value="">Select Speciality</option>');
response = JSON.parse(response);
$(response.Specialities).each(function () {
var option = $('<option />');
option.attr('value', this.SpecialityID).text(this.SpecialityName);
$(speciality).append(option);
});
},
error: function (response) {
alert("Error :" + response);
},
});
}
function _initGetCity() {
$.ajax({
type: "GET",
url: ajax_base_url + '/cities',
beforeSend: function () {
//do nothing
},
success: function (response) {
response = JSON.parse(response);
$(city).find(':first-child').remove();
$(city).prepend('<option value="">Select City, State</option>');
$(response.Cities).each(function () {
var option = $('<option />');
option.attr('value', this.city_id).attr('state_id', this.state_id).text(this.city_name + ", " + this.state_id);
$(city).append(option);
});
},
error: function (response) {
alert("Error :" + response);
},
});
}
function _displayResults() {
//debugger;
$(search_results).each(function () {
var image = base_url + '/assets/img/icon_no_logo.gif';
if (typeof this.profile_image !== 'undefined') {
if (this.profile_image.length) {
image = this.profile_image;
}
}
//if(typeof this.firstName !== 'undefined' )
var search_result = '<div class="media"><div class="media-left">' +
'<img class="media-object" src="' + image + '">' +
'</div>' +
'<div class="media-body">' +
'<h4 class="media-heading">' + this.firstName + ' ' + this.lastName + '</h4>' +
this.specialityName + '<br />' +
this.city + ', ' + this.state + ', ' + this.postcode + '<br />' +
'</div>' +
'</div>';
$(search_results_div).append(search_result);
search_results.shift();
result_displayed++;
if (result_displayed % 5 == 0) {
$(search_results_div).append('<button id="load-more">more</button>');
return false;
}
});
}
//http://stackoverflow.com/questions/881510/sorting-json-by-values
function sortResults(prop, order) {
search_results = JSON.parse(JSON.stringify(original_search_results));
search_results = search_results.sort(function(a, b) {
if (order == 'asc') {
sort_order = 'desc';
return (a[prop] > b[prop]) ? 1 : ((a[prop] < b[prop]) ? -1 : 0);
} else {
sort_order = 'asc';
return (b[prop] > a[prop]) ? 1 : ((b[prop] < a[prop]) ? -1 : 0);
}
});
}
function _bindEvents() {
$(document).on('click', search_button, function () {
var total_results = 0;
var city_id = $(city).val();
var state_id = $(city + " option:selected").attr("state_id");
var speciality_id = $(speciality).val();
var error = false;
var error_details = [];
result_displayed = 0;
search_results = '';
sort_order = 'desc';
original_search_results = '';
if (city_id === '') {
error_details.push('Please select city');
error = true;
}
if (speciality_id === '') {
error_details.push('Please select state');
error = true;
}
if (error) {
alert(error_details);
return false;
}
var data = {
'city_id': city_id,
'state_id': state_id,
'speciality_id': speciality_id
};
$.ajax({
type: "POST",
url: ajax_base_url + '/search',
data: data,
beforeSend: function () {
$(search_results_div).html('Searching');
},
success: function (response) {
response = JSON.parse(response);
total_results = response.Providers.length;
search_results = response.Providers;
original_search_results = JSON.parse(JSON.stringify(search_results));
if (total_results == 0)
$(search_results_div).html('No record found.');
else {
$(search_results_div).html('');
_displayResults();
}
}
});
});
$(document).on('click', '#load-more', function () {
$(this).remove();
_displayResults();
});
$(document).on('click', '#sort', function () {
sortResults('firstName', sort_order);
$(search_results_div).html('');
_displayResults();
});
$(document).on('click', '#open_search', function () {
var data = {
'open_search_text': $('#open_search_text').val()
};
$.ajax({
type: "POST",
url: ajax_base_url + '/opensearch',
data: data,
beforeSend: function () {
$(search_results_div).html('Searching');
},
success: function (response) {
response = JSON.parse(response);
total_results = response.Providers.length;
search_results = response.Providers;
if (total_results == 0)
$(search_results_div).html('No record found.');
else {
$(search_results_div).html('');
_displayResults();
}
}
});
});
$("#open_search_text").keypress(function (event) {
if (event.which == 13) {
event.preventDefault();
$("#open_search").click();
}
});
}
};
objCISearch = new CISearch();
$(document).ready(function () {
objCISearch.init();
objCISearch.initFillDropdowns();
});
|
// component/sliderColorPicker.js
Component({
/**
* 组件的属性列表
*/
properties: {
// 此处为页面传值进来的数据存储位置
//彩色线条长度
lineLength:{
type:Number, //此处可以规定值的类型
value: '300' //此处可以设置默认值,如果不传值则为默认值
},
sliderBtn:{
type:Number, //此处可以规定值的类型
value: '8' //此处可以设置默认值,如果不传值则为默认值
}
},
/**
* 组件的初始数据
*/
data: {
color:"#FFFFFF",
headX:12
},
/**
* 组件的方法列表
*/
methods: {
hexoToString(x){
x = x.toString(16).toUpperCase()
if(x.length == 1){
return "0"+x;
}
return x
},
moveSlider(e){
let that = this
let x = e.touches[0].x
let y = e.touches[0].y
if(x>=this.data.lineLength + this.data.headX ){
x = this.data.lineLength + this.data.headX
}
if(x<=this.data.headX){
x =this.data.headX
}
// console.log(x)
let color = this.calcuColor(x,this.data.lineLength)
this.setData({
color:color
},()=>{
that.triggerEvent('moveSlider', color)
})
// console.log(color)
this.drawImageBase(x,this.data.headY,color)
},
//FF0000 -> FFFF00 ->00FF00 -> 00FFFF-> 0000FF -> FF00FF
//色带长度 length = 290
//当前滑动距离为 sliderLength = x
//每块色带距离是 perColorLength = length / 5
//滑动到的色带次序 order = sliderLength / perColorLength 取整
//滑动到当前色带的距离 relLength = sliderLength % perColorLength 取余
// relLength_tmp = 255 - relLength 减少量
//x = 255*relLength/perColorLength 十进制数
// order 0 FF0000 -> FFFF00
// order 1 FFFF00 ->00FF00
// order 2 00FF00 -> 00FFFF
// order 3 00FFFF-> 0000FF
// order 4 0000FF -> FF00FF
calcuColor(cur,length){
//255 计算一个速率 从0 - 255
let sliderLength = cur - this.data.headX; //当前滑动距离为
let perColorLength = parseInt(length / 5); //每块色带距离是
let order = parseInt(sliderLength / perColorLength); //滑动到的色带次序
let relLength = parseInt(sliderLength % perColorLength); //滑动到当前色带的距离
let x = parseInt(255*relLength/perColorLength); // 十进制
let x_tmp = 255 - x;
let color = "#FF0000"
switch(order){
case 0:{
color = "#FF0000"
if(relLength = 0){
return color;
}
color = "#FF"+ this.hexoToString(x) +"00"
return color;
}
case 1:{
color = "#FFFF00"
if(relLength = 0){
return color;
}
color = "#"+ this.hexoToString(x_tmp) +"FF00"
return color;
}
case 2:{
color = "#00FF00"
if(relLength = 0){
return color;
}
color = "#00FF"+ this.hexoToString(x)
return color;
}
case 3:{
color = "#00FFFF"
if(relLength = 0){
return color;
}
color = "#00"+ this.hexoToString(x_tmp) +"FF"
return color;
}
case 4:{
color = "#0000FF"
if(relLength = 0){
return color;
}
color = "#"+this.hexoToString(x) +"00FF"
return color;
}
default:{
return "#FF00FF"
}
}
},
drawImageBase(x,y,color){
//初始化方法
const ctx = wx.createCanvasContext('slider',this);
ctx.beginPath();
// ctx.shadowOffsetX = 2; // 阴影Y轴偏移
// ctx.shadowOffsetY = 2; // 阴影X轴偏移
// ctx.shadowBlur = 2; // 模糊尺寸
// ctx.shadowColor = 'rgba(0, 0, 0, 0.5)'; // 颜色
ctx.arc(x,y,this.data.sliderBtn,0,2*Math.PI);
let strokeColor = color
ctx.fillStyle = color;//设置填充颜色
ctx.fill();//开始填充
ctx.strokeStyle= strokeColor;//将线条颜色设置为蓝色
ctx.stroke();
ctx.closePath();
ctx.beginPath();
// Create linear gradient
const grd = ctx.createLinearGradient(this.data.headX,this.data.headY, this.data.lineLength,10)
grd.addColorStop(0, '#FF0000')
grd.addColorStop(0.2, '#FFFF00')
grd.addColorStop(0.4, '#00FF00')
grd.addColorStop(0.6, '#00FFFF')
grd.addColorStop(0.8, '#0000FF')
grd.addColorStop(1, '#FF00FF')
// Fill with gradient
ctx.setFillStyle(grd);//将渐变色渲染入正方形
ctx.fillRect(this.data.headX, this.data.headY, this.data.lineLength, 2);//起点坐标为（20，20），长宽都为120px的正方形
ctx.closePath();
ctx.draw();
}
},
attached(){
//初始化方法
this.setData({
headY : this.data.sliderBtn + 2,
headX: this.data.sliderBtn + 2
},()=>{
this.drawImageBase(this.data.headX,this.data.headY,"#FF0000")
})
}
})
|
const config = require('config.json');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const db = require('_helpers/db');
const { mkactivity } = require('../users/users.controller');
const Quiz = db.Quiz;
const Item = db.Item;
module.exports = {
authenticate,
getAll,
getById,
create,
update,
delete: _delete,
getMatchup,
recordVote,
getResults
};
async function authenticate({ username, password }) {
const user = await Quiz.findOne({ username });
if (user && bcrypt.compareSync(password, user.hash)) {
const token = jwt.sign({ sub: user.id }, config.secret, { expiresIn: '7d' });
return {
...user.toJSON(),
token
};
}
}
async function getAll(userId) {
return await Quiz.find({userId:userId});
}
async function getById(id) {
return await Quiz.findById(id);
}
async function create(quizParam, userId) {
// put items into list
itemlist = []
for (let i = 0; i < quizParam.items.length; i++) {
var item = {
item : quizParam.items[i]["item"],
numSuccess : 0,
emoji: quizParam.items[i]["emoji"]
}
itemlist.push(item)
}
console.log(itemlist)
// create quiz object
var quiz = {
name: quizParam["name"],
quizCreator: quizParam["quizCreator"],
privacyType: quizParam["privacyType"],
items : itemlist,
userId : userId
}
var quizObject = new Quiz(quiz);
await quizObject.save();
}
async function update(id, userParam) {
const user = await User.findById(id);
// validate
if (!user) throw 'User not found';
if (user.username !== userParam.username && await User.findOne({ username: userParam.username })) {
throw 'Username "' + userParam.username + '" is already taken';
}
// hash password if it was entered
if (userParam.password) {
userParam.hash = bcrypt.hashSync(userParam.password, 10);
}
// copy userParam properties to user
Object.assign(user, userParam);
await user.save();
}
async function _delete(id) {
await Quiz.findByIdAndRemove(id);
}
async function getMatchup(quizId){
var quiz = await Quiz.findById(quizId)
var matchup = []
while (matchup.length != 2 || matchup[0].id === matchup[1].id){
matchup = []
for(var i=0;i<2;i++){
var rndIdx = Math.floor(Math.random() * quiz.items.length);
matchup.push(quiz.items[rndIdx])
}
}
return matchup
}
async function recordVote(quizId, itemId){
var found = false
var quiz = await Quiz.findById(quizId)
quiz.items.forEach((item) =>{
if(item.id === itemId){
found = true
item.numSuccess += 1
}
})
if( found){
await quiz.save()
}else{
throw "Item not found!"
}
}
async function getResults(quizId){
var quiz = await Quiz.findById(quizId)
return quiz.items.sort(function(a,b){
if(a.numSuccess < b.numSuccess)return 1
if(a.numSuccess > b.numSuccess)return -1
return 0
});
}
|
import debug from 'debug'
import {createAction} from 'redux-actions'
import _ from 'lodash'
import ApiHelper from '../../api/helper'
import actionTypes from './action-types'
import {getActionType, getPageKey} from './utils'
const dbg = debug('app:shared:page:actions')
export default function(resource, getPromise, altPageName) {
const pageKey = getPageKey(altPageName || resource)
function getPageState(state) {
return _.get(state, `${resource}.${pageKey}`)
}
function get(query, dispatch, scroll) {
dbg('get(%o): query=%o, scroll=%o', pageKey, query, scroll)
const action = scroll ? getActionType(pageKey, actionTypes.MORE) : getActionType(pageKey, actionTypes.GET)
dispatch(createAction(getActionType(pageKey, actionTypes.ACTIVE))())
dispatch(createAction(action, getPromise)(query))
}
return {
filter: (filter) => {
dbg('filter(%o): filter=%o', pageKey, filter)
return (dispatch, getState) => {
filter = _.omit(filter, (s) => { return _.isEmpty(_.trim(s)) })
let {query} = getPageState(getState())
const {sort, limit} = query
query = {
...filter,
sort: _.get(filter, 'sort') || sort,
offset: 0,
limit
}
get(query, dispatch)
}
},
sort: (field, isAscending) => {
dbg('sort(resource): field=%o, is-ascending=%o', pageKey, field, isAscending)
return (dispatch, getState) => {
const {query} = getPageState(getState())
get(
{
...query,
sort: ApiHelper.getSortParam(field, isAscending)
},
dispatch
)
}
},
page: (index) => {
dbg('page(%o): index=%o', pageKey, index)
return (dispatch, getState) => {
const {query} = getPageState(getState())
get(
{
...query,
offset: index * query.limit
},
dispatch
)
}
},
more: () => {
dbg('more(%o)', pageKey)
return (dispatch, getState) => {
const {query} = getPageState(getState())
get(
{
...query,
offset: query.offset + query.limit
},
dispatch,
true
)
}
}
}
}
|
(function(){
'use strict';
angular
.module("app")
.controller("UserController", UserController);
UserController.$inject = ["scheduleService", "subjectService", "studentService","groupService", "loginService", "$state"];
function UserController(scheduleService, subjectService, studentService, groupService, loginService, $state) {
var self = this;
self.userId = 0;
self.user = {};
self.group_name = "";
self.resultOfTest = 0 || localStorage.resultOfTest;
self.isEvent = isEvent;
self.logOut = logOut;
//->DatePicker options
self.userEvents = [];
self.calendarLoad = false;
self.dateEvent = new Date();
//<- the end of DatePicker options
activate();
function activate() {
getUserInfo()
.then(getEventsForUser)
.then(isEvent);
}
function getUserInfo() {
return loginService.isLogged()
.then(function (response) {
self.userId = response.data.id;
return studentService.getStudentById(self.userId)
.then(function (response) {
self.user = response.data[0];
return groupService.getOneGroup(self.user.group_id).then(function (response) {
self.group_name = response.data[0].group_name;
});
});
});
}
function logOut() {
loginService.logOut().then(function (response) {
localStorage.removeItem('userRole');
$state.go('login');
return response;
})
}
function getEventsForUser() {
return scheduleService.getScheduleForGroup(self.user.group_id)
.then(getScheduleForGroupComplete);
}
function getScheduleForGroupComplete(response) {
angular.forEach(response.data, function(schedule, index) {
//we use this variable for datepicker to display info when current date was clicked
self.userEvents[index] = {
date: new Date(schedule.event_date),
status: 'full'
};
getOneSubject(schedule, index);
});
self.calendarLoad = true;
}
function getOneSubject(schedule, index) {
return subjectService.getOneSubject(schedule.subject_id).then(function(response) {
self.userEvents[index].subject_name = response.data[0].subject_name;
});
}
//->DatePicker
self.dateOptions = {
customClass: getDayClass,
showWeeks: true,
startingDay: 1
};
function isEvent(data) {
var dayToCheck = new Date(data).setHours(0,0,0,0);
for (var i = 0; i < self.userEvents.length; i++) {
var currentDay = new Date(self.userEvents[i].date).setHours(0,0,0,0);
if (dayToCheck === currentDay && self.userEvents[i].subject_name) {
self.subject_name = self.userEvents[i].subject_name;
self.event = self.userEvents[i].date;
return true;
}
}
return '';
}
function getDayClass(data) {
var date = data.date,
mode = data.mode;
if (mode === 'day') {
var dayToCheck = new Date(date).setHours(0,0,0,0);
for (var i = 0; i < self.userEvents.length; i++) {
var currentDay = new Date(self.userEvents[i].date).setHours(0,0,0,0);
if (dayToCheck === currentDay) {
return self.userEvents[i].status;
}
}
}
return '';
}
//<- the end of DatePicker
}
}());
|
import React from 'react';
import { useState } from 'react';
export default function Modal({onShowChange, shrLink}) {
const [copied, setCopied] = useState(false);
const handleClick = () => {
onShowChange(false);
}
const clickNdCopy = () => {
var text = document.getElementById('textt').innerText;
var elem = document.createElement("textarea");
document.body.appendChild(elem);
elem.value = text;
elem.select();
document.execCommand("copy");
document.body.removeChild(elem);
setCopied(true);
console.log('it clicked')
}
return (
<div className="modal">
<div className="modal-content">
<div className="modal-header">
<h4 className="modal-title">Sharing is caring</h4>
</div>
<div className="modal-body">
<p className="paragraph" id="textt">{shrLink}</p>
</div>
<div className="modal-footer">
<button onClick ={handleClick} className="button">
Close
</button>
<button onClick={clickNdCopy} className="copy-btn button">
{copied?("Copied!"):("Click'n'Copy")}
</button>
</div>
</div>
</div>
)
}
|
require('dotenv').config();
var request = require('request');
var authentication = require('../../utils/access_token')
var credentials = require('../../utils/Credentials')
async function putCommon(url,body,authToken){
return new Promise((resolve,reject)=>{
var options = {
'method': 'PUT',
'url':`https://management.azure.com/${scope}/providers/Microsoft.Consumption/budgets/${budgetname}?api-version=2019-10-01`,
'headers': {
'Authorization': `Bearer ${authToken}`,
'Content-Type': 'application/json'
},
body: JSON.stringify(body)
};
request(options, async function(error, response) {
if (!error && (response.statusCode == 200 || response.statusCode == 201 || response.statusCode == 202)){
console.log("---------->"+reqData.userId)
if(response.body == ""){
resolve({
"statusCode" : response.statusCode,
"body" : response.body
})
}else{
resolve({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else if(!error && response.statusCode >= 400){
if(response.statusCode == 429 || response.statusCode == 404) {
common(url,body,authToken).then(res=>{
resolve(res)
}).catch(err=>{
reject(err)
})
}else{
console.log("---------->"+reqData.userId)
console.log(response.statusCode)
console.log(response.body)
reject({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else{
console.log(error)
reject(error)
}
})
})
}
async function getCommon(url,body,authToken){
return new Promise((resolve,reject)=>{
var options = {
'method': 'GET',
'url':`https://management.azure.com/${scope}/providers/Microsoft.Consumption/budgets/${budgetname}?api-version=2019-10-01`,
'headers': {
'Authorization': `Bearer ${authToken}`,
'Content-Type': 'application/json'
},
body: JSON.stringify(body)
};
request(options, async function(error, response) {
if (!error && (response.statusCode == 200 || response.statusCode == 201 || response.statusCode == 202)){
console.log("---------->"+reqData.userId)
if(response.body == ""){
resolve({
"statusCode" : response.statusCode,
"body" : response.body
})
}else{
resolve({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else if(!error && response.statusCode >= 400){
if(response.statusCode == 429 || response.statusCode == 404) {
common(url,body,authToken).then(res=>{
resolve(res)
}).catch(err=>{
reject(err)
})
}else{
console.log("---------->"+reqData.userId)
console.log(response.statusCode)
console.log(response.body)
reject({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else{
console.log(error)
reject(error)
}
})
})
}
async function deleteCommon(url,body,authToken){
return new Promise((resolve,reject)=>{
var options = {
'method': 'DELETE',
'url':`https://management.azure.com/${scope}/providers/Microsoft.Consumption/budgets/${budgetname}?api-version=2019-10-01`,
'headers': {
'Authorization': `Bearer ${authToken}`,
'Content-Type': 'application/json'
},
body: JSON.stringify(body)
};
request(options, async function(error, response) {
if (!error && (response.statusCode == 200 || response.statusCode == 201 || response.statusCode == 202)){
console.log("---------->"+reqData.userId)
if(response.body == ""){
resolve({
"statusCode" : response.statusCode,
"body" : response.body
})
}else{
resolve({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else if(!error && response.statusCode >= 400){
if(response.statusCode == 429 || response.statusCode == 404) {
common(url,body,authToken).then(res=>{
resolve(res)
}).catch(err=>{
reject(err)
})
}else{
console.log("---------->"+reqData.userId)
console.log(response.statusCode)
console.log(response.body)
reject({
"statusCode" : response.statusCode,
"body" : JSON.parse(response.body)
})
}
}else{
console.log(error)
reject(error)
}
})
})
}
exports.createBudget = async(req,res)=>{
try{
reqData = req.body
await credentials.getcredentials(req.headers.id).then(async(cred)=>{
console.log("----------",cred)
await authentication.clientCredAuthenticationForMsManagementApi(cred).then(async(resToken)=>{
authManagementResponse = resToken
authToken = authManagementResponse["access_token"]
await putCommon(reqData,authToken).then(async(results)=>{
console.log("--->",results)
res.send(results)
}).catch(err=>{
res.status(400).send(err)
})
}).catch((err)=>{
res.status(400).send(err)
})
}).catch(err=>{
res.status(400).send(err)
})
}catch(err){
console.log(err)
res.status(400).send(err)
}
}
exports.getBudget = async(req,res)=>{
try{
reqData = req.body
await credentials.getcredentials(req.headers.id).then(async(cred)=>{
console.log("----------",cred)
await authentication.clientCredAuthenticationForMsManagementApi(cred).then(async(resToken)=>{
authManagementResponse = resToken
authToken = authManagementResponse["access_token"]
await getCommon(reqData,authToken).then(async(results)=>{
console.log("--->",results)
res.send(results)
}).catch(err=>{
res.status(400).send(err)
})
}).catch((err)=>{
res.status(400).send(err)
})
}).catch(err=>{
res.status(400).send(err)
})
}catch(err){
console.log(err)
res.status(400).send(err)
}
}
exports.deleteBudget = async(req,res)=>{
try{
reqData = req.body
await credentials.getcredentials(req.headers.id).then(async(cred)=>{
console.log("----------",cred)
await authentication.clientCredAuthenticationForMsManagementApi(cred).then(async(resToken)=>{
authManagementResponse = resToken
authToken = authManagementResponse["access_token"]
await deleteCommon(reqData,authToken).then(async(results)=>{
console.log("--->",results)
res.send(results)
}).catch(err=>{
res.status(400).send(err)
})
}).catch((err)=>{
res.status(400).send(err)
})
}).catch(err=>{
res.status(400).send(err)
})
}catch(err){
console.log(err)
res.status(400).send(err)
}
}
|
var routeUtils = require('./route_utils.js');
var logger = require(LIB_DIR + 'log_factory').create("users_route");
var usersImpl = require(IMPLS_DIR + 'users_impl');
var UsersRoute = function(app){
app.get('/users/verify', function(req, res){
usersImpl.verify(req.query.token, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.get('/users/validate_token', function(req, res){
usersImpl.validateToken(req.query.token, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.get('/users/:id', function(req, res){
routeUtils.getById(req, res, usersImpl);
});
app.post('/users', function(req, res){
routeUtils.create(req, res, usersImpl);
});
app.put('/users/update_password', function(req, res){
usersImpl.updatePassword(req.body.email, req.body.password, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.put('/users/:id', function(req, res){
routeUtils.update(req, res, usersImpl);
});
app.get('/users', function(req, res){
routeUtils.search(req, res, usersImpl);
});
app.post('/users/authenticate', function(req, res){
usersImpl.authenticate(req.body.username, req.body.password, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.post('/users/signup', function(req, res){
usersImpl.signup(req.body.username, req.body.password, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.post('/users/forgot', function(req, res){
usersImpl.forgot(req.body.username, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
app.post('/users/send_verification', function(req, res){
usersImpl.sendVerificationEmail(req.body.username, function(err, data){
if(err == undefined){
routeUtils.respond(req, res, data);
}else{
routeUtils.respond(req, res, err);
}
});
});
};
module.exports = function(app){
return new UsersRoute(app);
};
|
const form = document.getElementById('form')
form.addEventListener('submit', (e) => {
e.preventDefault();
let email= document.getElementById('email').value;
let data = {
email
}
let convertData = JSON.stringify(data);
localStorage.setItem('lead', convertData)
if (email) {
alert('E-mail cadastrado!');
}
})
|
const { deepEqual } = require('assert')
const Context = require('../db/strategies/base/contextStrategy')
const Postgres = require('../db/strategies/postgres/postgres')
const yugiohSchema = require('../db/strategies/postgres/schemas/yugiohSchema')
const { MOCK_CARD_CREATE, MOCK_CARD_UPDATE } = require('./mocks')
describe('Postgres Strategy', function () {
this.timeout(Infinity)
let context = null
this.beforeAll(async () => {
const connection = await Postgres.connect()
const model = await Postgres.defineModel(connection, yugiohSchema)
context = new Context(new Postgres(connection, model))
await context.create(MOCK_CARD_UPDATE)
})
it('PostgreSQL Connection', async () => {
const res = await context.isConnected()
deepEqual(res, true)
})
it('Should create a card', async () => {
const res = await context.create(MOCK_CARD_CREATE)
delete res.id
deepEqual(res, MOCK_CARD_CREATE)
})
it('Should read a card given its name', async () => {
const [res] = await context.read({ name: MOCK_CARD_CREATE.name })
delete res.id
deepEqual(res, MOCK_CARD_CREATE)
})
it('Should update a card', async () => {
const [prevCard] = await context.read({ name: MOCK_CARD_UPDATE.name })
const updates = {
...MOCK_CARD_UPDATE,
name: 'The Winged Dragon of Ra'
}
const [statusUpdate] = await context.update(prevCard.id, updates)
deepEqual(statusUpdate, 1)
const [updatedCard] = await context.read({ id: prevCard.id })
deepEqual(updatedCard.name, updates.name)
})
it('Should remove a card', async () => {
const [card] = await context.read()
const res = await context.delete(card.id)
deepEqual(res, 1)
})
})
|
;
// form表单使用ajax提交
/*
* @params object data layuiFormData
* @params function succCallBack 成功回调函数
* @params function errorCallBack 失败回调函数
* */
function formAjax(data, succCallBack, errorCallBack) {
var formData = data.field;
var method = data.form.method ? data.form.method : 'post';
var url = data.form.action;
$.ajax({
url: url,
type: method,
data: formData,
beforeSend: function () {
this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
},
success: function (result, statusText, xhr, $form) {
if (result.code == 0) {
layer.msg(result.msg, {icon: 1, time: 2000});
if (result.data && result.data.url) {
location.href = result.data.url;
} else {
if (succCallBack && typeof (succCallBack) == "function") {
succCallBack(result);
} else {
window.parent.location.reload();
}
}
} else {
layer.msg(result.msg, {icon: 2, time: 2000});
if (errorCallBack && typeof (errorCallBack) == "function") {
errorCallBack(result);
} else {
window.parent.location.reload();
}
}
},
error: function (error) {
},
complete: function (result) {
layer.close(this.layerIndex);
},
});
}
// ajax提交
/*
* @params url url Url
* @params object data 提交数据
* @oarams string method 提交方式
* @params function succCallBack 成功回调函数
* @params function errorCallBack 失败回调函数
* */
function ajaxCommon(url, data, method = 'post', succCallBack, errorCallBack, isShowToast = true) {
$.ajax({
url: url,
type: method,
data: data,
beforeSend: function () {
this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
},
success: function (result, statusText, xhr, $form) {
if (result.code == 0) {
if (isShowToast) {
layer.msg(result.msg, {icon: 1, time: 2000});
}
if (result.data && result.data.url) {
location.href = result.data.url;
} else {
if (succCallBack && typeof (succCallBack) == "function") {
succCallBack(result);
} else {
window.parent.location.reload();
}
}
} else {
if (isShowToast) {
layer.msg(result.msg, {icon: 2, time: 2500});
}
if (errorCallBack && typeof (errorCallBack) == "function") {
errorCallBack(result);
} else {
window.parent.location.reload();
}
}
},
error: function (error) {
},
complete: function (result) {
layer.close(this.layerIndex);
},
});
}
// 刷新页面数据
function refreshViewData (tableElemId, formElemId) {
if (!tableElemId) {
window.location.reload();
}
layui.use(['form', 'table'], function () {
var option = {};
var formElem = formElemId ? '#' + formElemId : 'form';
var formOption = $(formElem).serializeArray();
$.each(formOption, function() {
option[this.name] = this.value;
});
var table = layui.table;
table.reload(tableElemId, {
where: option,
});
return false; //阻止表单跳转。如果需要表单跳转，去掉这段即可。
});
}
// 单文件上传
function upFile(elem, url, fileSize, accept, acceptMime, suffix) {
layui.use('upload', function () {
var $ = layui.jquery
, upload = layui.upload;
//普通图片上传
var uploadInst = upload.render({
elem: elem,
url: url,
size: fileSize,
acceptMime: acceptMime,
accept: accept, // 文件类型 file|普通文件， video|视频， audio|音频
exts: suffix, //只允许上传压缩文件
choose: function (obj) {
//预读本地文件示例，不支持ie8
obj.preview(function (index, file, result) {
// console.log(result);
$(elem).parent('.layui-upload').children('div:first').find('img:first').attr('src', result); //图片链接（base64）
});
},
done: function (res) {
if (res.code == 0) {
layer.msg(res.msg, {icon: 1, time: 2000});
$(elem).parent('.layui-upload').children('div:first').find('input:first').val(res.data.asset_id); //图片链接（base64）
} else {
layer.msg(res.msg, {icon: 2, time: 2000});
}
layer.photos({
photos: $(elem).parent('.layui-upload').children('div:first'),
});
},
error: function () {
//演示失败状态，并实现重传
var demoText = $('#demoText');
demoText.html('<span style="color: #FF5722;">上传失败</span> <a class="layui-btn layui-btn-xs up-file-reload">重试</a>');
demoText.find('.up-file-reload').on('click', function () {
uploadInst.upload();
});
}
});
});
}
//多图片上传
function upManyFile(elem, imageList, url, formKey, startAction, fileNum, fileSize, accept, acceptMime, suffix) {
// console.log(fileNum);
layui.use('upload', function () {
var $ = layui.jquery,
upload = layui.upload;
//多文件列表示例
var imageListView = $(imageList);
var uploadListIns = upload.render({
elem: elem,
url: url,
size: fileSize,
accept: accept, // 文件类型 file|普通文件， video|视频， audio|音频
acceptMime: acceptMime, // 可选择类型
exts: suffix, // 文件后缀
multiple: true, // 是否开启多文件
auto: true, // 是否开启自动上传
bindAction: startAction,
choose: function (obj) {
var files = this.files = obj.pushFile(); //将每次选择的文件追加到文件队列
//读取本地文件
obj.preview(function (index, file, result) {
// 判断图片数量
if (imageListView.children().length >= (fileNum)) {
layer.msg(`最多可以上传张${fileNum}图片`, {icon: 7, time: 2000});
delete files[index]; //删除对应的文件
return false;
}
// 移动按钮
var moveStr = `<button type="button" class="layui-btn layui-btn-xs btn-move-up">上移</button>
<button type="button" class="layui-btn layui-btn-xs btn-move-down">下移</button>`;
// 预览信息
var tr = $([
`<tr id="upload-${index}">
<td>${file.name}</td>
<td><img height="80px" src="${result}" alt="${file.name}" class="layui-upload-img"></td>
<td>${(file.size / 1014).toFixed(1)}kb</td>
<td><span class="up-image" data-up="false">等待上传</span></td>
<td>
<button type="button" class="layui-btn layui-btn-xs up-file-reload layui-hide">重传</button>
<button type="button" class="layui-btn layui-btn-xs layui-btn-danger img-delete">删除</button>
${moveStr}
</td>
</tr>`
].join(''));
//单个重传
tr.find('.up-file-reload').on('click', function () {
obj.upload(index, file);
});
//删除
tr.find('.img-delete').on('click', function () {
delete files[index]; //删除对应的文件
// 删除节点
tr.remove();
uploadListIns.config.elem.next()[0].value = ''; //清空 input file 值，以免删除后出现同名文件不可选
// 更新图片数量
$(elem).siblings('.file-count').text(imageListView.children().length);
});
// 插入信息
imageListView.append(tr);
// 更新图片数量
$(elem).siblings('.file-count').text(imageListView.children().length);
});
}
, done: function (res, index, upload) {
if (res.code == 0) { //上传成功
var tr = imageListView.find('tr#upload-' + index)
, tds = tr.children();
// 更改文本内容
tds.eq(3).html('<span class="up-image" data-up="true" style="color: #5FB878;">上传成功</span>');
// 插入form数据
tds.eq(4).append(`<input type="hidden" name="${formKey}[]" value="${res.data.asset_id}">`); //清空操作
return delete this.files[index]; //删除文件队列已经上传成功的文件
}
this.error(index, upload);
}
, error: function (index, upload) {
var tr = imageListView.find('tr#upload-' + index)
, tds = tr.children();
tds.eq(3).html('<span style="color: #FF5722;">上传失败</span>');
tds.eq(4).find('.up-file-reload').removeClass('layui-hide'); //显示重传
}
});
});
}
// 图片列表渲染
function imgList (elem, data, formKey) {
var length = data ? data.length : 0;
$(elem).parents('.img-list').prev().children('.file-count').text(length);
var imageListView = $(elem);
// 如果没有图片更改提示
if (length <= 0) {
var tr = `<tr>
<td colspan="5">您还没有上传图片</td>
</tr>`;
imageListView.append(tr);
} else {
// 渲染预览信息
data.forEach(function(v,i){
/*var moveStr = '';
if (i <= 0) {
moveStr = `<button type="button" class="layui-btn layui-btn-xs btn-move-down">下移</button>`;
} else if (i >=4) {
moveStr = `<button type="button" class="layui-btn layui-btn-xs btn-move-up">上移</button>`;
} else {
moveStr = `<button type="button" class="layui-btn layui-btn-xs btn-move-up">上移</button>
<button type="button" class="layui-btn layui-btn-xs btn-move-down">下移</button>`;
}*/
var moveStr = `<button type="button" class="layui-btn layui-btn-xs btn-move-up">上移</button>
<button type="button" class="layui-btn layui-btn-xs btn-move-down">下移</button>`;
var tr = $([
`<tr id="upload-${i}">
<td>${v.asset_filename}</td>
<td><img height="80px" src="${v.asset_file_path}" alt="${v.asset_filename}" class="layui-upload-img"></td>
<td>${(v.asset_file_size / 1014).toFixed(1)}kb</td>
<td><span class="up-image" data-up="${v.asset_id < 1 ? 'false' : 'true'}">${v.asset_id < 1 ? '丢失' : '已上传'}</span></td>
<td class="td-action">
<button type="button" class="layui-btn layui-btn-xs layui-btn-danger img-delete">删除</button>
${moveStr}
<input type="hidden" name="${formKey}[]" value="${v.asset_id}">
</td>
</tr>`
].join(''));
//删除
tr.find('.img-delete').on('click', function () {
tr.remove();
$(elem).siblings('.file-count').text(imageListView.children().length);
});
imageListView.append(tr);
});
}
}
|
import React, { Component } from 'react';
import { Route, Switch } from 'react-router-dom';
import { TransitionGroup, CSSTransition } from 'react-transition-group';
import './scss/App.css';
import frontEndProjects from './data/frontEndProjects';
import repetitiveProjects from './data/repetitiveProjects';
import transitionHandler from './helper/transitionHandler';
import Header from './components/Header';
import Intro from './components/Intro';
import Projects from './components/Projects';
import CaseStudy from './components/CaseStudy';
import Contact from './components/Contact';
import backEndProjects from './data/backEndProjects';
const { Lethargy } = require('lethargy');
// Cross-browser bind without using JQuery, taken from http://stackoverflow.com/a/3076693/3966682
function addEvent(el, eventType, handler) {
if (el.addEventListener) { // DOM Level 2 browsers
el.addEventListener(eventType, handler, false);
} else if (el.attachEvent) { // IE <= 8
el.attachEvent('on' + eventType, handler);
} else { // ancient browsers
el['on' + eventType] = handler;
}
};
class App extends Component {
state = {
pageIsAnimating: false,
showMouseUpIcon: false,
sideNavIsOpen: false, // header stuff
ariaHidden: true, // header stuff
navIsAnimating: false, //header stuff
mostRecentProjectVisited: null
}
componentDidMount = () => {
const { location, addHistory } = this.props;
addHistory(location);
// scroll event listener
/* window.addEventListener('wheel',this.detectScroll, {passive: true}); */
let el = document.querySelector('.app');
this.detectSwipe(el, swipedir => {
switch(swipedir) {
case 'up':
this.movementHandler('scrollDown');
break;
case 'down':
this.movementHandler('scrollUp');
break;
default:
break;
}
});
// ============================================================
const lethargy = new Lethargy(20,10,0.10);
// Define the function to run on mousewheel
const checkScroll = e => {
// Lethargy.check() must only be called once per mouse event
// If you need to use the result in more than one place
// you MUST store it as a variable and use that variable instead
// See https://github.com/d4nyll/lethargy/issues/5
const result = lethargy.check(e);
// false means it's not a scroll intent, 1 or -1 means it is
if (result === 1) {
this.movementHandler('scrollUp');
} else if (result === -1) {
this.movementHandler('scrollDown');
}
};
// Cross-browser way to bind to mouse events
addEvent(window, 'mousewheel', checkScroll);
addEvent(window, 'DOMMouseScroll', checkScroll);
addEvent(window, 'wheel', checkScroll);
addEvent(window, 'MozMousePixelScroll', checkScroll);
// ============================================================
}
handleMouseUpIcon = boolean => this.setState({showMouseUpIcon: boolean});
handleNav = (toggle= false) => {
const openSideNav = () => {
document.body.style.overflow = "hidden";
setTimeout( () => this.setState({ariaHidden: false}),10);
setTimeout( () => this.setState({navIsAnimating: false}),500);
}
const closeSideNav = () => {
if (this.state.sideNavIsOpen) {
this.setState({ariaHidden: true});
setTimeout( () => this.setState({sideNavIsOpen: false, navIsAnimating: false}),500);
}
}
const toggleSideNav = () => {
this.setState({sideNavIsOpen: true, navIsAnimating: true});
this.state.sideNavIsOpen ? closeSideNav() : openSideNav();
};
if (!this.state.navIsAnimating) toggle ? toggleSideNav() : closeSideNav();
}
movementHandler = direction => {
const { location } = this.props;
if (!this.state.pageIsAnimating) {
if (direction === 'scrollDown' &&
location.pathname === '/'
) {
this.props.history.push('/projects');
this.setState({pageIsAnimating: true});
} else if (
direction === 'scrollUp' &&
location.pathname === '/projects'
) {
this.props.history.push('/');
this.setState({pageIsAnimating: true});
} else if (
direction === 'scrollUp' &&
this.props.repetitiveProjects[location.pathname] &&
window.pageYOffset === 0 // 0 pageYOffset is top of page
) {
this.props.history.push('/projects');
this.setState({pageIsAnimating: true});
} else if (
direction === 'scrollDown' &&
location.pathname === '/projects' &&
this.state.mostRecentProjectVisited
) {
this.props.history.push(`${this.state.mostRecentProjectVisited}`);
this.setState({pageIsAnimating: true});
}
}
}
handleMostRecentProject = projectPathName => this.setState({mostRecentProjectVisited: projectPathName});
/* detectScroll = e => {
let delta = e.wheelDelta ? e.wheelDelta : -1 * e.deltaY;
// Negative delta is scroll down, positive delta is scroll up
let direction = delta < 0 ? 'scrollDown' : 'scrollUp';
this.movementHandler(direction);
} */
detectSwipe = (el, callback) => {
const { location } = this.props;
let touchsurface = el,
swipedir,
startX,
startY,
distX,
distY,
threshold = 100, //required min distance traveled to be considered swipe
restraint = 200, // maximum distance allowed at the same time in perpendicular direction
allowedTime = 500, // maximum time allowed to travel that distance
elapsedTime,
startTime,
handleswipe = callback || function(swipedir){}
touchsurface.addEventListener('touchstart', e => {
const touchobj = e.changedTouches[0];
swipedir = 'none';
startX = touchobj.pageX;
startY = touchobj.pageY;
startTime = new Date().getTime(); // record time when finger first makes contact with surface
// e.preventDefault()
}, {passive: true})
touchsurface.addEventListener('touchmove', e => {
if (
location.pathname === '/' ||
location.pathname === '/projects'
) {
e.preventDefault();
}
}, false)
touchsurface.addEventListener('touchend', e => {
let touchobj = e.changedTouches[0]
distX = touchobj.pageX - startX // get horizontal dist traveled by finger while in contact with surface
distY = touchobj.pageY - startY // get vertical dist traveled by finger while in contact with surface
elapsedTime = new Date().getTime() - startTime // get time elapsed
if (elapsedTime <= allowedTime){ // first condition for awipe met
if (Math.abs(distX) >= threshold && Math.abs(distY) <= restraint){ // 2nd condition for horizontal swipe met
swipedir = (distX < 0)? 'left' : 'right' // if dist traveled is negative, it indicates left swipe
}
else if (Math.abs(distY) >= threshold && Math.abs(distX) <= restraint){ // 2nd condition for vertical swipe met
swipedir = (distY < 0)? 'up' : 'down' // if dist traveled is negative, it indicates up swipe
}
}
handleswipe(swipedir)
// e.preventDefault();
}, {passive: true})
}
childFactoryCreator = () => {
const { historyObject } = this.props;
const { from, to } = historyObject;
const { classNames, enter, timeout } = transitionHandler(from, to);
return (
(child) => {
return ( React.cloneElement(child, { classNames, enter, timeout }) )
}
);
}
render() {
const { location, history, frontEndProjects } = this.props;
const { pageIsAnimating } = this.state;
// do not allow transition interruptions
if (!this.unblock && pageIsAnimating) {
this.unblock = history.block();
}
if (this.unblock && !pageIsAnimating) {
this.unblock();
this.unblock = null;
}
const scrollablePages = {
'/projects/tic-tac-toe': true,
'/projects/calculator': true,
'/projects/random-quote-machine': true,
'/projects/pomodoro-clock': true
};
return (
<div className={scrollablePages[`${location.pathname}`] ? 'app scrollable' : 'app'}>
<Header
location={location}
isAnimating={this.state.pageIsAnimating}
sideNavIsOpen={this.state.sideNavIsOpen}
ariaHidden={this.state.ariaHidden}
navIsAnimating={this.state.navIsAnimating}
handleHamburger={this.handleNav}
closeSideNav={this.handleNav}
showMouseUpIcon={this.state.showMouseUpIcon}
/>
<TransitionGroup
component={null}
childFactory={this.childFactoryCreator()}
>
<CSSTransition
key={location.pathname}
timeout={0}
onEnter={() => {
document.body.style.overflow = "hidden";
this.setState(() => ({pageIsAnimating: true}));
}}
onExited={() => {
const { to } = this.props.historyObject;
this.setState(() => ({pageIsAnimating: false}));
if (to !== '/' && to !== '/projects') {
document.body.style.overflow = "auto";
}
}}
>
<Switch location={location}>
<Route exact path={`/`} render={props =>
<Intro
{...props}
isAnimating={this.state.pageIsAnimating}
/>}
/>
<Route exact path={`/projects/`} render={props =>
<Projects
{...props}
projects={frontEndProjects}
mostRecentProject={this.handleMostRecentProject}
/>}
/>
{frontEndProjects.map( project => (
<Route key={project.title} exact path={`/projects/${project.title}`} render={props =>
<CaseStudy
{...props}
project={project}
enableMouseUpIcon={this.handleMouseUpIcon}
/>}
/>
))}
<Route exact path={`/contact`} render={props =>
<Contact
{...props}
/>}
/>
</Switch>
</CSSTransition>
</TransitionGroup>
</div>
);
}
}
App.defaultProps = {
repetitiveProjects,
frontEndProjects
};
export default App;
|
var fs = require('fs');
var EE = require('events').EventEmitter;
var fileEvents = new EE();
var Transform = module.exports = function(){
this.readFile = function(file, callback) {
fs.readFile(file, function(err, data) {
if (err) return console.log(err);
callback(null, data);
fileEvents.emit('donebitmap', data);
});
};
};
|
import React from 'react';
import Login from './login';
import MainScreen from './MainScreen'
import GamePlay from './GamePlay'
import Answer from './Answer'
import Correct from './Correct'
import Wrong from './Wrong'
import GameOver from './GameOver'
import {createSwitchNavigator,createAppContainer} from 'react-navigation';
export default class App extends React.Component {
render() {
return (
<TopLevelNavig/>
);
}
}
const AppStackNavigator=
createSwitchNavigator(
{
login:Login,
MainScreen:MainScreen,
GamePlay:GamePlay,
Answer:Answer,
Correct:Correct,
Wrong:Wrong,
GameOver:GameOver
},
{
initialRouteName: 'login',
});
const TopLevelNavig = createAppContainer(AppStackNavigator);
|
import React, {Component} from 'react';
class AddGroup extends Component {
constructor(props) {
super(props)
this.state= {
name: '',
nameTrainer:'',
}
this.saveGroup = this.saveGroup.bind(this)
}
saveGroup = (e) => {
e.preventDefault();
let group = {name: this.state.name, nameTrainer:this.state.nameTrainer}
this.props.history.push('/group')
}
onChange = (e) =>
this.setState({[e.target.name]: e.target.value});
render() {
return (
<div>
<h2 className="text-center">Add Group</h2>
<from>
<div className="from-group">
<label>Group Name:</label>
<input type="text" placeholder="Group Name" name="group name" className="form-control" value={this.state.name} onChange={this.onChange}/>
</div>
<div className="from-group">
<label>Trainer name:</label>
<input type="text" placeholder="Trainer name" name="trainer name" className="form-control" value={this.state.name} onChange={this.onChange}/>
</div>
<button className="btn-saveGroup" onClick={this.saveGroup}>Save</button>
</from>
</div>
);
}
}
export default AddGroup;
|
var express = require("express");
var consolidate = require("consolidate")
var application = express();
var server = require("http").Server(application);
var io = require("socket.io")(server);
application.use(
express.static("./public")
);
application.engine("html", consolidate.mustache);
application.set("view engine", "html");
application.set("views", "./views");
application.get("/", function (request, response) {
response.render("index", {
"partials" : {
"styles" : "partials/styles",
"header" : "partials/header",
"scripts" : "partials/scripts"
}
});
});
application.get("/playground/led", function (request, response) {
response.render("playground/led", {
"partials" : {
"styles" : "../partials/styles",
"header" : "../partials/header",
"scripts" : "../partials/scripts",
"hr" : "../partials/hr",
"connect" : "../partials/connect",
"led_pin_mode" : "../partials/led_pin_mode",
"led_on_off" : "../partials/led_on_off"
}
});
});
application.get("/playground/photocell", function (request, response) {
response.render("playground/photocell", {
"partials" : {
"styles" : "../partials/styles",
"header" : "../partials/header",
"scripts" : "../partials/scripts",
"hr" : "../partials/hr",
"connect" : "../partials/connect",
"photocell_listen" : "../partials/photocell_listen"
}
});
});
function debug(value) {
console.log(value);
}
function info(io, socket, key, value) {
io.emit(key, value);
}
function error(io, socket, key, value) {
io.emit(key, value);
}
var board;
var led9;
var led10;
var led11;
var photocell;
var five = require("johnny-five");
try {
io.on("connection", function (socket) {
debug("user connected");
socket.on("disconnect", function () {
debug("user disconnected");
});
socket.on("instruction", function (message) {
debug("instruction: " + message);
if (message == "connect") {
if (board) {
error(io, socket, "message", "Already connected to Arduino");
} else {
board = new five.Board();
board.on("ready", function () {
info(io, socket, "message", "Connected to Arduino");
});
board.on("error", function (e) {
error(io, socket, "message", e.message);
});
}
}
if (message == "led-pin-mode") {
if (board) {
led9 = new five.Led(9);
led10 = new five.Led(10);
led11 = new five.Led(11);
info(io, socket, "message", "Pin mode set");
} else {
error(io, socket, "message", "You must first connect to Arduino");
}
}
if (message == "led-9-on") {
if (board && led9) {
led9.on();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "led-9-off") {
if (board && led9) {
led9.off();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "led-10-on") {
if (board && led10) {
led10.on();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "led-10-off") {
if (board && led10) {
led10.off();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "led-11-on") {
if (board && led11) {
led11.on();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "led-11-off") {
if (board && led11) {
led11.off();
} else {
error(io, socket, "message", "You must first connect to Arduino and set pin mode");
}
}
if (message == "photocell-listen") {
if (board) {
photocell = new five.Sensor({
"pin" : "A0",
"freq" : 250
});
photocell.on("data", function () {
info(io, socket, "photocell-value", this.value);
});
} else {
error(io, socket, "message", "You must first connect to Arduino");
}
}
});
});
} catch (e) {
socket.broadcast.emit("message", e);
}
server.listen(3000, function () {
debug("listening on http://127.0.0.1:3000");
});
|
export const SEARCH_PENDING = 'SEARCH_PENDING';
export const SEARCH_RESULT = 'SEARCH_RESULT';
|
import React from "react";
import "./root.component.css";
import App from "./App";
export default function Root() {
return <App></App>;
}
|
const express = require('express');
const loginRouter = express.Router();
const Logindata = require('../model/Logindata')
function router(nav){
loginRouter.get('/',function(req,res){
res.render("login",
{
nav,
title:'login'
});
});
loginRouter.post('/success',function (req,res) {
const { username, password } = req.body;
console.log(username, password );
Logindata.findOne({username:username})
.then(function(user){
console.log(user);
if(password==user.password){
console.log("sucess");
res.redirect('/books');
}
else{
res.render('incorrectpassword');
}
});
// res.redirect('/books/none');
});
return loginRouter;
}
module.exports = router;
|
(function() {
let vgap = 250/700
state = {
dragtarget: false,
oldpt: [
-1.03,
0.13
],
w: 520,
h: 500,
origin: [
500,
120
],
ppm: 700,
background: [0, 61, 92],
items: [
{
type: 'js',
init(state) {
return
// place barrier at right location
let D = findObject(state, 'light#1'),
L1 = findObject(state, 'lens#1'),
L2 = findObject(state, 'lens#2'),
B = findObject(state, 'barrier#1')
// swap around
if (L1.position[0]>L2.position[0]) {
[L1, L2] = [L2, L1]
}
let Vin1 = 1/(D.position[0]-L1.position[0]),
Vout1 = Vin1+L1.power,
img1 = 1/Vout1,
Vin2 = 1/(img1-(L2.position[0]-L1.position[0])),
Vout2 = Vin2 + L2.power,
img2 = 1/Vout2
if (img2<0) {
img2 = 2.345
}
B.position[0] = B.position[2] = L2.position[0]+img2
if (B.barrieroff) {
B.position[0] += 2
B.position[2] += 2
}
}
},
{
type:'p5',
id:'labels',
init(state) {
// occurs after js item, so we can read out values & save them
this.L1 = findObject(state,'lens#1')
this.L2 = findObject(state,'lens#2')
this.object = findObject(state, 'light#1')
this.B = findObject(state, 'barrier#1')
},
draw(p5, vbox, ppm) {
// draw the gap between the two lenses
let L1 = this.L1,
L2 = this.L2,
gap = Math.abs(L1.position[0]-L2.position[0]),
bottom = Math.min(L1.position[1]-this.L1.aperture/2, L2.position[1]-this.L2.aperture/2)
// swap lenses around
if (L1.position[0]>L2.position[0]) {
[L1, L2] = [L2, L1]
}
// label the powers
p5.fill(255)
p5.noStroke()
p5.textSize(16)
p5.textAlign(p5.CENTER,p5.BOTTOM)
p5.textStyle(p5.ITALIC)
let s = p5.createSpan('<em>F<sub>1</sub></em>'),
pos = [ppm*L1.position[0], ppm*(L1.position[1]+L1.aperture/2)+25]
pos = [state.origin[0]+pos[0], state.origin[1]-pos[1]]
s.position(...pos)
s.class('note')
s = p5.createSpan('<em>F<sub>2</sub></em>'),
pos = [ppm*L2.position[0], ppm*(L2.position[1]+L2.aperture/2)+25]
pos = [state.origin[0]+pos[0], state.origin[1]-pos[1]]
s.position(...pos)
s.class('note')
// label the gap
p5.stroke(255)
p5.line(ppm*L1.position[0], ppm*bottom-10, ppm*L2.position[0], ppm*bottom-10)
p5.arrow(ppm*L1.position[0], ppm*bottom-10, -1, 0, 6, 3)
p5.arrow(ppm*L2.position[0], ppm*bottom-10, 1, 0, 6, 3)
p5.fill(255)
p5.noStroke()
p5.textSize(12)
p5.textAlign(p5.CENTER,p5.TOP)
p5.yup_text('d', ppm*(L1.position[0]+L2.position[0])/2, ppm*bottom-15)
// label the distance to the image
let img = this.B.position[0],
imgdist = img - L2.position[0]
if (imgdist!=2.345 && imgdist>0) {
p5.noFill()
p5.stroke(255)
p5.line(ppm*L2.position[0]+4, ppm*bottom-10, ppm*(L2.position[0]+imgdist), ppm*bottom-10)
p5.arrow(ppm*(L2.position[0]+imgdist), ppm*bottom-10, 1, 0, 6, 3)
p5.fill(255)
p5.noStroke()
p5.textSize(12)
p5.textAlign(p5.CENTER,p5.TOP)
p5.yup_text('1 / BVP',
ppm*(L2.position[0]+imgdist/2),
ppm*bottom-15)
p5.textAlign(p5.LEFT,p5.BOTTOM)
p5.textStyle(p5.NORMAL)
p5.yup_text('focal point', ppm*img+10, 0)
}
}
},
{
type:'p5',
id:'labels.1',
init(state) {
// occurs after js item, so we can read out values & save them
this.L1 = findObject(state,'lens#1.1')
this.L2 = findObject(state,'lens#2.1')
this.object = findObject(state, 'light#1.1')
this.B = findObject(state, 'barrier#1.1')
},
draw(p5, vbox, ppm) {
// draw the gap between the two lenses
let L1 = this.L1,
L2 = this.L2,
gap = Math.abs(L1.position[0]-L2.position[0]),
bottom = Math.min(L1.position[1]-this.L1.aperture/2, L2.position[1]-this.L2.aperture/2)
// swap lenses around
if (L1.position[0]>L2.position[0]) {
[L1, L2] = [L2, L1]
}
// label the powers
p5.fill(255)
p5.noStroke()
p5.textSize(16)
p5.textAlign(p5.CENTER,p5.BOTTOM)
p5.textStyle(p5.ITALIC)
let s = p5.createSpan('<em>F<sub>1</sub></em>'),
pos = [ppm*L1.position[0], ppm*(L1.position[1]+L1.aperture/2)+25]
pos = [state.origin[0]+pos[0], state.origin[1]-pos[1]]
s.position(...pos)
s.class('note')
s = p5.createSpan('<em>F<sub>2</sub></em>'),
pos = [ppm*L2.position[0], ppm*(L2.position[1]+L2.aperture/2)+25]
pos = [state.origin[0]+pos[0], state.origin[1]-pos[1]]
s.position(...pos)
s.class('note')
// label the gap
p5.stroke(255)
p5.line(ppm*L1.position[0], ppm*bottom-10, ppm*L2.position[0], ppm*bottom-10)
p5.arrow(ppm*L1.position[0], ppm*bottom-10, -1, 0, 6, 3)
p5.arrow(ppm*L2.position[0], ppm*bottom-10, 1, 0, 6, 3)
p5.fill(255)
p5.noStroke()
p5.textSize(12)
p5.textAlign(p5.CENTER,p5.TOP)
p5.yup_text('d', ppm*(L1.position[0]+L2.position[0])/2, ppm*bottom-15)
// label the distance to the image
let img = this.B.position[0],
imgdist = img - L1.position[0]
if (imgdist!=2.345) {
p5.noFill()
p5.stroke(255)
p5.line(ppm*L1.position[0]+4, ppm*bottom-10, ppm*(L1.position[0]+imgdist), ppm*bottom-10)
p5.arrow(ppm*(L1.position[0]+imgdist), ppm*bottom-10, -1, 0, 6, 3)
p5.fill(255)
p5.noStroke()
p5.textSize(12)
p5.textAlign(p5.CENTER,p5.TOP)
p5.yup_text('1 / FVP',
ppm*(L1.position[0]+imgdist/2),
ppm*bottom-15)
p5.textAlign(p5.RIGHT,p5.BOTTOM)
p5.textStyle(p5.NORMAL)
p5.yup_text('focal point', ppm*img-10, -vgap*ppm)
}
}
},
{
type: 'parallel light',
id: 'light#1',
position: [-1, 0],
target: 'lens#1',
spread: 'fill*0.8',
raycount: 6,
ui: {ylock:true},
style: {
stroke: [190,190,255],
strokeWidth: 1,
arrows: ['60%','50%','30%'],
arrowlen: 6
}
},
{
type: 'thinlens',
id: 'lens#1',
position: [-0.4,0],
axis: [1,0],
aperture: 0.2,
power: 2,
ui: {ylock:true},
style: {
stroke:[255,255,255],
strokeWeight:3
},
},
{
type: 'parallel light',
id: 'light#1.1',
position: [1, -vgap],
target: 'lens#2.1',
spread: 'fill*0.8',
raycount: 6,
ui: {ylock:true},
style: {
stroke: [190,190,255],
strokeWidth: 1,
arrows: [-0.15,'50%','30%'],
arrowlen: -6
}
},
{
type: 'thinlens',
id: 'lens#1.1',
position: [-0.4,-vgap],
axis: [1,0],
aperture: 0.2,
power: 2,
ui: {ylock:true},
style: {
stroke:[255,255,255],
strokeWeight:3
},
},
{
type: 'thinlens',
id: 'lens#2',
position: [-0.25,0],
axis: [1,0],
aperture: 0.2,
power: 3,
ui: {ylock:true},
style: {
stroke:[255,255,255],
strokeWeight:3,
z_order: 2,
virtualStroke: [190, 190, 0]
},
//virtual: ['light#1']
},
{
type: 'thinlens',
id: 'lens#2.1',
position: [-0.25,-vgap],
axis: [1,0],
aperture: 0.2,
power: 3,
ui: {ylock:true},
style: {
stroke:[255,255,255],
strokeWeight:3,
z_order: 2,
virtualStroke: [190, 190, 0]
},
//virtual: ['light#1']
},
{
type: 'barrier',
id: 'barrier#1',
position: [1/(2/(1-0.15*2)+3)+-0.25, -0.1, 1/(2/(1-0.15*2)+3)+-0.25, 0.1],
barrieroff: false,
style: {
stroke: [0,0,0,0]
}
},
{
type: 'barrier',
id: 'barrier#1.1',
position: (function() {
let FVP = 3/(1-0.15*3)+2
return [-0.4-1/FVP, -0.1-vgap, -0.4-1/FVP, 0.1-vgap]
})(),
barrieroff: false,
style: {
stroke: [0,0,0,0]
}
}
]
}
function controls(p5, state, w, h, ppm) {
let c = p5.createCheckbox('continue rays',false)
c.elt.onchange = function() {
findObject(state,'barrier#1').barrieroff = c.checked()
p5.redraw()
}
c.style('color','white')
c.style('width','150px')
c.style('font','10pt Arial, sans-serif')
function sizer(p5, state, w, h, ppm) {
c.position(w-100, h-25)
}
sizer(p5, state, w, h, ppm)
return sizer
}
/*
let actions = {
decorate: function(state, decoration) {
findObject(state,'light#1').style.decoration = decoration
findObject(state,'lens#1').style.decoration = decoration
findObject(state,'lens#2').style.decoration = decoration
return false
}
}
*/
new p5(makeP5App(state, ()=>false, {}), document.getElementById('Figure5 image'))
/*
d = document.getElementById('fig2handle')
d.onmousedown = function() {actions.decorate('ui')}
d.onmouseup = function() {actions.decorate()}
d.addEventListener("touchstart", ()=>actions.decorate('ui'), false);
d.addEventListener("touchend", actions.decorate, false);
*/
})()
|
import React, { Component, PropTypes } from 'react';
class DropdownItem extends Component {
constructor(props) {
super(props);
}
render() {
return (
<li onClick={this.props.onClick}>
<a href="#">{this.props.label}</a>
</li>
);
}
}
DropdownItem.propTypes = {
label: PropTypes.string.isRequired,
onClick: PropTypes.func.isRequired
}
DropdownItem.defaultProps = {
label: "",
}
export default DropdownItem;
|
import React, { useState, useEffect, Fragment } from 'react';
import img from './cryptomonedas.png'
//components
import Form from './components/Form'
import Spinner from './components/Spinner'
import Result from './components/Result'
function App() {
const [ criptomonedas, setCriptomonedas ] = useState([])
const [ result, setResult ] = useState({})
const [ money, setMoney ] = useState('')
const [ cripto, setCripto ] = useState('')
const [ loading, setLoading] = useState(false)
useEffect(()=>{
checkAPI()
},[])
useEffect(()=>{
//si no hay moneda no ejecuta
if(money === '') return
checkCripto()
setLoading(true)
// para que no se quede el spinner
setTimeout(()=>{
setLoading(false)
}, 1000)
},[money, cripto])
const checkAPI = async ()=>{
//trae el top 10 de la cripto moneda para mostrarlos en el formulario
const url = `https://min-api.cryptocompare.com/data/top/totaltoptiervolfull?limit=10&tsym=USD`
const data = await fetch(url)
const res = await data.json()
setCriptomonedas(res.Data)
}
const checkCripto = async ()=>{
// trae la consulta del usuario por cripto y moneda
const url =`https://min-api.cryptocompare.com/data/pricemultifull?fsyms=${cripto}&tsyms=${money}`
const data = await fetch(url)
const res = await data.json()
setResult(res.DISPLAY[cripto][money])
}
const saveMoney = (m, c)=>{
setMoney(m)
setCripto(c)
}
//show spiner or result
const component = (loading) ? <Spinner /> : <Result result={result} />
return (
<Fragment>
<h1 className="title"> Cotizar Criptomoneda </h1>
<div className="container">
<div className="row">
<div className="col-md-6 container-img">
<img className="image mx-auto" src={img} alt="icon"/>
</div>
<div className="col-md-6">
<h1 className="text-light mb-3 text-center">Cotiza criptomonedas al instante</h1>
<Form
criptomonedas={criptomonedas}
saveMoney={saveMoney}
/>
{component}
</div>
</div>
<div className="row mt-3">
</div>
</div>
</Fragment>
);
}
export default App;
|
/* global it */
/* global describe */
var sinon = require('sinon');
var assert = require('assert');
var tl = require('vsts-task-lib');
var task = require('../src/task.js');
var util = require('../src/util.js');
describe('app', function () {
'use strict';
it('should run the task', function () {
/* Arrange */
var taskStub = sinon.stub(task, 'run');
taskStub.withArgs('https://api.mobile.azure.com', "someuser/someapp", 'apikey', 'VSTS (Task:VSMobileCenterBuild)', 'v1.0');
sinon.stub(tl, 'debug');
var utilStub = sinon.stub(util, 'getMobileCenterEndpointDetails');
utilStub.withArgs('serverEndpoint').returns({ apiServer: 'https://api.mobile.azure.com', apiVersion: 'v1.0', authToken: 'apikey' });
var input = sinon.stub(tl, 'getInput');
input.withArgs('appSlug').returns('someuser/someapp');
var getVar = sinon.stub(tl, 'getVariable');
getVar.withArgs('MSDEPLOY_HTTP_USER_AGENT').returns(null);
try {
/* Act */
// requiring the app.js file should cause the task to be run
require('../src/app.js');
/* Assert */
// Test that the task was called
assert.equal(taskStub.calledOnce, true, 'task.run was not called');
// Test that is was called with the correct values
assert.equal(taskStub.getCall(0).args[0], 'https://api.mobile.azure.com', 'apiServer arg is not correct. ' + taskStub.getCall(0).args[0]);
assert.equal(taskStub.getCall(0).args[1], 'someuser/someapp', 'appSlug arg is not correct. ' + taskStub.getCall(0).args[1]);
assert.equal(taskStub.getCall(0).args[2], 'apikey', 'apiToken arg is not correct. ' + taskStub.getCall(0).args[2]);
assert.equal(taskStub.getCall(0).args[3], 'VSTS (Task:VSMobileCenterBuild)', 'userAgent arg is not correct. ' + taskStub.getCall(0).args[3]);
assert.equal(taskStub.getCall(0).args[4], 'v1.0', 'apiVersion arg is not correct. ' + taskStub.getCall(0).args[4]);
assert.equal(input.calledOnce, true, 'tl.getInput not called ' + input.callCount);
assert.equal(input.calledOnce, true, 'tl.getVariable not called ' + getVar.callCount);
}
finally {
taskStub.restore();
tl.debug.restore();
tl.getInput.restore();
tl.getVariable.restore();
}
});
});
|
'use strict';
var app = angular.module('app');
app.controller('chartHeaderFooterCtrl', function appCtrl($scope) {
// data context
$scope.ctx = {
chart: null,
itemsSource: []
};
for (var i = 0; i < 12; i++) {
$scope.ctx.itemsSource.push({
date: wijmo.Globalize.format(new Date(10, i, 1), 'MMM'),
sales: Math.random() * 1000
});
}
$scope.$watch('ctx.chart', function () {
if ($scope.ctx.chart) {
var chart = $scope.ctx.chart;
chart.beginUpdate();
chart.header = 'Monthly Sales Summary';
chart.headerStyle = { fontSize: 36 };
chart.footer = 'Footer (c) ' + new Date().getFullYear();
chart.footerStyle = { halign: 'right', foreground: 'gray' };
chart.legend.isVisible = false;
chart.endUpdate();
chart.tooltip.content = function (ht) {
return 'Month: ' + ht.item.date + '<br/>' + 'Sales: ' + ht.item.sales.toFixed();
};
}
});
});
|
import Person from './person.js';
import Task from './task.js';
//Array declaration
var tasksvalues=[];
var students = [
new Person("Paco", "Vañó", 5),
new Person("Lucia ", "Botella", 10),
new Person("German", "Ojeda", 3),
new Person("Salva", "Peris", 1),
new Person("Oscar", "Carrion", 40),
];
var tasks = [
new Task("exam"),
new Task("task")
];
//GETRANKING FUNCTION
function getRanking(students) {
order(students);
var studentsEl = document.getElementById("res");
while (studentsEl.firstChild) {
studentsEl.removeChild(studentsEl.firstChild);
}
var cont=-1;
students.forEach(function(studentItem) {
cont++;
var liEl = document.createElement("li");
var t = document.createTextNode(studentItem.surname + ", " + studentItem.name + ", " + studentItem.points + " "); // Create a text node
liEl.appendChild(t);
var addPointsEl = document.createElement("button");
var tb = document.createTextNode("+20");
addPointsEl.appendChild(tb);
studentsEl.appendChild(liEl);
addPointsEl.setAttribute("id",cont);
liEl.appendChild(addPointsEl);
tasks.forEach(function(itemtask){
var input = document.createElement("input");
var idinput= tasksvalues[cont][itemtask.title];
input.setAttribute("id",cont);
input.setAttribute("name",cont);
input.setAttribute(itemtask.title,idinput);
input.setAttribute("value",idinput);
var previusvalue = input.value;
liEl.appendChild(input);
//Onchange inputs
input.addEventListener("change", function(){
var integer = parseInt(input.value);
integer = Number.isInteger(integer);
console.log(integer);
if (integer){
changeValues(input.id,input.name,itemtask.title,input.value,previusvalue);
}else{
input.value="0";
}
});
});
//Onclick button +20
addPointsEl.addEventListener("click", function() {
studentItem.addPoints(20);
var idddd = addPointsEl.id;
var suma = tasksvalues[idddd].points+20;
tasksvalues[idddd].points=suma;
order(tasksvalues);
setTimeout(function(){getRanking(students)},1000);
});
});
}
//ONLOAD
window.onload = function() {
start();
getRanking(students);
clicktask();
titles();
}
function titles(newtitle){
var titles = document.getElementById("demo");
if (newtitle===undefined){
for (var a=0;a<students.length;a++){
var ty=tasks[a].title;
var newstrong = document.createElement("strong");
var t = document.createTextNode(ty);
newstrong.appendChild(t);
titles.appendChild(newstrong);
}
}else{
var newstrong = document.createElement("strong");
var t = document.createTextNode(newtitle);
newstrong.appendChild(t);
titles.appendChild(newstrong);
}
}
//Click task
function clicktask(){
var taskname = document.getElementById("taskname");
document.getElementById("bt").addEventListener("click", function(){
taskname.style.visibility="visible";
});
document.getElementById("taskname").addEventListener("change", function(){
tasks.push(new Task(taskname.value));
taskname.style.visibility="hidden";
taskname.value="";
start(tasks[tasks.length-1].title);
getRanking(students);
titles(tasks[tasks.length-1].title);
});
}
function start(last){
var aq=-1;
var key3;
if(last===undefined){
students.sort(function(a, b) {
return (b.points - a.points)
});
for(var i=0;i<tasksvalues.length;i++){
delete tasksvalues[i];
}
students.forEach(function(studentItem) {
aq++;
tasksvalues.push({name:studentItem.name});
for(var i=0;i<tasks.length;i++){
key3 = tasks[i].title;
tasksvalues[aq][key3]=0;
}
var pointsstudent = studentItem.points;
tasksvalues[aq].points=pointsstudent;
tasksvalues.sort(function(a, b) {
return (b.points - a.points)
});
});
console.log(tasksvalues);
}else{
for(var l=0;l<tasksvalues.length;l++){
tasksvalues[l][last]=0;
}
}
}
//changeValues (first substrac the previus value, and add the new points,finaly order the inputs)
function changeValues(id,name,task,value,previusvalue){
var previusvalueparse = parseInt(previusvalue);
var input = document.getElementById(id);
var parsednewvalue = parseInt(value);
students[id].restpoints(previusvalueparse);
students[id].addPoints(parsednewvalue);
tasksvalues[id][task]=parsednewvalue;
tasksvalues[id].points=students[id].points;
order(tasksvalues);
console.log(tasksvalues);
setTimeout(function(){getRanking(students)},500);
}
function order(item){
//Order array tasksvalues
item.sort(function(a, b) {
return (b.points - a.points)
});
}
|
var mealTemplate = document.querySelector('.mealTemplate').innerHTML;
var mealTemp = Handlebars.compile(mealTemplate);
var slide = 0;
burgers();
function burgers() {
var i;
var x = document.getElementsByClassName('mySlides');
for (i = 0; i < x.length; i++) {
x[i].style.display = "none";
}
slide++;
if (slide > x.length) {
slide = 1
}
x[slide - 1].style.display = "block";
setTimeout(burgers, 2000);
}
|
import OAuth2PasswordGrant from 'ember-simple-auth/authenticators/oauth2-password-grant';
export default OAuth2PasswordGrant.extend({
serverTokenEndpoint: 'http://localhost:60752/Token'
});
|
import { reactLocalStorage } from "reactjs-localstorage"
import history from "../../../../history"
import KhachHangService from "../../../../services/KhachHang.Service"
import lodash from "lodash";
import ToastifyMessage from "./../../../../utilities/ToastifyMessage";
function CapNhatThongTinTaiKhoan(props){
const data= reactLocalStorage.getObject('CurrentUser')
const CapNhatThongTin=()=>{
// let SoCMND= document.getElementById("txtSoCMND").value
// let MaKH= document.getElementById("maKH").value
// let HoTen= document.getElementById("txtHoTen").value
let HoTen = document.getElementById("txtHoTen").value;
let MaKH = document.getElementById("maKH").value;
let SoCMND = document.getElementById("txtCMND").value;
if (lodash.isEmpty(HoTen) || lodash.isEmpty(SoCMND)){
ToastifyMessage.ToastError("Phải nhập đầy đủ thông tin cần chỉnh sửa")
}
//console.log("SOCNMD", SoCMND)
let param={
MaKhachHang: MaKH,
HoTen: HoTen,
SoCMND: SoCMND
}
console.log("param",param)
KhachHangService.CapNhatThongTin(param).then((res)=>{
console.log(res)
ToastifyMessage.ToastSuccess("Cập nhật thành công")
history.push("/TaiKhoan")
props.isSuccess()
})
}
return(
<div>
<h1 className="text-center text-2xl">Quản lý thông tin</h1>
<div className="p-2">
<label>Mã khách hàng: </label>
<input className="bg-gray-200 border border-blue-500 w-full" id="maKH" defaultValue={data.MaKhachHang} disabled/>
</div>
<div className="p-2">
<label>Họ tên: </label>
<input className="border border-blue-500 w-full" type="text" defaultValue={data.HoTen} id="txtHoTen"/>
</div>
<div className="p-2">
<label>Số điện thoại: </label>
<input className="bg-gray-200 border border-blue-500 w-full" defaultValue={data.SoDienThoai} id="txtSoDienThoai" disabled/>
</div>
<div className="p-2">
<label>Số CMND: </label>
<input className="border border-blue-500 w-full" type="text" defaultValue={data.SoCMND} id="txtCMND"/>
</div>
<div className="p-2">
<label>Email: </label>
<input className="bg-gray-200 border border-blue-500 w-full" defaultValue={data.email} id="txtEmail" disabled/>
</div>
<button type="button" onClick={CapNhatThongTin}
className="cursor-pointer px-36 py-1.5 border-2 border-main bg-main text-white hover:bg-white hover:text-main hover:pointer">
Cập nhật thông tin
</button>
</div>
)
}
export default CapNhatThongTinTaiKhoan
|
'use strict';
exports.messagesPOST = function(args, res, next) {
/**
* parameters expected in the args:
* message (Message)
**/
// no response value expected for this operation
res.end();
}
exports.messagesSynthesisGET = function(args, res, next) {
/**
* parameters expected in the args:
**/
var examples = {};
examples['application/json'] = [ {
"minValue" : 123456789,
"maxValue" : 123456789,
"sensorType" : 123,
"mediumValue" : 123456789
} ];
if(Object.keys(examples).length > 0) {
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify(examples[Object.keys(examples)[0]] || {}, null, 2));
}
else {
res.end();
}
}
|
function somaRequest() {
var valor1 = document.getElementById("valor1").value
var valor2 = document.getElementById("valor2").value
var soma = Number(valor1) + Number(valor2)
console.log(soma)
document.getElementById("serverResponse").innerHTML = "Soma dos valores: " + soma + ".";
}
|
var fecha_solicitud = "25-6-2018";
var nombre = "pepito perez";
var fecha_nacimiento = "27-6-1997";
var correo = "alguien@ejemplo.com";
var telefono = "555776";
var genero = "masculino";
var departamento = "antioquia";
var ciudad = "medellin";
var direccion = "cra 22 #22c -22";
var domicilio = "finca"
var especifique_otro = "";
var integrantes = 3 ;
var adoptar = "porque mi gato quiere un amigo";
var experiencia = "si";
var otras_mascotas = "si";
var ingresos = 500000;
var ingresos_mascotas = 200000;
var tiempo = 1;
var ausente = "mi papito";
|
function add(n1, n2) {
if (typeof n1 !== 'number' || typeof n2 !== 'number')
throw new Error('Incorrect input!');
return n1 + n2;
}
//commented code below in the combine function parameters
//union types get more than 1 type in parameters
//literal with 3rd parameter
//3rd parameter optional with '?' suffix to parameter name
function combine(first, //number | string,
second, //number | string,
resultConversion //'as-text' | 'as-number'
) {
if (resultConversion === 'as-text')
return first.toString() + " & " + second.toString();
if (typeof first === 'number' && typeof second === 'number' || resultConversion === 'as-number')
return +first + +second; //'+' prefix force conversion to number
}
console.log(combine(30, 26, 'as-text'));
console.log(combine('30', '26', 'as-number'));
console.log(combine('L', 'Isamara', 'as-text'));
//function as a type
var combineValues;
combineValues = combine;
console.log(combineValues(5, 6));
|
export const SET_USER_COMPANY = 'SET_USER_COMPANY'
// Token
export const setUserDataCompany = (data) => ({
type: SET_USER_COMPANY,
data: data,
})
|
import React, {Component} from 'react';
import {
StyleSheet,
View,
TouchableHighlight,
ScrollView,
StatusBar,
TextInput,
} from 'react-native';
import Text from '../../components/Text';
import Icon from 'react-native-vector-icons/EvilIcons';
import CheckBox from '@react-native-community/checkbox';
import {colors} from '../../utils';
export default class ListScreen extends Component {
state = {
check: false,
check2: false,
check3: false,
check4: false,
check5: false,
check6: false,
};
handleCheckBox() {
this.setState({
check: !this.state.check,
});
}
handleCheckBox2() {
this.setState({
check2: !this.state.check2,
});
}
handleCheckBox3() {
this.setState({
check3: !this.state.check3,
});
}
handleCheckBox4() {
this.setState({
check4: !this.state.check4,
});
}
handleCheckBox5() {
this.setState({
check5: !this.state.check5,
});
}
handleCheckBox6() {
this.setState({
check6: !this.state.check6,
});
}
render() {
return (
<>
<ScrollView style={styles.container}>
<StatusBar barStyle="dark-content" backgroundColor="#E5E5E5" />
<View style={styles.Search}>
<TextInput placeholder="Search" style={styles.form} />
<Icon name="search" color="gray" size={30} style={styles.icon} />
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="addidas" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check}
onChange={() => this.handleCheckBox()}
/>
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="addidas Originals" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check2}
onChange={() => this.handleCheckBox2()}
/>
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="nike" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check3}
onChange={() => this.handleCheckBox3()}
/>
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="vans" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check4}
onChange={() => this.handleCheckBox4()}
/>
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="rebook" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check5}
onChange={() => this.handleCheckBox5()}
/>
</View>
<View style={styles.checkboxcontainer}>
<Text size="l" children="converse" />
<CheckBox
tintColors={{true: '#DB3022', false: '#9B9B9B'}}
value={this.state.check6}
onChange={() => this.handleCheckBox6()}
/>
</View>
</ScrollView>
<View style={styles.rec4}>
<TouchableHighlight
activeOpacity={0.6}
underlayColor="#DB3022"
onPress={() => alert('Pressed!')}
style={styles.bt}>
<Text size="m" children="Discard" />
</TouchableHighlight>
<TouchableHighlight
activeOpacity={0.6}
underlayColor="#DB3022"
onPress={() => alert('Pressed!')}
style={styles.bt}>
<Text size="m" children="Apply" />
</TouchableHighlight>
</View>
</>
);
}
}
const styles = StyleSheet.create({
container: {
height: '100%',
backgroundColor: '#e5e5e5',
},
Search: {
flexDirection: 'row',
marginTop: 50,
paddingHorizontal: 15,
},
form: {
width: '100%',
backgroundColor: 'white',
paddingHorizontal: 50,
borderWidth: 0,
borderRadius: 23,
justifyContent: 'center',
// marginHorizontal: 30,
},
icon: {
position: 'absolute',
marginTop: 15,
marginLeft: 35,
},
checkboxcontainer: {
flexDirection: 'row',
justifyContent: 'space-between',
paddingHorizontal: 15,
marginTop: 30,
},
rec4: {
backgroundColor: '#f9f9f9',
height: 104,
// paddingHorizontal: 15,
flexDirection: 'row',
elevation: 20,
width: '100%',
bottom: 0,
position: 'absolute',
justifyContent: 'center',
// alignItems: 'center',
},
bt: {
// position: 'absolute',
// bottom: 10,
// left: 5,
backgroundColor: 'white',
borderRadius: 50,
borderWidth: 1,
borderColor: 'black',
// border: 'none',
width: 160,
height: 40,
alignItems: 'center',
justifyContent: 'center',
marginTop: 25,
marginLeft: 10,
},
});
|
import React from "react";
const profileheader = () => {
return (
<div>
<div className="img">
<img src="" alt="" />
</div>
<div className="texts">
<div className="name">
<h2>Gusto University</h2>
</div>
<div className="types">
<h2>Type: University</h2>
</div>
<div className="subjects">
<h2>Subjects</h2>
<li>1</li>
<li>1</li>
<li>1</li>
</div>
<div className="ph-numbers">
<h2>Ph-No</h2>
</div>
</div>
</div>
);
};
export default profileheader;
|
let mapper = require('../mappers/user')
let User = require('../models/user')
let service = require('../service/user')
exports.create = async (body) => {
let entity = await service.create(body)
return mapper.toModel(entity)
}
exports.login = async (body) => {
let entity = await service.login(body)
return mapper.toModel(entity)
}
|
(function() {
'use strict';
angular
.module('Directives')
.directive('productsList', productsList);
productsList.$inject = ['$state'];
function productsList($state) {
var directive = {
templateUrl: 'view-modules/products/products-list/products-list.directive.html',
restrict: 'EA',
scope: {
// List of products to display
products: '=',
// Function to call when clicking a product
select: '='
}
};
return directive;
}
})();
|
var louis = require("../test/louis"),
cowboy = require("../lib/cowboy");
var latest_image;
var lou = new louis({
freq: 1000,
total: 10,
imagepath: "../test/"
});
var boy = new cowboy();
//start the test setInterval
lou.start();
var threshold = 128;
var destination_path = "../masked/";
lou.on("data", function( err, depth_imagepath, rgb_imagepath ){
var file_timestamp = depth_imagepath.substring(depth_imagepath.lastIndexOf("/")+1, depth_imagepath.lastIndexOf("."));
boy.mask(depth_imagepath, rgb_imagepath, destination_path, file_timestamp + ".png", threshold);
});
boy.on("done", function( image ){
console.log('done');
latest_image = image;
});
|
// import required dependencies
// const bcrypt = require('bcrypt');
// import required files
const conn = require('../configs/db');
console.log('model'); // where I am
module.exports = {
signupUser: function(data_signup) {
return new Promise( function(resolve, reject) {
conn.query('SELECT * FROM user WHERE username = ?',
data_signup.username, function(err, result) {
if (!err) {
if (result.length > 0) {
// reject(new Error('username was used by other'));
resolve({
status: 400,
error: true,
message: 'Username was already used by other',
result: {},
});
} else {
conn.query('INSERT INTO user SET ?',
data_signup, function(err, result) {
if (!err) {
resolve(result);
} else {
reject(err);
}
}
);
}
} else {
reject(err);
}
}
);
});
},
};
|
/**
* Created by hongdian on 2014/12/25.
* 订单
*/
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var OrderSchema = new Schema({
shop_id: {type: String},
shop_name: {type: String},
user_id: {type: String},
user_name: {type: String},
time: {type: String},
total: {type: Number, default: 0},
order: {type: []},
luck: {type: Number},
canceled: {type: Boolean},
payStatus: {type: String}
});
mongoose.model('Order', OrderSchema);
|
import React from "react";
import styled from "styled-components";
import { getItem } from "./api.js";
//items
import { DatasetItem } from "./Dataset.js";
import { TaskTypeItem } from "./TaskType.js";
import { MeasureItem } from "./Measure.js";
import { TaskItem } from "./Task.js";
import { FlowItem } from "./Flow.js";
import { RunItem } from "./Run.js";
import { StudyItem } from "./Study.js";
import { UserItem } from "./User.js";
import { Chip } from "@mui/material";
import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
import { Tooltip, TableRow, TableCell, Grid } from "@mui/material";
import withStyles from '@mui/styles/withStyles';
import { animated } from '@react-spring/web';
import useBoop from "../../components/Boop.js";
const TagChip = styled(Chip)`
margin-bottom: 5px;
margin-left: 5px;
`;
const PaperPlane = (props) => {
const [style, trigger] = useBoop({ rotation: -10, scale:3, x:500, y:-500, timing: 1000 });
style.color = props.color;
style.display = "inline-block";
style.paddingLeft = 20;
style.zIndex = 5000;
style.position = "relative";
return (
<animated.div style={style} onMouseEnter={trigger}>
<FontAwesomeIcon icon={["far","paper-plane"]} size="4x" />
</animated.div>
)
};
function fixUpperCase(str) {
let o = "";
for (let i = 0; i < str.length; i++) {
if (str[i].toLowerCase() !== str[i]) {
o += " " + str[i].toLowerCase();
} else {
o += str[i];
}
}
return o;
}
export class FeatureDetail extends React.Component {
render() {
let icon = "";
switch (this.props.item.type) {
case "numeric":
icon = "ruler-horizontal";
break;
case "nominal":
icon = "tag";
break;
default:
icon = "question-circle";
break;
}
return (
<TableRow className="contentSection item">
<TableCell width={25}>
<FontAwesomeIcon icon={icon} />
</TableCell>
<TableCell className={"itemName"}>
{this.props.item.name}
{this.props.item.target ? (
<span className={"subtitle"}> (target)</span>
) : (
""
)}
</TableCell>
<TableCell className={"itemDetail-small"}>
{this.props.item.type}
</TableCell>
<TableCell className={"itemDetail-small"}>
{this.props.item.distinct} distinct values
<br />
{this.props.item.missing} missing attributes
</TableCell>
</TableRow>
);
}
}
export const LightTooltip = withStyles(theme => ({
tooltip: {
backgroundColor: theme.palette.common.white,
color: "rgba(0, 0, 0, 0.87)",
boxShadow: theme.shadows[1],
fontSize: 16
}
}))(Tooltip);
export class QualityDetail extends React.Component {
render() {
return (
<TableRow>
<TableCell className={"itemHead"}>
<FontAwesomeIcon icon={"chart-bar"} />
</TableCell>
<TableCell className={"itemName"}>
{fixUpperCase(this.props.item.name)}
</TableCell>
<TableCell className={"itemDetail-small"}>
{this.props.item.value}
</TableCell>
</TableRow>
);
}
}
export class ParameterDetail extends React.Component {
fixUpperCase(str) {
let o = "";
for (let i = 0; i < str.length; i++) {
if (str[i].toLowerCase() !== str[i]) {
o += " " + str[i].toLowerCase();
} else {
o += str[i];
}
}
return o;
}
render() {
return (
<TableRow>
<TableCell>{fixUpperCase(this.props.item.name)}</TableCell>
<TableCell>{this.props.item.description}</TableCell>
<TableCell>{this.props.item.data_type}</TableCell>
<TableCell>{this.props.item.default_value}</TableCell>
</TableRow>
);
}
}
export class DependencyDetail extends React.Component {
render() {
return (
<TableRow>
<TableCell>{this.props.name}</TableCell>
<TableCell>{this.props.version}</TableCell>
</TableRow>
);
}
}
export class EvaluationDetail extends React.Component {
render() {
let classWiseEval = "";
if (this.props.item.array_data != null) {
var ID = 0;
let rows = [];
this.props.target_values.forEach((item, i) => {
let val = this.props.item.array_data[i];
rows.push(
<tr key={"key_" + this.props.item.evaluation_measure + i}>
<td key={ID++} style={{ width: "50%" }}>
{item}
</td>
<td key={ID++}>{val}</td>
</tr>
);
});
classWiseEval = (
<table width={"100%"}>
<tbody>{rows}</tbody>
</table>
);
}
return (
<TableRow>
<TableCell style={{ width: "50%" }}>
{this.props.item.evaluation_measure}
</TableCell>
<TableCell style={{ width: "25%" }}>{this.props.item.value}</TableCell>
<TableCell style={{ width: "25%" }}>{classWiseEval}</TableCell>
</TableRow>
);
}
}
export class FlowDetail extends React.Component {
render() {
return (
<TableRow>
<TableCell style={{ width: "50%" }}>
<span style={{ wordWrap: "break-word" }}>
{this.props.item.parameter}
</span>
</TableCell>
<TableCell>{this.props.item.value}</TableCell>
</TableRow>
);
}
}
export class EntryDetails extends React.Component {
constructor() {
super();
this.state = {};
this.state["obj"] = null;
this.state["error"] = null;
this.state["type"] = null;
this.state["entity"] = null;
}
componentDidUpdate() {
if (
this.state["type"] !== this.props.type ||
this.state["entity"] !== this.props.entity
) {
this.setState({ type: this.props.type });
this.setState({ entity: this.props.entity });
getItem(this.props.type, this.props.entity)
.then(data => {
this.setState({ obj: data });
})
.catch(error => {
this.setState({
obj: undefined,
error: error + ""
});
});
}
// Sanity check for bad ID types before rendering
if ((this.props.type === "study" || this.props.type === "benchmark") && this.state.obj !== null &&
this.props.filters["study_type"]["value"] !== this.state.obj.study_type
){ // auto-redirect for bad study type in URL
let currentUrlParams = new URLSearchParams(this.props.location.search);
currentUrlParams.set("study_type", this.state.obj.study_type);
this.props.history.push(
this.props.location.pathname + "?" + currentUrlParams.toString()
);
}
}
componentDidMount() {
this.componentDidUpdate();
}
updateTag = (value) => {
let currentUrlParams = new URLSearchParams(this.props.location.search);
currentUrlParams.set("tags.tag", value);
currentUrlParams.delete("id"); // selecting a tags should show match list
this.props.history.push(
this.props.location.pathname + "?" + currentUrlParams.toString()
);
};
render() {
if (this.state.error !== null) {
if (!this.state.error.includes("404")){
return (
<div className="mainBar">
<h1>An error occured</h1>
<p>{"" + this.state.error}</p>
</div>
);
}
} else if (this.state.obj === null) {
return (
<div className="mainBar">
<h2>Loading...</h2>
</div>
);
} else if (
this.props.type === "data" ||
this.props.type === "task" ||
this.props.type === "flow" ||
this.props.type === "run"
) {
var tags = undefined;
if (this.state.obj.tags) {
tags = this.state.obj.tags.map(t => (
t.tag.startsWith("study") ? "" :
<TagChip key={"tag_" + t.tag} label={" " + t.tag + " "} size="small" onClick={() => this.updateTag(t.tag)}/>
));
}
}
// A nice 404 message for 404s and restricted access
if ((this.state.error !== null && this.state.error.includes("404")) ||
(this.state.obj !== null && this.state.obj.visibility === "private" &&
this.state.obj.uploader_id !== this.props.userID)){
return (
<Grid container spacing={0} direction="column" alignItems="center" justifyContent="center" style={{ minHeight: '50vh' }}>
<Grid item xs={6}>
<h2>This is not the {this.props.type} you are looking for.</h2>
{ this.props.userID === undefined &&
<p>We couldn't find this. You might see more after logging in.</p>
}
</Grid>
<Grid item xs={3} style={{marginTop:50}}>
<PaperPlane color={this.props.color}/>
</Grid>
</Grid>
);
} else {
switch (this.props.type) {
case "data":
return (
<DatasetItem object={this.state.obj} tags={tags}></DatasetItem>
);
case "task":
return <TaskItem object={this.state.obj} tags={tags}></TaskItem>;
case "flow":
return <FlowItem object={this.state.obj} tags={tags}></FlowItem>;
case "run":
return <RunItem object={this.state.obj} tags={tags}></RunItem>;
case "study":
return <StudyItem object={this.state.obj}></StudyItem>;
case "user":
return <UserItem object={this.state.obj}></UserItem>;
case "task_type":
return <TaskTypeItem object={this.state.obj}></TaskTypeItem>;
case "measure":
return <MeasureItem object={this.state.obj}></MeasureItem>;
default:
return (
<DatasetItem object={this.state.obj} tags={tags}></DatasetItem>
);
}
}
}
}
|
'use strict'
/* eslint-disable no-undef */
const assert = require('yeoman-assert')
const helpers = require('yeoman-test')
const path = require('path')
const fs = require('fs');
const yaml = require('js-yaml');
describe('generate app', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo'
})
.then(() => {
})
});
describe('exists files', () => {
it('should exists project files', () => {
assert.file('pom.xml')
assert.file('.gitignore')
assert.file('filebeat.yml')
assert.file('start-fb.sh')
assert.file('start-code.sh')
assert.file('Dockerfile')
assert.file('entrypoint.sh')
assert.file('run.sh')
assert.file('LICENSE')
assert.file('README.md')
assert.file('scaffold.md')
assert.file('package.json')
assert.file('commitlint.config.js')
})
describe('api', () => {
it('should exists java files', () => {
})
it('should exists resources files', () => {
})
it('should exists test java files', () => {
})
it('should exists test resources files', () => {
})
});
describe('provider', () => {
it('should exists java files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/StartupApplication.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/ApplicationConfiguration.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/web/ReturnValueConfigurer.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/Payload.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/web/ApplicationErrorAttributes.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/exception/BizErrorResponseStatus.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/web/ConverterConfigurer.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/util/ConverterUtils.java')
assert.file('foo-service-provider/pom.xml')
})
it('should exists resources files', () => {
assert.file('foo-service-provider/src/main/resources/application.yml')
assert.file('foo-service-provider/src/main/resources/application-local.yml')
assert.file('foo-service-provider/src/main/resources/application-dev.yml')
assert.file('foo-service-provider/src/main/resources/application-qa.yml')
assert.file('foo-service-provider/src/main/resources/application-prod.yml')
})
it('should exists test java files', () => {
})
it('should exists test resources files', () => {
})
});
});
describe('required dependencies', () => {
describe('swagger', () => {
it('should have dependency', () => {
assert.fileContent([
['pom.xml', /<artifactId>versions-maven-plugin<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>foo-service-api<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-boot-starter-web<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>guava<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>commons-lang3<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>lombok<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-boot-devtools<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-boot-maven-plugin<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>joda-time<\/artifactId>/],
['foo-service-provider/pom.xml', /<artifactId>hutool-all<\/artifactId>/]
])
});
it('should have test dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<artifactId>spring-boot-starter-test<\/artifactId>/]
])
});
it('should have properties', () => {
const appYaml = yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml'));
assert(appYaml.swagger);
assert(appYaml.spring.application.name);
});
it('should disabled on env prod', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application-prod.yml')).swagger.enabled === false);
});
});
});
})
describe('generate demo', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
demo: true
})
.then(() => {
})
});
it('should exists files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/DemoController.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/DemoService.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/impl/DemoServiceImpl.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/exception/DemoException.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/converter/String2DemoControllerModelConverter.java')
});
});
describe('optional dependencies', () => {
describe('eureka', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
discovery: 'eureka',
feignCircuit: 'none',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>org.springframework.cloud<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-cloud-starter-netflix-eureka-client<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml')).eureka.client);
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application-local.yml')).eureka.client);
});
describe('openfeign', () => {
it('should exist demo files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/OpenFeignDemoController.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/remote/DemoFeignClient.java')
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>org.springframework.cloud<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-cloud-starter-openfeign<\/artifactId>/]
])
});
it('should exist annotations', () => {
assert.fileContent([
['foo-service-provider/src/main/java/com/deepexi/foo/StartupApplication.java', /import org.springframework.cloud.openfeign.EnableFeignClients;/],
['foo-service-provider/src/main/java/com/deepexi/foo/StartupApplication.java', /@EnableFeignClients/]
])
});
describe('hystrix', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
discovery: 'eureka',
feignCircuit: 'hystrix',
demo: true
})
.then(() => {
})
});
it('should have properties', () => {
const appYaml = yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml'));
assert(appYaml.feign.hystrix);
});
});
describe('sentinel', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
discovery: 'eureka',
feignCircuit: 'sentinel',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>org.springframework.cloud<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-cloud-starter-alibaba-sentinel<\/artifactId>/]
])
});
it('should have properties', () => {
const appYaml = yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml'));
assert(appYaml.feign.sentinel);
});
});
});
});
describe('mysql', () => {
// it('should ', () => {
// });
describe('mybatis', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
db: 'mysql',
orm: 'mybatis',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>org.mybatis.spring.boot<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>mybatis-spring-boot-starter<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml')).mybatis);
});
it('should exist files', () => {
assert.file('foo-service-provider/src/main/resources/mapper/.gitkeep')
});
it('should exist demo files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/CrudDemoController.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/CrudDemoService.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/impl/CrudDemoServiceImpl.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/mapper/DemoMapper.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/domain/DemoDo.java')
});
});
describe('mybatis-plus', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
db: 'mysql',
orm: 'mybatis-plus',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>com.baomidou<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>mybatis-plus-boot-starter<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml')).mybatis);
});
it('should exist files', () => {
assert.file('foo-service-provider/src/main/resources/mapper/.gitkeep')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/ApplicationMetaObjectHandler.java')
});
it('should exist contents', () => {
assert.fileContent([
['foo-service-provider/src/main/java/com/deepexi/foo/config/ApplicationConfiguration.java', /ApplicationMetaObjectHandler.RuntimeData/]
])
});
it('should exist demo files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/CrudDemoController.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/CrudDemoService.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/impl/CrudDemoServiceImpl.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/mapper/DemoMapper.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/domain/DemoDo.java')
});
});
describe('druid', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
db: 'mysql',
dbPool: 'druid'
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>com.alibaba<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>druid-spring-boot-starter<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application.yml')).spring.datasource.druid);
});
});
});
describe('mq', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
mq: 'rabbitmq',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>org.springframework.boot<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>spring-boot-starter-amqp<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/application-local.yml')).spring.rabbitmq);
});
it('should exist files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/RabbitMQConfiguration.java')
});
it('should exist demo files', () => {
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/controller/MQDemoController.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/MQDemoService.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/service/impl/RabbitMQDemoServiceImpl.java')
assert.file('foo-service-provider/src/main/java/com/deepexi/foo/config/RabbitMQDemoConfiguration.java')
});
});
describe('configservice', () => {
before(() => {
return helpers
.run(path.join(__dirname, '../../app'))
.withPrompts({
groupId: 'com.deepexi',
artifactId: 'foo-service',
basePackage: 'com.deepexi.foo',
configservice: 'apollo',
demo: true
})
.then(() => {
})
});
it('should have dependency', () => {
assert.fileContent([
['foo-service-provider/pom.xml', /<groupId>com.ctrip.framework.apollo<\/groupId>/],
['foo-service-provider/pom.xml', /<artifactId>apollo-client<\/artifactId>/]
])
});
it('should have properties', () => {
assert(yaml.safeLoad(fs.readFileSync('foo-service-provider/src/main/resources/bootstrap.yml')).apollo);
});
it('should exist files', () => {
assert.file('foo-service-provider/src/main/resources/META-INF/app.properties')
});
it('should exist demo files', () => {
});
});
});
|
Ext.define('Accounts.Application', {
extend: 'Ext.app.Application',
requires : [
'Accounts.store.AccountStore',
'Accounts.store.daily.CreditStore',
'Accounts.store.daily.DebitStore'
],
name: 'Accounts',
stores : [
'Accounts.store.AccountStore',
'Accounts.store.daily.CreditStore',
'Accounts.store.daily.DebitStore'
],
onAppUpdate: function () {
Ext.Msg.confirm('Application Update', 'This application has an update, reload?',
function (choice) {
if (choice === 'yes') {
window.location.reload();
}
}
);
}
});
|
// This script will read constants from `.js` files and generate `.d.ts` files.
var fs = require('fs')
var path = require('path')
function generateTyping(name, paths) {
var constants = require('../' + paths.join('/'))
var literalType = Object.values(constants)
.map((value) => JSON.stringify(value))
.join(' | ')
var interfaceType = JSON.stringify(constants)
// Special logic for "Type" since we want to have types extendable btw, e.g., micromark-extension-gfm adds other types.
if (name === 'Type') {
literalType = 'string'
}
// Special logic for "Code" since a `Code` value can be any unicode character.
if (name === 'Code') {
literalType = 'null | number'
}
fs.writeFileSync(
path.join(...paths) + '.d.ts',
[
'// This module is generated by `script/`.',
'',
`export type ${name} = ${literalType}`,
'',
'// @for-script: REMOVE_ALL_THING_BELOW',
'',
`export interface ${name}s ${interfaceType}`,
'',
`declare const value: ${name}s`,
'',
`export default value`,
''
].join('\n')
)
}
generateTyping('Code', ['lib', 'character', 'codes'])
generateTyping('Value', ['lib', 'character', 'values'])
generateTyping('Type', ['lib', 'constant', 'types'])
generateTyping('Constant', ['lib', 'constant', 'constants'])
|
/**
* Näyttää tai piilottaa tahdotun elementin.
* @param id Sen elementin ID, jonka näkyvyyttä tahdotaan säädellä.
*/
function naytaTaiPiilota(id) {
elementti = document.getElementById(id);
elementti.style.display =
elementti.style.display == 'block'? 'none' : 'block';
}
/**
* Luo ns. fragmentin, eli HTML-koodia jota voi lisätä sivulle.
* @param lisattava HTML-koodi.
*/
function luoElementti(lisattava) {
osa = document.createDocumentFragment();
valiaikainen = document.createElement('div');
valiaikainen.innerHTML = lisattava;
while (valiaikainen.firstChild)
osa.appendChild(valiaikainen.firstChild);
return osa;
}
lisatytKentat = 0;
/**
* Lisää lomakkeeseen uuden kentän.
*/
function lisaaKentta() {
if(lisatytKentat >= 5)
return;
lisatytKentat++;
osa = luoElementti(
'<p><label>Nimi: </label><input name="vaihtoehto_' + lisatytKentat + '"></input><br />' +
'<label>Kuvaus: </label><input name="kuvaus_' + lisatytKentat + '"></input></p>');
document.getElementById('vaihtoehdot').appendChild(osa,
document.getElementById('vaihtoehdot').children.lastChild);
}
/**
* Näyttää äänestyslaatikossa kuvauksena tahdotun tekstin.
*/
function naytaKuvauksena(teksti) {
elementti = document.getElementById('kuvausteksti');
if(elementti.style.display == 'none')
elementti.style.display = 'block';
elementti.innerHTML = teksti;
}
|
import axios from 'axios';
// module.exports = {
// getJokes:function(){
// return new Promise((resolve,reject) =>{
// fetch('https://api.chucknorris.io/jokes/random')
// .then(res => res.json())
// .then(data => {
// resolve(data.value);
// })
// })
// }
// }
// export const jokes = {
// getJokes:function(){
// return new Promise((resolve,reject) =>{
// fetch('https://api.chucknorris.io/jokes/random')
// .then(res => res.json())
// .then(data => {
// resolve(data.value);
// })
// })
// }
// }
export const jokes = {
getJokes:function(){
return new Promise((resolve,reject) =>{
axios.get('https://api.chucknorris.io/jokes/random')
.then(res =>{
resolve(res.data.value)
})
})
}
}
|
import db from "../../../utils/db";
export default async (req, res) => {
switch (req.method) {
case "GET":
getProfile(req, res);
break;
default:
break;
}
};
const getProfile = async (req, res) => {
const snapshot = await db.collection("users").get();
console.log(snapshot.docs.map((snap) => snap.data()));
res.send("byee");
};
|
(function(){
'use strict';
angular.module('frontend.core.auth.services')
.factory('Forgot', [
'$http', '$state', '$localStorage',
'AccessLevels', 'BackendConfig', 'MessageService',
function factory(
$http, $state, $localStorage,
AccessLevels, BackendConfig, MessageService
){
return{
sendmail: function sendmail(email){
console.log('huhuhuhu');
return $http
.post(BackendConfig.url+'/forgot',email,{withCredentirals: true})
.then(
function(response){
MessageService.success('Your mail has been sent.');
}
);
}
};
}
]
)
})
|
const parse = require('csv-parse');
const fs = require("fs");
async function readData(filePath) {
const csvData = [];
const stream = fs.createReadStream(filePath)
.pipe(
parse({
delimiter: ","
})
);
for await (const chunk of stream) {
csvData.push(chunk);
}
return csvData;
}
module.exports = { readData };
|
const express = require('express');
const musicFactory = require('../musicFactory');
const router = new express.Router;
router.get('/filterMusic', (req, res) => {
const queryStr = req.query;
const filteredMusic = musicFactory.filterMusic(queryStr);
res.status(200).json(filteredMusic);
})
router.get('/favorite', (req, res) => {
const id = req.query.id;
const favoriteMusic = musicFactory.addFavorite(id);
res.status(200).json(favoriteMusic);
})
module.exports = router;
|
'use strict';
import React from 'react';
import {
Route,
IndexRoute
} from 'react-router';
import {
App,
Home,
About,
Profile
} from '../containers';
export default (
<Route path="/" component={App}>
<IndexRoute component={Home} />
<Route path="about" component={About} />
<Route path="profile/:username" component={Profile} />
</Route>
)
|
const router = require("express").Router();
const jwt = require("jsonwebtoken");
const bcrypt = require("bcrypt");
const User = require("../schemas/user");
const { body, validationResult } = require('express-validator');
router.post("/login", [
body('email').isEmail().isLength({min: 6, max: 255}).exists(),
body('password').isString().isAlphanumeric().isLength({min: 10, max: 1023}).exists(),
],
async (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({ errors: errors.array() });
}
const user = await User.findOne({ email: req.body.email });
if (!user)
return res.status(400).json({ error: "That email isn't connected to a user" });
const password = await bcrypt.compare(req.body.password, user.password);
if (!password)
return res.status(400).json({ error: "Incorrect password" });
const secret = process.env.SECRET || 'Please Set The Secret'
const token = jwt.sign({name: user.name, id: user._id,}, secret, {expiresIn: '1h'});
res.header("token", token).json({error: null, data: {token}})
});
module.exports = router;
|
var pg = require('pg');
var connectionString = process.env.DATABASE_URL || 'postgres://localhost:5432/osmdhasboard';
var client = new pg.Client(connectionString);
client.connect();
var query = client.query("select * from planet_osm_line where (tags -> 'natural')= 'wood' limit 10");
query.on('end', function() { client.end(); });
|
import React, { Component } from "react";
import { connect } from "react-redux";
import { withRouter } from "react-router-dom";
import MainLayout from "../MainLayout/MainLayout";
import { getHelp } from "../../Actions/HelpActionCreator";
import { SubHeader } from "../StyledComponents";
import "./help.css";
class Help extends Component {
constructor(props) {
super(props);
this.state = {
articleOpen: false,
currentArticle: ""
};
}
componentDidMount() {
this.props.actions.getHelp();
this.checkLocation();
}
componentDidUpdate(prevProps) {
if (
this.props.helpData !== prevProps.helpData ||
this.props.history.location.pathname !== prevProps.location.pathname
) {
this.checkLocation();
}
}
checkLocation = () => {
let pathname = this.props.history.location.pathname;
if (this.props.helpData && pathname !== "/help") {
let articles = Object.keys(this.props.helpData);
for (var i = 0; i < articles.length; i++) {
if ("/help/" + articles[i] === pathname) {
let h = this.props.helpData[articles[i]];
this.setState({ currentArticle: h, articleOpen: true });
}
}
} else if (this.props.helpData && pathname === "/help") {
this.setState({ articleOpen: false, currentArticle: "" });
}
};
goToArticle(article) {
this.props.history.push(`/help/${article.url}`);
this.setState({ articleOpen: true, currentArticle: article });
}
renderQuestions(sectionName) {
let quest = Object.values(this.props.helpData);
const filteredquestions = quest.filter(q => {
return q.tag === sectionName && q.body;
});
return filteredquestions.map(question => (
<p
key={question.title}
onClick={() => {
this.goToArticle(question);
}}
className="question"
>
{question.title}
</p>
));
}
renderSections = () => {
let sectionsArry = [];
let articles = Object.values(this.props.helpData);
for (var i = 0; i < articles.length; i++) {
if (!sectionsArry.includes(articles[i].tag)) {
sectionsArry.push(articles[i].tag);
}
}
return sectionsArry.map(section => {
return (
<div className="help-category" key={section}>
<h2 className="help-category-title">{section ? section : "Other"}</h2>
{this.props.helpData && this.renderQuestions(section)}
</div>
);
});
};
renderTopQuestions = () => {
let quest = Object.values(this.props.helpData);
let questF = quest.filter(q => {
return q.isFeatured === true && q.body;
});
questF = questF.slice(0, 4);
return questF.map(q => {
return (
<div
onClick={() => {
this.goToArticle(q);
}}
className="top-question top"
key={q.url}
>
<h1>{q.title}</h1>
</div>
);
});
};
renderArticle() {
return this.state.currentArticle.body.map(section => {
if (section.body.includes("<br>")) {
let bod = section.body.split("<br>");
let len = bod.length;
for (var i = len; i > 0; i--) {
bod.splice(i, 0, <br />);
}
return (
<div className="article-section">
<h2 className="article-subtitle">{section.subtitle}</h2>
<p className="article-body">{bod}</p>
</div>
);
} else {
return (
<div className="article-section">
<h2 className="article-subtitle">{section.subtitle}</h2>
<p className="article-body">{section.body}</p>
</div>
);
}
});
}
render() {
return (
<MainLayout>
{this.state.articleOpen ? (
<div>
<div className="banner">
<h1>{this.state.currentArticle.title}</h1>
</div>
<div className="article-block">
<div className="related-articles">
<h1>Related Questions</h1>
<hr />
{this.renderQuestions(this.state.currentArticle.tag)}
</div>
<div className="article-padding">{this.renderArticle()}</div>
</div>
</div>
) : (
<div>
<SubHeader>help center</SubHeader>
<div className="top-questions-grid">
{this.props.helpData && this.renderTopQuestions()}
</div>
<SubHeader>all categories</SubHeader>
<div className="help-categories-grid">
{this.props.helpData && this.renderSections()}
</div>
</div>
)}
</MainLayout>
);
}
}
function mapStateToProps(state, props) {
return {
helpData: state.help.helpData
};
}
function mapDispatchToProps(dispatch) {
return {
actions: {
getHelp: function() {
dispatch(getHelp());
}
}
};
}
export default withRouter(
connect(
mapStateToProps,
mapDispatchToProps
)(Help)
);
|
require('@babel/register');
require('./script-1.js');
|
'use strict';
const loopback = require('loopback');
const boot = require('loopback-boot');
const app = loopback();
module.exports = app;
app.boot = cb => {
boot(app, __dirname, function(err) {
if (err) {
throw err;
}
cb();
});
};
|
{
influxdb: {
host: '127.0.0.1', // InfluxDB host (default 127.0.0.1)
port: 8086, // InfluxDB port (default 8086)
version: 1.2,
database: 'metrics', // InfluxDB db instance (required)
username: 'root', // InfluxDB db username (required)
password: 'root', // InfluxDB db password (required)
retentionPolicy: 'default',
flush: {
enable: true // enable regular flush strategy (default true)
},
proxy: {
enable: false, // enable the proxy strategy (default false)
suffix: 'raw', // metric name suffix (default 'raw')
flushInterval: 1000
},
includeStatsdMetrics: true,
includeInfluxdbMetrics: true
},
port: 8125, // statsD port
backends: ['./backends/console', 'statsd-influxdb-backend'],
debug: false,
legacyNamespace: false
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.