text
stringlengths 7
3.69M
|
|---|
/**
* Created by 53983 on 2017/5/27.
*/
goceanApp.controller('DealDetailCtrl', function ($scope, $rootScope, $state, $timeout, $stateParams, dealDetailService, configService,localStorageService) {
console.log('about DealDetailCtrl');
var params = configService.parseQueryString(window.location.href);
if (params.passportId){
params.nickName = decodeURI(params.nickName);
try {
params.nickName = Base64.decode(params.nickName);
}catch (e){
}
localStorageService.set("passport",params);
}
$scope.passport = localStorageService.get("passport");
var _state = "dealDetail";
if ($scope.passport == null ){
window.location = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=wx0cae6e3b9632e632&redirect_uri=http://wxsdk.yezaigou.com/wx/page/base&response_type=code&scope=snsapi_base&state="+_state;
return;
}
// 获取JSSDK
// configService.getJssdkInfo(window.location.href);
// 隐藏右上角
// configService.hideWXBtn();
$scope.page = 1;
$scope.rows = 10;
// 下拉刷新
var loading = false;
$scope.init = function (flag) {
if (flag){
$scope.page = 1;
$scope.dealList = [];
}
var obj = {
page:$scope.page,
rows:$scope.rows,
passportId : $scope.passport.passportId,
token : $scope.passport.token
};
dealDetailService.dealDetailList(obj).then(function(data){
if ("OK" == data.status) {
if (data.result && data.result.length > 0){
var dealList = data.result;
for (i in dealList){
dealList[i].amount = dealList[i].amount / 100;
}
if ($scope.dealList && $scope.dealList.length > 0){
$scope.dealList = $scope.dealList.concat(dealList);
} else {
$scope.dealList = dealList;
if ($scope.dealList.length < 10){
$(".weui-infinite-scroll").html('');
} else {
$(".weui-infinite-scroll").html('<p class="loading"><div class="infinite-preloader"></div>正在加载...</p>')
loading = false;
}
}
if(!$scope.$$phase){
$scope.$apply();
}
} else {
$(".weui-infinite-scroll").html('<p class="bottomNoMore"><div class="infinite-preloader"></div>没有更多</p>')
loading = true;
}
}
},function(err){
});
};
// 初始化
$scope.init(true);
// 上拉刷新
$("div.weui-pull-to-refresh").pullToRefresh().on("pull-to-refresh", function () {
$scope.page = 1;
setTimeout(function () {
$(".comment-content").each(function(){
$(this).remove();
});
$scope.init(true);
$("div.weui-pull-to-refresh").pullToRefreshDone(); // 重置下拉刷新
}, 1000); //模拟延迟
});
// 下拉刷新
$("div.weui-pull-to-refresh").infinite().on("infinite", function () {
if (loading) return;
$scope.page++;
loading = true;
setTimeout(function () {
$scope.init(false);
loading = false;
}, 1000); //模拟延迟
});
$(".infinite-preloader").on("show", function () { alert("it show!"); });
});
|
/*
* server.js
* from www.nodebeginner.org
*/
"use strict";
var http = require("http");
var url = require("url");
var configuration = require("./configuration.js");
function start(route) {
var port = process.env.PORT || configuration.get_port();
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
if (pathname === '/') {
pathname = '/index.html';
}
route(response, pathname);
}
http.createServer(onRequest).listen(port);
console.log("Server has started on port " + port);
}
exports.start = start;
|
export const HOL_LOAD_LIST="HOL_LOAD_LIST"
export const HOL_LOAD_LIST_FAILED="HOL_LOAD_LIST_FAILED"
export const HOL_LOAD_LIST_SUCCESS="HOL_LOAD_LIST_SUCCESS"
export const HOL_LOAD_ADD_FORM="HOL_LOAD_ADD_FORM"
export const HOL_SAVE_FORM="HOL_SAVE_FORM"
export const HOL_SAVE_FAILED_FORM="HOL_SAVE_FAILED_FORM"
export const HOL_SAVE_SUCCESS_FORM="HOL_SAVE_SUCCESS_FORM"
export const HOL_LOAD_FORM_SUCCESS="HOL_LOAD_FORM_SUCCESS"
export const HOL_LOAD_FORM_FAILED="HOL_LOAD_FORM_FAILED"
export const HOL_LOAD_EDIT_FORM="HOL_LOAD_EDIT_FORM"
export const HOL_UPDATE_SUCCESS_FORM="HOL_UPDATE_SUCCESS_FORM"
export const HOL_FORM_VALUE_CHANGED="HOL_FORM_VALUE_CHANGED"
export const HOL_LOAD_DELETE_DIALOG="HOL_LOAD_DELETE_DIALOG"
export const HOL_DELETE_ATTEMPT="HOL_DELETE_ATTEMPT"
export const HOL_DELETE_FAILED="HOL_DELETE_FAILED"
export const HOL_DELETE_SUCCESS="HOL_DELETE_SUCCESS"
export const HOL_CANCEL_DELETE="HOL_CANCEL_DELETE"
|
var data =[
{
id: "1",
firstname: "Emilio",
lastname: "Kay",
birthday: "11/11/1969",
company: "J&K",
email: "dk@email.com",
phone: "555-555-1234"
},
{
id: "2",
firstname: "Daniel",
lastname: "Berry",
birthday: "07/06/1980",
company: "Next Tech",
email: "db@email.com",
phone: "415-777-4321"
},
{
id: "3",
firstname: "Chuch",
lastname: "Mora",
birthday: "07/06/1980",
company: "Next Tech",
email: "db@email.com",
phone: "415-777-4321"
}
];
module.exports = data;
|
const AuthReducer = (state = {}, action) => {
switch (action.type) {
case 'INIT_REQUEST':
return {
...state,
loading: action.payload,
};
case 'FETCH_USER_PROFILE':
return {
...state,
profile: action.payload,
};
case 'FETCH_USER_SUCCESS':
return {
...state,
profile: action.payload,
loading: false,
hasTriedLogin: true,
};
case 'FETCH_USER_FAILURE':
return {
...state,
loading: false,
hasTriedLogin: true,
};
case 'GET_INTERVIEWS_REQUEST':
return {
...state,
interviewsLoading: true,
};
case 'GET_INTERVIEWS_FAILURE':
return {
...state,
interviewsLoading: false,
};
case 'GET_INTERVIEWS_SUCCESS':
return {
...state,
interviewsLoading: false,
interviews: action.payload,
};
case 'FIND_MEETING_TIMES_REQUEST':
return {
...state,
findMeetingTimesLoading: true,
};
case 'FIND_MEETING_TIMES_FAILURE':
return {
...state,
findMeetingTimesLoading: false,
};
case 'FIND_MEETING_TIMES_SUCCESS':
return {
...state,
findMeetingTimesLoading: false,
meetingSuggestions: action.payload,
};
case 'EMAIL_SEND_SUCCESS':
return {
...state,
loading: false,
status: action.payload,
};
case 'CREATE_EVENT_SUCCESS':
return {
...state,
loading: false,
};
case 'CANCEL_EVENT_SUCCESS':
return {
...state,
loading: false,
};
default:
return state;
}
};
export default AuthReducer;
|
import React from 'react';
import NavBar from '../containers/nav_bar.js';
import pusheen from '../pusheen.jpg';
const About = props => {
return (
<div>
<NavBar />
<div className="row justify-content-center mt-4">
<span>
This todo app was created by <b>Grant Yang</b>
</span>
</div>
<div className="row justify-content-center">
<span>Please contact me at grantyang1@gmail.com. Thank you!</span>
</div>
<div className="row justify-content-center mt-4">
<img className="pusheen rounded" src={pusheen} alt={'me_irl'} />
</div>
</div>
);
};
export default About;
|
const withImages = require("next-images");
const dotEnv = require("dotenv");
const prod = process.env.NODE_ENV === "production";
if (!prod) {
dotEnv.config();
}
module.exports = withImages({
env: {
MONGO_DB: process.env.MONGODB,
},
build: {
env: {
MONGO_DB: process.env.MONGODB,
},
},
});
|
import { shallow } from 'enzyme'
import React from 'react'
import CounterConnect from './counter-connect-component'
import Counter from './counter-connect-container'
import reducer, { INITIAL_STATE } from './counter-connect-reducer'
import { increment, decrement, reset } from './counter-connect-actions'
const wrapper = shallow(<CounterConnect />)
jest.mock('react-redux', () => {
return {
connect: (mapStateToProps, mapDispatchToProps) => ReactComponent => ({
mapStateToProps,
mapDispatchToProps,
ReactComponent,
}),
Provider: ({ children }) => children,
}
})
describe('Render element', () => {
it('snapshot counter connect', () => {
expect(wrapper.debug()).toMatchSnapshot()
})
})
describe('Counter reducer', () => {
it('NONE', () => {
const state = reducer(undefined, {})
expect(state).toStrictEqual(INITIAL_STATE)
})
it('INCREMENT', () => {
const state = reducer(INITIAL_STATE, increment())
expect(state.counter).toStrictEqual(1)
})
it('DECREMENT', () => {
const state = reducer(INITIAL_STATE, decrement())
expect(state.counter).toStrictEqual(-1)
})
it('RESET', () => {
const state = reducer(INITIAL_STATE, reset())
expect(state.counter).toStrictEqual(0)
})
it('DEFAULT', () => {
const state = reducer(INITIAL_STATE, {})
expect(state.counter).toStrictEqual(0)
})
it('test mapStateToProps', () => {
const state = {
totalCounter: {
counter: 0,
},
}
const resp = {
counter: state.totalCounter.counter,
}
expect(Counter.mapStateToProps(state)).toEqual(resp)
})
it('test mapDispatchToProps ', () => {
const resp = {
increment,
decrement,
reset,
}
expect(Counter.mapDispatchToProps).toEqual(resp)
})
})
|
import React from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';
import {UncontrolledTooltip} from 'reactstrap';
import {getTranslation} from '../../../utilities/i18n';
const FormSelect = (props) => {
let tooltip = null;
let targetId = props.id || props.name;
if (props.hint) {
tooltip = <UncontrolledTooltip placement={props.hintPlacement} target={targetId}>
{props.hint}
</UncontrolledTooltip>;
}
const {fieldLength, className, hint, hintPlacement, id, ...other} = props;
let myClassName = className;
if (fieldLength > 0) {
myClassName = classNames(`col-sm-${props.fieldLength}`, className);
}
return (
<React.Fragment>
<select id={targetId}
className={classNames('custom-select form-control form-control-sm mr-1', myClassName)}
{...other}
>
{props.children}
</select>
{tooltip}
</React.Fragment>
);
}
FormSelect.propTypes = {
id: PropTypes.string,
value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
name: PropTypes.string,
onChange: PropTypes.func,
fieldLength: PropTypes.number,
hint: PropTypes.string,
hintPlacement: PropTypes.oneOf(['right', 'top']),
children: PropTypes.node,
className: PropTypes.string
};
FormSelect.defaultProps = {
hint: null,
hintPlacement: 'top',
};
const FormOption = (props) => {
let label;
if (props.i18nKey) {
label = getTranslation(props.i18nKey) || props.value;
} else {
label = props.label || props.value;
}
const {value, i18nKey, ...other} = props;
return (
<React.Fragment>
<option value={props.value}
{...other}
>
{label}
</option>
</React.Fragment>
);
}
FormSelect.propTypes = {
value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
i18nKey: PropTypes.string,
label: PropTypes.string,
disabled: PropTypes.bool
};
export {
FormSelect, FormOption
};
|
import React, { Component } from 'react'
import "./Employee.css"
import EmployeeCard from "./EmployeeCard"
export default class EmployeeList extends Component {
render() {
console.log(this.props)
return (
<React.Fragment>
<div className="employeeHeader">
<div className="employeeButton">
<button type="button"
className="btn btn-success"
onClick={() => {
this.props.history.push("/employees/new")
}
}>Add New Employee
</button>
</div>
</div>
<div className="employee-container">
{this.props.employees.map(employee =>
<EmployeeCard
key={employee.id}
employee={employee} {...this.props} />
)
}</div>
</React.Fragment>
)
}
}
|
/* global emojify */
/* global moment */
/* global app */
/* global factory */
app.service('chatService', ['$rootScope','socketFactory',function($rootScope,socketFactory) {
var self = this;
this.messages = [];
socketFactory.on("server:message:new",function(data){
console.log(data);
self.messages.push({date : moment().format('HH:mm:ss'), playerName : data.playerName, message : data.message});
//force refresh
//$rootScope.$apply();
});
this.sendMessage = function(message){
console.log("this.sendMessage");
socketFactory.emit("client:message:send",message);
}
}]);
|
import mongoose, { Schema } from 'mongoose';
const UserSchema = new Schema({
email: { type: String, required: true },
firstName: { type: String, required: true },
lastName: { type: String, required: true },
role: { Type: String },
dob: { Type: Date },
createdAt: Date,
});
mongoose.model('user', UserSchema);
|
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var testSchema = Schema({
application: {
type: Schema.Types.ObjectId,
ref: 'Application'
},
name: {
type: String,
required: true
},
description: String,
type: String,
commands: [Schema.Types.Mixed],
});
module.exports = mongoose.model('Test', testSchema);
|
angular.module('Directives')
.directive('newCategoryModal', ['$filter', 'CategoryService', 'QuestionFactory', 'UserService', function ($filter, CategoryService, QuestionFactory, UserService) {
return {
restrict: 'E',
templateUrl: 'templates/directives/modals/new-category-modal.html',
transclude: true,
replace: true,
scope: false,
link: function (scope, element, attrs, controllers) {
debugger
var model = scope.model;
scope.resetCategoryModal = function () {
model.categoryName = null;
}
scope.global.showNewCategoryModal = function () {
debugger
scope.global.removeError();
scope.global.removeModalError();
scope.resetCategoryModal();
$(element[0]).modal('show');
}
scope.cancelAddCategory = function () {
scope.global.removeModalError();
scope.resetCategoryModal();
$(element[0]).modal('hide');
}
scope.addCategory = function () {
scope.global.removeModalError();
try {
CategoryService.newCategory(model.categoryName);
scope.resetCategoryModal();
$(element[0]).modal('hide');
}
catch (exception) {
console.log(exception);
}
}
}
};
}]);
|
const logger = require('logger');
const {
generateImageValidator,
generatePdfValidator,
} = require('./validators');
const { getBrowser, closeBrowser, goToPage } = require('infrastructure/browser.helper');
module.exports.generatePdf = async (ctx) => {
const result = await generatePdfValidator.validate(ctx);
ctx.assert(!result.errors, 400);
ctx.type = 'application/pdf';
ctx.attachment('out.pdf');
const { url, html, options, headers } = result.value;
logger.debug('URL: ', url);
logger.debug('HTML: ', html);
logger.debug('OPTIONS: ', options);
logger.debug('HEADERS: ', headers);
const browser = await getBrowser();
try {
const page = await goToPage({
browser,
headers,
url: url || 'data:text/html,<!DOCTYPE html><html lang="en">',
});
if (html) {
await page.setContent(html);
}
logger.debug('MAKE PDF');
ctx.body = await page.pdf(
Object.assign({
printBackground: true,
margin: {
top: '0.4in',
right: '0.4in',
bottom: '0.4in',
left: '0.4in',
},
}, options),
);
await page.close();
} catch (e) {
await closeBrowser(browser);
throw e;
}
};
module.exports.generateImage = async (ctx) => {
const result = await generateImageValidator.validate(ctx);
ctx.assert(!result.errors, 400);
const { url, html, options, headers } = result.value;
const imageType = options.type || 'png';
ctx.type = `image/${imageType}`;
ctx.attachment(`out.${imageType}`);
const browser = await getBrowser();
logger.debug('URL: ', url);
logger.debug('HTML: ', html);
logger.debug('OPTIONS: ', options);
logger.debug('HEADERS: ', headers);
try {
const page = await goToPage({
browser,
headers,
url: url || 'data:text/html,<!DOCTYPE html><html lang="en">',
});
if (html) {
await page.setContent(html);
}
logger.debug('MAKE IMAGE');
ctx.body = await page.screenshot({
fullPage: true,
}, options);
await page.close();
} catch (e) {
await closeBrowser(browser);
throw e;
}
};
|
var mongoose = require('mongoose');
var Pricelist = require('../models/pricelist.model');
var MemberSchema = mongoose.Schema({
userId: {
type: mongoose.Schema.ObjectId,
index: true,
required: true
},
name: {
type: String,
required: true
},
phone: {
type: String,
default: 'Phone number not submitted'
},
email: {
type: String,
default: 'E-mail not submitted'
},
totalDebt: {
type: Number,
default: 0
},
memberships: [{
mName: String,
start: Date,
end: Date,
daysLeft: Number,
length: Number,
cost: Number,
debt: Number,
log: [{
date: Date,
amount: Number
}]
}]
});
var Member = module.exports = mongoose.model('Member', MemberSchema);
function getEndDate (startDate, length) {
var length = 1000*60*60*24*parseInt(length);
var startDate = new Date (startDate);
return (new Date (startDate.getTime() + length));
}
function getDaysLeft (currentDate, endDate){
var day_ms = 1000*60*60*24;
var current = new Date(currentDate);
var end = new Date(endDate);
var daysLeft = Math.round((end.getTime() - current.getTime())/day_ms);
return (daysLeft > 0) ? daysLeft : 0;
}
// Post
module.exports.addMember = function (userId, input, res) {
Pricelist.findOne({_id: input.membershipId}, function(err, item){
if (err)
res.json({success: false, msg: 'Membership type not found.'});
else{
var end = getEndDate(input.start, item.length);
var daysLeft = getDaysLeft(input.submitTime, end);
var debt = item.cost - ((input.amount)?input.amount:0);
var newMember = new Member({
userId: userId,
name: input.name,
totalDebt: debt
});
if(input.phone)
newMember.phone = input.phone;
if(input.email)
newMember.email = input.email;
newMember.memberships.unshift({
mName: item.name,
start: input.start,
end: end,
daysLeft: daysLeft,
length: item.length,
cost: item.cost,
debt: debt,
});
if(input.amount){
newMember.memberships[0].log.unshift({
date: input.start,
amount: input.amount
});
}
newMember.save(function (err, member) {
if(err)
res.json({ success: false, msg: 'Failed to add member.'});
else
res.json({
success: true,
msg: 'New member added.',
member: {
id: member._id,
name: member.name,
debt: member.totalDebt,
start: member.memberships[0].start,
left: member.memberships[0].daysLeft
}
});
});
}
});
}
module.exports.newMembership = function(memberId, input, res){
Pricelist.findOne({_id: input.membershipId}, function(err, item){
if (err)
res.json({success: false, msg: 'Membership type not found.'});
else{
Member.findById(memberId, function(err, member){
if (err)
res.json({success: false, msg: 'Member not found.'});
else{
var end = getEndDate(input.start, item.length);
var daysLeft = getDaysLeft(input.submitTime, end);
var debt = item.cost - ((input.amount)?input.amount:0);
member.totalDebt = member.totalDebt + debt;
member.memberships.unshift({
mName: item.name,
start: input.start,
end: end,
daysLeft: daysLeft,
length: item.length,
cost: item.cost,
debt: debt,
});
if(input.amount){
member.memberships[0].log.unshift({
date: input.start,
amount: input.amount
});
}
member.save(function(err, member){
if(err)
res.json({ success: false, msg: 'Failed to create new membership.'});
else
res.json({ success: true, msg: 'Membership created.', member: member });
});
}
});
}
});
}
module.exports.newPayment = function(memberId, membershipId, input, res){
Member.findById(memberId, function (err, member){
if (err)
return res.json({success: false, msg: 'Member not found.'});
member.totalDebt = member.totalDebt - input.amount;
member.memberships.forEach(membership => {
if(membership._id == membershipId){
membership.debt = membership.debt - input.amount;
membership.log.unshift({
date: input.date,
amount: input.amount
});
}
});
member.save(function(err, member){
if(err)
res.json({ success: false, msg: 'Failed to log the payment.'});
else
res.json({ success: true, msg: 'Payment logged.', member: member });
});
});
}
// Delete
module.exports.removeMember = function(memberId, callback){
var query = {_id: memberId};
Member.findOneAndRemove(query, callback);
}
module.exports.removeMembership = function(memberId, membershipId, res){
Member.findById(memberId, function(err, member){
if (err)
return res.status(404).json({success: false, msg: 'Member not found.'});
if (member.memberships.length == 1)
return res.status(403).json({success: false, msg: 'Member must have at least one membership.'});
var counter = 0;
member.memberships.forEach(membership =>{
if(membership._id == membershipId){
member.totalDebt = member.totalDebt - membership.debt;
member.memberships.splice(counter,1);
}
counter++;
});
member.save(function(err, member){
if(err)
res.json({ success: false, msg: 'Failed to remove membership.' });
else
res.json({ success: true, msg: 'Membership is removed.', member: member });
});
})
}
module.exports.removePayment = function(memberId, membershipId, paymentId, res){
Member.findById(memberId, function(err, member){
if (err)
return res.json({success: false, msg: 'Member not found.'});
var counter = 0;
member.memberships.forEach(membership =>{
if(membership._id == membershipId){
membership.log.forEach(payment =>{
if(payment._id == paymentId){
member.totalDebt += payment.amount;
membership.debt += payment.amount;
membership.log.splice(counter,1);
}
counter++;
});
}
});
member.save( function(err, member){
if(err)
res.json({ success: false, msg: 'Failed to remove payment.' });
else
res.json({ success: true, msg: 'Payment is removed.', member: member });
});
})
}
// Put
module.exports.updateMemberInfo = function(memberId, input, callback){
var query = {_id: memberId};
var update = {
$set: {
name: input.name,
phone: input.phone,
email: input.email
}
};
var options = { new: true };
Member.findOneAndUpdate(query, update, options, callback);
}
module.exports.updateDaysLeft = function(userId, input, res){
Member.find({userId: userId}, function(err, members){
if(err)
res.json({ success: false, msg: 'Failed to update remaining days.'});
else{
members.forEach(member =>{
member.memberships.forEach(membership => {
if(membership.daysLeft != 0)
membership.daysLeft = getDaysLeft(input.date, membership.end);
});
member.save();
});
res.json({ success: true, msg: 'Remaining days updated.'});
}
});
}
// Get
module.exports.getMember = function(memberId, callback){
var query = {_id: memberId};
Member.findOne(query, callback);
}
module.exports.searchMembers = function(userId, name, callback){
var query = {
userId: userId,
name: { $regex: name, $options: "i" }
};
Member.find(query, callback);
}
module.exports.getStatistics = function(userId, res){
Member.find({userId: userId}, function(err, members){
if(err)
res.json({ success: false, msg: 'Failed to get statistics.'});
else{
var membersCount = 0;
var activeMembers = 0;
var indeptedMembers = 0;
var unpaidAmount = 0;
members.forEach(member =>{
if(member.memberships[0].daysLeft > 0)
activeMembers++;
if(member.totalDebt > 0)
indeptedMembers++;
unpaidAmount += member.totalDebt;
membersCount++;
});
var statistics = {
members: membersCount,
activeMembers: activeMembers,
indeptedMembers: indeptedMembers,
unpaidAmount: unpaidAmount
};
res.json(statistics);
}
});
}
module.exports.getMembers = function(userId, callback){
var query = {userId: userId};
var criterion = { totalDebt: -1 };
Member.find(query,{},{sort: criterion}, callback);
}
module.exports.getActiveMembers = function(userId, res){
Member.find({userId: userId}, function(err, members){
if(err)
res.json({ success: false, msg: 'Failed to get active members.'});
else{
var activeMem = [];
members.forEach(member =>{
if(member.memberships[0].daysLeft > 0){
var newMember = {
id: member._id,
name: member.name,
debt: member.totalDebt,
start: member.memberships[0].start,
left: member.memberships[0].daysLeft
};
activeMem.push(newMember);
}
});
var i,j,min, tmp;
for(i = 0; i < activeMem.length - 1; i++){
min = i;
for (j = i+1; j < activeMem.length; j++){
if(activeMem[min].left > activeMem[j].left)
min = j;
}
if(min != i){
tmp = activeMem[i];
activeMem[i] = activeMem[min];
activeMem[min] = tmp;
}
}
res.json(activeMem);
}
});
}
|
(function(globals) {
var define, requireModule;
(function() {
var registry = {}, seen = {};
define = function(name, deps, callback) {
registry[name] = { deps: deps, callback: callback };
};
requireModule = function(name) {
if (seen[name]) { return seen[name]; }
seen[name] = {};
var mod = registry[name];
if (!mod) {
throw new Error("Module '" + name + "' not found.");
}
var deps = mod.deps,
callback = mod.callback,
reified = [],
exports;
for (var i=0, l=deps.length; i<l; i++) {
if (deps[i] === 'exports') {
reified.push(exports = {});
} else {
reified.push(requireModule(deps[i]));
}
}
var value = callback.apply(this, reified);
return seen[name] = exports || value;
};
})();
define("ember-pusher/bindings",
["exports"],
function(__exports__) {
"use strict";
var global = (typeof window !== 'undefined') ? window : {},
Ember = global.Ember;
var Bindings = Ember.Mixin.create({
init: function() {
var target;
this._super();
if(!this.PUSHER_SUBSCRIPTIONS) { return; }
target = this;
Ember.keys(target.PUSHER_SUBSCRIPTIONS).forEach(function (channelName) {
var events = target.PUSHER_SUBSCRIPTIONS[channelName];
target.pusher.wire(target, channelName, events);
});
},
willDestroy: function() {
var target;
if(!this.PUSHER_SUBSCRIPTIONS) { return; }
target = this;
Ember.keys(target.PUSHER_SUBSCRIPTIONS).forEach(function (channelName) {
target.pusher.unwire(target, channelName);
});
this._super();
},
_pusherEventsId: function() {
return this.toString();
}
});
__exports__.Bindings = Bindings;
});
define("ember-pusher/client_events",
["exports"],
function(__exports__) {
"use strict";
var global = (typeof window !== 'undefined') ? window : {},
Ember = global.Ember;
var ClientEvents = Ember.Mixin.create({
// Fire an event programmatically. All Events must unfortunately use
// the client-<eventname> format for client events (a pusher restriction).
pusherTrigger: function(channelName, eventName, data) {
var channel = this.pusher.channelFor(channelName);
channel.trigger(eventName, data);
}
});
__exports__.ClientEvents = ClientEvents;
});
define("ember-pusher/controller",
["exports"],
function(__exports__) {
"use strict";
var global = (typeof window !== 'undefined') ? window : {},
Ember = global.Ember;
// Need to track
// 1) channel object
// 2) event bindings which consist of
// - handler
// - event name
// - a unique string representing the target
//
// bindings: {
// 'channel-one': {
// channel: Pusher.Channel,
// eventBindings: {
// Ember.Route.toString(): [
// { handler: Function, eventName: String },
// { handler: Function, eventName: String }
// ]
// }
// }
// }
//
// wire(target, channelName, events)
// ================
// Initialize object in bindings if it's empty, with eventBindings: {}
// If eventBindings.length for the current target is 0
// connect to the channel
// store channel in the hash
// For each event in events
// bind the channel to the eventName
// store the handler and eventName in the eventBindings array for this channel and controller
// the key for storing is in target._pusherTargetId()
// (we store the eventName for when we might want to programmatically unwire)
//
//
// unwire(route):
// =================
// get the channel object
// for each handler, eventName in eventBindings for the current route
// call channel.unbind(eventName, handler)
// delete the routes record in EventBindings
// if eventBindings for this channel is empty
// unsubscribe from the channel
// delete the channel from bindings
var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
var Controller = Ember.Controller.extend({
connection: null,
isDisconnected: true,
isConnected: Ember.computed.not('isDisconnected'),
init: function() {
this._super();
this.set('bindings', {});
},
// Called by the application initializer
didCreatePusher: function(pusher) {
this.set('connection', pusher);
pusher.connection.bind('connected', __bind(this._didConnect, this));
pusher.connection.bind('disconnected', __bind(this._didDisconnect, this));
pusher.connection.bind('unavailable', __bind(this._didDisconnect, this));
},
// @events a hash in the form { channel-name: ['event1', 'event2'] }
// @target any object that responds to send() and _pusherEventsId()
wire: function(target, channelName, events) {
Ember.assert("Did you forget to extend the EmberPusher.Bindings mixin in " +
"your class receiving events?", !!target._pusherEventsId);
var channel = this.connectChannel(channelName),
bindings = this.get('bindings'),
targetId = target._pusherEventsId();
// Setup the eventBindings array for this target
if(!bindings[channelName].eventBindings[targetId])
bindings[channelName].eventBindings[targetId] = [];
// Iterate over the events and bind them
events.forEach(function(eventName) {
var normalizedEventName = Ember.String.camelize(eventName), handler;
handler = function(data) {
if(target.get('logPusherEvents')) {
console.log(target.constructor.toString() +
": Pusher event received", eventName, data);
}
target.send(Ember.String.camelize(eventName), data);
};
channel.bind(eventName, handler);
bindings[channelName].eventBindings[targetId].pushObject({
handler: handler,
eventName: eventName
});
});
},
connectChannel: function(channelName) {
var pusher = this.get('connection'),
bindings = this.get('bindings');
if(!bindings[channelName]) {
bindings[channelName] = { eventBindings: {} };
}
if(Ember.isEmpty(Ember.keys(bindings[channelName].eventBindings))) {
bindings[channelName].channel = pusher.subscribe(channelName);
// Spit out a bunch of logging if asked
if(this.namespace && this.namespace.PUSHER_OPTS.logAllEvents) {
bindings[channelName].channel.bind_all(function(eventName, data) {
console.log(
"Pusher event received on " + channelName + ":",
eventName,
data
);
});
}
}
return bindings[channelName].channel;
},
unwire: function(target, channelName) {
var pusher = this.get('connection'),
bindings = this.get('bindings'),
targetId = target._pusherEventsId(),
channel = bindings[channelName].channel;
// Unbind all the events for this target
for(var binding in bindings[channelName].eventBindings[targetId]) {
channel.unbind(binding.eventName, binding.handler);
}
delete bindings[channelName].eventBindings[targetId];
// Unsubscribe from the channel if this is the last thing listening
if(Ember.keys(bindings[channelName].eventBindings).length === 0) {
pusher.unsubscribe(channelName);
delete bindings[channelName];
return true;
}
return false;
},
channelFor: function(channelName) {
// debugger;
return this.get('bindings')[channelName].channel;
},
socketId: function() {
try {
return this.get('connection').connection.socket_id;
}
catch(error) {
console.warn(error);
}
}.property('isDisconnected'),
_didConnect: function() {
this.set('isDisconnected', false);
},
_didDisconnect: function() {
this.set('isDisconnected', true);
}
});
__exports__.Controller = Controller;
});
define("ember-pusher/initializer",
["ember-pusher/controller","exports"],
function(__dependency1__, __exports__) {
"use strict";
var Controller = __dependency1__.Controller;
var global = (typeof window !== 'undefined') ? window : {},
Ember = global.Ember,
Pusher = global.Pusher;
function initialize() {
if(!Ember) { throw("Include Ember before EmberPusher"); }
if(!Pusher) { throw("Include Pusher before EmberPusher"); }
Ember.Application.initializer({
name: "pusherConnected",
initialize: function(container, application) {
var pusherController, options, pusher, dict;
dict = 'pusher:main';
container.register(dict, Controller);
pusherController = container.lookup(dict);
options = application.PUSHER_OPTS;
Ember.assert("You need to provide PUSHER_OPTS on your application", options);
Ember.assert("You need to include the pusher libraries", typeof Pusher !== 'undefined');
pusher = new Pusher(options.key, options.connection);
pusherController.didCreatePusher(pusher);
application.inject('controller', 'pusher', dict);
application.inject('route', 'pusher', dict);
}
});
}
__exports__.initialize = initialize;
});
define("ember-pusher",
["ember-pusher/controller","ember-pusher/bindings","ember-pusher/client_events","ember-pusher/initializer","exports"],
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
"use strict";
var Controller = __dependency1__.Controller;
var Bindings = __dependency2__.Bindings;
var ClientEvents = __dependency3__.ClientEvents;
var initialize = __dependency4__.initialize;
initialize();
__exports__.Controller = Controller;
__exports__.Bindings = Bindings;
__exports__.ClientEvents = ClientEvents;
__exports__.initialize = initialize;
});
window.EmberPusher = requireModule("ember-pusher");
})(window);
|
import React, { useState, useContext } from 'react'
import {
View,
ImageBackground,
ScrollView,
KeyboardAvoidingView,
Platform
} from 'react-native'
import * as Notifications from 'expo-notifications';
import styles from './styles'
import { colors, alignment } from '../../utils'
import TextField from '../../ui/Textfield/Textfield'
import MainBtn from '../../ui/Buttons/MainBtn'
import AlternateBtn from '../../ui/Buttons/AlternateBtn'
import { SafeAreaView } from 'react-native-safe-area-context'
import { useMutation, gql } from '@apollo/client'
import { TextDefault, FlashMessage } from '../../components'
import UserContext from '../../context/User'
import { createUser } from '../../apollo/server'
import { useNavigation } from '@react-navigation/native'
const CREATEUSER = gql`
${createUser}
`
function SignUp(props) {
const navigation = useNavigation()
const [fullname, setFullname] = useState('')
const [email, setEmail] = useState('')
const [phone, setPhone] = useState('')
const [password, setPassword] = useState('')
const [nameError, setNameError] = useState(null)
const [emailError, setEmailError] = useState(null)
const [passwordError, setPasswordError] = useState(null)
const [phoneError, setPhoneError] = useState(null)
const [loading, setLoading] = useState(false)
const { setTokenAsync } = useContext(UserContext)
const [mutate] = useMutation(CREATEUSER, { onCompleted, onError })
function validateCredentials() {
let result = true
setEmailError(null)
setPasswordError(null)
setPhoneError(null)
setNameError(null)
const emailRegex = /^\w+([\\.-]?\w+)*@\w+([\\.-]?\w+)*(\.\w{2,3})+$/
if (!emailRegex.test(email.trim())) {
setEmailError('Provide a valid email address')
result = false
}
if (!password) {
setPasswordError('Password is required')
result = false
}
const phoneRegex = /^\d{11,15}$/
if (!phoneRegex.test(phone)) {
setPhoneError('Provide a valid phone number')
result = false
}
const nameRegex = /([a-zA-Z]{3,30}\s*)+/
if (!nameRegex.test(fullname)) {
setNameError('Full name is required')
result = false
}
return result
}
async function onCompleted(data) {
try {
// const trackingOpts = {
// id: data.createUser.userId,
// usernameOrEmail: data.createUser.email
// }
// Analytics.identify(data.createUser.userId, trackingOpts)
// Analytics.track(Analytics.events.USER_CREATED_ACCOUNT, trackingOpts)
setTokenAsync(data.createUser.token)
navigation.navigate('MainLanding')
} catch (e) {
console.log(e)
} finally {
setLoading(false)
}
}
function onError(error) {
try {
FlashMessage({ message: error.message, type: 'warning', position: 'top' })
} catch (e) {
console.log(e)
} finally {
setLoading(false)
}
}
async function mutateLogin(user) {
setLoading(true)
let notificationToken = null
const { status: existingStatus } = await Notifications.getPermissionsAsync()
if (existingStatus === 'granted') {
notificationToken = await Notifications.getExpoPushTokenAsync()
}
mutate({ variables: { ...user, notificationToken: notificationToken.data } })
}
return (
<SafeAreaView style={[styles.flex, styles.safeAreaStyle]}>
<KeyboardAvoidingView
behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
style={styles.flex}>
<ScrollView
showsVerticalScrollIndicator={false}
contentContainerStyle={{ flexGrow: 1 }}
style={styles.flex}>
<View style={styles.container}>
<View style={styles.body}>
<View style={styles.header}>
<TextDefault
textColor={colors.fontMainColor}
H5
style={{ ...alignment.PLsmall }}>
{'Sign Up'}
</TextDefault>
<AlternateBtn
onPress={() =>
props.navigation.navigate('noDrawer', {
screen: 'MainLanding'
})
}
text="Continue as a Guest"
/>
</View>
<View style={styles.main}>
<ImageBackground
style={styles.bodyContainerBackground}
source={require('../../assets/images/formBackground.png')}
resizeMode="cover">
<View style={styles.mainTop}>
<TextDefault textColor={colors.fontMainColor} H4>
{'Hello Guest'}
</TextDefault>
<TextDefault textColor={colors.fontMainColor}>
{'Sign Up'}
</TextDefault>
</View>
<View style={styles.mainMid}>
<View style={alignment.MBsmall}>
<TextField
error={!!nameError}
placeholder="Full Name"
onChange={event => {
setFullname(
event.nativeEvent.text.toLowerCase().trim()
)
}}
/>
{!!nameError && (
<TextDefault textColor={colors.errorColor} small>
{nameError}
</TextDefault>
)}
</View>
<View style={alignment.MBsmall}>
<TextField
error={!!emailError}
placeholder="Email"
onChange={event => {
setEmail(event.nativeEvent.text.toLowerCase().trim())
}}
/>
{!!emailError && (
<TextDefault textColor={colors.errorColor} small>
{emailError}
</TextDefault>
)}
</View>
<View style={alignment.MBsmall}>
<TextField
error={!!phoneError}
placeholder="Mobile"
onChange={event => {
setPhone(event.nativeEvent.text.toLowerCase().trim())
}}
/>
{!!phoneError && (
<TextDefault textColor={colors.errorColor} small>
{phoneError}
</TextDefault>
)}
</View>
<View style={alignment.MBsmall}>
<TextField
error={!!passwordError}
placeholder="Password"
password={true}
onChange={event => {
setPassword(
event.nativeEvent.text.toLowerCase().trim()
)
}}
/>
{!!passwordError && (
<TextDefault textColor={colors.errorColor} small>
{passwordError}
</TextDefault>
)}
</View>
</View>
<View style={styles.mainBot}>
<View style={styles.botBtnContainer}>
<MainBtn
loading={loading}
onPress={async() => {
if (validateCredentials()|| true) {
const user = {
phone: phone.trim(),
email: email.toLowerCase().trim(),
password: password,
name: fullname,
picture: ''
}
mutateLogin(user)
}
}}
text="Sign up"
/>
</View>
<View style={styles.mixedLine}>
<TextDefault textColor={colors.fontSecondColor}>
{'Already have an account: '}
<TextDefault
style={styles.ftTextUnderline}
textColor={colors.fontMainColor}
onPress={() => props.navigation.navigate('SignIn')}>
{'Sign in'}
</TextDefault>
</TextDefault>
</View>
</View>
</ImageBackground>
</View>
</View>
</View>
</ScrollView>
</KeyboardAvoidingView>
</SafeAreaView>
)
}
export default SignUp
|
'use strict'
const moment = require('moment-timezone')
const TimeUnit = require('../enums/TimeUnit')
const { IllegalArgumentError } = require('@northscaler/error-support')
/**
* @deprecated Use https://moment.github.io/luxon/docs/class/src/interval.js~Interval.html if you can.
*/
class Period {
static beginningAtWithMinutes (begin, minutes) {
return new Period(begin.clone(), begin.clone().add(minutes, TimeUnit.MINUTE.key))
}
static compare (a, b) {
if (a._begin && !b._begin) return 1
if (!a._begin && b._begin) return -1
if (a._begin && b._begin) {
if (a._begin.isBefore(b._begin)) return -1
if (a._begin.isAfter(b._begin)) return 1
}
if (a._end && !b._end) return -1
if (!a._end && b._end) return 1
if (a._end && b._end) {
if (a._end.isBefore(b._end)) return -1
if (a._end.isAfter(b._end)) return 1
}
return 0
}
static equal (a, b) {
return Period.compare(a, b) === 0
}
/**
* Determines if the begin & end of {@param candidate} are within {@param container}'s begin & end.
*
* @param container {Period} The {@link Period} that potentially contains `candidate`.
* @param candidate {Period|moment} The {@link Period} or `moment` that is potentially contained by {@param container}.
* @return {*}
*/
static contain (container, candidate) {
if (candidate instanceof Period) return container.containsPeriod(candidate)
if (moment.isMoment(candidate)) return container.containsMoment(candidate)
throw new IllegalArgumentError('candidate')
}
/**
* Determines if the begin or end of {@param b} are within {@param a}'s begin & end.
*
* @param a {Period} The {@link Period} that potentially contains `candidate`.
* @param candidate The {@link Period} that is potentially contained by {@param a}.
* @return {*}
*/
static overlap (a, b) {
return a.overlaps(b)
}
_begin // moment-timezone
_end // moment-timezone
constructor (begin, end) {
this.begin = begin
this.end = end
}
equals (that) {
return Period.equal(this, that)
}
clone () {
return new Period(this._begin.clone(), this._end.clone())
}
get begin () {
return this._begin?.clone()
}
set begin (value) {
this._begin = this._testSetBegin(value)
}
_testSetBegin (value) {
if (!value) return value
value = moment(value).utc()
if (!value.isValid() || this._end?.isBefore(value)) {
throw new IllegalArgumentError(`value: ${value}`)
}
return value
}
withBegin (value) {
this.begin = value
return this
}
get end () {
return this._end?.clone()
}
set end (value) {
this._end = this._testSetEnd(value)
}
_testSetEnd (value) {
if (!value) return value
value = moment(value).utc()
if (!value.isValid() || this._begin?.isAfter(value)) {
throw new IllegalArgumentError(`value: ${value}`)
}
return value
}
withEnd (value) {
this.end = value
return this
}
get length () {
if (!this._begin || !this._end) return -1
return this._end.valueOf() - this._begin.valueOf()
}
/**
* Determines whether this {@link Period} begins at or before and ends at or after the given {@link Period}.
*
* @param that
* @return {boolean}
*/
containsPeriod (that) {
if (!that) throw new IllegalArgumentError('that')
if (that._begin) {
if (that._end) {
return (
this.containsMoment(that._begin, '[)') &&
this.containsMoment(that._end, '(]')
)
}
// else not that._end
return this._begin.isSameOrBefore(that._begin)
}
// else no that._begin
if (that._end) {
return this._end.isSameOrAfter(that._end)
}
return !(this._begin || this._end) // that is "forever", so this must be too to contain that
}
/**
* Determines whether the given value falls within this period, optionally with the given inclusivity.
*
* @param m the given `moment` instance; if `undefined`, this method returns `false`
* @param inclusivity {string} see https://momentjs.com/docs/#/query/is-between/ for possible values; default is `[)`, meaning inclusive of begin, exclusive of end
* @return {boolean}
*/
containsMoment (m, inclusivity) {
if (!moment.isMoment(m) || !m.isValid()) return false
inclusivity = inclusivity || '[)'
if (this._begin) {
if (this._end) {
return m.isBetween(this._begin, this._end, null, inclusivity)
}
// else no this._end
return inclusivity.startsWith('[')
? m.isSameOrAfter(this._begin)
: m.isAfter(this._begin)
}
// else no this._begin
if (this._end) {
return inclusivity.endsWith(']')
? m.isSameOrBefore(this._end)
: m.isBefore(this._end)
}
// neither this._begin nor this._end, meaning "forever"
return true
}
/**
* Determines whether the given period overlaps, or begin & end moments overlap, this period.
*
* @param period {Period} The period to check.
* @return {boolean}
*/
overlaps (period) {
if (this._begin) {
if (this._end) {
return (
this.containsMoment(period._begin, '[)') ||
this.containsMoment(period._end, '(]') ||
period.containsPeriod(this)
)
}
// else no this._end
return !period._end || this._begin.isSameOrBefore(period._begin)
}
// else no this._begin
if (this._end) {
return !period._begin || this._end.isSameOrAfter(period._end)
}
return true // forever overlaps everything
}
compareTo (that) {
return Period.compare(this, that)
}
toString () {
return `${this._begin ? this._begin.toISOString() : '-∞'},${
this._end ? this._end.toISOString() : '+∞'
}`
}
}
module.exports = Period
|
// Default user location
var userLat = 44.556;
var userLng = -69.646;
var userTime;
// Markers for shuttle stops.
var mainStLatLng = {lat: 44.550999, lng: -69.632022};
var gilmanStLatLng = {lat: 44.553614, lng: -69.637182};
var diamondLatLng = {lat: 44.562241, lng: -69.659671};
var davisLatLng = {lat: 44.564428, lng: -69.658850};
// Names of stops that will show up when one stop's marker is clicked.
var mainStString = '<div>173 Main St. & Appleton St.</div>';
var gilmanStString = '<div>Gilman St.</div>';
var diamondString = '<div>Diamond building</div>';
var davisString = '<div>Davis Science Building</div>';
// Locations of critical vertices on the path from Main St. to Gilman St & back.
var mgLatLng_001 = {lat: 44.551679, lng: -69.635225};
var mgLatLng_002 = {lat: 44.553167, lng: -69.634346};
// Locations of critical vertices on the path from Gilman St. to Diamond & back.
var gdLatLng_001 = {lat: 44.556345, lng: -69.654988};
var gdLatLng_002 = {lat: 44.557197, lng: -69.657624};
var gdLatLng_003 = {lat: 44.557434, lng: -69.658141};
var gdLatLng_004 = {lat: 44.557957, lng: -69.658622};
var gdLatLng_005 = {lat: 44.561336, lng: -69.660115};
var gdLatLng_006 = {lat: 44.561908, lng: -69.660352};
var gdLatLng_007 = {lat: 44.561983, lng: -69.659704};
var gdLatLng_008 = {lat: 44.562064, lng: -69.659634};
// Locations of critical vertices on the path from Diamond to Davis & back.
var ddLatLng_001 = {lat: 44.562267, lng: -69.659589};
var ddLatLng_002 = {lat: 44.562118, lng: -69.659593};
var ddLatLng_003 = {lat: 44.561975, lng: -69.659549};
var ddLatLng_004 = {lat: 44.561865, lng: -69.660306};
var ddLatLng_005 = {lat: 44.562531, lng: -69.660461};
var ddLatLng_006 = {lat: 44.562982, lng: -69.660462};
var ddLatLng_007 = {lat: 44.563372, lng: -69.660422};
var ddLatLng_008 = {lat: 44.564047, lng: -69.660254};
var ddLatLng_009 = {lat: 44.564460, lng: -69.660065};
var ddLatLng_010 = {lat: 44.565225, lng: -69.659534};
var ddLatLng_011 = {lat: 44.564955, lng: -69.659012};
var ddLatLng_012 = {lat: 44.564701, lng: -69.658627};
var ddLatLng_013 = {lat: 44.564518, lng: -69.658531};
// Locations of critical vertices on the path from Diamond to Gilman St & back.
var dgLatLng_001 = {lat: 44.562064, lng: -69.659634};
var dgLatLng_002 = {lat: 44.561983, lng: -69.659704};
var dgLatLng_003 = {lat: 44.561908, lng: -69.660352};
var dgLatLng_004 = {lat: 44.561336, lng: -69.660115};
var dgLatLng_005 = {lat: 44.557957, lng: -69.658622};
var dgLatLng_006 = {lat: 44.557434, lng: -69.658141};
var dgLatLng_007 = {lat: 44.557197, lng: -69.657624};
var dgLatLng_008 = {lat: 44.556345, lng: -69.654988};
// A list of the locations above, arranged in order so that the map can draw the route.
var shuttleCoords = [
mainStLatLng,
mgLatLng_001,
mgLatLng_002,
gilmanStLatLng,
gdLatLng_001,
gdLatLng_002,
gdLatLng_003,
gdLatLng_004,
gdLatLng_005,
gdLatLng_006,
gdLatLng_007,
gdLatLng_008,
diamondLatLng,
ddLatLng_001,
ddLatLng_002,
ddLatLng_003,
ddLatLng_004,
ddLatLng_005,
ddLatLng_006,
ddLatLng_007,
ddLatLng_008,
ddLatLng_009,
ddLatLng_010,
ddLatLng_011,
ddLatLng_012,
ddLatLng_013,
davisLatLng,
ddLatLng_013,
ddLatLng_012,
ddLatLng_011,
ddLatLng_010,
ddLatLng_009,
ddLatLng_008,
ddLatLng_007,
ddLatLng_006,
ddLatLng_005,
dgLatLng_003,
dgLatLng_004,
dgLatLng_005,
dgLatLng_006,
dgLatLng_007,
dgLatLng_008,
gilmanStLatLng,
mgLatLng_002,
mgLatLng_001,
mainStLatLng
];
|
var galleryIsotope;
var galleryView = {
initialize : function() {
var self = this;
self.initIsotope();
//self.initVenobox();
self.bindEvents();
},
bindEvents : function() {
var self = this;
$('#gallery-flters li').on('click', function() {
$("#gallery-flters li").removeClass('filter-active');
$(this).addClass('filter-active');
galleryIsotope.isotope({
filter: $(this).data('filter')
});
});
},
initIsotope : function(){
var self = this;
galleryIsotope = $('.gallery-container').isotope({
itemSelector: '.gallery-item',
layoutMode: 'fitRows'
});
},
initVenobox:function(){
var self = this;
// Initiate venobox (lightbox feature used in portofilo)
$('.venobox').venobox();
}
};
$(document).ready(function(){
galleryView.initialize();
});
|
import _ from "lodash";
import pagination from "../common/pagination.js";
import Admin from "../model/admin.js";
import Unit from "../model/unit.js";
import Unit_Employee from "../model/unit_employee.js";
import Unit_In_Proj from "../model/unit_in_proj.js";
const add_unit = async (req, res) => {
try {
const {
name,
description,
adminID
} = req.body;
const find_date = await new Date();
const date = find_date.toString()
const check_admin = await Admin.findOne({where: {workID: adminID}});
const duplicated_admin = await Unit.findOne({where:{adminID: adminID}});
const createAt = find_date.toString();
const createBy = req.userData.id
if(check_admin && duplicated_admin === null){
const check_unit_existence = await Unit.findOne({where: {name: name}});
if(check_unit_existence === null){
const new_unit = await Unit.create({
name,
description,
date,
adminID,
createAt,
createBy
})
return res.status(201).json({
message: "New Unit Created",
data: new_unit
})
}else{
return res.status(400).json({
message:"You can't create a existed unit"
})
}
}else{
return res.status(400).json({
message:"Invalid Manager ID"
});
}
} catch (error) {
return res.status(500).json({
message: "Server Error"
})
}
}
const update_unit = async (req, res) => {
const id = req.params.id;
try {
const {
name,
description,
adminID
} = req.body
const date = await new Date();
const updateAt = date.toString();
const updateBy = req.userData.id
const check_admin = await Admin.findOne({where: {workID: adminID}});
const duplicated_admin = await Unit.findOne({where: {adminID: adminID}});
if(check_admin && duplicated_admin === null){
const check_unit_existence = await Unit.findOne({where: {name: name}});
if(check_unit_existence === null){
Unit.update({
name,
description,
adminID,
updateBy,
updateAt
}, {where:{id:id}})
return res.status(200).json({
message:"Success"
})
}else{
return res.status(400).json({
message: "Existed Unit Name"
});
}
}else{
return res.status(400).json({
message:"Invalid Admin ID"
})
}
} catch (error) {
return res.status(500).json({
message: "Server Error"
})
}
}
const list_unit = async (req, res) => {
const page = req.query.page;
const page_size = req.query.pagesize;
try {
const all_unit = await Unit.findAll({
raw: true,
attributes: ['name','description']
})
const arr_unit = await Object.entries(all_unit);
const sort_unit = _.orderBy(arr_unit, prop => prop.name, 'desc');
const page_list = await pagination(sort_unit, page, page_size);
return res.status(200).json({
message: "All Unit",
unit: page_list
})
} catch (error) {
return res.status(500).json({
message: "Server Error"
})
}
}
const unit_detail = async (req, res) => {
const id = req.params.id;
try {
const find_unit = await Unit.findOne({where: {id:id}})
if(find_unit){
return res.status(200).json({
message:"Unit Found",
unit: find_unit
})
}else{
return res.status(404).json({
message: "Unit Not Found"
})
}
} catch (error) {
return res.status(500).json({
message: "Server Error"
})
}
}
const delete_unit = async (req, res) => {
const id = req.params.id;
// const find_unit = await Unit.findOne({where: {id: id}});
const check_employee_in_unit = await Unit_Employee.findAll({where: {unitID: id}});
const check_unit_in_project = await Unit_In_Proj.findAll({where:{unitID: id}});
// const check_admin = await Admin.findOne({where: {id: find_unit.adminID}});
try {
if(check_employee_in_unit.length === 0 && check_unit_in_project.length === 0){
await Unit.update({
isDeleted: 1
}, {where: {id: id}})
return res.status(200).json({
message:"Deleted"
})
}else{
return res.status(400).json({
message: "Can't deleted this unit"
})
}
} catch (error) {
return res.status(500).json({
message: "Server Error"
})
}
}
export default {
add_unit,
update_unit,
list_unit,
unit_detail,
delete_unit,
}
|
const { OrderModel } = require('./model');
class Order {
static get(options) {
return OrderModel.find(options);
}
static add(order) {
return OrderModel.create(order);
}
static updateStatus(id, status) {
return OrderModel.findOneAndUpdate(
{ _id: id },
{ status, updated: Date.now() },
);
}
}
module.exports = Order;
|
import React from 'react'; // eslint-disable-line no-unused-vars
import { LinkEditor as LinkEditorComponent } from '../../../components/link/components/link-editor';
export const LinkEditor = ({ attributes, actions }) => {
const {
blockClass,
link,
} = attributes;
const {
onChangeLinkTitle,
} = actions;
const linkObject = (typeof link === 'undefined') || link;
return (
<LinkEditorComponent
blockClass={blockClass}
link={linkObject}
onChangeTitle={onChangeLinkTitle}
/>
);
};
|
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
exports.__esModule = true;
var google_spreadsheet_1 = require("google-spreadsheet");
var Aluno = /** @class */ (function () {
function Aluno(matricula, nome, faltas, P1, P2, P3, situacao, Naf) {
this.matricula = matricula;
this.nome = nome;
this.faltas = faltas;
this.P1 = P1;
this.P2 = P2;
this.P3 = P3;
this.situacao = situacao;
this.Naf = Naf;
//Calculando a média...
this.media = Number(((P1 + P2 + P3) / 3).toFixed(2));
}
return Aluno;
}());
var alunosLidos;
var doc = new google_spreadsheet_1.GoogleSpreadsheet('1j0p6AO0gkDe1mL8y_-fiocti60x6oJ1G4urTL_VmzyM');
(function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, principal()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
}());
function principal() {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, LerAlunos()];
case 1:
_a.sent();
alunosLidos.forEach(function (aluno) {
calculaSituacaoAluno(aluno);
calculaNafAluno(aluno);
});
salvaAlunos();
return [2 /*return*/];
}
});
});
}
function calculaSituacaoAluno(aluno) {
// Se faltas forem maior do que 25% das 60 aulas, a situação do aluno será 'Reprovado por falta'
if (aluno.faltas > 15) {
aluno.situacao = 'Reprovado por Falta';
return;
}
// A média das provas P1, P2 e P3 menor do que 5, situação é 'Reprovado por nota'
if (aluno.media < 50) {
aluno.situacao = 'Reprovado por nota';
return;
}
// A média das provas P1, P2 e P3 maior ou igual a 5 e menor do que 7, a situação é 'Exame final'
if (aluno.media >= 50 && aluno.media < 70) {
aluno.situacao = 'Exame Final';
return;
}
// A média das provas P1, P2 e P3 maior ou igual 7, a situação é 'Aprovado'
aluno.situacao = 'Aprovado';
}
function calculaNafAluno(aluno) {
// A Naf é uma nota mínima, ou meta do aluno, na prova final.
// A relação deve ser respeitada: 5 <= (m + naf)/2
// - Isso significa, que temos que encontrar o valor mínimo de naf. Para isso, faremos:
// - naf >= 10 - m, ou seja, o valor mínimo para a naf é (10 - m)
// Caso a situação do aluno seja diferente de 'Exame final', preencher o Naf com 0
if (aluno.situacao != 'Exame Final') {
aluno.Naf = 0;
return;
}
// Arredondar o valor para o próximo número inteiro. Ou seja, o Naf não pode ser decimal.
aluno.Naf = Math.round(100 - aluno.media);
}
function LerAlunos() {
return __awaiter(this, void 0, void 0, function () {
var vetorAluno, sheet, linhas, contaAlunos, i, matricula, nome, faltas, p1, p2, p3, situacao, Naf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, accessSpreadsheet()];
case 1:
_a.sent();
vetorAluno = [];
sheet = doc.sheetsByIndex[0];
console.log(sheet.title);
return [4 /*yield*/, sheet.getRows()];
case 2:
linhas = _a.sent();
contaAlunos = linhas.length;
return [4 /*yield*/, sheet.loadCells('A1:H500')];
case 3:
_a.sent(); // loads a range of cells
for (i = 3; i <= contaAlunos; i++) {
matricula = Number(sheet.getCell(i, 0).value);
nome = sheet.getCell(i, 1).value;
faltas = Number(sheet.getCell(i, 2).value);
p1 = Number(sheet.getCell(i, 3).value);
p2 = Number(sheet.getCell(i, 4).value);
p3 = Number(sheet.getCell(i, 5).value);
situacao = sheet.getCell(i, 6).value;
Naf = Number(sheet.getCell(i, 7).value);
vetorAluno.push(new Aluno(matricula, nome, faltas, p1, p2, p3, situacao, Naf));
}
alunosLidos = vetorAluno;
return [2 /*return*/];
}
});
});
}
function accessSpreadsheet() {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, doc.useServiceAccountAuth({
client_email: "desafiotunts@silicon-dialect-319119.iam.gserviceaccount.com",
private_key: "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCxM+zbg/0m2m6r\n6cVhfM0fXzIVfb8Wgm7DN59YorvHrKr+WjkmH6UMKLbdiiabUPsZ1OWh3KFxE6tz\nxd3wymV3qrg7hpo4JPQv1/TZtFhI3YGUCCoMKdZK0FAO26yb+FEyVNi7gtmsLFy5\nxvPCt5ZPBVZ7NdEi2cDsCLORUNpRTEbkcZL9g9UsVG7F3B3ILNwZfzpFMCf3HUMF\nqDLconTk1S61WL2a0Ao/y4JNwqhApD+RuzuRckeIcMrItM3pGA1SZIbEgFYUrSU6\nyro9nZCh4VDahuINKqf7aqkEkhAECDhXO8d42pM79VpuXc50TVLFXbAmjMDbXfRc\nc1V6xSylAgMBAAECggEAAs/9quWXOit5BTPSelUg66YMT/NXzz4mZDp48M8IZvIS\ndrNXjoeDDESF09H9AeBmU9x2q+Z/Y3bkn5Oc4v+mCPZbMoqqM55BMpSIDNUuxN1L\nJgkpIwSeTkAB0p029J9w086CmsXyuX0CGGq+ygY1la8n1mXIxM0ATF6+UYifJm97\nixJGmWp3cJnd4FeA51cSvO/+NBd1AcFDNxLqbC+hD1+JOgNLaYcOACJ6iMA/5zuH\nJYoscTunN7fQIEVj7F5ws69WOuYDlGwCB0RtI6fRluPV4R8VlvHqrCLlr7GqIogR\nHSPeJlKueEUM/8uXBW/TqfOYraALo13CRlV4jymmcwKBgQDlP+rwrLP+K9GW08lu\nmOl7WAFRshXAM8aaAM8L9nAmoMWyl/n8jpzdA5BR7fsTRjxO2Kvmewrx/A9x4KOc\nseoWu216kKKngBdC7ws7hUYKKKgrMAITHVi236tmlz75K1BRj8fv0F9cizG8uaNN\nZULHb0niU24xU7/MEgmle4CJ0wKBgQDF4UdXNB+TTcww8llCPEWdYR9IqVZE2Dui\n0wTWjw8sgbBBSAZV3hpFblITujKlD+A86289R0Zd8qydWL4Urzwjbws//icnBzZS\nX9FHfP9lpd7WwYoWwQQJyfAdpsm3rNG/rZLyEYgahbrlE3XspSrXr65U+BBDIgn2\nOX5YrPkspwKBgQDMQLm7u7QW1sXDY2kKMBV+vvdV6Zx1hewCFIxktSpRUFc0ezHR\nMuNSC7XPOYDFOIPNIEFwddpXpePA64v6tY3CuTWeyTUSlg6jpUXVvzWbIYRMDlca\n3r/HF9un6UPDTzMdqERUR8xfMOmco6167Kil9mLW0szQCDVPxhZwKWxp3wKBgGX9\ntlqhGAFBoRQ9ZXo5PJxgedJmzXtQhHRpFV5NgEGtWp5bNEC/6ISO1ykp2H6xTx+3\nLa/E8+TqdsPnAJoCtBmDW6YRJjb8hagxkNmq+Kx4sQG54aXWuHEfL27pD6FnJvkH\nyuyP0rnw4aK+xBJEE2/2MgHDlgY0HjRV7+Rey1OTAoGADR+YGnQp0VIKWkR2afGA\n5viPyyIHtYbiGjSjfJbefqH/8KlIgSL7IU4XL5KDdeu9pMv8cb82PuBxhG5fQu/1\nSbZgIbQTXFwOsdMyNp2xDz8Iptv9O3Ksc8EWfiw/22ylLfipk8xrHK+KnY3bDJtK\nfn8jM8h0CXDqk5bCwka5jCQ=\n-----END PRIVATE KEY-----\n"
})];
case 1:
_a.sent();
return [4 /*yield*/, doc.loadInfo()];
case 2:
_a.sent(); // loads document properties and worksheets
console.log(doc.title);
return [2 /*return*/];
}
});
});
}
function salvaAlunos() {
return __awaiter(this, void 0, void 0, function () {
var sheet, linhas, contaAlunos, i, indiceAluno, situacao, Naf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
sheet = doc.sheetsByIndex[0];
return [4 /*yield*/, sheet.getRows()];
case 1:
linhas = _a.sent();
contaAlunos = linhas.length;
return [4 /*yield*/, sheet.loadCells('A1:H500')];
case 2:
_a.sent(); // loads a range of cells
i = 3;
_a.label = 3;
case 3:
if (!(i <= contaAlunos)) return [3 /*break*/, 6];
indiceAluno = i - 3;
situacao = sheet.getCell(i, 6);
Naf = sheet.getCell(i, 7);
situacao.value = alunosLidos[indiceAluno].situacao;
Naf.value = alunosLidos[indiceAluno].Naf;
return [4 /*yield*/, sheet.saveUpdatedCells()];
case 4:
_a.sent(); // save all updates in one call
_a.label = 5;
case 5:
i++;
return [3 /*break*/, 3];
case 6: return [2 /*return*/];
}
});
});
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import configureStore from './store/store';
import { receiveTodo } from './actions/todo_actions';
import { receiveTodos } from './actions/todo_actions';
import Root from './components/root';
//DELETE THIS
import allTodos from './reducers/selectors'
import TodoList from './components/todos/todo_list'
document.addEventListener("DOMContentLoaded", () => {
console.log("hello");
const root = document.getElementById("root");
ReactDOM.render(<Root store={configureStore()}/>, root);
})
//DELETE THIS
window.store = configureStore();
window.receiveTodo = receiveTodo;
window.receiveTodos = receiveTodos;
window.allTodos = allTodos;
window.TodoList = TodoList;
|
'use strict';
/* Controllers */
var galleryApp = angular.module('galleryApp', []);
galleryApp.controller('ArticleListController', function ($scope) {
var imageUrl = 'http://lorempixel.com/100/100/';
$scope.articles = [
{
'title': 'This is the First Article',
'content': 'Just some content for the first article.',
'imageUrl': imageUrl
},
{
'title': 'This is the Second Article',
'content': 'Just some content for the second article.',
'imageUrl': imageUrl
},
{
'title': 'And the Third One',
'content': 'Just some content for the third article.',
'imageUrl': imageUrl
}
];
});
|
/*global showDifference */
$(document).ready(function() {
"use strict";
var orig = [20, 30, 44, 54, 55, 11, 78, 14, 13, 79, 12, 98];
var arr = [12, 11, 13, 14, 20, 30, 44, 54, 55, 79, 78, 98];
showDifference("shellsortCON8", orig, arr);
});
|
// startup
import 'utils/startup';
import utils from 'utils';
// object models
import animalStartup from 'animal/split';
import assessmentStartup from 'assessment/split';
import dataPivotStartup from 'dataPivot/split';
import epiStartup from 'epi/split';
import epimetaStartup from 'epimeta/split';
import invitroStartup from 'invitro/split';
import litStartup from 'lit/split';
import mgmtStartup from 'mgmt/split';
import riskofbiasStartup from 'riskofbias/split';
import studyStartup from 'study/split';
import smartTagsStartup from 'smartTags/split';
import summaryStartup from 'summary/split';
import summaryFormsStartup from 'summaryForms/split';
// custom applications
import bmdStartup from 'bmd';
import robVisualStartup from 'robVisual';
import robTableStartup from 'robTable';
import robScoreCleanupStartup from 'robScoreCleanup';
import textCleanupStartup from 'textCleanup';
import nestedTagEditorStartup from 'nestedTagEditor';
window.app = {
utils,
animalStartup,
assessmentStartup,
dataPivotStartup,
epiStartup,
epimetaStartup,
invitroStartup,
litStartup,
mgmtStartup,
riskofbiasStartup,
studyStartup,
smartTagsStartup,
summaryStartup,
summaryFormsStartup,
bmdStartup,
robVisualStartup,
robTableStartup,
robScoreCleanupStartup,
textCleanupStartup,
nestedTagEditorStartup,
};
|
var _ = require('underscore');
var fn = require('../fn');
var datas = require('../datas');
var exports = {};
exports.init = function(userID) {}
exports.api = {
GetNetworkInfo: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.GetNetworkInfo, req.id));
},
SearchNetwork: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.SearchNetwork, req.id));
},
SearchNetworkResult: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.SearchNetworkResult, req.id));
},
RegisterNetwork: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.RegisterNetwork, req.id));
},
GetNetworkRegisterState: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.GetNetworkRegisterState, req.id));
},
GetNetworkSettings: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.GetNetworkSettings, req.id));
},
SetNetworkSettings: function(req, res, userID) {
var $data = datas[userID].$data;
res.send(fn.result($data.SetNetworkSettings, req.id));
}
}
module.exports = exports
|
import React, { Component } from 'react';
import {
BrowserRouter as Router,
Switch,
Route
} from "react-router-dom";
import routers from '../../Constants/routers';
import Navigation from './Navigation';
import Footer from './Footer'
export default class Layout extends Component {
render() {
return (
<Router>
<Navigation/>
<Switch>
{routers.map((router, index) => {
return (
<Route
key={index}
path={router.path}
component={router.component}
exact={true}
/>
)
})}
</Switch>
<Footer />
</Router>
)
}
}
|
var http = require('http');
var server = http.createServer(function(req, res) {
var body = "<h1>Selamat datang di NodeJS Programming</h1>";
res.writeHead(200, {
'Content-Type': 'text/html',
'Content-Length': body.length
});
res.write(body);
res.end;
});
const port = process.env.PORT || 8080;
server.listen(port);
console.log("http://localhost:5050");
|
import React, {Component} from 'react';
import './reset.css';
import './App.css';
import Title from './components/title/Title';
import Cart from './components/cart/Cart';
import Menu from './components/menu/Menu';
import DataCollect from './components/forms/DataCollect';
import MessageWindow from './components/message/MessageWindow';
class App extends Component {
render() {
return (
<div className="full-height full-width">
<Title/>
<div id="content">
<Cart/>
<DataCollect/>
</div>
<Menu/>
<MessageWindow/>
</div>
);
}
componentDidMount(){}
}
export default App;
|
<style>
/* The Image Box */
div.img {
border: 1px solid #ccc;
}
div.img:hover {
border: 1px solid #777;
}
/* The Image */
div.img img {
width: 100%;
height: auto;
cursor: pointer;
}
/* Description of Image */
div.desc {
padding: 15px;
text-align: center;
}
* {
box-sizing: border-box;
}
/* Add Responsiveness */
.responsive {
padding: 0 6px;
float: left;
width: 24.99999%;
}
/* The Modal (background) */
.modal {
display: none; /* Hidden by default */
position: fixed; /* Stay in place */
z-index: 1; /* Sit on top */
padding-top: 100px; /* Location of the box */
left: 0;
top: 0;
width: 100%; /* Full width */
height: 100%; /* Full height */
overflow: auto; /* Enable scroll if needed */
background-color: rgb(0,0,0); /* Fallback color */
background-color: rgba(0,0,0,0.9); /* Black w/ opacity */
}
/* Modal Content (image) */
.modal-content {
margin: auto;
display: block;
width: 80%;
max-width: 700px;
}
/* Caption of Modal Image */
#caption {
margin: auto;
display: block;
width: 80%;
max-width: 700px;
text-align: center;
color: #ccc;
padding: 10px 0;
height: 150px;
}
/* Add Animation */
.modal-content, #caption {
-webkit-animation-name: zoom;
-webkit-animation-duration: 0.6s;
animation-name: zoom;
animation-duration: 0.6s;
}
@-webkit-keyframes zoom {
from {transform:scale(0)}
to {transform:scale(1)}
}
@keyframes zoom {
from {transform:scale(0.1)}
to {transform:scale(1)}
}
/* The Close Button */
.close {
position: absolute;
top: 15px;
right: 35px;
color: #f1f1f1;
font-size: 40px;
font-weight: bold;
transition: 0.3s;
}
.close:hover,
.close:focus {
color: #bbb;
text-decoration: none;
cursor: pointer;
}
/* Responsive Columns */
@media only screen and (max-width: 700px){
.responsive {
width: 49.99999%;
margin: 6px 0;
}
.modal-content {
width: 100%;
}
}
@media only screen and (max-width: 500px){
.responsive {
width: 100%;
}
}
/* Clear Floats */
.clearfix:after {
content: "";
display: table;
clear: both;
}
</style>
|
import Vue from "vue";
import Router from "vue-router";
import Home from "../views/Home.vue";
import List from "../views/List.vue";
import Profile from "../views/Profile.vue";
import Settings from "../views/Settings.vue";
import Archive from "../views/Archive.vue";
import { authGuard } from "../auth";
require('@/assets/css/style.css');
Vue.use(Router);
const router = new Router({
mode: "history",
base: process.env.BASE_URL,
routes: [
{
path: "/",
name: "home",
component: Home
},
{
path: "/main",
name: "list",
component: List,
beforeEnter: authGuard
},
{
path: "/profile",
name: "profile",
component: Profile,
beforeEnter: authGuard
},
{
path: "/settings",
name: "settings",
component: Settings,
beforeEnter: authGuard
},
{
path: "/archive",
name: "archive",
component: Archive,
beforeEnter: authGuard
}
]
});
export default router;
|
const mongoose = require('mongoose');
const Product = require('./models/product');
const data = require('./dummyData');
mongoose.connect('mongodb://localhost/productDetails');
Product.insertData(data)
.then(() => {
console.log('Insert Data Success!');
mongoose.disconnect();
})
.catch((e) => {
console.error(e);
mongoose.disconnect();
});
|
class Weakness {
constructor (energyType, multiplier) {
this.energyType = energyType
this.multiplier = multiplier
}
}
module.exports = Weakness
|
import React, { useState, useRef, useEffect } from "react";
import { Link } from "react-router-dom";
import { Formik, Form, Field } from "formik";
import { Button } from "semantic-ui-react";
import { Mutation } from "react-apollo";
import * as Yup from "yup";
import AuthSystemFormWrapp from "components/Forms/AuthSystemForms/index";
import { CustomTextArea } from "components/Forms/CustomTextArea";
import * as path from "constants/routes";
import * as query from "api/mutations";
import { useClickOutside } from "utils/hooks.js";
import externalLink from "assets/external-link.svg";
import "./styles.scss";
const ContactUsSchema = Yup.object().shape({
description: Yup.string().required("Description is required!"),
});
const Legal = (props) => {
const [contactUsModal, toggleContactUs] = useState(false);
const [isSuccess, setSuccess] = useState(false);
const innerRef = useRef();
useClickOutside(innerRef, () => toggleContactUs(false));
useEffect(() => {
props.setActiveLink(props.location.pathname);
}, []);
const handleSubmit = async (contactUs, values, data) => {
try {
contactUs({
variables: {
message: values.description,
},
}).then((response) => {
if (response.data.contactUs.success) {
toggleContactUs(false);
setSuccess(true);
} else console.log("errors");
});
} catch (error) {}
};
const links = [
{
id: 1,
path: path.COOKIE_POLICY,
name: "Cookie Policy",
},
{
id: 2,
path: path.TERMS_AND_CONDITIONS,
name: " Terms and conditions",
},
{
id: 3,
path: path.FAQ,
name: "FAQ",
},
{
id: 4,
path: path.PRIVACY_POLICY,
name: "privacy policy",
},
{
id: 5,
path: path.CONTACT_US,
name: "contact us",
},
];
return (
<div className="legal">
<ul>
{links.map((link) => (
<li key={link.id}>
{link.name === "contact us" ? (
<Link to="#" onClick={() => toggleContactUs(true)}>
{link.name} <img src={externalLink} alt="" />
</Link>
) : (
<a href={link.path} target="_blank">
{link.name}
<img src={externalLink} alt="" />
</a>
)}
</li>
))}
</ul>
{contactUsModal && (
<div ref={innerRef}>
<AuthSystemFormWrapp
title="CONTACT US"
subtitle={
<>
Contact us or email us and we promise to get <br /> back to you
as soon as we can.
</>
}
onClose={() => toggleContactUs(false)}
>
<Mutation mutation={query.contactUs}>
{(contactUs, { loading }) => {
return (
<Formik
initialValues={{
description: "",
}}
validationSchema={ContactUsSchema}
onSubmit={(form, data) =>
handleSubmit(contactUs, form, data)
}
>
{({ values }) => (
<Form>
<Field
name="description"
type="text"
component={CustomTextArea}
placeholder="Got something you want to talk about?"
value={values.description}
rows="8"
maxLength={400}
/>
<Button
style={{ background: "#639BE6" }}
type="submit"
className="d-block mt-2 px-5 py-3 w-100"
loading={loading}
>
Send message
</Button>
</Form>
)}
</Formik>
);
}}
</Mutation>
</AuthSystemFormWrapp>
</div>
)}
{isSuccess && (
<AuthSystemFormWrapp
icon={<ion-icon name="checkmark-circle-outline"></ion-icon>}
title="success"
subtitle="Your message has been successfully sent"
withOutIcon
>
<Button
style={{ background: "#639BE6" }}
className="w-100"
onClick={() => setSuccess(false)}
>
Done
</Button>
</AuthSystemFormWrapp>
)}
</div>
);
};
export default Legal;
|
module.exports = function(grunt){
grunt.initConfig({
concat: {
options: {
separator:'\n\n //------------------------>\n',
banner:'\n\n //--------------->\n\n'
},
dist:{
src: 'builds/*.js',
dest:'js/script.js'
}
},
watch: {
options:{
spawn:false,
livereload:true
},
scripts:{
files:['views/**/*.html',
'builds/*.js',
'js/controllers/*.js',
'css/**.css'
],
tasks:['concat']
}
}
});
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.registerTask('default', ['concat', 'watch']);
};
|
import React, {useState} from 'react';
import {Card} from "../components";
import styled from "styled-components";
import {connect} from "react-redux";
const SearchContainer = styled.div`
width: 100%;
height: 50%;
flex-direction: row;
align-items: center;
justify-content: center;
margin-top: 10px;
margin-bottom: 20px;
margin-left: 75%;
`;
function Search({pokemon}) {
const [localFavorite, setLocalFavorite] = useState(pokemon.pokemon.isFavorite)
const [data, setData] = useState([]);
const handleAddFavorite = () => {
const favorite = {
name: pokemon.pokemon.name,
desc: pokemon.pokemon.desc,
image: pokemon.pokemon.image,
isFavorite: true
}
setData(prev => prev.push(favorite))
localStorage.setItem("Favorites", JSON.stringify(data))
setLocalFavorite(true)
}
return (
<SearchContainer>
{
pokemon.pokemon.name.length <= 0? null:
(<Card
name={pokemon.pokemon.name}
desc={pokemon.pokemon.desc}
image={pokemon.pokemon.image}
isFavorite={localFavorite}
handleButton={handleAddFavorite}
/>)
}
</SearchContainer>
)
}
const mapStateToProps = (state) => {
return state;
};
export default connect(mapStateToProps)(Search);
|
const sgMail = require("@sendgrid/mail");
const sendGridKey = process.env.SG_KEY;
sgMail.setApiKey(sendGridKey);
const sendWelcomeMail = (email, name) => {
sgMail.send({
from: "jitendrakumarbhamidipati@gmail.com",
to: email,
subject: `Welcome to the APP,${name}`,
text: `Thank you for joining in.Let me know how you get along with the APP`
});
};
const sendCancellationEmail = (email, name) => {
sgMail.send({
from: "jitendrakumarbhamidipati@gmail.com",
to: email,
subject: `Thank you for using the APP,${name}`,
text: "I hope you had good experience using it."
});
};
module.exports = {
sendWelcomeMail,
sendCancellationEmail
};
|
var express = require('express');
var app = express();
var fs = require('fs')
app.get(/(.+)$/i, function(req, res){
console.log(req.params[0]);
var file_name = __dirname + req.params[0];
fs.exists(file_name,
function(exists) {
if(exists){
res.sendFile(file_name);
} else {
res.send('Error 404: File name does not exists');
}
}
);
})
app.listen(80);
|
import React from 'react';
import { makeStyles } from '@material-ui/core';
import Theme from '../common/Theme';
const useStyles = makeStyles(() => ({
root: {
},
title: {
color: Theme.colors.primary,
fontSize: Theme.fontSize.pageName,
fontWeight: Theme.fontWeight.pageName,
lineHeight: '42px'
},
subTitle: {
color: Theme.colors.subTitle,
fontWeight: Theme.fontWeight.subTitle,
fontSize: Theme.fontSize.subTitle
}
}));
const PageTitle = ({ title, subTitle }) => {
const classes = useStyles();
return (
<div className={classes.root}>
<h2 className={classes.title}>{title}</h2>
<p className={classes.subTitle}>{subTitle}</p>
</div>
);
};
export default PageTitle;
|
import React from "react"
class Footer extends React.Component{
render(){
var tags = <div></div>
return (tags)
}
}
export default Footer
|
import axios from 'axios'
class LibraryService {
constructor() {
this.app = axios.create({
baseURL: `${process.env.REACT_APP_BASE_URL}/library`,
withCredentials: true
})
}
libraryList = date_requested => this.app.get(`/${date_requested}`)
bookingLibrary = (init_date, library_id) => this.app.get('/bookingLibrary', { init_date, library_id })
}
export default LibraryService
|
var Slate = {
"Block": {
"create": function() {},
"createList": function() {},
"fromJSON": function() {},
"toJSON": function() {},
"isBlock": function() {}
},
"Change": {
"call": function() {},
"withoutNormalization": function() {},
"deleteBackward": function() {},
"deleteForward": function() {},
"delete": function() {},
"insertBlock": function() {},
"insertFragment": function() {},
"insertInline": function() {},
"insertText": function() {},
"addMark": function() {},
"setBlocks": function() {},
"setInlines": function() {},
"splitBlock": function() {},
"splitInline": function() {},
"removeMark": function() {},
"toggleMark": function() {},
"unwrapBlock": function() {},
"unwrapInline": function() {},
"wrapBlock": function() {},
"wrapInline": function() {},
"wrapText": function() {},
"blur": function() {},
"collapseToAnchor": function() {},
"collapseToFocus": function() {},
"collapseToStart": function() {},
"collapseToEnd": function() {},
"collapseToStartOf": function() {},
"collapseToEndOf": function() {},
"collapseToStartOfPreviousBlock": function() {},
"collapseToStartOfNextBlock": function() {},
"collapseToEndOfPreviousBlock": function() {},
"collapseToEndOfNextBlock": function() {},
"collapseToStartOfPreviousText": function() {},
"collapseToStartOfNextText": function() {},
"collapseToEndOfPreviousText": function() {},
"collapseToEndOfNextText": function() {},
"extend": function() {},
"extendToStartOf": function() {},
"extendToEndOf": function() {},
"flip": function() {},
"focus": function() {},
"move": function() {},
"moveStart": function() {},
"moveEnd": function() {},
"moveOffsetsTo": function() {},
"moveToRangeOf": function() {},
"select": function() {},
"selectAll": function() {},
"deselect": function() {},
"deleteBackwardAtRange": function() {},
"deleteForwardAtRange": function() {},
"deleteAtRange": function() {},
"insertBlockAtRange": function() {},
"insertFragmentAtRange": function() {},
"insertInlineAtRange": function() {},
"insertTextAtRange": function() {},
"addMarkAtRange": function() {},
"setBlocksAtRange": function() {},
"setInlinesAtRange": function() {},
"splitBlockAtRange": function() {},
"splitInlineAtRange": function() {},
"removeMarkAtRange": function() {},
"toggleMarkAtRange": function() {},
"unwrapBlockAtRange": function() {},
"unwrapInlineAtRange": function() {},
"wrapBlockAtRange": function() {},
"wrapInlineAtRange": function() {},
"wrapTextAtRange": function() {},
"addMarkByKey": function() {},
"insertNodeByKey": function() {},
"insertFragmentByKey": function() {},
"insertTextByKey": function() {},
"moveNodeByKey": function() {},
"removeMarkByKey": function() {},
"removeNodeByKey": function() {},
"replaceNodeByKey": function() {},
"removeTextByKey": function() {},
"setMarkByKey": function() {},
"setNodeByKey": function() {},
"splitNodeByKey": function() {},
"unwrapInlineByKey": function() {},
"unwrapBlockByKey": function() {},
"unwrapNodeByKey": function() {},
"wrapBlockByKey": function() {},
"wrapInlineByKey": function() {},
"redo": function() {},
"undo": function() {},
"snapshotDetection": function() {}
},
"Character": {
"create": function() {},
"createList": function() {},
"fromJSON": function() {},
"isCharacter": function() {},
"toJSON": function() {}
},
"Data": {
"create": function() {},
"fromJSON": function() {}
},
"Document": {
"create": function() {},
"fromJSON": function() {},
"isDocument": function() {},
"filterDescendants": function() {},
"findDescendant": function() {},
"getBlocksAtRange": function() {},
"getBlocks": function() {},
"getCharactersAtRange": function() {},
"getChild": function() {},
"getClosestBlock": function() {},
"getClosestInline": function() {},
"getClosest": function() {},
"getDepth": function() {},
"getDescendant": function() {},
"getFirstText": function() {},
"getFragmentAtRange": function() {},
"getFurthest": function() {},
"getFurthestAncestor": function() {},
"getFurthestBlock": function() {},
"getFurthestInline": function() {},
"getFurthestOnlyChildAncestor": function() {},
"getInlinesAtRange": function() {},
"getLastText": function() {},
"getMarksAtRange": function() {},
"getNextBlock": function() {},
"getNextSibling": function() {},
"getNextText": function() {},
"getParent": function() {},
"getPreviousBlock": function() {},
"getPreviousSibling": function() {},
"getPreviousText": function() {},
"getTextAtOffset": function() {},
"getTextsAtRange": function() {},
"hasChild": function() {},
"hasDescendant": function() {},
"toJSON": function() {}
},
"Inline": {
"create": function() {},
"createList": function() {},
"fromJSON": function() {},
"isInline": function() {},
"filterDescendants": function() {},
"findDescendant": function() {},
"getBlocksAtRange": function() {},
"getBlocks": function() {},
"getCharactersAtRange": function() {},
"getChild": function() {},
"getClosestBlock": function() {},
"getClosestInline": function() {},
"getClosest": function() {},
"getDepth": function() {},
"getDescendant": function() {},
"getFirstText": function() {},
"getFragmentAtRange": function() {},
"getFurthest": function() {},
"getFurthestAncestor": function() {},
"getFurthestBlock": function() {},
"getFurthestInline": function() {},
"getFurthestOnlyChildAncestor": function() {},
"getInlinesAtRange": function() {},
"getLastText": function() {},
"getMarksAtRange": function() {},
"getNextBlock": function() {},
"getNextSibling": function() {},
"getNextText": function() {},
"getParent": function() {},
"getPreviousBlock": function() {},
"getPreviousSibling": function() {},
"getPreviousText": function() {},
"getTextAtOffset": function() {},
"getTextsAtRange": function() {},
"hasChild": function() {},
"hasDescendant": function() {},
"toJSON": function() {}
},
"Mark": {
"create": function() {},
"createSet": function() {},
"fromJSON": function() {},
"isMark": function() {},
"toJSON": function() {}
},
"Node": {
"filterDescendants": function() {},
"findDescendant": function() {},
"getBlocksAtRange": function() {},
"getBlocks": function() {},
"getCharactersAtRange": function() {},
"getChild": function() {},
"getClosestBlock": function() {},
"getClosestInline": function() {},
"getClosest": function() {},
"getDepth": function() {},
"getDescendant": function() {},
"getFirstText": function() {},
"getFragmentAtRange": function() {},
"getFurthest": function() {},
"getFurthestAncestor": function() {},
"getFurthestBlock": function() {},
"getFurthestInline": function() {},
"getFurthestOnlyChildAncestor": function() {},
"getInlinesAtRange": function() {},
"getLastText": function() {},
"getMarksAtRange": function() {},
"getNextBlock": function() {},
"getNextSibling": function() {},
"getNextText": function() {},
"getParent": function() {},
"getPreviousBlock": function() {},
"getPreviousSibling": function() {},
"getPreviousText": function() {},
"getTextAtOffset": function() {},
"getTextsAtRange": function() {},
"hasChild": function() {},
"hasDescendant": function() {}
},
"Operation": {
"insert_text": function() {},
"remove_text": function() {},
"add_mark": function() {},
"remove_mark": function() {},
"set_mark": function() {},
"insert_node": function() {},
"merge_node": function() {},
"move_node": function() {},
"remove_node": function() {},
"set_node": function() {},
"split_node": function() {},
"set_selection": function() {},
"set_value": function() {},
"apply": function() {},
"invert": function() {}
},
"Range": {
"create": function() {},
"fromJSON": function() {},
"isRange": function() {},
"toJSON": function() {},
"hasAnchorAtStartOf": function() {},
"hasFocusAtStartOf": function() {},
"hasStartAtStartOf": function() {},
"hasEndAtStartOf": function() {},
"hasEdgeAtStartOf": function() {},
"hasAnchorAtEndOf": function() {},
"hasFocusAtEndOf": function() {},
"hasStartAtEndOf": function() {},
"hasEndAtEndOf": function() {},
"hasEdgeAtEndOf": function() {},
"hasAnchorBetween": function() {},
"hasFocusBetween": function() {},
"hasStartBetween": function() {},
"hasEndBetween": function() {},
"hasEdgeBetween": function() {},
"hasAnchorIn": function() {},
"hasFocusIn": function() {},
"hasStartIn": function() {},
"hasEndIn": function() {},
"hasEdgeIn": function() {},
"isAtStartOf": function() {},
"isAtEndOf": function() {}
},
"Schema": {
"create": function() {},
"fromJSON": function() {},
"isSchema": function() {},
"toJSON": function() {}
},
"Text": {
"create": function() {},
"fromJSON": function() {},
"isText": function() {},
"toJSON": function() {}
},
"Value": {
"create": function() {},
"fromJSON": function() {},
"isValue": function() {},
"change": function() {},
"toJSON": function() {}
},
"setKeyGenerator": function() {},
"resetKeyGenerator": function() {}
};
|
import React,{useState} from "react";
import PropTypes from "prop-types";
function Checkbox(props) {
const {className, tooltip, ariaLabel,name, labelName } = props;
const [checked,setChecked] = useState(false);
function handleInputChange(event) {
const target = event.target;
const value = target.name === "" ? target.checked : target.value;
setChecked(value);
}
return <label>
{labelName}:
<input
name={name}
type="checkbox"
className={className}
title={tooltip}
aria-label={ariaLabel}
checked={checked}
onChange={handleInputChange}
/>
</label>
}
Checkbox.propTypes = {
ariaLabel: PropTypes.string.isRequired,
tooltip: PropTypes.string.isRequired,
labelName: PropTypes.string.isRequired,
className: PropTypes.string,
name: PropTypes.string
};
export default Checkbox;
|
import {state} from '../index';
import {elements, pets,apartments} from '../views/base';
import * as viewProp from '../views/viewProp';
import * as viewWeek from '../views/week';
import * as viewPetsAndApartments from '../views/viewPetsAndApartments';
import * as messages from '../views/messages';
import {maxHours, minHours, standardTime} from './time';
import * as timeScheduleUI from '../views/viewTimeSchedule';
import * as viewBudget from '../views/viewBudget';
export const setInit = () => {
// set initial parameters for new game
state.house = apartments['small'];
viewPetsAndApartments.viewUpdApartment('small');
state.pet = pets['none'];
viewPetsAndApartments.updPets('none');
state.budget = {
salary: 3000,
bank: 2000
};
messages.setToogle();
weekHours();
setInitTime();
setInitProp();
timeScheduleUI.upgWeek();
viewBudget.viewUpdBudget();
};
const setInitTime = () => {
// set initial time for a new game
state.time = {
week: 1,
month: 0,
year: 0,
};
viewWeek.viewSetWeek();
};
const setInitProp = () => {
// set initial properties for a new game
state.properties = {
'Research': 0,
'Alcoholism': 0,
'SocialLife': 0,
'Energy': 10,
'Happiness': 5,
};
// set initial properties in the UI
viewProp.viewSetProp();
};
export const weekHours = () => {
standardTime.calcWork();
state.weekTimes = {
'workHours': 5*standardTime['work'],
'extraWorkHours': minHours['extraWork'],
'commuteHours': 5 * standardTime['commute'],
'sleepHours': 7 * standardTime['sleep'],
'workOutHours': 0,
'hobbyHours': 0,
'pizzaHours': 0,
'drinkHours': 0,
'partyHours': 0,
calcTotHours: function() {
this['totHours'] = this['workHours'] + this['extraWorkHours'] + this['commuteHours'] + this['sleepHours'] + this['workOutHours'] + this['hobbyHours'] + this['pizzaHours'] + this['drinkHours'] + this['partyHours'];
this['totLeftHours'] = 168 - this['totHours'];
}
};
state.weekTimes.calcTotHours();
};
|
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
exports.__esModule = true;
exports.Client = void 0;
var Response_1 = require("./Response");
var axios_1 = __importDefault(require("axios"));
var qs_1 = __importDefault(require("qs"));
var Parser_1 = require("./Parser");
var Client = /** @class */ (function () {
function Client(domain, db, getAuth) {
this.domain = domain;
this.db = db;
this.getAuth = getAuth;
this.rowsPerPage = 200;
}
Client.prototype.call = function (options) {
return axios_1["default"](options)
.then(function (axiosResponse) {
return Parser_1.extractResponse(axiosResponse.data);
})
.then(function (xmlResponse) { return new Response_1.FMResponse(xmlResponse); });
};
Client.prototype.getDefaultOptions = function () {
return {
method: 'post',
url: "https://" + this.domain + "/fmi/xml/fmresultset.xml",
headers: {
Authorization: this.getAuth()
}
};
};
Client.prototype.findall = function (layout, page, paginated,scriptOptions) {
if (page === void 0) { page = 1; }
if (paginated === void 0) { paginated = false; }
var data = {
'-db': this.db,
'-lay': layout,
'-findall': '1'
};
if (scriptOptions !== undefined) {
data["-script"] = scriptOptions.script;
if (scriptOptions.params !== undefined) {
data["-script.param"] = scriptOptions.params.join('\n');
}
}
/*
if (paginated) {
data['-skip'] = this.rowsPerPage * page;
data['–relatedsets.max'] = this.rowsPerPage;
data['-max'] = this.rowsPerPage;
}
*/
var options = __assign(__assign({}, this.getDefaultOptions()), { data: qs_1["default"].stringify(data) });
return this.call(options);
};
Client.prototype.update = function (layout, recid, fields) {
var data = __assign(__assign({}, fields), { '-recid': recid, '-db': this.db, '-lay': layout, '-edit': '' });
var options = __assign(__assign({}, this.getDefaultOptions()), { data: qs_1["default"].stringify(data), method: 'POST' });
return axios_1["default"](options)
.then(function (response) {
return Promise.resolve(Parser_1.extractResponse(response.data));
});
};
Client.prototype.create = function (layout, fields, scriptOptions) {
var data = __assign(__assign({}, fields), { '-db': this.db, '-lay': layout, '-new': '' });
if (scriptOptions !== undefined) {
data = { '-db': this.db, '-lay': layout, '-new': '' };
data["-script"] = scriptOptions.script;
if (scriptOptions.params !== undefined) {
data["-script.param"] = scriptOptions.params.join('\n');
}
}
var options = __assign(__assign({}, this.getDefaultOptions()), { data: qs_1["default"].stringify(data), method: 'POST' });
return axios_1["default"](options)
.then(function (response) {
return Promise.resolve(Parser_1.extractResponse(response.data));
});
};
Client.prototype.isAuthorized = function () {
var data = {
'-db': this.db,
'-lay': 'asdflkjrandom',
'-findall': '1'
};
var options = this.getDefaultOptions();
options.url += '?' + qs_1["default"].stringify(data);
options.validateStatus = function (status) { return true; };
return axios_1["default"](options)
.then(function (response) {
console.log(response);
return response.status !== 401;
})["catch"](function (err) { return false; });
};
Client.prototype.customQuery = function (layout, fields) {
if (fields === void 0) { fields = {}; }
var sanFields = Object.keys(fields)
.reduce(function (obj, key) {
var _a;
var value = fields[key];
if (value === undefined)
return obj;
return __assign(__assign({}, obj), (_a = {}, _a[key] = value, _a));
}, {});
if (Object.keys(fields).length === 0)
return this.findall(layout);
var params = {};
var counter = 0;
var counters = [];
var addField = function (value) {
counter++;
params["-q" + counter.toString()] = fieldName;
params["-q" + counter.toString() + ".value"] = value;
return counter;
};
for (var fieldName in sanFields) {
var values = sanFields[fieldName];
var fieldCounters = values.map(addField);
counters.push(fieldCounters);
}
var lists = [
[]
];
counters.forEach(function (fieldCounters) {
lists = fieldCounters.reduce(function (duplicatedLists, counter) {
var newLists = lists.map(function (list) { return list.concat([counter]); });
return duplicatedLists.concat(newLists);
}, []);
});
var query = lists
.map(function (list) { return list.map(function (fieldCounter) { return "q" + fieldCounter; }).join(','); })
.map(function (formula) { return "(" + formula + ")"; }).join(';');
var data = __assign(__assign({}, params), { '-query': query, '-db': this.db, '-lay': layout, '–relatedsets.max': this.rowsPerPage, '-skip': 0, '-max': this.rowsPerPage, '-findquery': '' });
//let options: AxiosRequestConfig = this.getDefaultOptions();
//options.url += '?' + qs.stringify(data);
var options = __assign(__assign({}, this.getDefaultOptions()), { method: 'POST', data: qs_1["default"].stringify(data) });
return this.call(options);
};
return Client;
}());
exports.Client = Client;
|
import vendor from './vendor';
import database from 'modules/database';
import { captureTestErrors, tryCatch, bootstrapApp } from 'modules/utils/test';
describe('vendor route resource', () => {
const app = bootstrapApp(vendor);
const request = captureTestErrors(app);
afterAll(() => Promise.all(database.sequelize.close(), app.close()));
it(
'returns valid vendor',
tryCatch((done) => {
request.get('/1').expect(200, done);
})
);
it(
'POST creates vendor',
tryCatch((done) => {
request
.post('/')
.send({
vendorId: 3,
name: 'Juicy Co',
slug: 'juicy',
code: 'JC'
})
.expect(200, done);
})
);
it(
'PUT updates vendor',
tryCatch((done) => {
request
.put('/801')
.send({
vendorId: 3,
name: 'Jucy Company',
slug: 'juicy',
code: 'JC'
})
.expect(200, done);
})
);
it(
'DELETE deletes vendor',
tryCatch((done) => {
request.delete('/801').expect(200, done);
})
);
it(
'returns 200 for vendor',
tryCatch((done) => {
request.get('/20000').expect(200, done);
})
);
it(
'returns 400 for invalid vendor',
tryCatch((done) => {
request.get('/ham').expect(400, done);
})
);
it(
'GET returns valid vendor identifiers',
tryCatch((done) => {
request.get('/1/identifiers').expect(200, done);
})
);
it(
'GET returns valid vendor identifier',
tryCatch((done) => {
request.get('/1/identifier/1').expect(200, done);
})
);
it(
'POST creates valid vendor identifier',
tryCatch((done) => {
request
.post('/1/identifier')
.send({ dataSupplierId: 1, identifier: 'capellar' })
.expect(200, done);
})
);
it(
'PUT updates valid vendor identifier',
tryCatch((done) => {
request
.put('/1/identifier/1')
.send({ identifier: 'capellary' })
.expect(200, done);
})
);
it(
'DELETE deletes vendor identifier',
tryCatch((done) => {
request
.delete('/1/identifier/1')
.send({ identifier: 'cap_27-bears' })
.expect(200, done);
})
);
});
|
import { queryDevice } from '@/services/device';
export default {
namespace: 'device',
state: {
deviceData: [],
},
effects: {
*query({ payload }, { call, put }) {
const response = yield call(queryDevice, payload);
yield put({
type: 'saveDeviceData',
payload: response,
});
},
},
reducers: {
saveDeviceData(state, { payload }) {
return {
...state,
...payload,
}
},
clear() {
return {
deviceData: []
}
}
}
}
|
/*
This file is part of web3.js.
web3.js is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
web3.js is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with web3.js. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file formatters.js
* @author Marek Kotewicz <marek@ethdev.com>
* @author Fabian Vogelsteller <fabian@ethdev.com>
* @date 2015
*/
'use strict';
var utils = require('../utils/utils');
var config = require('../utils/config');
var Iban = require('./iban');
/**
* Should the format output to a big number
*
* @method outputBigNumberFormatter
* @param {String|Number|BigNumber}
* @returns {BigNumber} object
*/
var outputBigNumberFormatter = function (number) {
return utils.toBigNumber(number);
};
var isPredefinedBlockNumber = function (blockNumber) {
return blockNumber === 'latest' || blockNumber === 'pending' || blockNumber === 'earliest';
};
var inputDefaultBlockNumberFormatter = function (blockNumber) {
if (blockNumber === undefined) {
return config.defaultBlock;
}
return inputBlockNumberFormatter(blockNumber);
};
var inputBlockNumberFormatter = function (blockNumber) {
if (blockNumber === undefined) {
return undefined;
} else if (isPredefinedBlockNumber(blockNumber)) {
return blockNumber;
}
return utils.toHex(blockNumber);
};
/**
* Formats the input of a transaction and converts all values to HEX
*
* @method inputCallFormatter
* @param {Object} transaction options
* @returns object
*/
var inputCallFormatter = function (options){
options.from = options.from || config.defaultAccount;
if (options.from) {
options.from = inputAddressFormatter(options.from);
}
if (options.to) { // it might be contract creation
options.to = inputAddressFormatter(options.to);
}
['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
return options[key] !== undefined;
}).forEach(function(key){
options[key] = utils.fromDecimal(options[key]);
});
return options;
};
/**
* Formats the input of a transaction and converts all values to HEX
*
* @method inputTransactionFormatter
* @param {Object} transaction options
* @returns object
*/
var inputTransactionFormatter = function (options){
options.from = options.from || config.defaultAccount;
options.from = inputAddressFormatter(options.from);
if (options.to) { // it might be contract creation
options.to = inputAddressFormatter(options.to);
}
['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
return options[key] !== undefined;
}).forEach(function(key){
options[key] = utils.fromDecimal(options[key]);
});
return options;
};
/**
* Formats the output of a transaction to its proper values
*
* @method outputTransactionFormatter
* @param {Object} tx
* @returns {Object}
*/
var outputTransactionFormatter = function (tx){
if(tx.blockNumber !== null)
tx.blockNumber = utils.toDecimal(tx.blockNumber);
if(tx.transactionIndex !== null)
tx.transactionIndex = utils.toDecimal(tx.transactionIndex);
tx.nonce = utils.toDecimal(tx.nonce);
tx.gas = utils.toDecimal(tx.gas);
tx.gasPrice = utils.toBigNumber(tx.gasPrice);
tx.value = utils.toBigNumber(tx.value);
return tx;
};
/**
* Formats the output of a transaction receipt to its proper values
*
* @method outputTransactionReceiptFormatter
* @param {Object} receipt
* @returns {Object}
*/
var outputTransactionReceiptFormatter = function (receipt){
if(receipt.blockNumber !== null)
receipt.blockNumber = utils.toDecimal(receipt.blockNumber);
if(receipt.transactionIndex !== null)
receipt.transactionIndex = utils.toDecimal(receipt.transactionIndex);
receipt.cumulativeGasUsed = utils.toDecimal(receipt.cumulativeGasUsed);
receipt.gasUsed = utils.toDecimal(receipt.gasUsed);
if(utils.isArray(receipt.logs)) {
receipt.logs = receipt.logs.map(function(log){
return outputLogFormatter(log);
});
}
return receipt;
};
/**
* Formats the output of a block to its proper values
*
* @method outputBlockFormatter
* @param {Object} block
* @returns {Object}
*/
var outputBlockFormatter = function(block) {
// transform to number
block.gasLimit = utils.toDecimal(block.gasLimit);
block.gasUsed = utils.toDecimal(block.gasUsed);
block.size = utils.toDecimal(block.size);
block.timestamp = utils.toDecimal(block.timestamp);
if(block.number !== null)
block.number = utils.toDecimal(block.number);
block.difficulty = utils.toBigNumber(block.difficulty);
block.totalDifficulty = utils.toBigNumber(block.totalDifficulty);
if (utils.isArray(block.transactions)) {
block.transactions.forEach(function(item){
if(!utils.isString(item))
return outputTransactionFormatter(item);
});
}
return block;
};
/**
* Formats the output of a log
*
* @method outputLogFormatter
* @param {Object} log object
* @returns {Object} log
*/
var outputLogFormatter = function(log) {
if(log.blockNumber)
log.blockNumber = utils.toDecimal(log.blockNumber);
if(log.transactionIndex)
log.transactionIndex = utils.toDecimal(log.transactionIndex);
if(log.logIndex)
log.logIndex = utils.toDecimal(log.logIndex);
return log;
};
/**
* Formats the input of a whisper post and converts all values to HEX
*
* @method inputPostFormatter
* @param {Object} transaction object
* @returns {Object}
*/
var inputPostFormatter = function(post) {
// post.payload = utils.toHex(post.payload);
post.ttl = utils.fromDecimal(post.ttl);
post.workToProve = utils.fromDecimal(post.workToProve);
post.priority = utils.fromDecimal(post.priority);
// fallback
if (!utils.isArray(post.topics)) {
post.topics = post.topics ? [post.topics] : [];
}
// format the following options
post.topics = post.topics.map(function(topic){
// convert only if not hex
return (topic.indexOf('0x') === 0) ? topic : utils.fromUtf8(topic);
});
return post;
};
/**
* Formats the output of a received post message
*
* @method outputPostFormatter
* @param {Object}
* @returns {Object}
*/
var outputPostFormatter = function(post){
post.expiry = utils.toDecimal(post.expiry);
post.sent = utils.toDecimal(post.sent);
post.ttl = utils.toDecimal(post.ttl);
post.workProved = utils.toDecimal(post.workProved);
// post.payloadRaw = post.payload;
// post.payload = utils.toAscii(post.payload);
// if (utils.isJson(post.payload)) {
// post.payload = JSON.parse(post.payload);
// }
// format the following options
if (!post.topics) {
post.topics = [];
}
post.topics = post.topics.map(function(topic){
return utils.toAscii(topic);
});
return post;
};
var inputAddressFormatter = function (address) {
var iban = new Iban(address);
if (iban.isValid() && iban.isDirect()) {
return '0x' + iban.address();
} else if (utils.isStrictAddress(address)) {
return address;
} else if (utils.isAddress(address)) {
return '0x' + address;
}
throw new Error('invalid address');
};
var outputSyncingFormatter = function(result) {
if (!result) {
return result;
}
result.startingBlock = utils.toDecimal(result.startingBlock);
result.currentBlock = utils.toDecimal(result.currentBlock);
result.highestBlock = utils.toDecimal(result.highestBlock);
if (result.knownStates) {
result.knownStates = utils.toDecimal(result.knownStates);
result.pulledStates = utils.toDecimal(result.pulledStates);
}
return result;
};
module.exports = {
inputDefaultBlockNumberFormatter: inputDefaultBlockNumberFormatter,
inputBlockNumberFormatter: inputBlockNumberFormatter,
inputCallFormatter: inputCallFormatter,
inputTransactionFormatter: inputTransactionFormatter,
inputAddressFormatter: inputAddressFormatter,
inputPostFormatter: inputPostFormatter,
outputBigNumberFormatter: outputBigNumberFormatter,
outputTransactionFormatter: outputTransactionFormatter,
outputTransactionReceiptFormatter: outputTransactionReceiptFormatter,
outputBlockFormatter: outputBlockFormatter,
outputLogFormatter: outputLogFormatter,
outputPostFormatter: outputPostFormatter,
outputSyncingFormatter: outputSyncingFormatter
};
|
import React from "react";
import InputExample from "./InputExample";
import { InputStory } from "../Input.stories.styles";
const WithDisabledReadOnlyExampleStory = () => {
return (
<InputStory>
<h3>
<small>
<code>isDisabled</code>
</small>
</h3>
<InputExample isDisabled placeholder="First Name" />
<InputExample isDisabled value="Sam Bennett" />
<br />
<h3>
<small>
<code>disabled</code>
</small>
</h3>
<InputExample disabled placeholder="First Name" />
<InputExample disabled value="Sam Bennett" />
<br />
<h3>
<small>
<code>isReadOnly</code>
</small>
</h3>
<InputExample isReadOnly placeholder="First Name" />
<InputExample isReadOnly value="Sam Bennett" />
<InputExample isReadOnly value="This is a very long text to test that you can scroll this input horizontally." />
</InputStory>
);
};
export default WithDisabledReadOnlyExampleStory;
|
import styled from 'styled-components'
const TextWrap = styled.div`
height: 100%;
.am-navbar-left-icon{
color:#ccc !important;
}
.am-navbar-title{
color:#666 !important;
}
.demoTitle:before,
.demoTitle:after {
border-bottom: none;
}
.am-list-body{
width:100%;
height:auto;
margin-top:.1rem;
}
.am-list{
width:100%;
position: relative;
textarea{
font-family: 'PingFangSC-Regular', 'PingFang SC';
font-weight: 400;
font-size: 14px;
color: #000000;
}
.am-textarea-label{
font-family: 'PingFangSC-Regular', 'PingFang SC';
font-weight: 400;
font-style: normal;
font-size: 14px;
color: #868686;
}
.am-list-content{
font-family: 'PingFangSC-Regular', 'PingFang SC';
font-weight: 400;
font-style: normal;
font-size: 14px;
color: #868686;
}
.am-list-extra{
flex-basis: 68%;
color: #000;
font-size: 14px;
line-height: 1.5;
text-align: left;
width: auto;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
padding-top: 7px;
padding-bottom: 7px;
}
.tag{
width:100%;
height:.44rem;
position: relative;
.biao{
font-family: 'PingFangSC-Regular', 'PingFang SC';
height:.2rem;
line-height:.2rem;
font-weight: 400;
font-style: normal;
font-size: 14px;
color: #868686;
display:block;
position: absolute;
left:.15rem;
top:.11rem;
}
.am-tag{
position: absolute;
top:.1rem;
}
.am-tag-active{
color:#fff;
background-color:rgba(0, 204, 153, 1);
}
}
}
`
export default TextWrap
|
import { Component, EventEmitter, Input, Output } from '@angular/core';
var PassengerCardComponent = (function () {
function PassengerCardComponent() {
this.selectedItemChange = new EventEmitter();
}
PassengerCardComponent.prototype.isSelected = function () {
if (this.selectedItem) {
return this.selectedItem === this.item ? 'yes' : 'no';
}
};
PassengerCardComponent.prototype.select = function () {
this.selectedItemChange.emit(this.item);
};
return PassengerCardComponent;
}());
export { PassengerCardComponent };
PassengerCardComponent.decorators = [
{ type: Component, args: [{
selector: 'passenger-card',
templateUrl: './passenger-card.component.html'
},] },
];
/** @nocollapse */
PassengerCardComponent.ctorParameters = function () { return []; };
PassengerCardComponent.propDecorators = {
'item': [{ type: Input },],
'selectedItem': [{ type: Input },],
'selectedItemChange': [{ type: Output },],
};
|
import "./config.js";
import "./account/index.js";
|
import React from 'react';
import '../CSS/Work.css';
// import 'materialize-css/dist/css/materialize.min.css';
class MyPost extends React.Component {
constructor(props) {
super(props);
}
render() {
return (
<div className="PostDiv" onClick={this.props.MyClick} >
<h6 className="">{this.props.Title}</h6>
<span className="" >{this.props.Name}</span><br />
<span className="" >Expected Salary : {this.props.Salary}</span><br />
<span className="" >Education : {this.props.Education}</span><br />
<span className="" >Experience : {this.props.Experience}</span><br />
<span className="" >Email : {this.props.Email}</span><br />
<button style={{
backgroundColor: this.props.bgColor,
color: this.props.mycolor
}}
className="PostBtn " onClick={this.props.ClickApply} >{this.props.btntext}</button>
</div>
)
}
}
export default MyPost;
|
/*A promise is an object that may produce a single value some time in the future:
either a resolved value, or a reason that it’s not resolved (e.g., a network error occurred).
A promise may be in one of 3 possible states: fulfilled, rejected, or pending.
then() always returns a Promise, which enables you to chain method calls:
*/
function callback(req,res){
console.log("ready0");//
callback1({
console.log("ready1");
callback2({
console.log("ready2");
callback3({
console.log("ready3");
callback4(){
console.log("ready4");
}
});
});
});
}
//callback hell
app.get('/api',callback);
app.get('/api',callback1);
callback1().then({
return callback2();
}).then({
return callback3();
}).then({
return "done";
})
asyncFunc1()
.then(result1 => {
// Use result1
return asyncFunction2(); // (A)
})
.then(result2 => { // (B)
// Use result2
})
.catch(error => {
// Handle errors of asyncFunc1() and asyncFunc2()
});
/*Asynchronus execution:*/
asyncFunc1()
.then(() => asyncFunc2());
/*Synchronus execution:*/
asyncFunc1();
asyncFunc2();
|
var pos = require('pos');
var words = new pos.Lexer().lex('Best place to live in California');
var tags = new pos.Tagger()
.tag(words)
.map(function(tag){
console.log(tag);
return tag[0] + '/' + tag[1];
})
.join(' ');
console.log(tags);
|
import React from 'react';
import '../../styles/dashboard.css';
import Header from '../nav/DashboardHeader';
import Footer from '../nav/DashboardFooter';
import SideBar from '../nav/DashboardSidebar';
const Vote = () => {
return (
<div>
<Header />
<SideBar />
<div className="main-content">
<div className="title">
vote /
</div>
<div className="main">
<div className="widget widget_table" style={{ overflow: 'auto' }}>
<div className="title heado">Vote a Political Party Candidate</div>
<div className="widget_stat widget_stat_table">
<div className = "success-msg" id = "success-msg" />
<div className = "warning-msg" id = "warning-msg" />
<div className = "error-msg" id = "error-msg" />
<div className = "info-msg" id = "info-msg" />
<div style={{ overflow: 'auto' }}>
<form action="#" method="GET">
<table style={{ overflow: 'scroll' }}>
<thead>
<tr>
<th>Office</th>
<th>Candidate</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<div className="input-group">
<select id="officeList" name="offices">
<option value="">Select an office</option>
</select>
</div>
</td>
<td>
<div className="input-group">
<select id="candidateList" name="candidates">
<option value="name1">Candidates</option>
</select>
</div>
</td>
</tr>
</tbody>
</table>
<button className="btn btnmore" id="voteButton">Vote</button>
</form>
</div>
</div>
</div>
</div>
</div>
<Footer />
</div>
);
};
export default Vote;
|
(function(){
var BufferCache = function(){
var _cache = {};
this.get = function(cacheKey){
return _cache[cacheKey];
};
this.set = function(cacheKey, value){
_cache[cacheKey] = value;
};
this.remove = function(cacheKey){
delete _cache[cacheKey];
};
this.clear = function(){
_cache = {};
};
this.has = function(cacheKey){
return (this.get(cacheKey) !== undefined) ? true : false;
};
this.size = function(){
return Object.keys(_cache).length;
};
};
Schroeder.BufferCache = BufferCache;
})();
|
console.log("Hello TypeScript");
//-------------------------------
// function add(num1:number, num2:number, showResult:boolean, phrase:string) {
// // if (typeof num1 !== 'number' || typeof num2 !== 'number') {
// // throw new Error ('Incorrect input')
// // }
// const res = num1 + num2
// if (showResult) {console.log (phrase + res) }
// else {return res}
// }
// const nr1 = 5;
// const nr2 = 2.8;
// const printResult = true;
// const resultPhrase = "Result is "
// add(nr1, nr2, printResult, resultPhrase)
//---------Object Type----------------------
// const student : object = {
// name : "Max",
// age : 20
// }
// const person : {
// name : string
// age : number
// } = {
// name : "Rex",
// age : 30
// }
// console.log(person.name)
//-----------Array Type--------------------
// let favActivites : string[];
// favActivites = ["music", "movie"]
// let favs : any[];
// favs = [3, "movie"]
// const boys = {
// name : "Mike",
// age : 10,
// hobbies : ['run','dive' ]
// }
// for (const hobby of boys.hobbies) {
// console.log(hobby.toUpperCase())
// //console.log(hobby.map()) //Error ! Because an srray does not get map
// }
//-------Tuple--------------------
// const person33 : {
// name : string,
// role : [number, string] //this describes a tuple
// name : "Rex",
// role : [1, 'author'] //Should contain only 2 elements, one number and one string
// }
// person33.role.push('admin') //Error
// person33.role[1] = 3 //Error
//--------------ENUM--------------------
// // const ADMIN = 0;
// // const READ_ONLY = 1;
// // const AUTHOR = 2;
// enum Role {ADMIN, READ_ONLY, AUTHOR, OTHER="READER"};
// //You do not have to start w 0 => enum Role {ADMIN=5, READ_ONLY, AUTHOR} =>the others are 6 and 7 now
// //Can also use differnet types => enum Role {ADMIN="ADMIN", READ_ONLY=100, AUTHOR=200}
// const person34 = {
// name : 'Max',
// hobbies : ["run", "music", "jump"],
// // role : 2
// role1 : Role.AUTHOR,
// role2 : Role.OTHER
// }
// if (person34.role1 === 2) {
// console.log(person34.name);
// console.log("is author");
// }
// console.log(person34.role1);
// console.log(person34.role2);
//-----ANY TYPE-----------------
// let i1 : number | string;
// let i2 : any;
// let iArray : any[];
// type Combineable = number | string;
// type ConversionDescriptor = "as-number" | "as-text"
// function combine (
// input1 : Combineable,
// input2 : number | string,
// resultConversion : "as-number" | "as-text" //literal type
// //resultConversion :ConversionDescriptor
// ) {
// let result;
// if (typeof input1 === 'number' && typeof input2 === 'number' || resultConversion === "as-number") {
// result = +input1 + +input2;
// console.log(result)
// } else {
// result = input1.toString() + input2.toString()
// console.log(result)
// }
// return result
// }
// combine(30,26,"as-number"); //56
// combine("30","26","as-number"); //56
// combine("Max","Anna","as-text"); //MaxAnna
//-----------VOID,UNDEFINED,FUNCTION TYPES-----------
// function printResult1(num:number): undefined {
// console.log('Result '+ num)
// return
// }
// printResult1(1);
// //void is the general use for functions that does not return anything => console will give undefined
// function printResult2(num:number):void {
// console.log('Result '+ num)
// }
// printResult2(2);
// function add(n1:number, n2:number) {
// return n1 + n2
// }
// let combineValues1 : Function;
// combineValues1 = add;
// //combineValues = 5; //Error
// //if we combineValues = printResult; TS will not complain. But we dont want that.
// //So we should re-define it
// let combineValues2 : (a:number, b:number)=> number
//---------------------------------------
// function addAndHandle (n1:number, n2:number, cb:(num:number)=> void){
// const result = n1 + n2
// cb(result)
// }
// addAndHandle(10, 20, (result)=>{console.log(result)}); //30
//----------------------------------------
// let userInput : unknown;
// let userName : string;
// userInput = 4;
// userName = "John";
// //userName = userInput //Error
//----------------------------------------
// function generateError(message:string, code:number):never {
// throw {message:message, errorCode:code}
// }
// const errResult = generateError("An error has occured", 400);
// console.log(errResult)
// //Gives nothing. No null, no undefined but nothing. Therefore we add the type never to func.
// //void is another opt we could use, but never describes it better
|
exports.getNotFoundPage = (req,res, next) => {
res.status('404').render('stubs/404', {pageTitle: "Page is not found"});
}
|
export const styles = theme => ({
headerStyle: {
marginTop: '0px',
marginBottom: '0px',
fontSize: '24px',
},
root: {
flexGrow: 1,
},
paper: {
padding: theme.spacing(2),
textAlign: 'center',
color: theme.palette.text.secondary,
},
noCaseNotesImg: {
width: '70%',
height: '70%',
display: 'block',
marginTop: '20%',
marginLeft: 'auto',
marginRight: 'auto',
},
noCaseNotesTxt: {
textAlign: 'center',
},
});
export default styles;
|
import {
createI18n
} from 'vue-i18n';
import {
en
} from '../languages/en'
import {
vn
} from '../languages/vn'
const messages = {
vn: vn,
gb: en
}
const i18n = createI18n({
locale: localStorage.getItem('lang') ? localStorage.getItem('lang') : 'gb',
fallbackLocale: 'en',
messages
})
export default i18n
|
$(document).ready(function() {
$("input:checkbox").checkbox();
$("#form_config").rpcform({
success: function(a) {
sbar.text("Configuration appliquée")
},
error: function(a) {
sbar.error(null, "Impossible d'appliquer la configuration")
}
});
$(".form_remove_redir").rpcform({
success: function(a) {
sbar.text("Redirection supprimée")
},
error: function(a) {
sbar.error(null, "Impossible de supprimer la redirection")
}
});
$("#redirs_list tbody").dynamiclist({
jsonrpc: {
method: "igd.redirs_get"
},
ejs: {
url: "tpl/igd_redir.ejs",
data: function(a) {
return {
v: a
}
}
},
interval: 5000,
jsonfield: function(a) {
return a
},
jsonkey: function(a) {
var b = "";
if (a.ext_src_ip) {
b = b + a.ext_src_ip
}
b = b + "/" + a.int_port + "/" + a.int_ip + "/" + a.proto;
return b
},
})
});
|
//service to handle authentication
angular.module("myApp").factory("AuthenticationService", function($http, flash, SessionService) {
var cacheSession = function() {
SessionService.set('authenticated',true);
};
var unCacheSession = function() {
SessionService.unset('authenticated');
};
var checkSession = function() {
return SessionService.get('authenticated') == "true";
}
return {
login: function(credentials) {
var p = $http.post('api/v1/auth/login',credentials)
.success(function(data) {
cacheSession();
flash.success = data.flash;
})
.error(function(data) {
flash.error = data.flash;
});
return p;
},
logout: function() {
var p = $http.get('api/v1/auth/logout')
.success(unCacheSession);
return p;
},
isLoggedIn: function() {
return checkSession();
}
}
});
|
import React from 'react';
import { connect } from 'react-redux';
import {withRouter} from 'react-router-dom'
import {Card , CardImg , Button} from 'reactstrap';
import {addCart } from '../redux/ActionCreators';
import {useDispatch} from 'react-redux';
import {ProductsButtons} from './ProductsComponent';
/*const mapStateToProps = state => {
return{
cart: state.cart,
antacids: state.products.antacids
}
}*/
const mapDispatchToProps = {
addCart
}
const AntacidsInfo = ({antacid}) => {
console.log(antacid)
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${antacid.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={antacid.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{antacid.category}</Button>
<br />
<h3><strong>{antacid.brandName}</strong></h3>
<br />
<h4>{antacid.genericName}</h4>
<br />
<h3><strong> ₦{antacid.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(antacid)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const AntiMalarialsInfo = ({antiMalarial}) => {
console.log(antiMalarial);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${antiMalarial.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={antiMalarial.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{antiMalarial.category}</Button>
<br />
<h3><strong>{antiMalarial.brandName}</strong></h3>
<br />
<h4>{antiMalarial.genericName}</h4>
<br />
<h3><strong> ₦{antiMalarial.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(antiMalarial)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const BabyProductsInfo = ({babyProduct}) => {
console.log(babyProduct)
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${babyProduct.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={babyProduct.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{babyProduct.category}</Button>
<br />
<h3><strong>{babyProduct.brandName}</strong></h3>
<br />
<h4>{babyProduct.genericName}</h4>
<br />
<h3><strong> ₦{babyProduct.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(babyProduct)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const ColdFlusInfo = ({coldFlu}) => {
console.log(coldFlu)
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${coldFlu.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={coldFlu.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{coldFlu.category}</Button>
<br />
<h3><strong>{coldFlu.brandName}</strong></h3>
<br />
<h4>{coldFlu.genericName}</h4>
<br />
<h3><strong> ₦{coldFlu.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(coldFlu)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const CreamsInfo = ({cream}) => {
console.log(cream)
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${cream.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={cream.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{cream.category}</Button>
<br />
<h3><strong>{cream.brandName}</strong></h3>
<br />
<h4>{cream.genericName}</h4>
<br />
<h3><strong> ₦{cream.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(cream)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const EssentialOilsInfo = ({essentialOil}) => {
console.log(essentialOil);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${essentialOil.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={essentialOil.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{essentialOil.category}</Button>
<br />
<h3><strong>{essentialOil.brandName}</strong></h3>
<br />
<h4>{essentialOil.genericName}</h4>
<br />
<h3><strong> ₦{essentialOil.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(essentialOil)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const MedicalDevicesInfo = ({medicalDevice}) => {
console.log(medicalDevice)
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${medicalDevice.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={medicalDevice.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{medicalDevice.category}</Button>
<br />
<h3><strong>{medicalDevice.brandName}</strong></h3>
<br />
<h4>{medicalDevice.genericName}</h4>
<br />
<h3><strong> ₦{medicalDevice.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(medicalDevice)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const PainKillersInfo = ({painKiller}) => {
console.log(painKiller);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${painKiller.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={painKiller.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{painKiller.category}</Button>
<br />
<h3><strong>{painKiller.brandName}</strong></h3>
<br />
<h4>{painKiller.genericName}</h4>
<br />
<h3><strong> ₦{painKiller.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(painKiller)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const PPEsInfo = ({ppe}) => {
console.log(ppe);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${ppe.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={ppe.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{ppe.category}</Button>
<br />
<h3><strong>{ppe.brandName}</strong></h3>
<br />
<h4>{ppe.genericName}</h4>
<br />
<h3><strong> ₦{ppe.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(ppe)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const ProvisionsInfo = ({provision}) => {
console.log(provision);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${provision.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={provision.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{provision.category}</Button>
<br />
<h3><strong>{provision.brandName}</strong></h3>
<br />
<h4>{provision.genericName}</h4>
<br />
<h3><strong> ₦{provision.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(provision)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
const SupplementsInfo = ({supplement}) => {
console.log(supplement);
const dispatch = useDispatch();
const handleClick = product => {
dispatch(addCart(product));
alert(`${supplement.brandName} has been added to your cart`)
}
return (
<>
<div className='row m-3'>
<div className='col-md-6'>
<Card>
<CardImg src={supplement.src} />
</Card>
</div>
<div className='col-md-5'>
<Button outline color='secondary' className='productBtn' size='sm'>{supplement.category}</Button>
<br />
<h3><strong>{supplement.brandName}</strong></h3>
<br />
<h4>{supplement.genericName}</h4>
<br />
<h3><strong> ₦{supplement.price}</strong></h3>
<br />
<Button color='warning' onClick={() => handleClick(supplement)}><strong>Add to cart</strong></Button>
</div>
</div>
</>
)
}
export function ProductItem(props) {
console.log(props)
const renderItem = () => {
if (props.antacid){
return <AntacidsInfo antacid={props.antacid} />
}
if (props.antiMalarial){
return <AntiMalarialsInfo antiMalarial={props.antiMalarial} />
}
if (props.babyProduct){
return <BabyProductsInfo babyProduct= {props.babyProduct} />
}
if (props.coldFlu) {
return <ColdFlusInfo coldFlu={props.coldFlu} />
}
if (props.cream) {
return <CreamsInfo cream={props.cream}/>
}
if (props.essentialOil){
return <EssentialOilsInfo essentialOil={props.essentialOil} />
}
if (props.medicalDevice) {
return <MedicalDevicesInfo medicalDevice={props.medicalDevice} />
}
if (props.painKiller){
return <PainKillersInfo painKiller= {props.painKiller} />
}
if (props.ppe) {
return <PPEsInfo ppe={props.ppe} />
}
if (props.provision) {
return <ProvisionsInfo provision={props.provision} />
}
if (props.supplement) {
return <SupplementsInfo supplement={props.supplement} />
}
else return <div></div>
}
return(
<div className='container'>
<div className='row offset-1'>
{renderItem()}
</div>
<hr/>
<ProductsButtons />
</div>
)
}
export default withRouter(connect(null , mapDispatchToProps)(ProductItem))
|
const { task } = require('hardhat/config')
require('@nomiclabs/hardhat-etherscan')
require('@nomiclabs/hardhat-waffle')
require('hardhat-gas-reporter')
require('dotenv').config()
module.exports = {
networks: {
hardhat: {
forking: {
url: `https://eth-mainnet.alchemyapi.io/v2/${process.env.ALCHEMY_KEY}`,
blockNumber: 11929707
}
},
rinkeby: {
url: `https://eth-rinkeby.alchemyapi.io/v2/${process.env.ALCHEMY_KEY}`,
accounts: [process.env.RINKEBY_PRIVKEY]
},
live: {
url: `https://eth-mainnet.alchemyapi.io/v2/${process.env.ALCHEMY_KEY}`,
accounts: [process.env.MAINNET_PRIVKEY]
}
},
etherscan: {
apiKey: process.env.ETHERSCAN_API_KEY
},
solidity: {
compilers: [
{
version: '0.7.3'
},
{
version: '0.5.16'
},
{
version: '0.6.11'
}
]
},
gasReporter: {
currency: 'USD',
gasPrice: 100
}
}
|
$(window).scroll(function() {
var scrollAmount = $(this).scrollTop();
if (scrollAmount >= 300) {
$('.container').css({
'background-color': '#fff',
'height': '3.5rem',
'border-bottom-color': '#ddd',
'border-bottom-width': '1px',
'border-bottom-style': 'solid'
});
$('#nav-left,.nav-right').css({
'top': '.7rem',
'color': '#8A8A8A'
})
$('#btn-dl').css({
'color': '.#fff'
});
} else {
$('.container').css({
'background-color': '',
'height': '',
'border-bottom-color': '',
'border-bottom-width': '',
'border-bottom-style': ''
});
$('#nav-left,.nav-right').css({
'top': '',
'color': ''
})
}
});
|
'use strict';
var Structs = require('./structs');
module.exports = AbiCache;
function AbiCache(network, config) {
// Help (or "usage") needs {defaults: true}
config = Object.assign({}, { defaults: true }, config);
var cache = {};
/**
@arg {boolean} force false when ABI is immutable. When force is true, API
user is still free to cache the contract object returned by xmax-studio-js
*/
function abiAsync(code) {
var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
if (force == false && cache[code] != null) {
return Promise.resolve(cache[code]);
}
return network.getCode(code).then(function (_ref) {
var abi = _ref.abi;
var schema = abiToFcSchema(abi);
var structs = Structs(config, schema); // structs = {structs, types}
return cache[code] = Object.assign({ abi: abi, schema: schema }, structs);
});
}
function abi(code) {
var c = cache[code];
if (c == null) {
throw new Error('Abi \'' + code + '\' is not cached, call abiAsync(\'' + code + '\')');
}
return c;
}
return {
abiAsync: abiAsync,
abi: abi
};
}
function abiToFcSchema(abi) {
// customTypes
// For FcBuffer
var abiSchema = {};
// convert abi types to Fcbuffer schema
if (abi.types) {
// aliases
abi.types.forEach(function (e) {
abiSchema[e.new_type_name] = e.type;
});
}
if (abi.structs) {
abi.structs.forEach(function (e) {
var base = e.base,
fields = e.fields;
abiSchema[e.name] = { base: base, fields: fields };
if (base === '') {
delete abiSchema[e.name].base;
}
});
}
return abiSchema;
}
|
export default class Circle {
constructor(animation, parentCircle = null) {
this.animation = animation
this.canvas = animation.canvasElt
this.ctx = animation.ctx
if (parentCircle === null) {
this.radius = 20 + Math.round(Math.random() * 10)
this.posX = this.radius + Math.floor(Math.random() * (this.canvas.width - 2 * this.radius))
this.posY = -this.radius - Math.random() * 300
this.color = animation.colors[Math.floor(Math.random() * animation.colors.length)]
this.velocityX = 0
this.velocityY = Math.random() * 20
} else {
this.radius = parentCircle.radius / (2 + Math.random() * 2)
this.posX = parentCircle.posX
this.posY = parentCircle.posY
this.color = parentCircle.color
this.velocityX = Math.random() * 2 - 1
this.velocityY = parentCircle.velocityY * (Math.random() * (0.8 - 0.6) + 0.6).toFixed(2)
}
}
updateCoordinates() {
this.velocityY += this.animation.gravity
this.posX += this.velocityX
this.posY += this.velocityY
if (this.posX + this.radius >= this.canvas.width || this.posX <= this.radius) this.velocityX *= -1
if (this.posY + this.radius >= this.canvas.height) {
this.posY = this.canvas.height - this.radius
this.velocityY *= -(this.animation.elasticity)
if (this.radius > 5) {
this.animation.generateChildren(this)
} else {
this.animation.deleteBall(this)
}
}
}
draw() {
this.updateCoordinates()
this.ctx.beginPath()
this.ctx.arc(this.posX, this.posY, this.radius, 0, Math.PI * 2)
this.ctx.fillStyle = this.color
this.ctx.fill()
}
}
|
import React,{useState} from 'react'
import AddCircleIcon from '@material-ui/icons/AddCircle';
import { makeStyles,useTheme } from '@material-ui/core/styles';
import Typography from '@material-ui/core/Typography';
import useMediaQuery from '@material-ui/core/useMediaQuery';
import Grid from '@material-ui/core/Grid';
import Button from '@material-ui/core/Button';
import CropIcon from '@material-ui/icons/Crop';
import Brightness5Icon from '@material-ui/icons/Brightness5';
import RotateLeftIcon from '@material-ui/icons/RotateLeft';
import RotateRightIcon from '@material-ui/icons/RotateRight';
import RestoreIcon from '@material-ui/icons/Restore';
import Divider from '@material-ui/core/Divider';
import Slider from '@material-ui/core/Slider';
const useStyle=makeStyles(theme=>({
Icon:{
position:"relative",
top:"28%",
width:"1.5em",
height:"1.5em ",
},
customFileUpload :{
background: "white",
border:"1px solid white",
width:"100px",
height:"100px",
borderRadius:15,
display: "inline-block",
padding: "6px 12px",
cursor: "pointer",
boxShadow:theme.shadows[10],
},
fileUpload:{
display:"none"
},
imgPreview:{
height:'20em',
width:'20em',
borderRadius:15,
marginTop:'5em',
[theme.breakpoints.down('md')]:{
height:'15em',
width:'15em',
marginTop:'3em',
},
[theme.breakpoints.down('xs')]:{
height:'8em',
width:'8em',
marginTop:'2em',
},
},
imagetoBeEdited:{
height:'40em',
width:'30em',
marginTop:'3em',
[theme.breakpoints.down('xs')]:{
height:'30em',
width:'20em',
marginTop:'2em',
},
},
imagePopupContainer:{
width:"100vw",
height:"100vh",
},
menuItems:{
backgroundColor:"black",
width:"100%"
},
saveCloseButton:{
backgroundColor:"black"
},
myButtons:{
backgroundColor:'orange',
color:'white',
marginTop:'1em',
},
brightnessSlider:{
width:'10em'
},
brightnessSliderContainer:{
display:"none",
}
}))
const EditorPopup=(props)=>{
const classes=useStyle();
const theme=useTheme();
const [value, setValue] = React.useState(0);
const matchesXS=useMediaQuery(theme.breakpoints.down('sm'));
const handleBrightness=(event)=>{
// event.target.closest('button').parentElement.parentElement.previousSibling.childNodes[0].style.filter=`brightness(${value})`
console.log(document.getElementById("brightnessSliderContainer").style.display)
if(document.getElementById("brightnessSliderContainer").style.display===''||document.getElementById("brightnessSliderContainer").style.display==='none')
{document.getElementById("brightnessSliderContainer").style.display='block'}
else{
document.getElementById("brightnessSliderContainer").style.display='none'
}
}
const handleEditPopupClose=(event)=>{
document.getElementsByClassName("imgPopupContainer")[0].style.display="none"
}
const handleSliderChange = (event, newValue) => {
setValue(newValue);
document.getElementById("imagetoBeEdited").style.filter=`brightness(${value}%)`
};
const valuetext=(value)=> {
return `${value}%`;
}
const brightnessSlider=(
<Grid className={classes.brightnessSliderContainer} id="brightnessSliderContainer" item xs>
<Slider
className={classes.brightnessSlider}
value={typeof value === 'number' ? value : 0}
getAriaValueText={valuetext}
onChange={handleSliderChange}
aria-labelledby="input-slider"
valueLabelDisplay="auto"
step={10}
max={150}
/>
</Grid>
)
return (
<Grid container direction="column" justify="center" className="imgPopupContainer" style={{display:"none",top:0,backgroundColor:'black',position:'absolute',zIndex:3,width:"100%",height:"100%"}}>
<Grid item >
<img className={classes.imagetoBeEdited} id='imagetoBeEdited' src={props.myblobfile} alt="imagetobeedited" />
</Grid>
{brightnessSlider}
<Grid item container direction="row" justify="center" spacing={matchesXS?1:2} className={classes.menuItems} >
<Grid item> <Button className={classes.myButtons} size={matchesXS?"small":'medium'} variant="contained"><RestoreIcon/></Button></Grid>
<Grid item><Button className={classes.myButtons} size={matchesXS?"small":'medium'} variant="contained"><RotateLeftIcon/></Button></Grid>
<Grid item> <Button className={classes.myButtons} size={matchesXS?"small":'medium'} variant="contained"><RotateRightIcon/></Button></Grid>
<Grid item><Button className={classes.myButtons} size={matchesXS?"small":'medium'} variant="contained"><CropIcon/></Button></Grid>
<Grid item> <Button className={classes.myButtons} size={matchesXS?"small":'medium'} variant="contained" onClick={handleBrightness}><Brightness5Icon/></Button></Grid>
</Grid>
<Grid item container direction="row" spacing={3} justify="center" className={classes.saveCloseButton} >
<Grid item>
<Button className={classes.myButtons} variant='contained'>Save</Button>
</Grid>
<Grid item>
<Button className={classes.myButtons} variant='contained' onClick={handleEditPopupClose}>Close</Button>
</Grid>
</Grid>
</Grid>
)
}
export default function ImageEditor(props){
const classes=useStyle();
const [myfile,setFile]=useState([]);
const theme=useTheme();
const [myblobfile,setblobFile]=useState(0);
const matchesXS=useMediaQuery(theme.breakpoints.down('xs'));
const getBase64=(file)=> {
var reader = new FileReader();
reader.readAsDataURL(file);
reader.onload = function () {
var tempArr = myfile;
const base64String = reader.result
.replace('data:', '')
.replace(/^.+,/, '');
tempArr.push(base64String);
setFile(tempArr);
console.log(myfile);
};
reader.onerror = function (error) {
console.log('Error: ', error);
};
}
const handleChange=(event) =>{
if(event.target.files[0]){
console.log(event.target.files[0])
//tempArr.push(URL.createObjectURL(event.target.files[0]));
setblobFile(URL.createObjectURL(event.target.files[0]));
console.log(myblobfile)
getBase64(event.target.files[0]);
}
//RES.images=this.state.myfile;
}
const handleEditPopup=(event)=>{
document.getElementsByClassName("imgPopupContainer")[0].style.display="block"
}
return (
<div>
<Typography variant='h5'>Upload Images</Typography>
<label htmlFor="file-upload" className={classes.customFileUpload} >
<AddCircleIcon className={classes.Icon} />
</label>
<input id="file-upload" type="file" className={classes.fileUpload} onChange={handleChange}/>
<Grid container style={{display:myblobfile===[]?"none":"block"}}>
<Grid container item direction='column' alignItems='center'>
<Grid item >
<img className={classes.imgPreview} src={myblobfile}/>
</Grid>
<Grid container item direction="row" justify='center' spacing={matchesXS?1:2}>
<Grid item>
<Button variant='outlined' size={matchesXS?"small":'medium'} >X</Button>
</Grid>
<Grid item>
<Button variant='outlined' size={matchesXS?"small":'medium'} onClick={handleEditPopup}>Edit</Button>
</Grid>
</Grid>
</Grid>
</Grid>
<EditorPopup myblobfile={myblobfile}/>
</div>
)
}
|
// filters the routers
import React from 'react'
import { connect } from 'react-redux'
import RouterFilter from './router_filter'
import ShareWidget from './share_widget'
const Routers = (props) => (
<div className='col-md-6 little-space'>
<ShareWidget />
<div >
<h3 className='question-text'> Router Options </h3>
</div>
<RouterFilter props={props} />
</div>
)
// var priceAnswer = this.props.userAnswers[0]
// if(!priceAnswer || priceAnswer === "anyprice" || priceAnswer === "clearprice") {
// priceAnswer = ""
// }
// var antennaAnswer = this.props.userAnswers[1]
// if(!antennaAnswer) {
// antennaAnswer = ""
// }
// var parentalAnswer = this.props.userAnswers[2]
// if(!parentalAnswer) {
// parentalAnswer = ""
// }
// var frequencyAnswer = this.props.userAnswers[3]
// if(!frequencyAnswer) {
// frequencyAnswer = ""
// }
// var dataTransferAnswer = this.props.userAnswers[4]
// if(!dataTransferAnswer) {
// dataTransferAnswer = ""
// }
// var lanPortAnswer = this.props.userAnswers[5]
// if(!lanPortAnswer) {
// lanPortAnswer = ""
// }
// var NumDevicesAnswer = this.props.userAnswers[6]
// if(!NumDevicesAnswer) {
// NumDevicesAnswer = ""
// }
// preload.routers.forEach(function(router) {
// if(antennaAnswer === "<4"){
// if(router['antennas'] <= 4) {
// console.log("router")
// }
// }
// if(antennaAnswer === ">4"){
// if(router['antennas'] > 4 || router.mesh_network === "TRUE") {
// console.log(router)
// }
// }
// })
// return (
// <div className='my-container'>
// <ShareWidget />
// <div >
// <h3 className='question-text'> Router Options </h3>
// </div>
// <div className="search">
// {props.answers}
// {*preload.routers
// .filter(router => {
// if(priceAnswer === "<100"){
// if(router['price ($)'] <= 100) {
// return router
// }
// }
// else if(priceAnswer === "<150"){
// if(router['price ($)'] < 150) {
// return router
// }
// } else if(priceAnswer === "<200"){
// if(router['price ($)'] < 200) {
// return router
// }
// } else {
// return router
// }
// })
// .filter(router => {
// if(antennaAnswer === "<4"){
// if(router['antennas'] <= 4) {
// return router
// }
// }
// if(antennaAnswer === ">4"){
// if(router['antennas'] > 4 || router.mesh_network === "TRUE") {
// return router
// }
// } else {
// return router
// }
// })
// .filter(router => router['MU-MIMO (number of devices)'].indexOf(NumDevicesAnswer) >= 0)
// .filter(router => router['parent_control_specialty'].indexOf(parentalAnswer) >= 0)
// .filter(router => router['5ghz frequency'].indexOf(frequencyAnswer) >= 0)
// .filter(router => router['data_transfer_value (1=<1300; 2>1300 mbps)'].indexOf(dataTransferAnswer) >= 0)
// .filter(router => {
// if(lanPortAnswer === ">4"){
// if(router['LAN_ports'] >= 4) {
// return router
// }
// } else {
// return router
// }
// }).map( router => <ShowCard key={router.ASIN} {...router}/>)
// *}
// </div>
// </div>
// )
// }
const mapStateToProps = state => ({
routers:state.routers,
PRICE_QUESTION: state.PRICE_QUESTION,
ROOM_QUESTION:state.ROOM_QUESTION,
NUM_DEVICES_QUESTION:state.NUM_DEVICES_QUESTION,
PARENTAL_QUESTION:state.PARENTAL_QUESTION,
FREQUENCY_QUESTION:state.FREQUENCY_QUESTION,
DATA_TRANSFER_QUESTION:state.DATA_TRANSFER_QUESTION,
LAN_PORT_QUESTION:state.LAN_PORT_QUESTION
});
export default connect(mapStateToProps)(Routers)
|
var app = angular.module("personal");
require("stompjs/lib/stomp");
var ws = null;
var test = "";
app.service("serverConnection", function() {
function connect(scope,store,playeraction,complie) {
var connection = new SockJS("/firstOne");
ws = Stomp.over(connection);
var position={};
ws.connect(
{},
function(frame) {
ws.subscribe("/game/connection", function(message) {
position=JSON.parse(message.body);
storeUpdate(position, store,playeraction,scope);
});
},
function(error) {
return message.error;
}
);
}
function sendText(obj) {
ws.send("/app/play", {}, JSON.stringify(obj));
}
return { connect, sendText };
});
function storeUpdate(data, store,playeraction,scope){
for(var i =0; i<data.values.length;i++){
if(data.values[i][0]==store.Name){
store.pos_x=data.values[i][1]
store.pos_y=data.values[i][2]
store.id=data.values[i][3];
playeraction.moveEnemys(store)
playeraction.movePlayer(scope,store);
store.enemys[i]="x";
}else{
store.enemys[i]=data.values[i];
playeraction.moveEnemys(store)
playeraction.movePlayer(scope,store);
}
}
}
|
(function(app) {
'use strict';
function verifyRec(params) {
if (params.endDate < params.startDate) {
return 'End date must be larger or equal to start date.';
}
if (params.referenceDate < params.startDate) {
return 'Reference date must be larger or equal to start date.';
}
if (params.referenceDate > params.endDate) {
return 'Reference date must be smaller or equal to end date.';
}
return null;
}
function checkOverlap(startDate, endDate) {
return function(rec) {
return startDate >= rec.startDate && startDate <= rec.endDate || endDate >= rec.startDate && endDate <= rec.endDate;
};
}
app.db.createBudgetingPeriod = function(params, callback) {
var data = app.db.storage.budgetingPeriods;
var err = verifyRec(params);
if (err) {
callback(err, null);
} else {
var id = data.findIndex(checkOverlap(params.startDate, params.endDate));
if (id >= 0) {
err = 'Overlapping period exists.'
callback(err, null);
} else {
var rec = {
startDate: params.startDate,
endDate: params.endDate,
referenceDate: params.referenceDate,
plannedIncomes: [],
plannedExpenses: [],
actualIncomes: [],
actualExpenses: [],
status: true,
};
data.push(rec);
app.db.storage.activePeriod = rec;
app.db.persist(function() {
callback(null, data.length - 1);
});
}
}
};
app.db.updateBudgetingPeriod = function(params, callback) {
var data = app.db.storage.budgetingPeriods;
var err = verifyRec(params);
if (err) {
callback(err, null);
} else {
var id = data.findIndex(checkOverlap(params.startDate, params.endDate));
if (id >= 0 && id != params.id) {
err = 'Overlapping period exists.'
callback(err, null);
} else {
var rec = data[params.id];
rec.startDate = params.startDate;
rec.endDate = params.endDate;
app.db.persist(function() {
callback(null, params.id);
});
}
}
};
app.db.deleteBudgetingPeriod = function(params, callback) {
var data = app.db.storage.budgetingPeriods;
data.splice(params.id, 1);
app.db.persist(function() {
callback(null);
});
};
app.db.getBudgetingPeriods = function() {
return app.db.storage.budgetingPeriods.sort(function(a, b) {
return a.startDate - b.startDate;
});
};
app.db.getBudgetingPeriod = function(id) {
return app.db.storage.budgetingPeriods[id];
}
})(frugalisApp);
|
var express = require('express');
const { resolve } = require('path');
var router = express.Router();
var conf = require('../../conf');
router.get('/', function (req, res) {
options = {};
res.render('home', {
options: options,
});
});
router.get('/description', function (req, res) {
options = {};
res.render('migrate', {
options: options,
});
});
router.get('/tokens', function (req, res) {
options = {};
res.render('migrate', {
options: options,
});
});
// ======= EXPORT THE ROUTER =========================
module.exports = router;
|
var tau = 6.283185307179586
var canvas = document.getElementById("canvas")
var context = canvas.getContext("2d")
UFX.draw.setcontext(context)
if (!DEBUG) {
UFX.key.watchlist = "up down left right space tab".split(" ")
}
UFX.key.init()
UFX.key.remaparrows(true)
UFX.key.qdown = true
UFX.maximize.fill(canvas, "total")
UFX.scenes.title = {
think: function () {
if (loadf >= 1 && UFX.key.ispressed.space) {
UFX.scene.swap("play")
}
},
draw: function () {
UFX.draw("fs #444 f0")
UFX.draw("fs white ss black")
var h = Math.floor(Math.min(canvas.width / 20, canvas.height / 10))
UFX.draw("[ lw 2 textalign center t", canvas.width / 2, canvas.height / 2)
UFX.draw("font", 2*h + "px~'Piedra' fst Ad~Astra 0", -2.4*h)
UFX.draw("font", h + "px~'Piedra' fst by~Christopher~Night 0 0")
UFX.draw("font", h + "px~'Piedra' fst Universe~Factory~Games 0", 1.2*h)
if (loadf >= 1) {
UFX.draw("font", 1.4*h + "px~'Piedra' fst press~Space~to~" + (localStorage.LD29save ? "continue" : "begin"), 0, 4*h)
} else {
UFX.draw("font", 1.4*h + "px~'Piedra' fst Loading:~" + Math.round(100*loadf) + "%", 0, 4*h)
}
UFX.draw("]")
},
}
UFX.scenes.death = {
start: function () {
this.t = 0
},
think: function (dt) {
this.t += dt
if (this.t > 2) UFX.scene.swap("title")
},
draw: function () {
if (this.t < 1) {
UFX.scenes.play.draw()
} else {
UFX.scenes.title.draw()
}
var alpha = Math.min(Math.max(1 - Math.abs(this.t - 1), 0), 1)
UFX.draw("[ fs red alpha", alpha, "f0 ]")
},
}
UFX.scenes.reset = {
start: function () {
this.t = 0
},
think: function (dt) {
this.t += dt
if (this.t > 2) UFX.scene.swap("title")
},
draw: function () {
if (this.t < 1) {
UFX.scenes.play.draw()
} else {
UFX.scenes.title.draw()
}
var alpha = Math.min(Math.max(1 - Math.abs(this.t - 1), 0), 1)
UFX.draw("[ fs white alpha", alpha, "f0 ]")
},
}
var loadf = 0
UFX.scene.init({ ups: 60, maxupf: 6 })
UFX.scene.push("title")
UFX.resource.onloading = function (f) {
loadf = f
}
UFX.resource.onload = function () {
loadf = 1
UFX.resource.mergesounds("jump")
}
function playsound(sname) {
try {
UFX.resource.sounds[sname].play()
} catch (e) {
}
}
var musicplaying = null, musicvolume = settings.musicvolume
function playmusic(mname) {
try {
var m = UFX.resource.sounds[mname]
if (m === musicplaying) return
if (musicplaying) musicplaying.pause()
m.volume = musicvolume
m.currentTime = 0
m.play()
m.loop = true
musicplaying = m
} catch (e) {
}
}
UFX.resource.loadwebfonts("Viga", "Pirata One", "Sansita One", "Piedra")
UFX.resource.load({
gamedata: "gamedata.json",
jump0: "sfx/jump0.ogg",
jump1: "sfx/jump1.ogg",
jump2: "sfx/jump2.ogg",
jump3: "sfx/jump3.ogg",
hurt: "sfx/hurt.ogg",
powerup: "sfx/powerup.ogg",
pickup: "sfx/pickup.ogg",
explosion: "sfx/explosion.ogg",
warp: "sfx/warp.ogg",
defeat: "sfx/defeat.ogg",
song1: "sfx/cheese.ogg",
song2: "sfx/hands.ogg",
song3: "sfx/tired.ogg",
})
|
import React, { useState } from 'react';
import PropTypes from 'prop-types';
import './Recommendations.css';
import Thumbnail from '../Thumbnail/Thumbnail';
import DetailsCard from '../DetailsCard/DetailsCard';
import { getAnimes } from '../apiCalls';
const Recommendations = ({ animes, genre }) => {
const [details, setDetails] = useState(null);
const [error, setError] = useState('');
const [canSave, setCanSave] = useState(true);
const getDetails = (url) => {
getAnimes(url)
.then(data => {
setDetails(data)
setCanSave(true)
returnToTop();
})
.catch(err => {
setError(err);
})
}
const returnToTop = () => {
document.body.scrollTop = 0;
document.documentElement.scrollTop = 0;
}
const titles = animes.map(anime => {
return (
<Thumbnail anime={anime} getDetails={getDetails} key={anime.mal_id}/>
)
})
return (
<main className="main">
<h2 className="rec-header">Recommendations</h2>
<div className="main-home">
{(details && !details.message) &&
<section className="details-sect">
<DetailsCard details={details} canSave={canSave} setCanSave={setCanSave}/>
</section> }
{(details && details.message) &&
<section className="details-sect">
<h3>Something went wrong. Please try again</h3>
</section>}
<section className="recs-container">
<h2>{genre}</h2>
{titles}
</section>
</div>
</main>
)
}
export default Recommendations;
Recommendations.propTypes = {
animes: PropTypes.array,
genre: PropTypes.string
};
|
/* global angular */
/* global $ */
/* PlayerController */
angular.module('musicBattleApp').controller('PlayerController',['$rootScope','$scope','playerService','notificationService',
function($rootScope,$scope,playerService,notificationService){
//Scope properties
$scope.players = [];
$scope.isLoggedIn = playerService.isLoggedIn;
$scope.playerName = null;
//Scope watchs
$scope.$watch(function(scope) { return playerService.playerInformations.isLoggedIn },
function(newValue) {
$scope.isLoggedIn = newValue;
}
);
$scope.$watch(function(scope) { return playerService.players },
function(newValue) {
$scope.players = [];
$scope.players = newValue;
}
);
//Scope methods
//Hit when a player is ready
$scope.playerReady = function(){
if(playerService.addPlayer($scope.playerName)){
console.log("Player " + $scope.playerName + " ready");
playerService.setPlayerName($scope.playerName);
playerService.initPlayers();
}
};
}]);
|
(function(shoptet) {
/**
* Function that fires after end of resize
*
* This function does not accept any arguments.
*/
function resizeEnd() {
if (new Date() - shoptet.runtime.resize.rtime < shoptet.runtime.resize.delta) {
setTimeout(resizeEnd, shoptet.runtime.resize.delta);
} else {
shoptet.runtime.resize.timeout = false;
shoptet.scripts.signalNativeEvent('resizeEnd', document);
var window_changed = $(window).width() !== shoptet.runtime.resize.windowWidth;
if (window_changed) {
resizeEndCallback();
shoptet.runtime.resize.windowWidth = $(window).width();
}
var height = window.innerHeight;
if (height !== shoptet.runtime.resize.windowHeight) {
document.documentElement.style.setProperty('--vh', (height * 0.01) + 'px');
shoptet.runtime.resize.windowHeight = height;
}
}
}
shoptet.runtime = shoptet.runtime || {};
shoptet.runtime.setPcsTimeout = false;
// we need to clear messages after page load
shoptet.runtime.dismiss = setTimeout(function() {
hideMsg();
}, shoptet.config.dismissTimeout);
shoptet.runtime.resize = {
delta: 300,
rtime: false,
timeout: false,
windowWidth: false,
windowHeight: false
};
shoptet.runtime.cloudZoom = false;
shoptet.runtime.updateMenu = false;
shoptet.runtime.adminBar = false;
shoptet.scripts.libs.runtime.forEach(function(fnName) {
var fn = eval(fnName);
shoptet.scripts.registerFunction(fn, 'runtime');
});
document.addEventListener('DOMContentLoaded', function() {
shoptet.runtime.resize.windowWidth = $(window).width();
shoptet.runtime.resize.windowHeight = window.innerHeight;
document.documentElement.style.setProperty('--vh',
(shoptet.runtime.resize.windowHeight * 0.01) + 'px'
);
});
window.addEventListener('resize', function() {
shoptet.runtime.resize.rtime = new Date();
if (shoptet.runtime.resize.timeout === false) {
shoptet.runtime.resize.timeout = true;
setTimeout(function() {
shoptet.runtime.resizeEnd();
}, shoptet.runtime.resize.delta);
}
});
shoptet.events.paymentGwRedirectScheduled = new Promise(resolve => {
shoptet.runtime.resolvePaymentGwRedirectScheduled = resolve;
});
})(shoptet);
|
const { Pool } = require('pg');
const pool = new Pool({
user: 'adam',
password: 'test',
database: 'photo_gallery',
port: 5432,
max: 20,
idleTimeoutMillis: 30000,
connectionTimeoutMillis: 2000,
});
pool.connect();
module.exports = {
pool,
query: (text, params, cb) => pool.query(text, params, cb),
};
|
import React from 'react';
import 'bootstrap/dist/css/bootstrap.min.css';
export default class BestStockRow extends React.Component {
constructor(props) {
super(props);
}
render() {
return (
<div className="stockResults">
<div className="ticker">{this.props.bestStock.ticker}</div>
<div className="name">{this.props.bestStock.company}</div>
<div className="sector">{this.props.bestStock.sector}</div>
<div className="open">{this.props.bestStock.open}</div>
<div className="high">{this.props.bestStock.high}</div>
</div>
);
}
}
|
require.config({
baseUrl: "js"
});
define([
'apps/my_app',
'util/dispatcher'
], function(MyApp, Dispatcher) {
var app = new MyApp({el: document.body});
Dispatcher.bind('my_view:click', app.clickHandler, app);
});
|
import './App.css';
import React, {useEffect} from 'react';
import {useDispatch, useSelector} from 'react-redux';
import CardList from './components/CardList';
import SearchBox from './components/SearchBox';
import Scroll from './components/Scroll';
import ErrorBoundary from './components/ErrorBoundary';
import {requestMonsters, setSearchField} from './actions';
const App = () => {
const {searchfield} = useSelector(
(state) => state.searchMonsters
);
const {monsters, isPeding, error} = useSelector(
(state) => state.requestMonsters
);
const dispatch = useDispatch();
const onSearchChange = (event) => {
dispatch(setSearchField(event.target.value))
}
const onRequestMonsters = () => {
dispatch(requestMonsters())
};
useEffect(() => {
onRequestMonsters()
// eslint-disable-next-line
}, []);
const filteredMonsters = monsters.filter(monster => {
return monster.name.toLowerCase().includes(searchfield.toLowerCase());
});
return isPeding ?
<h1>Loading</h1> :
error ?
<h1>Cannot retreive Monsters</h1> :
(
<div className = 'tc'>
<h1 className = 'f-5 ma2'>Monster Friends</h1>
<SearchBox searchChange = {onSearchChange}/>
<Scroll>
<ErrorBoundary>
<CardList monsters = {filteredMonsters} />
</ErrorBoundary>
</Scroll>
</div>
);
}
export default App;
// This code uses a class component and no hooks//
// import './App.css';
// import React, {Component} from 'react';
// import {connect} from 'react-redux';
// import CardList from './components/CardList';
// import SearchBox from './components/SearchBox';
// import Scroll from './components/Scroll';
// import ErrorBoundary from './components/ErrorBoundary';
// import {requestMonsters, setSearchField} from './actions';
// const mapStateToProps = (state) => {
// return {
// searchfield: state.searchMonsters.searchfield,
// monsters: state.requestMonsters.monsters,
// isPeding: state.requestMonsters.isPeding,
// error: state.requestMonsters.error
// }
// };
// const mapDispatchToProps = (dispatch) => {
// return {
// onSearchChange: (event) => dispatch(setSearchField(event.target.value)),
// onRequestMonsters: () => dispatch(requestMonsters())
// }
// };
// class App extends Component {
// componentDidMount() {
// this.props.onRequestMonsters()
// };
// render() {
// const {searchfield, onSearchChange, monsters, isPeding} = this.props;
// const filteredMonsters = monsters.filter(monster => {
// return monster.name.toLowerCase().includes(searchfield.toLowerCase());
// })
// return isPeding ?
// <h1>Loading</h1> :
// (
// <div className = 'tc'>
// <h1 className = 'f-5 ma2'>Monster Friends</h1>
// <SearchBox searchChange = {onSearchChange}/>
// <Scroll>
// <ErrorBoundary>
// <CardList monsters = {filteredMonsters} />
// </ErrorBoundary>
// </Scroll>
// </div>
// );
// }
// }
// export default connect(mapStateToProps, mapDispatchToProps)(App);
|
'use strict';
angular.module('PersonalWebsiteAngularApp', ['ngResource']).config(function($routeProvider) {
return $routeProvider.when('/', {
templateUrl: 'views/homeView.html',
controller: 'HomeViewCtrl'
}).when('/resume', {
templateUrl: 'views/resumeView.html',
controller: 'ResumeViewCtrl'
}).when('/contact', {
templateUrl: 'views/contactView.html',
controller: 'ContactViewCtrl'
}).when('/video', {
templateUrl: 'views/videoView.html',
controller: 'VideoViewCtrl'
}).when('/photo', {
templateUrl: 'views/photoView.html',
controller: 'PhotoViewCtrl'
}).when('/blog', {
templateUrl: 'views/blogView.html',
controller: 'BlogViewCtrl'
}).otherwise({
redirectTo: '/'
});
});
|
OperacionesManager.module("ContratoApp.Editar", function(Editar, OperacionesManager, Backbone, Marionette, $, _){
Editar.Controller = {
editar: function(codigo){
var contrato = OperacionesManager.request("contratos:entity", codigo);
console.log(contrato.toJSON());
var crearPrincipal = new Editar.Principal({
model: contrato,
});
OperacionesManager.regions.main.show(crearPrincipal);
crearPrincipal.on("contrato:mostrarEditarCliente", function(){
var mostrarEditarContratoCliente = new Editar.ContratoClienteForm({
model: contrato,
});
mostrarEditarContratoCliente.on("clientes:busqueda", function(input){
var clientes = OperacionesManager.request("clientes:entities");
var clientes_clone = clientes.clone();
var input = input.toLowerCase();
var clientes_filtrados = clientes.filter(function(cliente){
var n = cliente.get("usuario").nombres.toLowerCase().search(input);
var a = cliente.get("usuario").apellidos.toLowerCase().search(input);
var c = cliente.get("usuario").cedula.toString().search(input);
if (n != -1 || a != -1 || c != -1) {
return true;
}
});
clientes_clone.reset();
clientes_clone.add(clientes_filtrados);
var busquedaClientes = new Editar.Clientes({
collection: clientes_clone,
});
if (input.length) {
mostrarEditarContratoCliente.clientesRegion.show(busquedaClientes);
}
else {
mostrarEditarContratoCliente.clientesRegion.empty();
}
});
mostrarEditarContratoCliente.on("childview:mostrarContrato", function(cliente){
mostrarEditarContratoCliente.clientesRegion.empty();
var cliente_id = cliente.model.get("id");
var $input = $("#crear-contrato-cliente");
$input.val(cliente.model.get("usuario").nombres + " " + cliente.model.get("usuario").apellidos);
$input.data("id", cliente_id);
});
mostrarEditarContratoCliente.on("contrato:guardarCliente", function(cliente){
$.ajax({
data: {
contrato_id: contrato.get('id'),
cliente_id: cliente,
},
url: '/ajax/contratos/editar-contrato-cliente/',
type: 'POST',
success: function(data) {
console.log("Guardado exitoso");
location.reload(true);
}
});
});
crearPrincipal.principalRegion.show(mostrarEditarContratoCliente);
});
crearPrincipal.on("contrato:mostrarEditarDatos", function(){
var mostrarEditarContratoDatos = new Editar.ContratoDatosForm({
model: contrato,
});
mostrarEditarContratoDatos.on("contrato:guardarDatos", function(plazo, porcentaje){
$.ajax({
data: {
contrato_id: contrato.get('id'),
plazo_id: plazo,
porcentaje: porcentaje,
},
url: '/ajax/contratos/editar-contrato-datos/',
type: 'POST',
success: function(data) {
console.log("Guardado exitoso");
location.reload(true);
}
});
});
crearPrincipal.principalRegion.show(mostrarEditarContratoDatos);
});
crearPrincipal.on("contrato:mostrarEditarArticulo", function(e){
var articulo_encontrado = _.filter(contrato.get("articulos"), function(articulo){
return articulo.id == e.currentTarget.dataset.pk;
});
contrato.set('articulos', articulo_encontrado);
var mostrarEditarContratoArticulo = new Editar.ContratoArticuloForm({
model: contrato,
});
mostrarEditarContratoArticulo.on("contrato:editarArticulo", function(clase, subclase, categoria, subcategoria, tiposubcategoria, observacion, peso, costo, opciones, html, articulo_id){
console.log("******");
console.log(tiposubcategoria);
var clase_nombre = _.find(data.clases, function(data){
return data.id == clase;
});
var subclase_nombre = _.find(data.subclases, function(data){
return data.id == subclase;
});
var categoria_nombre = _.find(data.categorias, function(data){
return data.id == categoria;
});
var tiposubcategoria_text = "";
for (var i = tiposubcategoria.length - 1; i >= 0; i--) {
var tipo_subcategoria_nombre = _.find(data.tipo_subcategorias, function(data){
return data.id == tiposubcategoria[i];
});
tiposubcategoria_text = tiposubcategoria_text + " " + tipo_subcategoria_nombre.nombre;
};
var opciones_text = "";
for (var i = opciones.length - 1; i >= 0; i--) {
var opcion_nombre = _.find(data.opciones, function(data){
return data.id == opciones[i];
});
opciones_text = opciones_text + " " + opcion_nombre.opcion;
};
var descripcion = clase_nombre.descripcion + " " + subclase_nombre.descripcion + " " + categoria_nombre.nombre + " " + tiposubcategoria_text + " " + opciones_text + " " + observacion;
var articulo_1 = {
articulo_id: articulo_id,
clase: clase,
subclase: subclase,
categoria: categoria,
tiposubcategoria: tiposubcategoria,
opciones: opciones,
observacion: observacion,
peso: peso,
costo: costo,
descripcion: descripcion,
}
console.log(articulo_1);
var articulo_model = new OperacionesManager.Entities.Articulo(articulo_1);
// var articulosView = new Editar.Articulo({
// model: articulo_model,
// });
// var $articulo_html = html;
// $articulo_html.find(".articulos").hide();
// $articulo_html.find(".articulo-nuevo").show();
$.ajax({
data: { articulo: JSON.stringify(articulo_model.toJSON()) },
url: '/ajax/contratos/editar-articulo/',
type: 'POST',
success: function(data) {
location.reload(true);
}
});
});
crearPrincipal.principalRegion.show(mostrarEditarContratoArticulo);
});
OperacionesManager.regions.main.show(crearPrincipal);
}
}
});
|
"use strict";
import React from "react";
import "bootstrap/dist/css/bootstrap.min.css";
class CityForm extends React.Component {
render() {
return (
<form onSubmit={(e) => this.props.renderForm(e)}>
<fieldset>
<label>cat name</label>
<input type="text" name="name" />
<label>cat breed</label>
<input type="submit" value="Update" />
</fieldset>
</form>
// <form onSubmit={(e) => this.props.renderForm(e)}>
// <fieldset>
// <label>cat name</label>
// <input type="text" name="name" />
// <label>cat breed</label>
// <input type="submit" value="Update" />
// </fieldset>
// </form>
);
}
}
export default CityForm;
|
import React from "react";
import {
Grid,
Button,
FormControlLabel,
Checkbox
} from "@material-ui/core";
import { connect } from "react-redux";
import { EgretTextField, EgretSelect } from '../../egret'
import { COLORS } from '../../app/config'
const SELECT_DATA = [
{ id: 1, name: 'Commercial Real Estate' },
{ id: 2, name: 'Cannabis Application Support' },
{ id: 3, name: 'Consumer Product & services' },
{ id: 4, name: 'Clean Tech, Fitness' },
{ id: 5, name: 'Financial Services' },
{ id: 6, name: 'Medical Technology, Biotech, Healthcare' },
{ id: 7, name: 'Education & E-Learning' },
];
function About(props) {
return (
<div className="about">
<div className="image-content"></div>
<Grid container spacing={2} style={{ flex: 1, paddingTop: 60 }}>
<Grid item lg={6} md={6} xs={12} className="info-container px-sm-80 mb-sm-50">
<div className="flex flex-column">
<span className="more-about mb-sm-40">Tell Us More About</span>
<div className="flex flex-middle flex-space-between mb-sm-60">
<div className="more-item">
<span>15+</span>
<span>Years in operation</span>
</div>
<div className="more-item">
<span>750+</span>
<span>Projects done</span>
</div>
<div className="more-item">
<span>6</span>
<span>Offices</span>
</div>
</div>
<div className="flex flex-column award">
<span className="mb-sm-24">AWWARDS & Recogntion</span>
<div className="flex flex-middle">
<img src="/assets/images/award-1.png" alt="award-1" />
<img src="/assets/images/award-2.png" alt="award-2" />
<img src="/assets/images/award-3.png" alt="award-3" />
<img src="/assets/images/award-4.png" alt="award-4" />
</div>
</div>
</div>
</Grid>
<Grid item lg={6} md={6} xs={12} className="info-form px-sm-80">
<div className="about-content p-sm-50">
<Grid container spacing={2}>
<Grid item lg={6} md={6} xs={12}>
<EgretTextField
placeholder="First Name"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={6} md={6} xs={12}>
<EgretTextField
placeholder="Last Name"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretTextField
placeholder="Phone Number"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretTextField
placeholder="Your Email Address"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretTextField
placeholder="Country"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretTextField
placeholder="Company"
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretSelect
className="select-service"
placeholder="Select a Service"
data={SELECT_DATA}
backgroundcolor={COLORS.WHITE}
bordercolor={'rgba(0, 0, 0, 0.23)'}
color={'rgba(0, 0, 0, 0.87)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<EgretTextField
placeholder="Project Decription"
multiple
bordercolor={'rgba(0, 0, 0, 0.23)'}
/>
</Grid>
<Grid item lg={12} md={12} xs={12}>
<div className="flex flex-middle flex-space-between">
<FormControlLabel
control={
<Checkbox
name="send"
color="primary"
/>
}
label="Send NDA"
/>
<Button
color="primary"
startIcon={<img src="/assets/images/path.png" alt="path" />}
>
Attach file
</Button>
</div>
</Grid>
<Button variant="contained" color="primary" className="btnSubmit">
Schedule a consultation
</Button>
</Grid>
</div>
</Grid>
</Grid>
</div>
);
}
const mapStateToProps = state => ({
});
export default connect(
mapStateToProps,
{ }
)(About);
|
import { parse } from 'querystring'
import createCtx from './createCtx'
import request from './request'
import theme from './theme'
const getPageQuery = () => parse(window.location.href.split('?')[1])
export {
createCtx,
request,
theme,
getPageQuery
}
|
module.exports = [{
plugin: require('/Users/sfair01/Sites/sfairchild/node_modules/gatsby-plugin-offline/gatsby-browser.js'),
options: {"plugins":[]},
},{
plugin: require('/Users/sfair01/Sites/sfairchild/gatsby-browser.js'),
options: {"plugins":[]},
}]
|
import React from "react";
import { Container, Spinner } from "./styles";
function LoadingSpinner() {
return <Container>
<Spinner />
</Container>;
}
export default LoadingSpinner;
|
var storage = (function () {
return {
get : function (argument) {
// body...
},
set : function (argument) {
// body...
}
}
})();
|
const mongoose = require('mongoose');
mongoose.connect('mongodb://127.0.0.1:27017/CBP_BTC-USD', {
useNewUrlParser: true,
useCreateIndex: true,
useUnifiedTopology: true
})
const Schema = mongoose.Schema;
// Create Schema and Model
const HistorySchema = new Schema({
time: Date,
low: Number,
high: Number,
open: Number,
close: Number,
volume: Number
})
// const CoinSchema = new Schema({
// exchange: String,
// symbol: String,
// history: [HistorySchema]
// })
const Coin = mongoose.model('entry', HistorySchema);
const Entry = new Coin( {
time: new Date(1438423140000),
low: 279.75,
high: 279.91,
open: 279.80,
close: 279.90,
volume: 0.0565
});
// console.log(Entry)
// console.log('Before Entry.save');
Entry.save({upsert: true }).then((Entry) => {
console.log(Entry)
mongoose.disconnect();
}).catch((error) => {
console.log(`Error: ${error}`)
mongoose.disconnect();
})
// module.export = CoinData;
|
module.exports = {
plugins: ['import', 'json', 'unicorn', 'sort-imports-es6-autofix', 'jest-dom'],
extends: ['airbnb-base', 'plugin:unicorn/recommended', 'prettier', 'prettier/unicorn'],
env: {
jest: true,
browser: true,
},
}
|
import styled from "styled-components";
const StyledContainer = styled.div`
margin: 5rem;
margin-top: 2rem;
`;
const Styles = {
Container: StyledContainer
};
export default Styles;
|
function calculateCurrentGrade(){
//quiz
var quiz = arrayFromString(document.getElementById("quizzes").value);
var numQuizArr = convertArrayStringToNumber(quiz);
var avgQuiz = averageArray(numQuizArr);
var quizWeight = document.getElementById("quizWeight").value;
var quizWeightedAvg = weightAvg(avgQuiz,quizWeight);
colorRowByGrade("qRow",avgQuiz);
//test
var test = arrayFromString(document.getElementById("tests").value);
var numTestArr = convertArrayStringToNumber(test);
var avgTest = averageArray(numTestArr);
var testWeight = document.getElementById("testWeight").value;
var testWeightedAvg = weightAvg(avgTest,testWeight);
colorRowByGrade("tRow", avgTest);
//homework
var hw = arrayFromString(document.getElementById("hw").value);
var numHwArr = convertArrayStringToNumber(hw);
var avgHw = averageArray(numHwArr);
var hwWeight = document.getElementById("hwWeight").value;
var hwWeightedAvg = weightAvg(avgHw,hwWeight);
colorRowByGrade("hRow", avgHw);
if (isNaN(parseInt(document.getElementById("finalWeight").value)) === true ){
document.getElementById("currentGrade").innerHTML = "ERROR: Please enter a valid number for your final weight.";
return;
}
var currentGrade = Math.round(((quizWeightedAvg + testWeightedAvg + hwWeightedAvg)/
(1- (document.getElementById("finalWeight").value)/100)));
document.getElementById("currentGrade").innerHTML = "Your current grade is: " + currentGrade + "%.";
return currentGrade;
}
function colorRowByGrade(row, grade){
if ((grade) >= 90){
document.getElementById(row).style.backgroundColor = "green";
}
if ((grade) >= 80 && grade < 90){
document.getElementById(row).style.backgroundColor = "yellow";
}
if ((grade)< 80){
document.getElementById(row).style.backgroundColor = "red";
}
}
function arrayFromString(str) {
return str.split(",");
}
function convertArrayStringToNumber(strArr){
var numArr = [];
for (var i=0; i < strArr.length; i++){
if (isNaN(strArr[i]) === true ){
return;
}
numArr.push(parseInt(strArr[i]));
}
return numArr;
}
function averageArray(arr){
var sum = 0;
for (var i=0; i < arr.length; i++){
if (isNaN(arr[i]) === true ){
return;
}
sum += arr[i];
}
return sum / arr.length;
}
function weightAvg(num,weight){
return num * weight/100;
}
function validateInput(){
if (parseInt(document.getElementById("quizWeight").value) + parseInt(document.getElementById("testWeight").value) + parseInt(document.getElementById("hwWeight").value) +
parseInt(document.getElementById("finalWeight").value) === 100){
calculateCurrentGrade()
}else{
document.getElementById("currentGrade").innerHTML = "ERROR: Make sure your weights add up to 100."
}
}
function validateFields() {
var intDesiredGrade = parseInt(document.getElementById("desiredGrade").value);
if( isNaN(intDesiredGrade) === true) {
document.getElementById("gradeNeeded").innerHTML = "ERROR: Please enter a valid number for your desired grade.";
}
else {
calculateGradeNeeded();
}
}
function calculateGradeNeeded(){
document.getElementById("gradeNeeded").innerHTML = "You need to get " + getGradeNeeded() + "% on your final to get a " +
document.getElementById("desiredGrade").value + "% in this class." ;
}
//EDIT THIS!!!
function getGradeNeeded(){
var desiredGrade = parseInt(document.getElementById("desiredGrade").value);
var finalWeight = parseInt(document.getElementById("finalWeight").value);
var current = (calculateCurrentGrade() / 100) * (100-finalWeight);
var neededNotRounded = ((desiredGrade - current)/finalWeight)*100;
return Math.round(neededNotRounded);
}
function reset(){
document.getElementById("currentGrade").innerHTML = "";
document.getElementById("gradeNeeded").innerHTML = "";
document.getElementById("quizzes").value = "";
document.getElementById("quizWeight").value = "";
document.getElementById("tests").value = "";
document.getElementById("testWeight").value = "";
document.getElementById("hw").value = "";
document.getElementById("hwWeight").value = "";
document.getElementById("finalWeight").value = "";
document.getElementById("desiredGrade").value = "";
document.getElementById("qRow").style.backgroundColor = "darkolivegreen";
document.getElementById("tRow").style.backgroundColor = "darkolivegreen";
document.getElementById("hRow").style.backgroundColor = "darkolivegreen";
}
|
import React from 'react';
import { Modal, Tabs } from 'antd';
import { connect } from 'react-redux';
import { doChangeUserLoginModalVisible } from '../../../redux/action/user.js';
import AppHeaderUserLogin from './app-header-user-login/index.js';
import AppHeaderUserRegister from './app-header-user-register/index.js';
import AppHeaderUserResetPassword from './app-header-user-resetPassword/index.js';
import './index.css'
const TabPane = Tabs.TabPane;
export class AppHeaderUser extends React.Component{
constructor(props){
super(props);
}
render(){
return (
<Modal
className="app-header-user"
visible={this.props.loginModalVisible}
onCancel={() => {this.props.onChangeUserLoginModalVisible(false)}}
maskClosable={false}
footer={null}
>
<Tabs defaultActiveKey="1">
<TabPane tab="帐号登录" key="1">
<div className="app-header-user-frame">
<AppHeaderUserLogin/>
</div>
</TabPane>
<TabPane tab="注册新账号" key="2">
<div className="app-header-user-frame">
<AppHeaderUserRegister/>
</div>
</TabPane>
<TabPane tab="修改密码" key="3">
<div className="app-header-user-frame">
<AppHeaderUserResetPassword/>
</div>
</TabPane>
</Tabs>
</Modal>
)
}
}
const mapStateToProps = (state) => {
return {
loginModalVisible: state.user.loginModalVisible,
}
}
const mapDispatchToProps = (dispatch) => {
return {
onChangeUserLoginModalVisible: (modalVisible) => dispatch(doChangeUserLoginModalVisible(modalVisible))
}
}
export default connect(mapStateToProps, mapDispatchToProps)(AppHeaderUser);
|
import React from 'react'
import { connect } from 'react-redux'
import { Card, CardMedia, CardTitle, CardText } from 'material-ui/Card'
const SelectedVideo = ({ video }) =>
video && (
<Card style={{ flexBasis: '70%' }}>
<CardMedia style={{ position: 'relative' }}>
<iframe
allowFullScreen
style={{ height: 500 }}
title={video.snippet.title}
src={`https://www.youtube.com/embed/${video.id.videoId}`}
/>
</CardMedia>
<CardTitle title={video.snippet.title} />
<CardText>{video.snippet.description}</CardText>
</Card>
)
export default connect(
state => ({
video: state.youtube.selectedVideo
}),
null
)(SelectedVideo)
|
const knex = require("../db/connection");
function list(movieId) {
return knex("reviews as r")
.join("critics as c", "r.critic_id", "c.critic_id")
.select("r.*", "c.*")
.where("r.movie_id", movieId)
.then((data) => {
const restructuredData = data.map((review) => {
const critic = {
preferred_name: review.preferred_name,
surname: review.surname,
organization_name: review.organization_name,
};
const { review_id, content, score, critic_id, movie_id } = review;
return {
review_id,
content,
score,
critic_id,
movie_id,
critic,
};
});
return restructuredData;
});
}
function read(reviewId) {
return knex("reviews").select("*").where({ review_id: reviewId });
}
function update(updatedReview, reviewId) {
console.log("updatedReview received from controller", updatedReview);
return knex("reviews")
.where({ review_id: reviewId })
.update(updatedReview, "*")
.then(([data]) => {
console.log("after then data", data);
return knex("critics")
.select("*")
.where({ critic_id: data.critic_id })
.then(([critic]) => {
const combinedData = {
...data,
critic,
};
return combinedData;
});
});
}
function destroy(reviewId) {
return knex("reviews").where({ review_id: reviewId }).del();
}
module.exports = {
list,
read,
update,
delete: destroy,
};
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.