Upload folder using huggingface_hub (part 124)

pool/shard011/JavaScript/0070299_playground.js

@@ -0,0 +1,64 @@
+const memoryFS = require("memory-fs");
+const cloneDeep = require("lodash.clonedeep");
+
+const webpackConfigurations = require("./webpack.config.shared");
+
+const compile = (webpackEngine, config, fs) => {
+  const compiler = webpackEngine(cloneDeep(config));
+  compiler.outputFileSystem = fs;
+  return new Promise((resolve, reject) => {
+    compiler.run((err, stats) => {
+      if (err || stats.hasErrors()) {
+        reject(new Error(err || stats.compilation.errors));
+      }
+      const code = fs
+        .readFileSync(`${webpackConfigurations.buildPath}/main.js`)
+        .toString();
+      console.log(code);
+      // eval(code);
+      resolve();
+    });
+  });
+};
+
+const compileWithWebpackVersion = (webpackVersion, configName) =>
+  compile(
+    require(`../${webpackVersion}/node_modules/webpack`),
+    {
+      mode: "development",
+      entry: {
+        main: "./test/common/src/index.js"
+      },
+      output: {
+        filename: "[name].js",
+        chunkFilename: "[name].js",
+        publicPath: "originalPublicPath/",
+        path: webpackConfigurations.buildPath
+      },
+      module: {
+        rules: [
+          {
+            test: /index\.js$/,
+            use: {
+              loader: path.resolve(
+                `test/${webpackVersion}/node_modules/worker-loader`
+              )
+            }
+          }
+        ]
+      },
+      plugins: [
+        new WebpackRequireFrom({
+          path: "staticPath/"
+        })
+      ]
+    },
+    new memoryFS()
+  );
+
+(async function run() {
+  await compileWithWebpackVersion(
+    "webpack4",
+    "replaceSrcMethodName_pluginConf"
+  );
+})();

pool/shard011/JavaScript/0070300_Images.react.js

@@ -0,0 +1,48 @@
+const React = require('react');
+
+const Row = require('react-bootstrap/lib/row');
+const Col = require('react-bootstrap/lib/Col');
+const logs = require('../utilities/logsMixin');
+
+var imgArray = ["./img/sf1.jpg", "./img/sf2.jpg", "./img/sf3.jpg", "./img/sf4.jpg"]
+
+const imageStyle ={
+  width: "100%",
+  height: "auto"
+
+}
+const Images = React.createClass({
+
+//-------default API------------------
+
+// getDefaultProps: function(){},
+//getInitialState: function(){},
+// componentWillMount: function(){},
+// componentDidMount: function(){},
+//componentWillReceiveProps: function(){},
+//shouldComponentUpdate: function(){},
+// componentWillUpdate: function(){},
+
+render: function() {
+  var imgs;
+
+  if (imgArray.length > 0) {
+    imgs = imgArray.map(function(val, idx){
+      return (
+        <Col key={idx} xs={6}><img style={imageStyle} src={val}></img></Col>
+      )
+    })
+  }
+
+  return (
+      <Row >
+        {imgs}
+      </Row>
+    )
+
+},
+// componetDidUpdate: function(){},
+// compoentWillUnmount: function(){}
+});
+
+module.exports = Images

pool/shard011/JavaScript/0070301_star-rating-test.js

@@ -0,0 +1,125 @@
+import EmberObject from '@ember/object';
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+import { render, click } from '@ember/test-helpers';
+import hbs from 'htmlbars-inline-precompile';
+
+module('Integration | Component | star-rating', function(hooks) {
+  setupRenderingTest(hooks);
+
+  test('Renders the full and empty stars correctly with integer ratings', async function(assert) {
+    let song = EmberObject.create({ rating: 4 });
+    this.set('song', song);
+    this.set('maxRating', 5);
+
+    await render(hbs`{{star-rating item=song rating=song.rating maxRating=maxRating}}`);
+
+    assert.dom('.glyphicon-star').exists({ count: 4 }, "The right amount of full stars is rendered");
+    assert.dom('.glyphicon-star-empty').exists({ count: 1 }, "The right amount of empty stars is rendered");
+
+    this.set('maxRating', 10);
+    assert.dom('.glyphicon-star').exists({ count: 4 }, "The right amount of full stars is rendered after changing maxRating");
+    assert.dom('.glyphicon-star-empty').exists({ count: 6 }, "The right amount of empty stars is rendered after changing maxRating");
+
+    this.set('song.rating', 2);
+    assert.dom('.glyphicon-star').exists({ count: 2 }, "The right amount of full stars is rendered after changing rating");
+    assert.dom('.glyphicon-star-empty').exists({ count: 8 }, "The right amount of empty stars is rendered after changing rating");
+  });
+
+  test('Applies the passed fullClassNames and emptyClassNames', async function(assert) {
+    let song = EmberObject.create({ rating: 4 });
+    this.set('song', song);
+    this.set('maxRating', 5);
+
+    await render(hbs`{{star-rating item=song rating=song.rating maxRating=maxRating fullClassNames='fa fa-star' emptyClassNames='fa fa-star-o'}}`);
+
+    assert.dom('.fa-star').exists({ count: 4 }, "The right amount of full stars is rendered");
+    assert.dom('.fa-star-o').exists({ count: 1 }, "The right amount of empty stars is rendered");
+  });
+
+  test('Renders the full and empty stars correctly with float ratings', async function(assert) {
+    let song = EmberObject.create({ rating: 3.2 });
+    this.set('song', song);
+    this.set('maxRating', 5);
+
+    await render(hbs`{{star-rating item=song rating=song.rating maxRating=maxRating}}`);
+
+    assert.dom('.glyphicon-star').exists({ count: 3 }, "The right amount of full stars is rendered");
+    assert.dom('.glyphicon-star-empty').exists({ count: 2 }, "The right amount of empty stars is rendered");
+
+    this.set('maxRating', 10);
+
+    assert.dom('.glyphicon-star').exists({ count: 3 }, "The right amount of full stars is rendered after changing maxRating");
+    assert.dom('.glyphicon-star-empty').exists({ count: 7 }, "The right amount of empty stars is rendered after changing maxRating");
+
+    this.set('song.rating', 1.9);
+    assert.dom('.glyphicon-star').exists({ count: 2 }, "The right amount of full stars is rendered after changing rating");
+    assert.dom('.glyphicon-star-empty').exists({ count: 8 }, "The right amount of empty stars is rendered after changing rating");
+  });
+
+  test('Triggers the passed-in action when clicked', async function(assert) {
+    let song = EmberObject.create({ rating: 4 }),
+        clickedRating;
+
+    this.set('song', song);
+    this.set('maxRating', 5);
+
+    this.actions = {
+      updateRating(params) {
+        clickedRating = params.rating;
+      }
+    };
+
+    await render(hbs`{{star-rating item=song rating=song.rating on-click=(action "updateRating")}}`);
+
+    let firstStar = document.querySelectorAll('.rating-star')[0];
+    await click(firstStar);
+    assert.equal(clickedRating, 1, "The `updateRating` action was called");
+  });
+
+  test('In block form, yields back the decorated stars', async function(assert) {
+    let song = EmberObject.create({ rating: 4 });
+    this.set('song', song);
+    this.set('maxRating', 5);
+
+    await render(hbs`
+      {{#star-rating item=song rating=song.rating maxRating=maxRating as |stars|}}
+        {{#each stars as |star|}}
+          <span class="{{if star.full 'full-star' 'empty-star'}}"></span>
+        {{/each}}
+      {{/star-rating}}
+    `);
+
+    assert.dom('.full-star').exists({ count: 4 }, "The right amount of full stars is rendered");
+    assert.dom('.empty-star').exists({ count: 1 }, "The right amount of empty stars is rendered");
+  });
+
+  test('In block form, calls the passed in `on-click` action', async function(assert) {
+    let song = EmberObject.create({ rating: 4 });
+    let clickedRating;
+
+    this.set('song', song);
+    this.set('maxRating', 5);
+    this.actions = {
+      updateRating: function(params) {
+        clickedRating = params.rating;
+      }
+    };
+
+    await render(hbs`
+      {{#star-rating item=song rating=song.rating maxRating=maxRating on-click=(action "updateRating") as |stars setRating|}}
+        {{#each stars as |star|}}
+          <span
+            class="rating-star"
+            onclick={{action setRating star.rating}}>
+            <span class="fa fa-star"></span>
+          </span>
+        {{/each}}
+      {{/star-rating}}
+    `);
+
+    let firstStar = document.querySelectorAll('.rating-star')[0];
+    await click(firstStar);
+    assert.equal(clickedRating, 1, "The `updateRating` action was called");
+  });
+});

pool/shard011/JavaScript/0070302_config.js

@@ -0,0 +1,134 @@
+var HOST = "";
+
+jsolait.baseURI = HOST + "/jsolait/";	
+var serviceURL = HOST + "/rpc.cgi";
+var jsonrpc = null;
+var Version = "1.0.1";
+var DEBUG = false;
+var methods = [ "config.getVariable", 
+				"config.setVariable", 
+				"config.getConfig",
+				"file.exists", 
+				"misc.remoteCmd", 
+				"misc.fileDownload",
+				"misc.fileUpload",
+				"misc.getVersion",
+				"misc.getGatewayNetworkInfo",
+				"misc.setGatewayNetworkInfo",		
+				"misc.getNtpServers",
+				"misc.setNtpServers",
+				"misc.softwareReset",
+				"misc.hardReset",
+				"misc.setGprsProviderInfo", 
+				"misc.getGprsProviderInfo",
+				"user.secure_challenge", 
+				"user.secure_login",
+				"user.logout" ];
+				
+function InitJSON(){	
+    try {		
+        jsonrpc = imprt("jsonrpc");
+    } catch (e) {
+        alert(e);
+    }	
+}
+
+function SetPageCommonElements(){
+	document.title = "MCS Admin";                     	
+	var divHeader = document.getElementById("header");
+	if (divHeader){
+		divHeader.innerHTML = "<table width='100%' cellspacing='0' cellpadding='0' border='0'>" +
+								"<tr>" +
+								"<td align='left'><img id='imgCompany' src='images/CompanyLogo.png' height='30px'></td>" +						      
+								"<td align='right'>/admin/ User Interface</td>"
+								"</tr>" +
+							  "</table>";
+	}
+	
+	var divFooter = document.getElementById("footer");
+	if (divFooter){    
+		divFooter.innerHTML = "<p><table width='100%' 	><tr><td align='left'>Version " + Version + " </td><td align='right'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; NIVIS&reg; 2012</tr></table></p>";
+	}
+	
+    var divMenu = document.getElementById("columnB");    
+    if (divMenu != null) {
+        divMenu.innerHTML = "<h3>Upgrade</h3>"+
+                          "<ul class='list1'>"+
+                            "<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='firmware_upgrade.html'>Edge Router Firmware</a></li>"+
+                            "<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='load_versa_node_firmware.html'>Transceiver Firmware</a></li>"+
+							"<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='upload.html'>Application Website</a></li>"+
+                          "</ul>"+
+                          "<h3>Configuration</h3>"+
+                            "<ul class='list1'>"+
+							"<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='application.html'>Log Files</a></li>"+
+							"<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='update_profile.html'>Reset Profile</a></li>"+
+							"<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='edit_configuration.html'>Advanced Settings</a></li>"+
+							"<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='network_configuration.html'>Network</a></li>" +
+                          "</ul>"+
+                          "<h3>Session</h3>"+
+                          "<ul class='list1'>"+
+                            "<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='changepassword.html'>Change Password</a></li>"+
+                            "<li>&nbsp;&nbsp;&nbsp;&nbsp;<a href='login.html'>Logout</a></li>"+
+                          "</ul>"; 
+    }
+}
+
+function HandleException(ex, msg){
+	if (ex.message != null && 
+		ex.message.toLowerCase().indexOf("login first") != -1 ||
+		ex.message.toLowerCase().indexOf("unable to start session") != -1 ||
+		ex.message.toLowerCase().indexOf("internal xml-rpc error") != -1 ||
+		ex.message.toLowerCase().indexOf("internal json-rpc error") != -1)		
+	{
+		top.location.href = "login.html?exp";
+		return;
+	}
+	if(!DEBUG){
+		alert(msg);
+	}else{
+		alert(msg + "\n" + ex);
+	}
+}
+
+function operationDoneListener(text) {
+		ToggleProgressOperation(false);
+		innerHTML = "";
+		var operationStatus = document.getElementById('operationStatus');
+		if ( text ){
+			if ( text.result ){
+				innerHTML = "Log results:<br><pre>" + text.result + "</pre>";
+				DisplayOperationResult("operationStatus", "Operation successfully completed !");
+			} else if ( text.error ){
+				innerHTML = "Log results:<br><pre>" + text.error + "</pre>";
+				DisplayOperationResultError("operationStatus", "Operation failed !");
+			}
+		}
+		document.getElementById("result").innerHTML = innerHTML;				
+}
+
+function DisplayOperationResult(controlId, msg) {
+    var control = document.getElementById(controlId);
+    control.className = "opResultGreen";
+    control.innerHTML = msg;
+}
+
+function DisplayOperationResultError(controlId, msg) {
+    var control = document.getElementById(controlId);
+    control.className = "opResultRed";
+    control.innerHTML = msg;
+}
+
+function ClearOperationResult(controlId) {
+    DisplayOperationResult(controlId, "");    
+    var control = document.getElementById(controlId);
+    control.className = "";
+}
+
+function ToggleProgressOperation(bool){
+	var operationStatus = document.getElementById("operationStatusImg");
+	if(bool){
+		operationStatus.style.display = "inline";
+	} else{
+		operationStatus.style.display = "none";
+	}
+}

pool/shard011/JavaScript/0070304_tools.js

@@ -0,0 +1,83 @@
+var program = require('commander');
+var fs = require('fs');
+var path = require('path');
+var Imagemin = require('imagemin');
+var imageminOptipng = require('imagemin-optipng');
+
+var redirectFilePath = './config/redirect-urls.json';
+var addRedirect = function(oldUrl, newUrl, callback) {
+  fs.readFile(redirectFilePath, function(err, json) {
+    if (err) { return callback(err); }
+
+    var data = JSON.parse(json);
+    data.push({
+      from: oldUrl,
+      to: newUrl
+    });
+
+    json = JSON.stringify(data, null, 2);
+    fs.writeFile(redirectFilePath, json, callback);
+  });
+};
+
+
+program
+  .version('0.0.1');
+
+
+program.command('mv <oldUrl> <newUrl>')
+  .action(function (oldUrl, newUrl) {
+    if (oldUrl[0] !== '/') {
+      oldUrl = '/' + oldUrl;
+    }
+    if (newUrl[0] !== '/') {
+      newUrl = '/' + newUrl;
+    }
+    var oldPath = 'articles' + oldUrl + '.md';
+    var newPath = 'articles' + newUrl + '.md';
+    fs.rename(oldPath, newPath, function(err) {
+      if (err) { return console.error(err); }
+
+      addRedirect(oldUrl, newUrl, function(err) {
+        if (err) { return console.error(err); }
+
+        console.log('File renamed');
+      });
+    });
+  });
+
+
+program.command('imgs')
+  .action(function() {
+    new Imagemin()
+      .src('media/**/*.png')
+      .dest('media')
+      .use(imageminOptipng({optimizationLevel: 3}))
+      .run((err, files) => {
+        if (err) {
+          console.error(err);
+        }
+        console.log('Minified ' + files.length + ' images.');
+        //=> {path: 'build/images/foo.jpg', contents: <Buffer 89 50 4e ...>}
+      });
+  });
+
+program.command('img <imgPath>')
+  .action(function(imgPath) {
+    new Imagemin()
+      .src(imgPath)
+      .dest(path.dirname(imgPath))
+      .use(imageminOptipng({optimizationLevel: 3}))
+      .run((err, files) => {
+        if (err) {
+          console.error(err);
+        }
+        console.log('Minified ' + files.length + ' images.');
+        //=> {path: 'build/images/foo.jpg', contents: <Buffer 89 50 4e ...>}
+      });
+  });
+
+
+
+
+program.parse(process.argv);

pool/shard011/JavaScript/0070306_index.js

@@ -0,0 +1,89 @@
+import React, {Component} from 'react'
+import Dropdown from 'rc-dropdown'
+import Menu, {Item as MenuItem, Divider, SubMenu} from 'rc-menu';
+import 'rc-dropdown/assets/index.css';
+import 'rc-menu/assets/index.css';
+import {menu as fspMenu} from '../../settings/fspSettings';
+import './style.css'
+import {createHashHistory} from 'history'
+const history = createHashHistory({queryKey: false});
+class FSPMenu extends Component {
+
+    state = {
+        visible: false
+    };
+
+    onClick({selectedKeys}) {
+        if (!this.props.multiple) {
+            this.setState({
+                visible: false
+            })
+        }
+    }
+
+    onSelect({selectedKeys}) {
+        this.handleDropdownChanges(selectedKeys)
+    }
+
+    onVisibleChange(visible) {
+        this.setState({visible})
+    }
+
+    getDefaultView() {
+        return 'uganda/mobilemoney';
+    }
+
+    handleDropdownChanges(selectedFilters) {
+        const selected = selectedFilters[0] || this.getDefaultView();
+        const split = selected.split('/');
+        const country = split[0];
+        const view = split[1];
+        history.replace(`/fsp/${country}/${view}`);
+    }
+
+    render() {
+
+        const menu = (
+            <Menu
+                multiple={this.props.multiple}
+                onClick={this.onClick.bind(this)}
+                onSelect={this.onSelect.bind(this)}
+                onDeselect={this.onSelect.bind(this)}
+                className={this.props.multiple ? 'checkboxes' : ''}
+            >
+                {fspMenu.map(({id, description, subMenu}) => {
+                        if (subMenu) {
+                            return (
+                                <SubMenu title={description} key={id}>
+                                    {
+                                        subMenu.map(sub => (
+                                            <MenuItem key={`${id}/${sub.id}`}>{sub.description}</MenuItem>
+                                        ))
+                                    }
+                                </SubMenu>
+                            );
+                        } else return (
+                            <MenuItem key={id}>{description}</MenuItem>
+                        );
+                    }
+                )}
+            </Menu>
+        );
+
+        return (
+            <Dropdown
+                trigger={['click']}
+                overlay={<div style={{width: 200, backgroundColor: 'white'}}>{menu}</div>}
+                onVisibleChange={this.onVisibleChange.bind(this)}
+                visible={this.state.visible}
+                defaultActiveFirst
+                overlayClassName="overlays-dropdown">
+                <span className='filter' title='Thematic Analysis'>Thematic Analysis&ensp;▾</span>
+            </Dropdown>
+        )
+    }
+
+
+}
+
+export default FSPMenu

pool/shard011/JavaScript/0070308_progress.js

@@ -0,0 +1,33 @@
+Progress = function (player, elapsed, total, meter) {
+	this.player = player;
+	this.elapsed = elapsed;
+	this.total = total;
+	this.meter = meter;
+
+	var _this = this;
+
+	this.player.addEventListener("timeupdate", function (event) {
+		function renderTime(seconds) {
+			var _minutes = Math.floor(seconds / 60);
+			var _seconds = Math.floor(seconds - _minutes * 60);
+
+			_minutes = _minutes < 10 ? "0" + _minutes : _minutes;
+			_seconds = _seconds < 10 ? "0" + _seconds : _seconds;
+
+			return _minutes + ":" + _seconds;
+		}
+
+		var elapsed = event.target.currentTime;
+		var total = event.target.duration;
+
+		_this.elapsed.textContent = renderTime(elapsed);
+		_this.total.textContent = renderTime(total);
+		_this.meter.setAttribute("style", "width: " + (elapsed / total * 100) + "%");
+	});
+
+	this.player.addEventListener("ended", function (event) {
+		_this.elapsed.textContent = "";
+		_this.total.textContent = "";
+		_this.meter.setAttribute("style", "width: 0");
+	});
+};

pool/shard011/JavaScript/0070309_setup.js

@@ -0,0 +1,30 @@
+var open = require('open');
+
+module.exports = function (clientID, cb) {
+  var REDIRECT_URI = 'https://rogeriopvl.github.com/downstagram';
+
+  console.log('\n********** DOWNSTAGRAM OAUTH SETUP **********');
+  console.log('\n To use downstagram you need to authorize it to access your instagram account.');
+  console.log('Your browser will open for you to authorize the app...');
+
+  var authURI = [
+    'https://instagram.com/oauth/authorize/?',
+    'client_id=' + clientID,
+    '&redirect_uri=' + REDIRECT_URI,
+    '&response_type=token'
+  ].join('');
+
+  console.log('\n If your browser does not open up, you can stil open it manually:');
+  console.log(authURI, ' \n');
+
+  open(authURI);
+
+  console.log('Now according to the intructions in the App page, insert your access token here:');
+
+  process.stdin.resume();
+  process.stdin.on('data', function (chunk) {
+    var token = chunk.toString().trim();
+    process.stdin.pause();
+    cb(null, token);
+  });
+};

pool/shard011/JavaScript/0070311_step3_controller.js

@@ -0,0 +1,158 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @typedef {object} hawqHaConfigDependencies
+ */
+
+var App = require('app');
+require('utils/configs/hawq_ha_config_initializer');
+
+App.AddHawqStandbyWizardStep3Controller = Em.Controller.extend({
+  name: "addHawqStandbyWizardStep3Controller",
+
+  // Used in service_config.hbs
+  // selectedService
+  // hideDependenciesInfoBar
+  // versionLoaded
+
+  selectedService: null,
+
+  hawqProps: null,
+
+  hideDependenciesInfoBar: true,
+
+  versionLoaded: true,
+
+  // Used in step3.hbs
+  // isLoaded
+  // isSubmitDisabled
+  // hawqMasterDirectoryCleanUpMessage
+  isLoaded: false,
+
+  isSubmitDisabled: Em.computed.not('isLoaded'),
+
+  loadStep: function () {
+    this.renderConfigs();
+  },
+
+  content: Em.Object.create({
+    controllerName: 'addHawqStandbyWizardStep3Controller'
+  }),
+
+  /**
+   * Render configs to show them in <code>App.ServiceConfigView</code>
+   */
+  renderConfigs: function () {
+
+    var configs = require('data/configs/wizards/hawq_ha_properties').haConfig;
+
+    var serviceConfig = App.ServiceConfig.create({
+      serviceName: configs.serviceName,
+      displayName: configs.displayName,
+      configCategories: [],
+      showConfig: true,
+
+      configs: []
+    });
+
+    configs.configCategories.forEach(function (configCategory) {
+      if (App.Service.find().someProperty('serviceName', configCategory.name)) {
+        serviceConfig.configCategories.pushObject(configCategory);
+      }
+    }, this);
+
+    this.renderConfigProperties(configs, serviceConfig);
+    App.ajax.send({
+      name: 'config.tags',
+      sender: this,
+      success: 'loadConfigTagsSuccessCallback',
+      error: '',
+      data: {
+        serviceConfig: serviceConfig
+      }
+    });
+
+  },
+
+  loadConfigTagsSuccessCallback: function (data, opt, params) {
+    var urlParams = '(type=hawq-site&tag=' + data.Clusters.desired_configs['hawq-site'].tag + ')';
+    App.ajax.send({
+      name: 'reassign.load_configs',
+      sender: this,
+      data: {
+        urlParams: urlParams,
+        serviceConfig: params.serviceConfig
+      },
+      success: 'loadConfigsSuccessCallback',
+      error: 'loadConfigsSuccessCallback'
+    });
+  },
+
+  loadConfigsSuccessCallback: function (data, opt, params) {
+    params = params.serviceConfig ? params.serviceConfig : {};
+    this.setDynamicConfigValues(params, data);
+    this.setProperties({
+      selectedService: params,
+      isLoaded: true,
+      hawqProps: data
+    });
+  },
+
+  setDynamicConfigValues: function (configs, data) {
+    var topologyLocalDB = this.get('content').getProperties(['masterComponentHosts']);
+    configs.configs.forEach(function (config) {
+      App.HawqHaConfigInitializer.initialValue(config, topologyLocalDB);
+    });
+    App.HawqHaConfigInitializer.cleanup();
+    return configs;
+  },
+
+  /**
+   * Load child components to service config object
+   * @param _componentConfig
+   * @param componentConfig
+   */
+  renderConfigProperties: function (_componentConfig, componentConfig) {
+    _componentConfig.configs.forEach(function (_serviceConfigProperty) {
+      var serviceConfigProperty = App.ServiceConfigProperty.create(_serviceConfigProperty);
+      componentConfig.configs.pushObject(serviceConfigProperty);
+      serviceConfigProperty.set('isEditable', serviceConfigProperty.get('isReconfigurable'));
+    }, this);
+  },
+
+
+  submit: function () {
+    if (!this.get('isSubmitDisabled')) {
+      const dataDir = this.get('hawqProps').items[0].properties['hawq_master_directory'];
+      const hawqStandby = this.get('content.hawqHosts.newHawqStandby');
+      App.showConfirmationPopup(
+        function() {
+          App.get('router.mainAdminKerberosController').getKDCSessionState(function() {
+            App.router.send("next");
+          });
+        },
+        Em.I18n.t('admin.addHawqStandby.wizard.step3.confirm.dataDir.body').format(dataDir, hawqStandby),
+        null,
+        Em.I18n.t('admin.addHawqStandby.wizard.step3.confirm.dataDir.title'),
+        "Confirm"
+      );
+    }
+  },
+
+});

pool/shard011/JavaScript/0070313_post_draft.test.js

@@ -0,0 +1,150 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import React from 'react';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+
+import Preferences from '@mm-redux/constants/preferences';
+import intitialState from '@store/initial_state';
+import {renderWithReduxIntl} from '@test/testing_library';
+
+import PostDraft from './post_draft';
+
+jest.mock('app/components/compass_icon', () => 'Icon');
+
+const mockStore = configureMockStore([thunk]);
+const state = {
+    ...intitialState,
+    entities: {
+        ...intitialState.entities,
+        channels: {
+            ...intitialState.entities.channels,
+            channels: {
+                'channel-id': {
+                    id: 'channel-id',
+                    name: 'test-channel',
+                    display_name: 'Display Name',
+                    type: 'O',
+                },
+            },
+            channelMemberCountsByGroup: {},
+        },
+    },
+    device: {
+        ...intitialState.device,
+        dimension: {
+            deviceWidth: 375,
+            deviceHeight: 812,
+        },
+    },
+};
+const store = mockStore(state);
+
+describe('PostDraft', () => {
+    const baseProps = {
+        testID: 'post_draft',
+        canPost: true,
+        channelId: 'channel-id',
+        channelIsArchived: false,
+        channelIsReadOnly: false,
+        deactivatedChannel: false,
+        registerTypingAnimation: () => jest.fn(),
+        rootId: '',
+        screenId: 'NavigationScreen1',
+        theme: Preferences.THEMES.denim,
+    };
+
+    test('Should render the DraftInput', () => {
+        const {getByTestId, queryByText, toJSON} = renderWithReduxIntl(
+            <PostDraft
+                {...baseProps}
+            />,
+            store,
+        );
+
+        expect(toJSON()).toMatchSnapshot();
+        expect(getByTestId('post_draft.post.input')).toBeTruthy();
+        expect(queryByText('Close Channel')).toBeNull();
+    });
+
+    test('Should render the Archived for channelIsArchived', () => {
+        const {queryByTestId, getByText, toJSON} = renderWithReduxIntl(
+            <PostDraft
+                {...baseProps}
+                channelIsArchived={true}
+            />,
+            store,
+        );
+
+        expect(toJSON()).toMatchSnapshot();
+
+        // Should not render text input
+        expect(queryByTestId('post_draft.post.input')).toBeNull();
+
+        // Should match text description
+        expect(getByText('You are viewing an')).toBeTruthy();
+        expect(getByText('archived channel')).toBeTruthy();
+        expect(getByText('. New messages cannot be posted.')).toBeTruthy();
+        expect(getByText('Close Channel')).toBeTruthy();
+    });
+
+    test('Should render the Archived for deactivatedChannel', () => {
+        const {queryByTestId, getByText, toJSON} = renderWithReduxIntl(
+            <PostDraft
+                {...baseProps}
+                deactivatedChannel={true}
+            />,
+            store,
+        );
+
+        expect(toJSON()).toMatchSnapshot();
+
+        // Should not render text input
+        expect(queryByTestId('post_draft.post.input')).toBeNull();
+
+        // Should match text description
+        expect(getByText('You are viewing an')).toBeTruthy();
+        expect(getByText('archived channel')).toBeTruthy();
+        expect(getByText('. New messages cannot be posted.')).toBeTruthy();
+        expect(getByText('Close Channel')).toBeTruthy();
+    });
+
+    test('Should render the ReadOnly for channelIsReadOnly', () => {
+        const {queryByTestId, getByText, queryByText, toJSON} = renderWithReduxIntl(
+            <PostDraft
+                {...baseProps}
+                channelIsReadOnly={true}
+            />,
+            store,
+        );
+
+        expect(toJSON()).toMatchSnapshot();
+
+        // Should not render text input
+        expect(queryByTestId('post_draft.post.input')).toBeNull();
+
+        // Should match text description
+        expect(getByText('This channel is read-only.')).toBeTruthy();
+        expect(queryByText('Close Channel')).toBeNull();
+    });
+
+    test('Should render the ReadOnly for canPost', () => {
+        const {queryByTestId, getByText, queryByText, toJSON} = renderWithReduxIntl(
+            <PostDraft
+                {...baseProps}
+                canPost={false}
+            />,
+            store,
+        );
+
+        expect(toJSON()).toMatchSnapshot();
+
+        // Should not render text input
+        expect(queryByTestId('post_draft.post.input')).toBeNull();
+
+        // Should match text description
+        expect(getByText('This channel is read-only.')).toBeTruthy();
+        expect(queryByText('Close Channel')).toBeNull();
+    });
+});

pool/shard011/JavaScript/0070314_index.js

@@ -0,0 +1,26 @@
+/* global fetch */
+import search from './search';
+import album from './album';
+
+import API_URL from './config';
+import toJSON from './utils';
+
+export default class SpotifyWrapper {
+  constructor(options) {
+    this.apiURL = options.apiURL || API_URL;
+    this.token = options.token;
+
+    this.album = album.bind(this)();
+    this.search = search.bind(this)();
+  }
+
+  request(url) {
+    const headers = {
+      headers: {
+        Authorization: `'Bearer ${this.token}'`,
+      },
+    };
+
+    return fetch(url, headers).then(toJSON);
+  }
+}

pool/shard011/JavaScript/0070320_cohorts.js

@@ -0,0 +1,272 @@
+// structure stolen from http://briancray.com/posts/javascript-module-pattern
+
+var CohortManager = (function ($) {
+    // private variables and functions
+
+    // using jQuery
+    function getCookie(name) {
+        var cookieValue = null;
+        if (document.cookie && document.cookie != '') {
+            var cookies = document.cookie.split(';');
+            for (var i = 0; i < cookies.length; i++) {
+                var cookie = $.trim(cookies[i]);
+                // Does this cookie string begin with the name we want?
+                if (cookie.substring(0, name.length + 1) == (name + '=')) {
+                    cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+                    break;
+                }
+            }
+        }
+        return cookieValue;
+    }
+    var csrftoken = getCookie('csrftoken');
+    
+    function csrfSafeMethod(method) {
+        // these HTTP methods do not require CSRF protection
+        return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
+    }  
+    $.ajaxSetup({
+        crossDomain: false, // obviates need for sameOrigin test
+        beforeSend: function(xhr, settings) {
+            if (!csrfSafeMethod(settings.type)) {
+                xhr.setRequestHeader("X-CSRFToken", csrftoken);
+            }
+        }
+    });
+
+    // constructor
+    var module = function () {
+        var el = $(".cohort_manager");
+        // localized jquery
+        var $$ = function (selector) {
+            return $(selector, el)
+        }
+        var state_init = "init";
+        var state_summary = "summary";
+        var state_detail = "detail";
+        var state = state_init;
+        
+        var url = el.data('ajax_url');
+        var self = this;
+
+        // Pull out the relevant parts of the html
+        // global stuff
+        var errors = $$(".errors");
+
+        // cohort summary display
+        var summary = $$(".summary");
+        var cohorts = $$(".cohorts");
+        var show_cohorts_button = $$(".controls .show_cohorts");
+        var add_cohort_input = $$(".cohort_name");
+        var add_cohort_button = $$(".add_cohort");
+        
+        // single cohort user display
+        var detail = $$(".detail");
+        var detail_header = $(".header", detail);
+        var detail_users = $$(".users");
+        var detail_page_num = $$(".page_num");
+        var users_area = $$(".users_area");
+        var add_members_button = $$(".add_members");
+        var op_results = $$(".op_results");
+        var cohort_id = null;
+        var cohort_title = null;
+        var detail_url = null;
+        var page = null;
+
+        // *********** Summary view methods
+
+        function show_cohort(item) {
+            // item is a li that has a data-href link to the cohort base url
+            var el = $(this);
+            cohort_title = el.text();
+            detail_url = el.data('href');
+            cohort_id = el.data('id');
+            state = state_detail;
+            render();
+            return false;
+        }
+
+        function add_to_cohorts_list(item) {
+            var li = $('<li><a href="#"></a></li>');
+            $("a", li).text(item.name)
+                .data('href', url + '/' + item.id)
+                .addClass('link')
+                .click(show_cohort);
+            cohorts.append(li);
+        };
+
+        function log_error(msg) {
+            errors.empty();
+            errors.append($("<li />").text(msg).addClass("error"));
+        };
+        
+        function load_cohorts(response) {
+            cohorts.empty();
+            if (response && response.success) { 
+                response.cohorts.forEach(add_to_cohorts_list);
+            } else {
+                log_error(response.msg || "There was an error loading cohorts");
+            }
+            summary.show();
+        };
+
+
+        function added_cohort(response) {
+            if (response && response.success) {
+                add_to_cohorts_list(response.cohort);
+            } else {
+                log_error(response.msg || "There was an error adding a cohort");
+            }                
+        }
+
+        // *********** Detail view methods
+
+        function remove_user_from_cohort(username, cohort_id, row) {
+            var delete_url = detail_url + '/delete';
+            var data = {'username': username}
+            $.post(delete_url, data).done(function() {row.remove()})
+                .fail(function(jqXHR, status, error) {
+                    log_error('Error removing user ' + username + 
+                              ' from cohort. ' + status + ' ' + error);
+                });
+        }
+
+        function add_to_users_list(item) {
+            var tr = $('<tr><td class="name"></td><td class="username"></td>' + 
+                       '<td class="email"></td>' + 
+                       '<td class="remove"></td></tr>');
+            var current_cohort_id = cohort_id;
+
+            $(".name", tr).text(item.name);
+            $(".username", tr).text(item.username);
+            $(".email", tr).text(item.email);
+
+            $(".remove", tr).html('<a href="#">remove</a>')
+                .click(function() { 
+                    remove_user_from_cohort(item.username, current_cohort_id, tr);
+                    return false;
+                });
+            
+            detail_users.append(tr);
+        };
+
+                
+        function show_users(response) {
+            detail_users.html("<tr><th>Name</th><th>Username</th><th>Email</th></tr>");
+            if (response && response.success) { 
+                response.users.forEach(add_to_users_list);
+                detail_page_num.text("Page " + response.page + " of " + response.num_pages);
+            } else {
+                log_error(response.msg || 
+                          "There was an error loading users for " + cohort.title);
+            }
+            op_results.empty();
+            detail.show();
+        }
+            
+
+        function added_users(response) {
+            op_results.empty();
+            if (response && response.success) {
+                function add_to_list(text, color) {
+                    op_results.append($("<li/>").text(text).css("color", color));
+                }
+                response.added.forEach(
+                    function(item) {
+                        add_to_list(
+                            "Added: " + item.name + ", " + item.username + ", " + item.email,
+                            "green"
+                        );
+                    }
+                );
+                response.changed.forEach(
+                    function(item) {
+                        add_to_list(
+                            "Moved from cohort " + item.previous_cohort + ": " + item.name + ", " + item.username + ", " + item.email,
+                            "purple"
+                        )
+                    }
+                );
+                response.present.forEach(
+                    function(item) {
+                        add_to_list("Already present: " + item, "black");
+                    }
+                );
+                response.unknown.forEach(
+                    function(item) {
+                        add_to_list("Unknown user: " + item, "red")
+                    }
+                );
+                users_area.val('')
+            } else {
+                log_error(response.msg || "There was an error adding users");
+            }                
+        }
+
+        // ******* Rendering
+
+            
+        function render() {
+            // Load and render the right thing based on the state
+             
+            // start with both divs hidden
+            summary.hide();
+            detail.hide();
+            // and clear out the errors
+            errors.empty();
+            if (state == state_summary) {
+                $.ajax(url).done(load_cohorts).fail(function() {
+                    log_error("Error trying to load cohorts");
+                });
+            } else if (state == state_detail) {
+                detail_header.text("Members of " + cohort_title);
+                $.ajax(detail_url).done(show_users).fail(function() {
+                    log_error("Error trying to load users in cohort");
+                });
+            }
+        }
+
+        show_cohorts_button.click(function() { 
+            state = state_summary;
+            render();
+            return false;
+        });
+        
+        add_cohort_input.change(function() {
+            if (!$(this).val()) {
+                add_cohort_button.removeClass('button').addClass('button-disabled');
+            } else {
+                add_cohort_button.removeClass('button-disabled').addClass('button');
+            }
+        });
+
+        add_cohort_button.click(function() { 
+            var add_url = url + '/add';
+            data = {'name': add_cohort_input.val()}
+            $.post(add_url, data).done(added_cohort);
+            return false;
+        });
+
+        add_members_button.click(function() { 
+            var add_url = detail_url + '/add';
+            data = {'users': users_area.val()}
+            $.post(add_url, data).done(added_users);
+            return false;
+        });
+
+
+    };
+
+    // prototype
+    module.prototype = {
+        constructor: module,
+    };
+
+    // return module
+    return module;
+})(jQuery);
+
+$(window).load(function () {
+    var my_module = new CohortManager();
+})
+

pool/shard011/JavaScript/0070325_tr.js

@@ -0,0 +1,51 @@
+var catw = require('../');
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var tmpdir = os.tmpdir || os.tmpDir;
+var mkdirp = require('mkdirp');
+var concat = require('concat-stream');
+var through = require('through');
+
+test('source transform', function (t) {
+    t.plan(4);
+    var dir = path.join(tmpdir(), 'cat-watch-test-exec', Math.random()+'');
+    mkdirp.sync(dir);
+    
+    fs.writeFileSync(path.join(dir, 'beep.txt'), 'beep');
+    fs.writeFileSync(path.join(dir, 'boop.txt'), 'boop');
+    
+    var cat = catw(path.join(dir, '*.txt'), {
+        transform: function (file) {
+            if (path.basename(file) !== 'beep.txt') return through();
+            return through(write);
+            function write (buf) {
+                this.queue(buf.toString('utf8').toUpperCase());
+            }
+        }
+    });
+    t.on('end', function () { cat.close() });
+    var expected = [ 'BEEPboop', 'BEEP boop', 'BEEP boop!', 'BEEP boop!!!' ];
+    
+    cat.on('stream', function (stream) {
+        stream.pipe(concat(function (body) {
+            t.equal(body.toString('utf8'), expected.shift());
+            setTimeout(nextUpdate, 100);
+        }));
+    });
+    
+    var updates = [
+        [ 'beep.txt', 'beep ' ],
+        [ 'boop.txt', 'boop!' ],
+        [ 'c.txt', '!!' ]
+    ];
+    
+    function nextUpdate () {
+        if (updates.length === 0) return;
+        var file = updates.shift();
+        fs.writeFile(path.join(dir, file[0]), file[1], function (err) {
+            if (err) return t.fail(err)
+        });
+    }
+});

pool/shard011/JavaScript/0070328_params.js

@@ -0,0 +1,171 @@
+/**
+ *
+ * ProjectName：blogme
+ * Description：
+ * Created by qimuyunduan on 16/4/13 .
+ * Revise person：qimuyunduan
+ * Revise Time：16/4/13 下午3:27
+ * @version
+ *
+ */
+var _              = require('lodash'),
+	Promise        = require('bluebird'),
+	errors         = require('../errors'),
+	utils          = require('../utils'),
+	events         = require('../events'),
+	appBookshelf   = require('./base'),
+	validator      = require('validator'),
+	param,
+	params;
+
+param = appBookshelf.Model.extend({
+
+	tableName: ' params ',
+
+	saving: function saving() {
+
+		var self = this;
+
+	},
+
+	validate: function validate() {
+
+	},
+
+	toJSON: function toJSON(options) {
+		options = options || {};
+
+		var attrs = appBookshelf.Model.prototype.toJSON.call(this, options);
+		// remove password hash for security reasons
+		delete attrs.password;
+
+		if (!options || !options.context || (!options.context.user && !options.context.internal)) {
+			delete attrs.email;
+		}
+
+		return attrs;
+	},
+
+	format: function format(options) {
+		if (!_.isEmpty(options.website) &&
+			!validator.isURL(options.website, {
+				require_protocol: true,
+				protocols: ['http', 'https']})) {
+			options.website = 'http://' + options.website;
+		}
+		return appBookshelf.Model.prototype.format.call(this, options);
+	},
+
+	findOne: function findOne(data, options) {
+
+	},
+
+	edit: function edit(data, options) {
+
+	},
+
+	add: function add(data, options) {
+
+	},
+
+	// Finds the user by email, and checks the password
+	check: function check(object) {
+
+	},
+
+	changePassword: function changePassword(object, options) {
+
+	},
+
+	generateResetToken: function generateResetToken(email, expires, dbHash) {
+		return this.getByEmail(email).then(function then(foundUser) {
+			if (!foundUser) {
+				return Promise.reject(new errors.NotFoundError('errors.models.user.noUserWithEnteredEmailAddr'));
+			}
+
+			var hash = crypto.createHash('sha256'),
+				text = '';
+
+			// Token:
+			// BASE64(TIMESTAMP + email + HASH(TIMESTAMP + email + oldPasswordHash + dbHash ))
+			hash.update(String(expires));
+			hash.update(email.toLocaleLowerCase());
+			hash.update(foundUser.get('password'));
+			hash.update(String(dbHash));
+
+			text += [expires, email, hash.digest('base64')].join('|');
+			return new Buffer(text).toString('base64');
+		});
+	},
+
+	validateToken: function validateToken(token, dbHash) {
+
+		var tokenText = new Buffer(token, 'base64').toString('ascii'),
+			parts,
+			expires,
+			email;
+
+		parts = tokenText.split('|');
+
+		// Check if invalid structure
+		if (!parts || parts.length !== 3) {
+			return Promise.reject(new errors.BadRequestError('errors.models.user.invalidTokenStructure'));
+		}
+
+		expires = parseInt(parts[0], 10);
+		email = parts[1];
+
+		if (isNaN(expires)) {
+			return Promise.reject(new errors.BadRequestError('errors.models.user.invalidTokenExpiration'));
+		}
+
+		if (expires < Date.now()) {
+			return Promise.reject(new errors.ValidationError('errors.models.user.expiredToken'));
+		}
+
+		if (tokenSecurity[email + '+' + expires] && tokenSecurity[email + '+' + expires].count >= 10) {
+			return Promise.reject(new errors.NoPermissionError('errors.models.user.tokenLocked'));
+		}
+
+		return this.generateResetToken(email, expires, dbHash).then(function then(generatedToken) {
+			// Check for matching tokens with timing independent comparison
+			var diff = 0,
+				i;
+
+			// check if the token length is correct
+			if (token.length !== generatedToken.length) {
+				diff = 1;
+			}
+
+			for (i = token.length - 1; i >= 0; i = i - 1) {
+				diff |= token.charCodeAt(i) ^ generatedToken.charCodeAt(i);
+			}
+
+			if (diff === 0) {
+				return email;
+			}
+
+			tokenSecurity[email + '+' + expires] = {
+				count: tokenSecurity[email + '+' + expires] ? tokenSecurity[email + '+' + expires].count + 1 : 1
+			};
+			return Promise.reject(new errors.BadRequestError('errors.models.user.invalidToken'));
+		});
+	},
+
+});
+
+params = appBookshelf.Collection.extend({
+	model:param
+});
+
+module.exports = {
+	param:{
+		model: function(){
+			return param;
+		},
+		collection:function(){
+			return params;
+		}
+	}
+
+};

pool/shard011/JavaScript/0070330_idempotency.spec.js

@@ -0,0 +1,156 @@
+import { markdownToDraft, draftToMarkdown } from '../src/index';
+
+/*
+ * Note: These tests are to make sure markdown to draft and then back to markdown have the exact same value before-and-after
+ *
+ * However, there are some cases where this will not be possible -
+ * For example, this is valid in draftjs:
+ * _I am italic content with a space included at the end _
+ * but markdown will struggle with this so we need to convert it to:
+ * _I am italic content with a space after the closing italic symbol instead of before_
+ * The end result should basically look the same to a human, but behind the scenes it has to be a bit different.
+ *
+ * Still, for the most part results should match, so these tests are for cases when they _should_ match.
+*/
+
+describe('idempotency', function () {
+
+  it('renders new lines text correctly', function () {
+    var markdownString = 'Test\n\n\nHello There\n\nSmile\n\n\n\n\n\n\n\nYep Hi';
+    var draftJSObject = markdownToDraft(markdownString, {preserveNewlines: true});
+    var markdownFromDraft = draftToMarkdown(draftJSObject, {preserveNewlines: true});
+
+    expect(markdownFromDraft).toEqual(markdownString);
+
+    markdownString = 'a\nb\n\nc\n\n\nd';
+    draftJSObject = markdownToDraft(markdownString, {preserveNewlines: true});
+    markdownFromDraft = draftToMarkdown(draftJSObject, {preserveNewlines: true});
+
+    expect(markdownFromDraft).toEqual(markdownString);
+
+    markdownString = '\n\na';
+    draftJSObject = markdownToDraft(markdownString, {preserveNewlines: true});
+    markdownFromDraft = draftToMarkdown(draftJSObject, {preserveNewlines: true});
+    expect(markdownFromDraft).toEqual(markdownString);
+
+  });
+
+  it('renders new lines text correctly with styled blocks', function () {
+    var markdownString = '# Test\n\n\nHello There\n\nSmile\n\n\n\n\n\n\n\nYep Hi';
+    var draftJSObject = markdownToDraft(markdownString, {preserveNewlines: true});
+    var markdownFromDraft = draftToMarkdown(draftJSObject, {preserveNewlines: true});
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it ('renders preserved new lines after list correctly', function () {
+    var markdown = '- unordered item\n\n\n1. ordered item\n\n\nparagraph'
+    var rawDraftConversion = markdownToDraft(markdown, {preserveNewlines: true });
+    var markdownConversion = draftToMarkdown(rawDraftConversion, {preserveNewlines: true});
+
+    expect(markdownConversion).toEqual(markdown);
+  });
+
+  it('renders blockquotes correctly', function () {
+    var markdownString = '> Hello I am Blockquote\n\nI am not\n\n> I am';
+    var draftJSObject = markdownToDraft(markdownString, {preserveNewlines: true});
+    var markdownFromDraft = draftToMarkdown(draftJSObject, {preserveNewlines: true});
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders italic text correctly', function () {
+    var markdownString = '_I am italic_ …I am not italic.';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders bold text correctly', function () {
+    var markdownString = 'Hello **I am bold** I am not bold.';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders nested styles correctly', function () {
+    var markdownString = '**bold** _italic_ test **bold _italic_** _italic_ _italic **bold** italic **bold italic**_';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders inline code correctly', function () {
+    var markdownString = 'Test `here is some inline code`';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders code fences correctly', function () {
+    var markdownString = '```\nHello I am Codefence\n```';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders blockquotes correctly', function () {
+    var markdownString = '> Hello I am Blockquote';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  // TODO this test should pass but markdown-to-draft doesn’t correctly create empty markdown blocks in this case currently.
+  xit('renders blockquotes with blank lines correctly', function () {
+    var markdownString = '> Hello I am Blockquote\n> more\n> \n> \n> hey';
+    var draftJSObject = markdownToDraft(markdownString);
+    var markdownFromDraft = draftToMarkdown(draftJSObject);
+
+    expect(markdownFromDraft).toEqual(markdownString);
+  });
+
+  it('renders links correctly', function () {
+    var markdown = 'This is a test of [a link](https://google.com)\n\nAnd [perhaps](https://facebook.github.io/draft-js/) we should test once more.';
+    var rawDraftConversion = markdownToDraft(markdown);
+    var markdownConversion = draftToMarkdown(rawDraftConversion);
+
+    expect(markdownConversion).toEqual(markdown);
+  });
+
+  it ('renders codeblock with syntax correctly', function () {
+    var markdown = '```javascript\nsingle line codeblock\n```';
+    var rawDraftConversion = markdownToDraft(markdown);
+    var markdownConversion = draftToMarkdown(rawDraftConversion);
+    expect(markdownConversion).toEqual(markdown);
+  });
+
+  it('renders "the kitchen sink" correctly', function () {
+    var markdown = '# Hello!\n\nMy name is **Rose** :)\nToday, I\'m here to talk to you about how great markdown is!\n\n## First, here\'s a few bullet points:\n\n- One\n- Two\n- Three\n\n```\nA codeblock\n```\n\nAnd then... `some monospace text`?\nOr... _italics?_';
+    var rawDraftConversion = markdownToDraft(markdown);
+    var markdownConversion = draftToMarkdown(rawDraftConversion);
+
+    expect(markdownConversion).toEqual(markdown);
+  });
+
+  it ('renders escaped italics correctly', function () {
+    var markdown = 'test \\_not italic\\_ test';
+    var rawDraftConversion = markdownToDraft(markdown);
+    var markdownConversion = draftToMarkdown(rawDraftConversion);
+
+    expect(markdownConversion).toEqual(markdown);
+  });
+
+  it ('renders escaped bold correctly', function () {
+    var markdown = 'test \\*\\*not italic\\*\\* test';
+    var rawDraftConversion = markdownToDraft(markdown);
+    var markdownConversion = draftToMarkdown(rawDraftConversion);
+
+    expect(markdownConversion).toEqual(markdown);
+  });
+});

pool/shard011/JavaScript/0070333_a.js

@@ -0,0 +1,26 @@
+/**
+ * 2017-9-16   sunzhiyue
+ */
+var b = function(){
+
+};
+b.arr = [1, 2, 3, 4, 5];
+b.obj = {
+    name : 'wan',
+    age : 18,
+    car : true
+}
+b.fun = function(){
+    console.log('fun');
+}
+
+Object.defineProperty(b,'len',{
+    enumerable: true,
+    configurable: false,
+    get: function() { return this.arr.length; }
+}
+
+)
+b.arr.length = 10;
+console.log(b.len);
+console.log(b.obj.len);

pool/shard011/JavaScript/0070334_script.js

@@ -0,0 +1,12 @@
+var onlyUniques = (...args) => {
+  let array = [];
+  for (let i = 0; i < args.length; i++) {
+    if (!array.includes(args[i])) {
+      array.push(args[i]);
+    }
+  }
+  return array;
+};
+
+console.log(onlyUniques("cat", "cat", "dog", "pig")); //['cat', 'dog', 'pig']
+console.log(onlyUniques(1, 4, 7, 1, 2, 7, 4)); //[1, 4, 7, 2]

pool/shard011/JavaScript/0070335_express.js

@@ -0,0 +1,102 @@
+var Q = require('q'),
+    pkg = require('../package.json'),
+
+    express = require('express'),
+    consolidate = require('consolidate'),
+    morgan = require('morgan'),
+    compression = require('compression'),
+    finalhandler = require('finalhandler'),
+    colors = require('colors/safe'),
+    http = require('http'),
+    env = require('./env.js');
+
+
+// ----------------------------------------------------------------------------
+
+
+console.log(colors.underline(pkg.name) + ' v' + pkg.version + ' starting up...');
+
+Q.when(makeApp()).then(function(app) {
+
+  var server = http.createServer(app),
+      port = env('expressPort');
+
+  server.listen(port, '0.0.0.0', function () {
+    console.info(colors.blue('listening on port %s'), port);
+  });
+
+});
+
+
+// ----------------------------------------------------------------------------
+
+
+morgan.token('ms', function (req, res){
+  if (!res._header || !req._startAt) { return ''; }
+  var diff = process.hrtime(req._startAt);
+  var ms = diff[0] * 1e3 + diff[1] * 1e-6;
+  return Math.ceil(ms)+'ms';
+});
+
+function render404 (req, res) {
+  finalhandler(req, res)(false);
+}
+
+
+function makeApp () {
+
+  var app = express(),
+      log = morgan( ':method :url :ms :status' );
+
+  app.engine('html', consolidate.lodash);
+  app.set('view engine', 'html');
+  app.set('views', __dirname);
+
+
+  // middleware stack starts here
+  app.use(compression());
+
+  app.get('/robots.txt', [
+    log,
+    function (req, res) {
+      res.type('text/plain');
+      res.send('User-agent: *\nDisallow: /');
+    }
+  ]);
+
+
+  app.use('/api/foo', [
+    log,
+    function (req, res, next) {
+      var d = parseInt(req.query.delay, 10);
+      if(d>0) { setTimeout(next, Math.min(d,10) * 1000); }
+      else next();
+    },
+    render404
+  ]);
+
+  // serve the api
+  app.use('/api', [
+    log,
+    require('./api/index.js'),
+    render404
+  ]);
+
+  // any other path, serve 404
+  app.all('*', [
+    log,
+    render404
+  ]);
+
+  var mongo = require('./mongo.js');
+
+  if(mongo.connection.readyState === 1) {
+    return app;
+  }
+  else {
+    return Q.ninvoke(mongo.connection, 'once', 'connected').then(function() {
+      return app;
+    });
+  }
+
+}

pool/shard011/JavaScript/0070336_index.js

@@ -0,0 +1,55 @@
+import React, { Fragment } from 'react';
+import PropTypes from 'prop-types';
+import { connect } from 'react-redux';
+import { createStructuredSelector } from 'reselect';
+
+import { titleCase, truncate } from 'voca';
+
+import { selectPrimaryMeaning, selectSecondaryMeanings } from 'features/reviews/selectors';
+
+import { PrimaryMeaning, SecondaryMeanings } from './styles';
+
+VocabMeaning.propTypes = {
+  primaryMeaning: PropTypes.string.isRequired,
+  secondaryMeanings: PropTypes.arrayOf(PropTypes.string),
+  shouldTruncate: PropTypes.bool,
+  showSecondary: PropTypes.bool,
+  renderPrimary: PropTypes.func,
+  renderSecondary: PropTypes.func,
+};
+
+VocabMeaning.defaultProps = {
+  secondaryMeanings: [],
+  showSecondary: true,
+  shouldTruncate: false,
+  renderPrimary: ({ text }) => <PrimaryMeaning>{text}</PrimaryMeaning>, // eslint-disable-line react/prop-types
+  renderSecondary: ({ text }) => text && <SecondaryMeanings>{text}</SecondaryMeanings>, // eslint-disable-line react/prop-types
+};
+
+function VocabMeaning({
+  primaryMeaning,
+  secondaryMeanings,
+  shouldTruncate,
+  showSecondary,
+  renderPrimary,
+  renderSecondary,
+}) {
+  const noSplit = ["'"];
+  let secondaryText = secondaryMeanings.join(', ');
+  secondaryText = truncate(secondaryText, shouldTruncate ? 30 : secondaryText.length);
+  return (
+    <Fragment>
+      {renderPrimary({ text: titleCase(primaryMeaning, noSplit) })}
+      {showSecondary &&
+        !!secondaryText.length &&
+        renderSecondary({ text: titleCase(secondaryText, noSplit) })}
+    </Fragment>
+  );
+}
+
+const mapStateToProps = createStructuredSelector({
+  primaryMeaning: selectPrimaryMeaning,
+  secondaryMeanings: selectSecondaryMeanings,
+});
+
+export default connect(mapStateToProps)(VocabMeaning);

pool/shard011/JavaScript/0070337_utils.js

@@ -0,0 +1,135 @@
+export class VisibilityTracker {
+  constructor(
+    {ratioThreshold = 0.9, durationThreshold = 2, upperDurationThreshold = 1800} = {},
+    onFlush = () => {}
+  ) {
+    this.components = {};
+    this.groups = {};
+    this.ratioThreshold = ratioThreshold;
+    this.durationThreshold = durationThreshold;
+    // Upper duration threshold should remove any cases where the page is left
+    // open and forgotten
+    this.upperDurationThreshold = upperDurationThreshold;
+
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden') {
+        this.stopAndFlush(onFlush);
+      } else if (document.visibilityState === 'visible') {
+        this.restart();
+      }
+    });
+  }
+
+  update(comp, entry) {
+    let screenCoveredRatio = 0;
+    if (entry.rootBounds && entry.rootBounds.height !== 0) {
+      const rootArea = entry.rootBounds.height * entry.rootBounds.width;
+      const cardArea = entry.boundingClientRect.height * entry.boundingClientRect.width;
+      screenCoveredRatio = 1 - (rootArea - (cardArea * entry.intersectionRatio)) / rootArea;
+    }
+
+    // Update or add the component
+    if (!this.components[comp.$meta.uid]) {
+      this.components[comp.$meta.uid] = {}
+    }
+    const compData = this.components[comp.$meta.uid];
+    compData.component = comp;
+    compData.intersectionRatio = entry.intersectionRatio;
+    compData.screenCoveredRatio = screenCoveredRatio;
+    compData.isVisible = this.isCompVisible(comp);
+    
+    const group = comp.$meta.group;
+    if (!group) return;
+
+    // Group the component
+    if (!this.groups[group.$meta.uid]) {
+      const components = this.components;
+      this.groups[group.$meta.uid] = {
+        tag: group.$meta.tag,
+        components: [],
+        get isVisible() {
+          return this.components.some((uid) => components[uid].isVisible);
+        },
+      };
+    }
+    if (
+      this.groups[group.$meta.uid].components.indexOf(comp.$meta.uid) === -1
+    ) {
+      this.groups[group.$meta.uid].components.push(comp.$meta.uid);
+    }
+
+    const timer = this.updateGroupTimer(group);
+    const duration = (Date.now() - timer) / 1000;
+    
+    return {
+      report: (
+        !this.groups[group.$meta.uid].isVisible &&
+        timer &&
+        duration >= this.durationThreshold &&
+        duration < this.upperDurationThreshold
+      ),
+      tag: group.$meta.tag,
+      duration: duration,
+    };
+  }
+
+  isCompVisible(comp) {
+    let onScreen = false;
+    const componentData = this.components[comp.$meta.uid];
+
+    // Report if the component it is mostly visible
+    if (componentData.intersectionRatio > this.ratioThreshold) {
+      onScreen = true;
+    }
+
+    // Covers the most screen space
+    onScreen = onScreen || (Object.values(this.components).every(
+      (comp) => comp.screenCoveredRatio <= componentData.screenCoveredRatio,
+    ) && componentData.screenCoveredRatio > 0.1);
+
+    return onScreen;
+  }
+
+  updateGroupTimer(group) {
+    const groupData = this.groups[group.$meta.uid];
+
+    let timer = null;
+    if (groupData.isVisible) {
+      if (!groupData.timer) {
+        groupData.timer = Date.now();
+      }
+      timer = groupData.timer;
+    } else {
+      timer = groupData.timer;
+      groupData.timer = null;
+    }
+
+    return timer;
+  }
+
+  stopAndFlush(callbackfn) {
+    Object.values(this.groups)
+      .filter((groupData) => groupData.isVisible)
+      .forEach((groupData) => {
+        const duration = (Date.now() - groupData.timer ?? Date.now()) / 1000;
+
+        groupData.stopped = true;
+        groupData.timer = null;
+
+        callbackfn({
+          report: duration >= this.durationThreshold && duration < this.upperDurationThreshold,
+          tag: groupData.tag,
+          duration: duration,
+        });
+      });
+  }
+
+  restart() {
+    Object.values(this.groups)
+      .filter((groupData) => groupData.stopped)
+      .forEach((groupData) => {
+        groupData.stopped = false;
+        groupData.timer = Date.now();
+      });
+  }
+}

pool/shard011/JavaScript/0070338_cMosca.js

@@ -0,0 +1,114 @@
+/**
+ * Created by stitchcula on 2016/9/4.
+ */
+
+import mosca from 'mosca'
+
+export default class Mosca {
+    constructor(mongo){
+        this.mongo=mongo
+        var ascoltatore={
+            type:'redis',
+            redis:require('redis'),
+            host:process.env['REDIS_HOST'],
+            port:process.env['REDIS_PORT'],
+            password:process.env['REDIS_AUTH'],
+            return_buffers:true
+        }
+        this.settings={
+            port:1883,
+            backend:ascoltatore,
+            persistence:{
+                factory: mosca.persistence.Redis,
+                host:process.env['REDIS_HOST'],
+                port:process.env['REDIS_PORT'],
+                password:process.env['REDIS_AUTH']
+            }
+        }
+    }
+    listen(port){
+        if(port) this.settings.port=port
+        this.server = new mosca.Server(this.settings)
+        this.server.on('ready',this.onReady.bind(this))
+        this.server.on('published',this.onPublished.bind(this))
+        this.server.on("clientDisconnected",this.onDisconnected.bind(this))
+    }
+    async onReady(){
+        this.server.authenticate =async function(client, obj, token, callback) {//online login
+            token=token.toString()
+            if(obj&&token) {
+                var {uin,device_id}=JSON.parse(obj)
+                var res =uin?(await this.mongo.collection("users").findOne({token, uin})):
+                    (await this.mongo.collection("users").findOne({token, device_id}))
+                if (res) {
+                    await this.mongo.collection("online_list")
+                        .insertOne({session: client.id, uin,device_id, time: new Date().getTime()})
+                    /*
+                    if(uin)//用户接入的时候报告设备状态
+                        setTimeout(function () {
+                            this.server.publish({
+                                topic: "$SMTH/" + device_id + "/ONLINE",
+                                payload: res.uin,
+                                qos: 1, retain: false
+                            })}.bind(this), 1000)
+                    else//设备一上线就通知用户
+                        this.server.publish({
+                            topic: "$SMTH/" + device_id + "/ONLINE",
+                            payload: res.uin,
+                            qos: 1, retain: false
+                        })
+                        */
+                    callback(null, true);
+                } else
+                    callback(null, false);
+            }
+        }.bind(this)
+        this.server.authorizePublish=function (client, topic, payload, callback) {
+            console.log("authorizePublish:"+client.id)
+            callback(null,true)
+        }
+        this.server.authorizeSubscribe=function (client, topic, callback) {
+            console.log("authorizeSubscribe:"+client.id)
+            callback(null,true)
+        }
+        console.log("MQTT broker is running at "+new Date())
+    }
+    async onPublished(packet){
+        //Topic->device id or user uin
+        //node_id->modules id or user token
+        //node_type->modules or USER
+        //msg_type->data/notice
+        if(packet.topic.split('/')[0]!="$SMTH"||packet.topic.split('/')[2])
+            return
+        var {node_id,node_type,msg_type,msg_id,msg_c}=JSON.parse(packet.payload.toString())
+        console.log(packet.topic+":"+node_id+
+            " SEND "+JSON.stringify({node_type,msg_type,msg_id,msg_c})+
+            " at "+new Date())
+        if(node_type=="USER"){//User->Edison
+            //todo:
+            //user's order, save to db
+        }else{//Edison->User
+            //save to db
+            //device's data or notice, if it's notice,user sure response.
+            await this.mongo.collection("publish_msg")
+                .insertOne({uin:packet.topic,node_id,node_type,msg_type,msg_id,msg_c})
+            if(msg_type=="NOTICE"){
+                this.server.publish({
+                    topic:packet.topic+"/NOTICE",
+                    payload:packet.payload,
+                    qos:1,retain:false
+                })
+            }
+        }
+    }
+    async onDisconnected(client){//offline logout
+        var res=await this.mongo.collection("online_list")
+            .removeOne({session:client.id})
+        /*
+        this.server.publish({topic:"$SMTH/"+res.device_id+"/OFFLINE",
+            payload:packet.payload,
+            qos:1,retain:false})
+            */
+        console.log(res.result)
+    }
+}

pool/shard011/JavaScript/0070339_main-resource-test.js

@@ -0,0 +1,74 @@
+/**
+ * @license Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+
+/* eslint-env jest */
+
+const Runner = require('../../../runner.js');
+const assert = require('assert');
+
+describe('MainResource computed artifact', () => {
+  let computedArtifacts;
+
+  beforeEach(() => {
+    computedArtifacts = Runner.instantiateComputedArtifacts();
+  });
+
+  it('returns an artifact', () => {
+    const record = {
+      url: 'https://example.com',
+    };
+    const networkRecords = [
+      {url: 'http://example.com'},
+      record,
+    ];
+    computedArtifacts.requestNetworkRecords = _ => Promise.resolve(networkRecords);
+    const URL = {finalUrl: 'https://example.com'};
+
+    return computedArtifacts.requestMainResource({URL}).then(output => {
+      assert.equal(output, record);
+    });
+  });
+
+  it('thows when main resource can\'t be found', () => {
+    const networkRecords = [
+      {url: 'https://example.com'},
+    ];
+    computedArtifacts.requestNetworkRecords = _ => Promise.resolve(networkRecords);
+    const URL = {finalUrl: 'https://m.example.com'};
+
+    return computedArtifacts.requestMainResource({URL}).then(() => {
+      assert.ok(false, 'should have thrown');
+    }).catch(err => {
+      assert.equal(err.message, 'Unable to identify the main resource');
+    });
+  });
+
+  it('should identify correct main resource in the wikipedia fixture', () => {
+    const wikiDevtoolsLog = require('../../fixtures/wikipedia-redirect.devtoolslog.json');
+    const URL = {finalUrl: 'https://en.m.wikipedia.org/wiki/Main_Page'};
+    const artifacts = {devtoolsLog: wikiDevtoolsLog, URL};
+
+    return computedArtifacts.requestMainResource(artifacts).then(output => {
+      assert.equal(output.url, 'https://en.m.wikipedia.org/wiki/Main_Page');
+    });
+  });
+
+  it('should identify correct main resource with hash URLs', () => {
+    const networkRecords = [
+      {url: 'https://beta.httparchive.org/reports'},
+      {url: 'https://beta.httparchive.org/reports/state-of-the-web'},
+    ];
+
+    computedArtifacts.requestNetworkRecords = _ => Promise.resolve(networkRecords);
+    const URL = {finalUrl: 'https://beta.httparchive.org/reports/state-of-the-web#pctHttps'};
+    const artifacts = {URL};
+
+    return computedArtifacts.requestMainResource(artifacts).then(output => {
+      assert.equal(output.url, 'https://beta.httparchive.org/reports/state-of-the-web');
+    });
+  });
+});

pool/shard011/JavaScript/0070340_WFSService.js

@@ -0,0 +1,167 @@
+/**
+ * WFSService handles rendering of all wfs layers onto the map
+ * @module map
+ * @class WFSService
+ * 
+ */
+allModules.service('WFSService',['$rootScope','GoogleMapService','LayerManagerService','Constants','GetWFSRelatedService','GMLParserService','QuerierPanelService','RenderStatusService','UtilitiesService','NVCLService',
+                                 function ($rootScope,GoogleMapService,LayerManagerService,Constants,GetWFSRelatedService,GMLParserService,QuerierPanelService,RenderStatusService,UtilitiesService,NVCLService) {
+   
+        /**
+        * Render a point data to the map 
+        * @method renderPoint
+        * @param point - the point to render
+        * @param map - The map where the point is to be rendered
+        */  
+        this.renderPoint = function(point,map){                     
+            var marker = new google.maps.Marker({
+                position:point.coords,
+                map: map,
+                title: point.name
+            });
+            
+            marker.addListener('click', function() {
+                // Ask the map to display a loading mask
+                GoogleMapService.busyStart();
+                
+                // Invoke core tray image carousel
+                if (point.featureNode.nodeName=='gsml:Borehole') {
+                    QuerierPanelService.setCarouselBusy(true);
+                    NVCLService.getCoreDisplay(point.description, point.featureNode.nodeName, point.name);
+                }
+                
+                // Set data for the query panel and display it
+                var displayable = QuerierPanelService.setPanelNode(point.featureNode, "Feature", "WFS", false);
+                if (displayable) {
+                    QuerierPanelService.openPanel(true);
+                }
+                
+                // Ask the map to dissolve the loading mask
+                GoogleMapService.busyEnd();
+            });
+           return marker;
+       };
+       
+       /**
+        * Render a LINESTRING data to the map 
+        * @method renderLineString
+        * @param linestring - the linestring to render
+        * @param map - The map where the point is to be rendered
+        */  
+       this.renderLineString = function(linestring,map){
+           
+       };
+       
+       /**
+        * Render a POLYGON data to the map 
+        * @method renderPolygon
+        * @param polygon - the polygon to render
+        * @param map - The map where the point is to be rendered
+        */
+       this.renderPolygon = function(polygon,map){
+           
+       };   
+ 
+        /**
+         * Method to decide how the wfs layer should be rendered and add the wfs to the map 
+         * @method renderLayer
+         * @param layer - The layer containing the wfs to be rendered
+         */
+        this.renderLayer = function(layer,param){   
+            var map =  GoogleMapService.getMap();            
+            var me = this;
+            var onlineResources = LayerManagerService.getWFS(layer);
+            RenderStatusService.setMaxValue(layer,onlineResources.length);
+            for(var index in onlineResources){
+                
+                if(UtilitiesService.filterProviderSkip(param.optionalFilters, onlineResources[index].url)){
+                    RenderStatusService.updateCompleteStatus(layer,onlineResources[index],Constants.statusProgress.SKIPPED);
+                    continue;
+                }
+                
+                RenderStatusService.updateCompleteStatus(layer,onlineResources[index],Constants.statusProgress.RUNNING);
+                
+                GetWFSRelatedService.getFeature(layer, onlineResources[index],param).then(function(response){
+                    try{
+                        var rootNode = GMLParserService.getRootNode(response.data.gml);
+                        var primitives = GMLParserService.makePrimitives(rootNode);
+                        
+                        RenderStatusService.updateCompleteStatus(layer,response.resource,Constants.statusProgress.COMPLETED);
+                        
+                        for(var key in primitives){
+                            switch(primitives[key].geometryType){
+                                case Constants.geometryType.POINT:
+                                    GoogleMapService.addMarkerToActive(layer.id,me.renderPoint(primitives[key],map));
+                                    break;
+                                case Constants.geometryType.LINESTRING:
+                                    me.renderLineString(primitives[key],map);
+                                    break;
+                                case Constants.geometryType.POLYGON:
+                                    me.renderPolygon(primitives[key],map);
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }catch(err){
+                        RenderStatusService.updateCompleteStatus(layer,response.resource,Constants.statusProgress.ERROR); 
+                    }
+                   
+
+                },function(error){
+                    RenderStatusService.updateCompleteStatus(layer,error.onlineResource,Constants.statusProgress.ERROR);
+                });
+          
+            }
+            
+        };
+        
+        /**
+         * Method to decide how the wfs resource should be rendered and add the wfs to the map 
+         * @method renderResource
+         * @param resource - The resource containing the wfs to be rendered
+         */
+        this.renderCSWRecord = function(layer,cswRecord){   
+            var map =  GoogleMapService.getMap();            
+            var me = this;
+            var onlineResources = LayerManagerService.getWFSFromCSW(cswRecord);
+            RenderStatusService.setMaxValue(layer,onlineResources.length);
+                        
+            
+            for(var index in onlineResources){
+                RenderStatusService.updateCompleteStatus(layer,onlineResources[index],Constants.statusProgress.RUNNING);
+                GetWFSRelatedService.getFeature(layer, onlineResources[index]).then(function(response){
+                    try{
+                        var rootNode = GMLParserService.getRootNode(response.data.gml);
+                        var primitives = GMLParserService.makePrimitives(rootNode);
+                        
+                        RenderStatusService.updateCompleteStatus(layer,response.resource,Constants.statusProgress.COMPLETED);
+                        
+                        for(var key in primitives){
+                            switch(primitives[key].geometryType){
+                                case Constants.geometryType.POINT:
+                                    GoogleMapService.addMarkerToActive(layer.id,me.renderPoint(primitives[key],map));
+                                    break;
+                                case Constants.geometryType.LINESTRING:
+                                    me.renderLineString(primitives[key],map);
+                                    break;
+                                case Constants.geometryType.POLYGON:
+                                    me.renderPolygon(primitives[key],map);
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }catch(err){
+                        RenderStatusService.updateCompleteStatus(layer,response.resource,Constants.statusProgress.ERROR); 
+                    }
+                    
+                },function(error){
+                    RenderStatusService.updateCompleteStatus(layer,error.onlineResource,Constants.statusProgress.ERROR);
+                });
+            }
+            
+        };
+    
+     
+}]);

pool/shard011/JavaScript/0070341_routes.js

@@ -0,0 +1,57 @@
+(function() {
+  var nextId = 0;
+  var people = [
+    {
+      "id": "" + (nextId++),
+      "name": "Saasha",
+      "age": "6"
+    }, {
+      "id": "" + (nextId++),
+      "name": "Planet",
+      "age": "8"
+    }
+  ];
+
+  var isUniqueName = function(name) {
+    var result = people.filter(function(person) {
+      return person.name === name;
+    });
+    return result.length === 0;
+  };
+
+  module.exports = function(app, options) {
+    app.get('/', function(req, res) {
+      return res.render("" + options.base + "/index.html");
+    });
+    app.get('/people', function(req, res) {
+      return res.json(people);
+    });
+    app.post('/people', function(req, res) {
+      var age, message, name, person;
+      name = req.body.name;
+      age = req.body.age;
+      message = {
+        "title": "Duplicate!",
+        "message": "" + name + " is a duplicate.  Please enter a new name."
+      };
+      if (!isUniqueName(name)) {
+        return res.send(message, 403);
+      }
+      person = {
+        "id": "" + (nextId++),
+        "name": "" + name,
+        "age": "" + age
+      };
+      people.push(person);
+      return res.json(person);
+    });
+    return app.get('/people/:id', function(req, res) {
+      var id = req.params.id;
+      var current = people.filter(function(person)  {
+        return person.id === id;
+      });
+      return res.json(current || null);
+    });
+  };
+
+}).call(this);

pool/shard011/JavaScript/0070344_worker.js

@@ -0,0 +1,53 @@
+var CACHE_NAME = 'pwa-zero-inside';
+var urlsToCache = [
+    '/',
+    'static',
+    'images/myProfile.jpg',
+    'images/portfolio/gponbot/web-home.png',
+    'images/portfolio/pettracker/IMG_20200530_181223.jpg',
+    'images/portfolio/shap/IMG_2020-11-30-20-36-25-499.jpg',
+    'images/portfolio/watermonitoring/ss1.png'
+];
+
+// Install a service worker
+self.addEventListener('install', event => {
+    // Perform install steps
+    event.waitUntil(
+        caches.open(CACHE_NAME)
+            .then(function(cache) {
+                console.log('Opened cache');
+                return cache.addAll(urlsToCache);
+            })
+    );
+});
+
+// Cache and return requests
+self.addEventListener('fetch', event => {
+    event.respondWith(
+        caches.match(event.request)
+            .then(function(response) {
+                    // Cache hit - return response
+                    if (response) {
+                        return response;
+                    }
+                    return fetch(event.request);
+                }
+            )
+    );
+});
+
+// Update a service worker
+self.addEventListener('activate', event => {
+    var cacheWhitelist = ['pwa-zero-inside'];
+    event.waitUntil(
+        caches.keys().then(cacheNames => {
+            return Promise.all(
+                cacheNames.map(cacheName => {
+                    if (cacheWhitelist.indexOf(cacheName) === -1) {
+                        return caches.delete(cacheName);
+                    }
+                })
+            );
+        })
+    );
+});

pool/shard011/JavaScript/0070348_not-equal-email-domain.js

@@ -0,0 +1,45 @@
+import _ from 'lodash';
+
+/**
+ * Validate email's domain to not equal to the listed domains
+ * in ruleObj.params[0]. Separate the domains using comma (,).
+ *
+ * @param val - email
+ * @param ruleObj
+ *
+ * @returns {Boolean}
+ */
+
+const validate = (val, ruleObj) => {
+  if (!val) {
+    return true;
+  }
+
+  const parts = val.split('@');
+
+  if (parts.length !== 2) {
+    // most likely not email
+    return false;
+  }
+
+  const domain = parts.pop();
+
+  if (!domain) {
+    return false;
+  }
+
+  const lowerDomain = domain.toLowerCase();
+
+  const prohibitedDomains = _.chain(ruleObj.params[0])
+    .toLower()
+    .split(',')
+    .map(domain => _.trim(domain))
+    .compact()
+    .value();
+
+  return !_.includes(prohibitedDomains, lowerDomain);
+};
+
+const message = '<%= propertyName %>\'s domain is not valid.';
+
+export default {validate, message};

pool/shard011/JavaScript/0070350_file.js

@@ -0,0 +1,262 @@
+define("widget.FileInput", ["AbilianWidget", "jquery", "FileAPI", "Hogan"], (
+  Abilian,
+  $,
+  api,
+  Hogan
+) => {
+  "use strict";
+  /**
+   * File input widget. Uses FileAPI (http://mailru.github.io/FileAPI/)
+   */
+  const defaults = {
+    fileItemTemplate: Hogan.compile(
+      '<div id="{{ uid }}" class="file-item">\n' +
+        '<span class="file-info">{{ name }} ({{ size }})</span> ' +
+        '<a class="close" href="#">&times;</a>' +
+        "\n</div>"
+    ),
+    progressTemplate:
+      '<div class="progress">' +
+      '<div class="progress-bar" role="progressbar" ' +
+      '     aria-valuenow="0" aria-valuemin="0" ' +
+      '     aria-valuemax="100" style="width: 0;">' +
+      "</div>" +
+      "</div>",
+    inputTemplate: '<input type="hidden" name="{{ name }}" />',
+    progressBarHeight: "0.2em",
+  };
+
+  function FileInput(node, options) {
+    const self = this;
+    this.currentlyUploaded = {};
+    this.options = $.extend({}, defaults, options);
+    this.form = node.parent("form");
+    this.$input = node.find(".js-fileapi-wrapper input");
+    this.$input.attr("disabled", null);
+    this.rootNode = node;
+    this.button = node.find(".js-fileapi-wrapper .btn-file");
+    this.multiple = Boolean(this.$input.attr("multiple"));
+    this.$input.attr("multiple", null);
+    this.inputName = this.$input.attr("name");
+    this.$input.attr("name", null);
+    this.listNode = node.find(".selected-files");
+
+    if (node.data("cloned")) {
+      this.listNode.empty();
+    } else {
+      this.listNode.find(".file-item-existing").each(function () {
+        self.setupExistingFileNode($(this));
+      });
+      this.listNode.find(".file-item-uploaded").each(function () {
+        self.setupFileNode($(this));
+      });
+    }
+
+    this.button.on("change", "input", this.addFiles.bind(this));
+
+    this.form.on("submit", this.onFormSubmit.bind(this));
+  }
+
+  FileInput.prototype = {
+    addFiles(evt) {
+      const self = this;
+      let files = api.getFiles(evt);
+
+      if (!this.multiple) {
+        this.listNode.empty();
+        files = files.slice(0, 1);
+      }
+
+      $(files).each(function () {
+        self.addFileNode(evt.target, this);
+      });
+    },
+
+    setupExistingFileNode(node) {
+      const button = node.find("button");
+      const unwrappedButton = button.get(0);
+      const deleted = button.data("deleted");
+
+      if (!unwrappedButton) {
+        return;
+      }
+
+      unwrappedButton.markerInputElement = $("<input>").attr({
+        type: "hidden",
+        name: button.data("name"),
+        value: button.data("value"),
+      });
+
+      if (deleted) {
+        node.append(unwrappedButton.markerInputElement);
+      }
+
+      button.on("click", { node: node }, this.onExistingNodeChange.bind(this));
+    },
+
+    setupFileNode(node) {
+      node.find("a.close").on("click", this.removeFileNode.bind(this));
+    },
+
+    addFileNode(input, file) {
+      const el = this.createFileNode(file);
+      this.setupFileNode(el);
+      this.listNode.append(el);
+      this.triggerUpload(el, file);
+    },
+
+    triggerUpload(element, file) {
+      const uid = api.uid(file);
+      this.currentlyUploaded[uid] = true;
+
+      api.upload({
+        url: Abilian.api.upload.newFileUrl,
+        headers: {
+          Accept: "application/json",
+          "X-CSRF-Token": Abilian.csrf_token,
+        },
+        files: { file: file },
+        progress: this.onFileProgress.bind(this),
+        complete: this.onFileComplete.bind(this),
+      });
+    },
+
+    removeFileNode(evt) {
+      evt.preventDefault();
+      $(evt.target).parent(".file-item").remove();
+    },
+
+    createFileNode(file) {
+      const infos = this.getFileInfos(file);
+      const el = $(this.options.fileItemTemplate.render(infos));
+      const progress = $(this.options.progressTemplate).css({
+        height: this.options.progressBarHeight,
+      });
+
+      el.append(progress);
+      return el;
+    },
+
+    getElementForFile(file) {
+      const uid = api.uid(file);
+      return $(document.getElementById(uid));
+    },
+
+    getFileInfos(file) {
+      return {
+        name: this.sanitizeFilename(file.name),
+        type: file.type,
+        size: this.humanSize(file.size),
+        uid: api.uid(file),
+      };
+    },
+
+    onExistingNodeChange(evt) {
+      const button = $(evt.target);
+      const markerInputElement = evt.target.markerInputElement;
+      const isActive = button.hasClass("active");
+
+      button.toggleClass("active");
+
+      if (isActive) {
+        button.removeClass("btn-danger");
+        button.addClass("btn-default");
+        $(markerInputElement).remove();
+      } else {
+        button.removeClass("btn-default");
+        button.addClass("btn-danger");
+        button.parent(".file-item").append(markerInputElement);
+      }
+    },
+
+    onFileProgress(evt, file, xhr, options) {
+      const progress = (evt.loaded / evt.total) * 100;
+      this.getElementForFile(file)
+        .find(".progress-bar")
+        .css({ width: `${progress}%` });
+    },
+
+    onFileComplete(err, xhr, file, options) {
+      const $el = this.getElementForFile(xhr.currentFile);
+      const uid = api.uid(xhr.currentFile);
+
+      delete this.currentlyUploaded[uid];
+
+      if (err) {
+        $el.remove();
+        alert("Echec de l'envoi du fichier!"); // FIXME: i18n
+        return;
+      }
+
+      const $input = $("<input>").attr({
+        type: "hidden",
+        name: this.inputName,
+      });
+      const responseText = xhr.responseText;
+      const result = JSON.parse(responseText);
+
+      $el.find(".progress").remove();
+      $input.val(result.handle);
+      $el.append($input);
+    },
+
+    onFormSubmit(e) {
+      if (Object.keys(this.currentlyUploaded).length > 0) {
+        e.preventDefault();
+        alert("Des fichiers sont en cours d'envoi"); // FIXME: i18n
+      }
+    },
+
+    sanitizeFilename(filename) {
+      return filename.replace(/\\/g, "/").replace(/.*\//, "");
+    },
+
+    humanSize(size) {
+      let unit = "b";
+      let divider = null;
+
+      if (size > api.TB) {
+        unit = "TB";
+        divider = api.TB;
+      } else if (size > api.GB) {
+        unit = "GB";
+        divider = api.GB;
+      } else if (size > api.MB) {
+        unit = "MB";
+        divider = api.MB;
+      } else if (size > api.KB) {
+        unit = "KB";
+        divider = api.KB;
+      }
+
+      if (divider) {
+        size = (size / divider).toFixed(2);
+      }
+
+      return size.toString() + unit;
+    },
+  };
+
+  function createFileInput(options) {
+    const element = $(this);
+    const widget = new FileInput(element, options);
+    element.data("file-input", widget);
+    return widget;
+  }
+
+  Abilian.registerWidgetCreator("fileInput", createFileInput);
+
+  $.fn.fileInput = function (options) {
+    return this.each(function () {
+      const node = $(this);
+      let widget = node.data("file-input");
+      if (widget === undefined) {
+        widget = new FileInput(node, options);
+        node.data("file-input", widget);
+      }
+      return widget;
+    });
+  };
+
+  return FileInput;
+});

pool/shard011/JavaScript/0070351_app.js

@@ -0,0 +1,34 @@
+var evalApp = angular.module( 'evalApp', 
+[ 'templates-app',
+  'templates-common',
+  'evalApp.home',
+  'evalApp.about',
+  'evalApp.login',
+  'evalApp.admin',
+  'evalApp.user',
+  'evalApp.newTemplate',
+  'evalApp.evaluations',
+  'evalApp.course',
+  'ui.router'
+]);
+
+evalApp.constant('SERVER_URL', 'http://dispatch.ru.is/h48/api/v1/');
+
+evalApp.config( function myAppConfig ( $stateProvider, $urlRouterProvider ) {
+  $urlRouterProvider.otherwise( '/login' );
+});
+
+evalApp.run( function run () {
+});
+
+evalApp.controller( 'AppCtrl', function AppCtrl ( $scope, $location ) {
+  $scope.$on('$stateChangeSuccess', function(event, toState, toParams, fromState, fromParams){
+    if ( angular.isDefined( toState.data.pageTitle ) ) {
+      $scope.pageTitle = toState.data.pageTitle + ' | Evaluation App' ;
+    }
+  });
+});
+
+evalApp.directive('evaluation-question', function() {
+  return ;
+});

pool/shard011/JavaScript/0070352_calendars-service.spec.js

@@ -0,0 +1,107 @@
+const expect = require('chai').expect;
+const rewire = require('rewire');
+const sinon = require('sinon');
+const Promise = require('bluebird');
+const mockEventList = require('./mocks/eventList.json');
+
+const CalendarService = rewire('../services/calendar-service');
+
+describe('Calendar Test', () => {
+	const calendar = CalendarService.__get__('calendar');
+	let jwtRevert;
+
+	beforeEach(done => {
+		const stub = sinon.stub().returns(Promise.resolve('a secured client'));
+		jwtRevert = CalendarService.__set__('createJWT', stub);
+		done();
+	});
+
+	afterEach(() => jwtRevert());
+
+	it('should send an update to Google Calendar', done => {
+		const updateEvent = CalendarService.__get__('updateEvent');
+		const updateSpy = sinon.spy(calendar.events, 'update');
+		const fakeResourceBody = {
+			summary: 'testing',
+			foo: 'bar'
+		};
+
+		// Since it will fail as this isn't an actual event
+		updateEvent({eventId: 'event1', calendarId: 'calendar1'}, fakeResourceBody)
+			.catch(() => {
+				const expectedParams = {
+					eventId: 'event1',
+					calendarId: 'calendar1',
+					resource: fakeResourceBody,
+					auth: 'a secured client'
+				};
+
+				// eslint-disable-next-line no-unused-expressions
+				expect(updateSpy.calledWith(expectedParams)).to.be.true;
+				done();
+			});
+	});
+
+	it('should return a sync token', done => {
+		const mockFullSync = () => Promise.resolve(mockEventList);
+		const revert = CalendarService.__set__('getFullSync', mockFullSync);
+		const getSyncToken = CalendarService.__get__('getSyncToken');
+
+		getSyncToken()
+			.then(syncToken => {
+				expect(syncToken).to.equal('CPiw4dWUu84CEPiw4dWUu84CGAU=');
+				revert();
+				done();
+			});
+	});
+
+	it('should perform a full sync', done => {
+		const getFullSync = CalendarService.__get__('getFullSync');
+		const mock1 = {
+			events: [1, 2],
+			nextPageToken: 2
+		};
+		const mock2 = {
+			events: [3, 4],
+			syncToken: 'token'
+		};
+		// Override eventList to check integrity of callback
+		const eventListMock = params => {
+			if (params.nextPageToken) {
+				return Promise.resolve(mock2);
+			}
+			return Promise.resolve(mock1);
+		};
+		const revert = CalendarService.__set__('listEvents', eventListMock);
+		getFullSync('brhim@apidevdemo.com').then(lastPageResponse => {
+			expect(lastPageResponse.syncToken).to.equal('token');
+			revert();
+			done();
+		});
+	});
+
+	it('should perform an incremental sync', done => {
+		const listStub = sinon.stub().returns(Promise.resolve([]));
+		const listRevert = CalendarService.__set__('listEvents', listStub);
+		const getIncrementalSync = CalendarService.__get__('getIncrementalSync');
+		const mockCalendarInfo = {
+			syncToken: '12345abcefg',
+			calendarId: 'calendarId1'
+		};
+
+		getIncrementalSync(mockCalendarInfo)
+			.then(() => {
+				const expectedParams = {
+					auth: 'a secured client',
+					calendarId: 'calendarId1',
+					singleEvents: false,
+					syncToken: '12345abcefg',
+					showDeleted: true
+				};
+				// eslint-disable-next-line no-unused-expressions
+				expect(listStub.calledWith(expectedParams)).to.be.true;
+				listRevert();
+				done();
+			});
+	});
+});

pool/shard011/JavaScript/0070360_Leg.js

@@ -0,0 +1,51 @@
+import { LEG_CAVE } from '../core/constants';
+
+class Leg {
+
+	constructor ( factory, legInfo, s1, s2 ) {
+
+		const s1Start = ( s1.shortestPathDistance() < s2.shortestPathDistance() );
+		const survey = factory.survey;
+
+		this.factory = factory;
+		this.legLength = legInfo.length;
+		this.index = legInfo.index;
+		this.segmentId = legInfo.segment;
+		this.startStation = s1Start ? s1 : s2;
+		this.endStation = s1Start ? s2 : s1;
+		this.legs = survey.getFeature( LEG_CAVE );
+
+	}
+
+	start () {
+
+		return this.startStation;
+
+	}
+
+	end () {
+
+		return this.endStation;
+	}
+
+	length () {
+
+		return this.legLength;
+
+	}
+
+	color ( color = false ) {
+
+		this.legs.setLegColor( this.index * 2, color );
+
+	}
+
+	segment() {
+
+		return this.factory.getSegment( this.segmentId );
+
+	}
+
+}
+
+export { Leg };

pool/shard011/JavaScript/0070364_handler.js

@@ -0,0 +1,176 @@
+var AbstractAdminContentHandler = Class.create(AbstractContentHandler,  {
+	show: function(data){
+		this.data = data;
+		adminTemplateEngine.process(this.tpl, data, this.target, this.finished.bind(this));
+	}
+});
+
+/**
+ * PkgNavHandler
+ */
+var ScriptListHandler  = Class.create(AbstractAdminContentHandler, {
+	initialize: function($super, target){
+		$super('tplScriptList', target);
+		this.provider = new ScriptListProvider(this.show.bind(this));
+		this.ajaxload = true;
+	}
+});
+
+/**
+ * PkgNavHandler
+ */
+var PkgConfListHandler  = Class.create(AbstractAdminContentHandler, {
+	initialize: function($super, target){
+		$super('tplPkgSettings', target);
+		this.provider = new PkgConfListProvider(this.show.bind(this));
+		this.ajaxload = true;
+	}
+});
+
+/**
+ * PkgListHandler
+ */
+var PkgListHandler  = Class.create(AbstractAdminContentHandler, {
+	initialize: function($super, target){
+		$super('tplPkgList', target);
+		this.provider = new PkgListProvider(this.show.bind(this));
+		this.ajaxload = true;
+		this.fakeprovider = new PkgFakeProvider(this.show.bind(this));
+	},
+								   
+	loadPkg: function(sel, needle){
+		this.provider.setSelection(sel, needle);
+		if (this.provider.packages.length != 0) {
+			this.requestStarted();
+			this.fakeprovider.setList(this.provider.getSelected());
+			this.fakeprovider.load();
+		}
+		else
+			this.load();
+		
+	},
+								   
+	loadAll: function(){
+		this.loadPkg(this.provider.ALL);
+	},
+								   
+	loadUpgradable: function(){
+		this.loadPkg(this.provider.UPGRADE);
+	},
+								   
+	loadInstalled: function(){
+		this.loadPkg(this.provider.INST);
+	},
+
+	loadFilter: function(needle){
+		this.loadPkg(this.provider.SEARCH, needle);
+	}
+});
+
+/**
+ * PkgNavHandler
+ */
+var PkgNavHandler = Class.create(AbstractAdminContentHandler,{
+	initialize: function($super, target){
+		$super('tplNavPkgs', target);
+	},
+
+	load: function(){
+		data = {};
+		core.setAjaxLoad('navContent');
+		this.show(data);
+	}
+});
+
+/**
+ * SwitchFeedHandler
+ * 
+ */
+var SwitchFeedHandler  = Class.create(AbstractAdminContentHandler, {
+	initialize: function(){
+		this.provider = new SimpleRequestProvider();
+	},
+									  
+	load: function(url, parms){
+		this.provider.simpleResultQuery(
+				url,
+				parms,
+				this.simpleResultCallback.bind(this)
+			);
+	},
+
+	showSimpleResult: function(result){
+		id = result.getStateText();
+		element = document.getElementById(id.replace('.off','') + "-pic");
+		hiddenInput  = document.getElementById(id.replace('.off','') + "-name");
+		if (result.getState()) {
+			if (id.endsWith('.conf')) {
+				element.alt='disable';
+				element.src = '/web-data/img/minus.png';
+				var title = 'enable ' + id;
+				element.up('.sPkgConfFeedsLink').title='disable ' + id;
+				
+			}	
+			else {
+				element.alt='enable';
+				element.src = '/web-data/img/plus.png';
+				var title = 'enable ' + id.replace('.off','');
+				element.up('.sPkgConfFeedsLink').title='enable ' + id.replace('.off','');
+			}
+			hiddenInput.value=id;
+		}
+		else {
+			alert(id);
+		};
+	},
+});
+
+/**
+ * MemoryHandler
+ * 
+ */
+
+var MemoryHandler  = Class.create(AbstractAdminContentHandler, {
+	initialize: function(){
+		this.provider = new MemoryProvider(this.show.bind(this));
+	},
+									  
+	load: function(url, parms){
+		this.provider.simpleResultQuery(
+				url,
+				parms,
+				this.simpleResultCallback.bind(this)
+			);
+	},
+
+	getMem: function(){
+		this.load('/webadmin/web/getmemory');
+	},
+
+	showSimpleResult: function(result){
+		str = result.getStateText();
+		if (result.getState()) {
+			document.getElementById('memContent').innerHTML=result.getStateText() + " MB free";
+		}
+		else {
+			alert(str);
+		};
+	},
+});
+
+/**
+ * SimpleWebAdminPageHandler
+ * 
+ */
+
+var templateEngine2 = new TemplateEngine('/webadmin/tpl/');
+
+var SimpleWebAdminPageHandler = Class.create(AbstractContentHandler,{
+	initialize: function($super, target){
+		$super(null, target);
+	},
+
+	show: function(tpl, data){
+		templateEngine2.process(tpl, data, this.target, this.finished.bind(this));
+	}
+});

pool/shard011/JavaScript/0070365_Tags.js

@@ -0,0 +1,74 @@
+const React = require('react');
+const classNames = require('classnames');
+const Icon = require('./Icon');
+
+const Tags = React.createClass({
+    propTypes: {
+        children: React.PropTypes.node
+    },
+
+    render() {
+        return (
+            <ul className="tags">
+                {this.props.children}
+            </ul>
+        );
+    }
+});
+
+const TagItem = React.createClass({
+    propTypes: {
+        title:   React.PropTypes.string,
+        href:    React.PropTypes.string,
+        active:  React.PropTypes.bool,
+        onClick: React.PropTypes.func,
+        // count and showX are exclusive
+        count:   React.PropTypes.number,
+        showX:   React.PropTypes.bool
+    },
+
+    getDefaultProps() {
+        return {
+            href: '#',
+            showX: false
+        };
+    },
+
+    onClick(e) {
+        const { onClick }  = this.props;
+
+        if (!onClick) {
+            return;
+        }
+
+        e.preventDefault();
+        onClick();
+    },
+
+    render() {
+        const { active, count, showX, title, href } = this.props;
+
+        const className = classNames('tag', {
+            active
+        });
+
+        let inner = '';
+        if (showX) {
+            inner = <span className="extra"> <Icon id="x"/></span>;
+        } else if (typeof count !== 'undefined') {
+            inner = <span className="extra"> | {count}</span>;
+        }
+
+        return (
+            <li className={className}>
+                <a href={href} onClick={this.onClick}>
+                    <span className="name">{title}</span>
+                    {inner}
+                </a>
+            </li>
+        );
+    }
+});
+
+module.exports = Tags;
+module.exports.Item = TagItem;

pool/shard011/JavaScript/0070366_getNotifications.js

@@ -0,0 +1,40 @@
+import { createSelector } from 'reselect';
+import * as commons from './commons';
+
+/**
+ * Select notifications for a member from state
+ *
+ * @alias module:Members.getNotifications
+ * @category selectors
+ *
+ * @example
+ * const mapStateToProps = (state, props) => ({
+ *   show: BetaSeries.getSelector('members', 'getNotifications')(state, { memberId: props.memberId });
+ * });
+ *
+ * @param {Object}  [state]           Redux state
+ * @param {Object}  [obj]             Accept the following:
+ * @param {Object}  [obj.memberId]    Member ID
+ *
+ * @returns {Array}                   Notifications array element or `undefined`
+ */
+
+const getNotifications = createSelector(
+  [commons.getMembers, commons.getNotifications, commons.getMemberId],
+  (members, membersNotifications, memberId) => {
+    const notifications = !Object.prototype.hasOwnProperty.call(
+      membersNotifications,
+      memberId
+    )
+      ? null
+      : membersNotifications[memberId];
+
+    if (!notifications) {
+      return undefined;
+    }
+
+    return notifications;
+  }
+);
+
+export default getNotifications;

pool/shard011/JavaScript/0070373_form.js

@@ -0,0 +1,141 @@
+/**
+ * JavaScript for form editing date conditions.
+ *
+ * @module moodle-availability_date-form
+ */
+M.availability_date = M.availability_date || {};
+
+/**
+ * @class M.availability_date.form
+ * @extends M.core_availability.plugin
+ */
+M.availability_date.form = Y.Object(M.core_availability.plugin);
+
+/**
+ * Initialises this plugin.
+ *
+ * Because the date fields are complex depending on Moodle calendar settings,
+ * we create the HTML for these fields in PHP and pass it to this method.
+ *
+ * @method initInner
+ * @param {String} html HTML to use for date fields
+ * @param {Number} defaultTime Time value that corresponds to initial fields
+ */
+M.availability_date.form.initInner = function(html, defaultTime) {
+    this.html = html;
+    this.defaultTime = defaultTime;
+};
+
+M.availability_date.form.getNode = function(json) {
+    var strings = M.str.availability_date;
+    var html = strings.direction_before + ' <span class="availability-group">' +
+            '<label><span class="accesshide">' + strings.direction_label + ' </span>' +
+            '<select name="direction">' +
+            '<option value="&gt;=">' + strings.direction_from + '</option>' +
+            '<option value="&lt;">' + strings.direction_until + '</option>' +
+            '</select></label></span> ' + this.html;
+    var node = Y.Node.create('<span>' + html + '</span>');
+
+    // Set initial value if non-default.
+    if (json.t !== undefined) {
+        node.setData('time', json.t);
+        // Disable everything.
+        node.all('select:not([name=direction])').each(function(select) {
+            select.set('disabled', true);
+        });
+
+        var url = M.cfg.wwwroot + '/availability/condition/date/ajax.php?action=fromtime' +
+            '&time=' + json.t;
+        Y.io(url, { on : {
+            success : function(id, response) {
+                var fields = Y.JSON.parse(response.responseText);
+                for (var field in fields) {
+                    var select = node.one('select[name=x\\[' + field + '\\]]');
+                    select.set('value', fields[field]);
+                    select.set('disabled', false);
+                }
+            },
+            failure : function() {
+                window.alert(M.str.availability_date.ajaxerror);
+            }
+        }});
+    } else {
+        // Set default time that corresponds to the HTML selectors.
+        node.setData('time', this.defaultTime);
+    }
+    if (json.d !== undefined) {
+        node.one('select[name=direction]').set('value', json.d);
+    }
+
+    // Add event handlers (first time only).
+    if (!M.availability_date.form.addedEvents) {
+        M.availability_date.form.addedEvents = true;
+
+        var root = Y.one('#fitem_id_availabilityconditionsjson');
+        root.delegate('change', function() {
+            // For the direction, just update the form fields.
+            M.core_availability.form.update();
+        }, '.availability_date select[name=direction]');
+
+        root.delegate('change', function() {
+            // Update time using AJAX call from root node.
+            M.availability_date.form.updateTime(this.ancestor('span.availability_date'));
+        }, '.availability_date select:not([name=direction])');
+    }
+
+    if (node.one('a[href=#]')) {
+        // Add the date selector magic.
+        M.form.dateselector.init_single_date_selector(node);
+
+        // This special handler detects when the date selector changes the year.
+        var yearSelect = node.one('select[name=x\\[year\\]]');
+        var oldSet = yearSelect.set;
+        yearSelect.set = function(name, value) {
+            oldSet.call(yearSelect, name, value);
+            if (name === 'selectedIndex') {
+                // Do this after timeout or the other fields haven't been set yet.
+                setTimeout(function() {
+                    M.availability_date.form.updateTime(node);
+                }, 0);
+            }
+        };
+    }
+
+    return node;
+};
+
+/**
+ * Updates time from AJAX. Whenever the field values change, we recompute the
+ * actual time via an AJAX request to Moodle.
+ *
+ * This will set the 'time' data on the node and then update the form, once it
+ * gets an AJAX response.
+ *
+ * @method updateTime
+ * @param {Y.Node} component Node for plugin controls
+ */
+M.availability_date.form.updateTime = function(node) {
+    // After a change to the date/time we need to recompute the
+    // actual time using AJAX because it depends on the user's
+    // time zone and calendar options.
+    var url = M.cfg.wwwroot + '/availability/condition/date/ajax.php?action=totime' +
+            '&year=' + node.one('select[name=x\\[year\\]]').get('value') +
+            '&month=' + node.one('select[name=x\\[month\\]]').get('value') +
+            '&day=' + node.one('select[name=x\\[day\\]]').get('value') +
+            '&hour=' + node.one('select[name=x\\[hour\\]]').get('value') +
+            '&minute=' + node.one('select[name=x\\[minute\\]]').get('value');
+    Y.io(url, { on : {
+        success : function(id, response) {
+            node.setData('time', response.responseText);
+            M.core_availability.form.update();
+        },
+        failure : function() {
+            window.alert(M.str.availability_date.ajaxerror);
+        }
+    }});
+};
+
+M.availability_date.form.fillValue = function(value, node) {
+    value.d = node.one('select[name=direction]').get('value');
+    value.t = parseInt(node.getData('time'), 10);
+};

pool/shard011/JavaScript/0070375_Gruntfile.js

@@ -0,0 +1,17 @@
+var UmxGruntConfig = require('umx-grunt-config');
+module.exports = function(grunt) {
+    var configurator = new UmxGruntConfig(require, grunt);
+    configurator.initBump();
+    configurator.initWebpack();
+    configurator.initWatch();
+    configurator.initJshint();
+    configurator.initMochaTest();
+    configurator.initUglify();
+    configurator.registerBumpTasks();
+    grunt.initConfig(configurator.config);
+    grunt.registerTask('test', [ 'jshint', 'mochaTest' ]);
+    grunt.registerTask('build', [ 'test', 'webpack' ]);
+    grunt.registerTask('build-min', [ 'build', 'uglify' ]);
+    grunt.registerTask('commit', [ 'build-min', 'bump-commit' ]);
+    grunt.registerTask('default', [ 'build-min' ]);
+}

pool/shard011/JavaScript/0070376_util.js

@@ -0,0 +1,49 @@
+/**
+ * @file General utilities and settings.
+ *
+ * It also contains some helper functions to be used in EJS templates.
+ *
+ * @module lib/util
+ */
+
+'use strict'
+
+var path = require('path')
+
+/**
+ * Directory with all the fate data.
+ * @type {string}
+ */
+module.exports.dir      = '/var/www/fateweb'
+
+/**
+ * Port to listen on.
+ * @type {number}
+ */
+module.exports.port     = 8080
+
+/**
+ * Get the Gitweb URL of a piece of history between two commits or from
+ * one commit back.
+ *
+ * @param newer   {string} Revision of the newer commit.
+ * @param [older] {string} Revision of the older commit.
+ * @return        {string} HTML code for a hyperlink to the URL of the history.
+ */
+module.exports.linkGitHist = function (newer, older) {
+  var end = older ? ';hp=' + older : ''
+  return '<a href="http://git.videolan.org/?p=ffmpeg.git;a=shortlog;h=' + newer + end + '">'
+       +   (older ? older : newer)
+       + '</a>'
+}
+
+module.exports.formatConfig = function (str) {
+  if (str == undefined) return ''
+  return str.replace(/(?!^)--/g, '<br>--')
+}
+
+module.exports.log = path.resolve(__dirname, '..', 'logs', 'access.log')
+
+module.exports.proxy = true
+
+module.exports.cache = 10

pool/shard011/JavaScript/0070378_find.js

@@ -0,0 +1,47 @@
+module.exports = app => {
+  class Post extends app.Service {
+      //新增数据
+      * create(post){
+          return yield this.ctx.model.Post.create(post);
+      }
+      //删除数据
+      * delete(id){
+          return yield this.ctx.model.Post.destroy({where:{id: id}});
+      }
+      //更新操作
+      * update(id,msg){
+          return yield this.ctx.model.Post.update(msg,{where:{id: id}});
+      }
+      //关联查询
+      * find(id){
+          const post = yield this.ctx.model.Post.findById(id,{
+              include: [{
+                  model: this.ctx.model.User,
+                  as: 'user',
+                  attributes: ['id','name','age'],
+              }],
+          });
+          if(!post){
+              this.ctx.throw(404,'post not found');
+          }
+          return post;
+      };
+      //单表查询
+      * findSigle(id){
+          const post = yield this.ctx.model.Post.findOne({where:{id: id}});
+          if(!post){
+              this.ctx.throw(404,'post not found');
+          }
+          return post;
+      }
+      //单表查询，查询条件为数组
+      * findInArray(ids){
+          const post = yield this.ctx.model.Post.findAll({where: {id: ids}});
+          if(!post){
+              this.ctx.throw(404,'post not found');
+          }
+          return post;
+      }
+  }
+  return Post;
+}

pool/shard011/JavaScript/0070394_mobile_operator.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var MobileOperator = {
+  BRAZIL_MCC: 724,
+  BRAZIL_CELLBROADCAST_CHANNEL: 50,
+
+  userFacingInfo: function mo_userFacingInfo(mobileConnection) {
+    var network = mobileConnection.voice.network;
+    var iccInfo = mobileConnection.iccInfo;
+    var operator = network.shortName || network.longName;
+
+    if (iccInfo.isDisplaySpnRequired && iccInfo.spn
+        && !mobileConnection.voice.roaming) {
+      if (iccInfo.isDisplayNetworkNameRequired) {
+        operator = operator + ' ' + iccInfo.spn;
+      } else {
+        operator = iccInfo.spn;
+      }
+    }
+
+    var carrier, region;
+    if (this.isBrazil(mobileConnection)) {
+      // We are in Brazil, It is legally required to show local info
+      // about current registered GSM network in a legally specified way.
+      var lac = mobileConnection.voice.cell.gsmLocationAreaCode % 100;
+      var carriers = MobileInfo.brazil.carriers;
+      var regions = MobileInfo.brazil.regions;
+
+      carrier = carriers[network.mnc] || (this.BRAZIL_MCC.toString() + network.mnc);
+      region = (regions[lac] ? regions[lac] + ' ' + lac : '');
+    }
+
+    return {
+      'operator': operator,
+      'carrier': carrier,
+      'region': region
+    };
+  },
+
+  isBrazil: function mo_isBrazil(mobileConnection) {
+    var cell = mobileConnection.voice.cell;
+    return mobileConnection.voice.network.mcc == this.BRAZIL_MCC &&
+           cell && cell.gsmLocationAreaCode;
+  }
+};
+
+
+var MobileInfo = {
+  brazil: {
+    carriers: {
+      '0': 'NEXTEL',
+      '2': 'TIM', '3': 'TIM', '4': 'TIM',
+      '5': 'CLARO', '6': 'VIVO', '7': 'CTBC', '8': 'TIM',
+      '10': 'VIVO', '11': 'VIVO', '15': 'SERCOMTEL',
+      '16': 'OI', '23': 'VIVO', '24': 'OI', '31': 'OI',
+      '32': 'CTBC', '33': 'CTBC', '34': 'CTBC', '37': 'AEIOU'
+    },
+    regions: {
+      '11': 'SP', '12': 'SP', '13': 'SP', '14': 'SP', '15': 'SP', '16': 'SP',
+      '17': 'SP', '18': 'SP', '19': 'SP',
+      '21': 'RJ', '22': 'RJ', '24': 'RJ',
+      '27': 'ES', '28': 'ES',
+      '31': 'MG', '32': 'MG', '33': 'MG', '34': 'MG', '35': 'MG', '37': 'MG',
+      '38': 'MG',
+      '41': 'PR', '42': 'PR', '43': 'PR', '44': 'PR', '45': 'PR', '46': 'PR',
+      '47': 'SC', '48': 'SC', '49': 'SC',
+      '51': 'RS', '53': 'RS', '54': 'RS', '55': 'RS',
+      '61': 'DF',
+      '62': 'GO',
+      '63': 'TO',
+      '64': 'GO',
+      '65': 'MT', '66': 'MT',
+      '67': 'MS',
+      '68': 'AC',
+      '69': 'RO',
+      '71': 'BA', '73': 'BA', '74': 'BA', '75': 'BA', '77': 'BA',
+      '79': 'SE',
+      '81': 'PE',
+      '82': 'AL',
+      '83': 'PB',
+      '84': 'RN',
+      '85': 'CE',
+      '86': 'PI',
+      '87': 'PE',
+      '88': 'CE',
+      '89': 'PI',
+      '91': 'PA',
+      '92': 'AM',
+      '93': 'PA', '94': 'PA',
+      '95': 'RR',
+      '96': 'AP',
+      '97': 'AM',
+      '98': 'MA', '99': 'MA'
+    }
+  }
+};

pool/shard011/JavaScript/0070396_eachs.js

@@ -0,0 +1,102 @@
+/* jshint strict: true, undef: true */
+/* globals spec, _, to_string, is_enumerable, length, keys_or_indexes */
+/* globals exports */
+
+
+// TODO: spec :eachs does not alter inputs
+spec(
+  ["01", "12"],
+  function eachs_passes_key_and_val() {
+
+    var v = [];
+    eachs( [1,2], function (kx, x) { v.push("" + kx + x); });
+    return v;
+  }
+);
+
+spec(
+  ["1a", "1b", "2a", "2b"],
+  function eachs_passes_vals_of_multiple_colls() {
+
+    var v = [];
+    eachs( [1,2], ["a", "b"], function (kx, x, ky, y) { v.push("" + x + y); });
+    return v;
+  }
+);
+
+spec(
+  ["onea", "twoa"],
+  function eachs_passes_keys_and_vals_of_arrays_and_plain_objects() {
+
+    var v = [];
+    eachs({one: 1, two: 2}, ["a"], function (kx, x, ky, y) { v.push("" + kx + y); });
+    return v;
+  }
+);
+
+spec(
+  ["1a", "1b", "2a", "2b"],
+  function eachs_passes_vals_of_plain_object_and_array() {
+
+    var v = [];
+    eachs({one: 1, two: 2}, ["a", "b"], function (kx, x, ky, y) { v.push("" + x + y); });
+    return v;
+  }
+);
+
+spec( [],
+  function eachs_returns_empty_array_if_one_array_is_empty() {
+
+    var v = [];
+    eachs({one: 1, two: 2}, [], ["a"], function (kx, x, ky, y, kz, z) {
+      v.push("" + kx + y);
+    });
+    return v;
+  }
+);
+
+exports.eachs = eachs;
+function eachs() {
+
+  var args = _.toArray(arguments);
+
+  if (args.length < 2)
+    throw new Error("Not enough args: " + to_string(args));
+  var f    = args.pop();
+
+  // === Validate inputs before continuing:
+  for (var i = 0; i < args.length; i++) {
+    if (!is_enumerable(args[i]))
+        throw new Error("Invalid value for eachs: " + to_string(args[i]));
+  }
+
+  // === Process inputs:
+  var cols_length = length(args);
+
+  return eachs_row_maker([], 0, _.map(args, keys_or_indexes));
+
+  function eachs_row_maker(row, col_i, key_cols) {
+    if (col_i >= cols_length) {
+      if (row.length !== f.length)
+        throw new Error("f.length (" + f.length + ") should be " + row.length + " (collection count * 2 )");
+      f.apply(null, [].concat(row)); // set reduced value
+      return;
+    }
+
+    var keys = key_cols[col_i].slice(0);
+    var vals = args[col_i];
+    ++col_i;
+
+    for(var i = 0; i < keys.length; i++) {
+      row.push(keys[i]); // key
+      row.push(vals[keys[i]]); // actual value
+
+      eachs_row_maker(row, col_i, key_cols);
+
+      row.pop();
+      row.pop();
+    }
+
+    return;
+  }
+}

pool/shard011/JavaScript/0070398_fs.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const fs = jest.genMockFromModule(`fs`)
+
+let mockFiles = {}
+function __setMockFiles(newMockFiles) {
+  mockFiles = Object.assign({}, newMockFiles)
+}
+
+function readFileSync(filePath, parser) {
+  return mockFiles[filePath]
+}
+
+fs.__setMockFiles = __setMockFiles
+fs.readFileSync = readFileSync
+
+module.exports = fs

pool/shard011/JavaScript/0070399_list-elem.js

@@ -0,0 +1,61 @@
+(function() {
+  window.daElements.listElem = {
+    properties: {
+      localData: {
+        type: Array,
+        value: []
+      },
+      filters: {
+        type: Array,
+        notify: true,
+        value: []
+      },
+      activeFilterId: {
+        type: Number,
+        value: null,
+        observer: 'filter',
+        notify: true
+      },
+      user: {
+        type: String
+      }
+    },
+    listeners: {
+      'cell-tap': 'cellTap'
+    },
+    cellListeners: {
+      'Docket': 'docketTap'
+    },
+    ready: function() {
+      return app.patchDatatable(this.$.datatableList, this);
+    },
+    refresh: function() {
+      console.log("refreshing case list");
+      this.$.datatableList.data = [];
+      this.filter();
+      return this.$.datatableList.data = this.localData;
+    },
+    filter: function() {
+      var filter;
+      if (this.activeFilterId !== null) {
+        filter = this.filters[this.activeFilterId];
+        return this.localData = filter.filter(app.cases);
+      } else {
+        return this.localData = app.cases;
+      }
+    },
+    cellTap: function(e) {
+      if (this.cellListeners[e.detail.column.header] != null) {
+        return this[this.cellListeners[e.detail.column.header]](e);
+      }
+    },
+    docketTap: function(e) {
+      if (e.detail.item["case"] != null) {
+        return app.displayCase(e.detail.item["case"].id);
+      } else {
+        return app.displayCase(e.detail.item.id);
+      }
+    }
+  };
+
+}).call(this);

pool/shard011/JavaScript/0070400_Provider.js

@@ -0,0 +1,103 @@
+"use strict";
+
+angular.module('FullstackApp.Provider',[])
+.factory('ProviderFct', function() {
+
+	var providerFct = {
+		new: function() {
+
+			var model = {
+				id: null,
+				name: ""
+			};
+
+			return model;	
+		}
+	}
+
+	return providerFct;
+})
+.service('ProviderSvc',function( $http ) {
+	this.providers = [];
+	var That = this;
+
+	this.getAll = function() { 
+		var promise = new Promise(
+			function( resolve, reject) {
+				if ( That.providers.length ) {
+					resolve( That.providers);
+				}
+				else {
+					$http.get('/providers').then(function(res) {
+						That.providers = res.data;
+						resolve( res.data)
+					}).catch(reject);
+				}
+			}
+		);
+		return promise;
+	}
+	this.delete = function( provider ) { return $http.delete('/providers/' + provider.id) }
+	this.save = function( provider ) {
+		var promise = new Promise(
+			function( resolve, reject ) {
+				$http.post('/providers/:id', provider).then(resolve, reject); 
+			}
+		);
+		return promise;
+	}
+	this.getAll = this.getAll.bind( this );
+})
+.controller('ProviderCtrl',function( $scope, ProviderSvc, ProviderFct ) {
+
+	angular.extend($scope, {
+		providers: [],
+		newProvider: ProviderFct.new()
+	});
+	
+	$scope.saveProvider = function( provider ) {
+		ProviderSvc.save( provider ).then(function( res ){
+			if (!provider.id) {
+				$scope.providers.push( res.data.model );
+				$scope.newProvider.name = "";
+			}
+			$scope.$emit('providersChange', $scope.providers);
+		}).catch( function( err ) {
+			$scope.showError( err.data );
+		});
+
+	}
+
+	// Adds a new provider
+	$scope.addProvider = function() {
+		if ( $scope.newProvider.name.length ) $scope.saveProvider( $scope.newProvider );
+	}
+
+	// Updates a provider's name
+	$scope.editProvider = function( provider ) {
+		var name = prompt("Enter the provider's name", provider.name);
+		if ( angular.isString( name ) && name.length ) {
+			provider.name = name;
+			$scope.saveProvider( provider );
+		}
+	}
+
+	// Deletes a provider
+	$scope.deleteProvider = function( provider ) {
+		if (confirm("Are you sure you want to delete the provider: ".concat(provider.name,"?"))) {
+			ProviderSvc.delete( provider ).then(function( res ) {
+				var i = $scope.providers.indexOf( provider );
+				$scope.providers.splice(i, 1);
+				$scope.$emit('providersChange', $scope.providers);
+			});
+		}
+	}
+
+	// Loads the provider's list
+	ProviderSvc.getAll().then(function( providers ) {
+		$scope.providers = providers;		
+		$scope.$emit('providersChange', providers);
+	}).catch(function( res ) {
+		$scope.showError( res.data.err );
+	})
+});

pool/shard011/JavaScript/0070407_blip-assistant.js

@@ -0,0 +1,305 @@
+function BlipAssistant() {
+	/* this is the creator function for your scene assistant object. It will be passed all the 
+	   additional parameters (after the scene name) that were passed to pushScene. The reference
+	   to the scene controller (this.controller) has not be established yet, so any initialization
+	   that needs the scene controller should be done in the setup function below. */
+
+  // Database object
+  this.sqlite = new Sqlite("tram2000")
+  // Number of seconds since beginning of the journey
+	this.seconds = 0
+  // Latest timestamp returned by GPS
+  this.timestamp = 0
+  this.positions_queue = []
+  // Keeps active blip object
+  this.blip = false
+  // Latest know position
+//  this.lat_lng = false
+  // How many stops did we past
+  this.count = 0
+  //
+  this.last_measure = 0
+}
+
+// this function is for setup tasks that have to happen when the scene is first created
+BlipAssistant.prototype.setup = function() {
+
+  // Timer setup
+  this.timerRollHandler = this.timerRoll.bind(this)
+  this.interval = window.setInterval(this.timerRollHandler, 1000)
+
+  // Command menu setup
+  this.commandMenuModel = {items: [{label: 'Pokaż szczegóły', command: 'show-details'}, {label: 'Reset', icon:'refresh', command:'reset'}]}
+  this.controller.setupWidget(Mojo.Menu.commandMenu, {}, this.commandMenuModel)
+
+  // Start tracking
+  this.controller.serviceRequest('palm://com.palm.location', {
+    method        : "startTracking",
+    parameters: {
+		  accuracy    : 1,
+	    responseTime: 1,
+      subscribe   : true
+		},
+    onSuccess     : this.onGpsSuccess.bind(this),
+    onFailure     : this.onGpsFailure.bind(this)
+  })
+
+  // Require the device to stay awake
+  this.controller.serviceRequest("palm://com.palm.power/com/palm/power", {
+    method        : "activityStart",
+    parameters: {
+      id          : "com.palm.app.news.update-1",
+      duration_ms : "900000" // = 15 minutes (max)
+    },
+    onSuccess     : function(){ console.log("Keeping awake for 15 min...") },
+    onFailure     : function(){ console.log("Keeping awake failure.") }
+  })
+
+}
+
+BlipAssistant.prototype.onGpsSuccess = function(data) {
+
+  // Time which might be useful if we create new blip
+  this.timestamp = data.timestamp
+  this.positions_queue.push({lat: data.latitude, lng: data.longitude, time: data.timestamp})
+//  console.log(Object.toJSON(this.positions_queue))
+
+}
+
+BlipAssistant.prototype.onGpsFailure = function(status){
+  // console.log("Porażka gps" + Object.toJSON(errorCode))
+  window.clearInterval(this.interval)
+  this.controller.showAlertDialog({
+    onChoose: function() {  },
+    title: 'Błąd GPS ('+ status.errorCode +')',
+    message: 'Nie mogłem ustalić bieżącego położenia.',
+    choices: [
+      {label: 'Spróbuj ponownie'},
+      {label: 'Anuluj'}
+    ]
+  })
+}
+
+// On found nearby stops
+BlipAssistant.prototype.dbSuccessHandler = function(transaction, SQLResultSet) {
+  // Handle successful queries including receiving results
+  // console.log("SQL success: " + SQLResultSet.rows.length)
+  var the_nearest_stop
+  var position = this.positions_queue[this.positions_queue.length - 1]
+
+  if(SQLResultSet.rows.length > 1) {
+    // Find the closest stop
+    var first_stop = SQLResultSet.rows.item(0)
+    // Infinity
+    var closest_distance = length(decodeGeoHash(first_stop.geo), position) // We can use this.lat_lng because it is the same as current position
+    the_nearest_stop = first_stop
+
+    for(var i=1; i<SQLResultSet.rows.length; i++){
+      var stop = SQLResultSet.rows.item(i)
+      var distance = length(decodeGeoHash(stop.geo), position)
+      if(closest_distance > distance){
+        closest_distance = distance
+        the_nearest_stop = stop
+      }
+    }
+  } else if(SQLResultSet.rows.length == 1) {
+    the_nearest_stop = SQLResultSet.rows.item(0)
+  } else {
+    // Nothing to do here
+    return
+  }
+
+  // console.log("Najbliższy przystanek: " + the_nearest_stop.id)
+  // console.log("Next: " + Object.toJSON(this.blip.next))
+
+//  if(!this.blip){
+//    // The same stop. Nothing do do here
+//    return
+//  }
+
+  // Check whether or not we are where we were
+  if(this.blip && this.blip.beg_id != the_nearest_stop.id) {
+
+    if(this.blip.next.indexOf( the_nearest_stop.id ) == -1) {
+      var transfer = false
+      $.each(this.blip.alternate_next, function(id, hash){
+        if(hash.next.indexOf( the_nearest_stop.id ) != -1){
+          transfer = {id: id, time: hash.time}
+          return
+        }
+      })
+      if(transfer) { // There was a transfer (previously)
+        // Remove redundant data
+        var transfer_time = Math.round((transfer.time - this.blip.beg_time) / 1000)
+//        console.log(transfer_time)
+        this.data = this.blip.data.substring(transfer_time)
+
+        this.blip.beg_id = transfer.id
+        this.blip.beg_time = transfer.time
+      } else {
+        // We may transferred
+        if(!this.blip.alternate_next[the_nearest_stop.id]) {
+          this.blip.alternate_next[the_nearest_stop.id] = {next: the_nearest_stop.next.split(","), time: this.timestamp}
+
+        }
+        return
+      }
+    }
+    // Otherwise we have the simplest scenario
+
+    // Finish and save current blip
+    // These are common actions for both situations: with and without transfer
+    this.blip.end_id = the_nearest_stop.id
+    this.blip.save()
+    this.blip = false
+
+  } else if(this.blip) {
+    // Prevent double blip
+    return
+  }
+  
+  // Begin new blip
+  this.blip = new Blip(this.sqlite, this.timestamp, the_nearest_stop)
+  this.controller.get("count").update(this.count++)
+}
+
+BlipAssistant.prototype.timerRoll = function(event){
+
+  // Update timer
+  this.seconds++
+  var min = Math.floor(this.seconds / 60)
+  var sec = this.seconds % 60
+  if(sec < 10) sec = "0" + sec
+  this.controller.get("time").update(min + ":" + sec)
+
+  this.last_measure++
+  // Calculate speed
+  var speed = 0
+  // If this is not a first call (so we can display current speed)
+
+  if(this.positions_queue.length == 2){
+    // Current position
+    var location = this.positions_queue.pop()
+    // this will be our reference
+    var prev_location = this.positions_queue.pop()
+
+    // Estimate current speed (if there is a movement)
+    if(prev_location.lat != location.lat || prev_location.lng != location.lng)
+      speed = Math.round(length(prev_location, location) * ((location.time - prev_location.time) * (100/36)))
+
+  } else if(location && this.last_measure == 1) {
+    // First call or GPS didn't return position
+    speed = 0
+  } else {
+    // GPS doesn't respond for 3 seconds or more
+    speed = -1
+  }
+
+  console.log("speed: " + speed)
+  //  console.log(Object.toJSON(data))
+  if(speed == -1) {
+    speed = "-"
+  } else {
+
+    // Only if there is no speed,
+    // check if we are close enough to a stop (or stops)
+    if(speed == 0) Stops.findNearby(this.sqlite, location, this.dbSuccessHandler.bind(this))
+
+    // append new data to blip
+    if(this.blip) {
+      this.blip.add( length(location, this.blip) * 1000, this.last_measure )
+      this.last_measure = 0
+    }
+
+    this.positions_queue = [location]
+
+    speed += " km/h"
+  }
+
+  this.controller.get("speed").update(speed)
+
+  // We no longer need previous position
+//  this.lat_lng = p2
+
+
+}
+
+BlipAssistant.prototype.activate = function(event) {
+	/* put in event handlers here that should only be in effect when this scene is active. For
+	   example, key handlers that are observing the document */
+}
+
+
+BlipAssistant.prototype.deactivate = function(event) {
+	/* remove any event handlers you added in activate and do any other cleanup that should happen before
+	   this scene is popped or another scene is pushed on top */	   
+}
+
+BlipAssistant.prototype.cleanup = function(event) {
+	/* this function should do any cleanup needed before the scene is destroyed as 
+	   a result of being popped off the scene stack */
+	   
+	clearInterval(this.interval)
+}
+
+BlipAssistant.prototype.toggleDetails = function(){
+  //  console.log("showing details")
+  $("#details").toggleClass("hidden")
+  // Nie mogłem połączyć się z siecią internet.
+}
+
+BlipAssistant.prototype.handleCommand = function(event) {
+
+  if(event.type == Mojo.Event.command) {
+    switch(event.command) {
+      case 'show-details':
+        this.commandMenuModel.temp = this.commandMenuModel.items
+        this.commandMenuModel.items = [{label: 'Ukryj szczegóły', command: 'hide-details'}, {label: 'Reset', icon:'refresh', command:'reset'}] 
+        this.controller.modelChanged(this.commandMenuModel)
+        this.toggleDetails()
+        break
+
+      case 'hide-details':
+        this.commandMenuModel.items = this.commandMenuModel.temp
+        this.controller.modelChanged(this.commandMenuModel)
+        this.toggleDetails()
+        break
+    
+      case 'reset':
+        Mojo.Controller.stageController.activeScene().showAlertDialog({
+          onChoose: function(value) {
+            if(value){
+              this.blip = false
+              this.count = 0
+              this.seconds = -1
+              this.controller.get("count").update("-")
+            }
+          },
+          title: "Restart",
+          message: "Czy na pewno chcesz na nowo rozpocząć proces monitorowania podróży?",
+          	choices:[
+              {label: 'Tak', value: true},
+          		{label: 'Nie', value: false}
+          	]
+      	})
+        break
+    }
+  }
+}
+
+// Converts degrees to radians
+Number.prototype.toRad = function() {
+  return this * Math.PI / 180
+}
+
+// Returns length between two points in km
+function length(p1, p2){
+  var R = 6371                            // Radius of the earth in km
+  var dLat = (p2.lat - p1.lat).toRad()    // Javascript functions in radians
+  var dLon = (p2.lng - p1.lng).toRad()
+  var a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+      Math.cos(p1.lat.toRad()) * Math.cos(p2.lat.toRad()) *
+      Math.sin(dLon/2) * Math.sin(dLon/2)
+  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+  return R * c  // Return distance in km
+}

pool/shard011/JavaScript/0070410_eserveri.js

@@ -0,0 +1,52 @@
+exports.run = function(bot, msg, args) {
+  var tag = msg.guild.owner.user;
+  msg.delete();
+  msg.channel.send({
+    embed: {
+      color: 3447003,
+      author: {
+        name: msg.guild.name,
+        icon_url: msg.guild.iconURL
+      },
+      title: 'Statistics',
+      url: '',
+      description: 'serverinfo',
+      fields: [{
+          name: 'Owner:',
+          value: `${tag.username}#${tag.discriminator} (${msg.guild.owner.id})`
+        },
+        {
+          name: 'Member Count',
+          value: `${msg.guild.memberCount} (${msg.guild.members.filter(m=>m.user.bot).size} Bots)`,
+          inline: true
+        },
+        {
+          name: 'AFK Timeout',
+          value: `${msg.guild.afkTimeout / 60} minutes`,
+          inline: true
+        },
+        {
+          name: 'Location',
+          value: msg.guild.region,
+          inline: true
+        },
+        {
+          name: 'Created',
+          value: msg.guild.createdAt.toLocaleString(),
+          inline: true
+        }
+      ],
+      timestamp: new Date(),
+      footer: {
+        icon_url: bot.user.avatarURL,
+        text: '© Ｊｅｓｓｅ / Ｍａｘｉｎｅ#8621'
+      }
+    }
+  });
+}
+
+exports.info = {
+  name: 'server',
+  usage: 'server',
+  description: 'shows the serverinfo in embed'
+};

pool/shard011/JavaScript/0070413_js.js

@@ -0,0 +1,29 @@
+exports.vargs = function(args, n) { return Array.prototype.slice.call(args, n || 0); }
+exports.isArray = function(input) { return Object.prototype.toString.call(input) === '[object Array]'; }
+
+exports.shallowCopy = function(input) {
+	if (exports.isArray(input)) {
+		return input.slice(0);
+	} else {
+		var out = {};
+		for (var key in input) {
+			if (input.hasOwnProperty(key)) {
+				out[key] = input[key];
+			}
+		}
+	}
+	
+	return out;
+}
+
+exports.merge = function(base, extra) {
+	base = base || {};
+	
+	for (var key in extra) {
+		if (extra.hasOwnProperty(key) && !base.hasOwnProperty(key)) {
+			base[key] = extra[key];
+		}
+	}
+	
+	return base;
+}

pool/shard011/JavaScript/0070414_md023.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceBeforeHeadingRe = /^((?:\s+)|(?:[>\s]+\s\s))[^>\s]/;
+
+module.exports = {
+  "names": [ "MD023", "heading-start-left", "header-start-left" ],
+  "description": "Headings must start at the beginning of the line",
+  "tags": [ "headings", "headers", "spaces" ],
+  "function": function MD023(params, onError) {
+    filterTokens(params, "heading_open", function forToken(token) {
+      const { lineNumber, line } = token;
+      const match = line.match(spaceBeforeHeadingRe);
+      if (match) {
+        const [ prefixAndFirstChar, prefix ] = match;
+        let deleteCount = prefix.length;
+        const prefixLengthNoSpace = prefix.trimEnd().length;
+        if (prefixLengthNoSpace) {
+          deleteCount -= prefixLengthNoSpace - 1;
+        }
+        addErrorContext(
+          onError,
+          lineNumber,
+          line,
+          null,
+          null,
+          [ 1, prefixAndFirstChar.length ],
+          {
+            "editColumn": prefixLengthNoSpace + 1,
+            "deleteCount": deleteCount
+          });
+      }
+    });
+  }
+};

pool/shard011/JavaScript/0070415_tab.js

@@ -0,0 +1,155 @@
+/* ========================================================================
+ * Bootstrap: tab.js v3.3.7
+ * http://getbootstrap.com/javascript/#tabs
+ * ========================================================================
+ * Copyright 2011-2016 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ * ======================================================================== */
+
+
++function ($) {
+  'use strict';
+
+  // TAB CLASS DEFINITION
+  // ====================
+
+  var Tab = function (element) {
+    // jscs:disable requireDollarBeforejQueryAssignment
+    this.element = $(element);
+    // jscs:enable requireDollarBeforejQueryAssignment
+  };
+
+  Tab.VERSION = '3.3.7';
+
+  Tab.TRANSITION_DURATION = 150;
+
+  Tab.prototype.show = function () {
+    var $this    = this.element;
+    var $ul      = $this.closest('ul:not(.dropdown-menu)');
+    var selector = $this.data('target');
+
+    if (!selector) {
+      selector = $this.attr('href');
+      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, ''); // strip for ie7
+    }
+
+    if ($this.parent('li').hasClass('active')) return;
+
+    var $previous = $ul.find('.active:last a');
+    var hideEvent = $.Event('hide.bs.tab', {
+      relatedTarget: $this[0]
+    });
+    var showEvent = $.Event('show.bs.tab', {
+      relatedTarget: $previous[0]
+    });
+
+    $previous.trigger(hideEvent);
+    $this.trigger(showEvent);
+
+    if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return;
+
+    var $target = $(selector);
+
+    this.activate($this.closest('li'), $ul);
+    this.activate($target, $target.parent(), function () {
+      $previous.trigger({
+        type: 'hidden.bs.tab',
+        relatedTarget: $this[0]
+      });
+      $this.trigger({
+        type: 'shown.bs.tab',
+        relatedTarget: $previous[0]
+      })
+    })
+  };
+
+  Tab.prototype.activate = function (element, container, callback) {
+    var $active    = container.find('> .active');
+    var transition = callback
+      && $.support.transition
+      && ($active.length && $active.hasClass('fade') || !!container.find('> .fade').length);
+
+    function next() {
+      $active
+        .removeClass('active')
+        .find('> .dropdown-menu > .active')
+          .removeClass('active')
+        .end()
+        .find('[data-toggle="tab"]')
+          .attr('aria-expanded', false);
+
+      element
+        .addClass('active')
+        .find('[data-toggle="tab"]')
+          .attr('aria-expanded', true);
+
+      if (transition) {
+        element[0].offsetWidth; // reflow for transition
+        element.addClass('in')
+      } else {
+        element.removeClass('fade')
+      }
+
+      if (element.parent('.dropdown-menu').length) {
+        element
+          .closest('li.dropdown')
+            .addClass('active')
+          .end()
+          .find('[data-toggle="tab"]')
+            .attr('aria-expanded', true)
+      }
+
+      callback && callback()
+    }
+
+    $active.length && transition ?
+      $active
+        .one('bsTransitionEnd', next)
+        .emulateTransitionEnd(Tab.TRANSITION_DURATION) :
+      next();
+
+    $active.removeClass('in')
+  };
+
+
+  // TAB PLUGIN DEFINITION
+  // =====================
+
+  function Plugin(option) {
+    return this.each(function () {
+      var $this = $(this);
+      var data  = $this.data('bs.tab');
+
+      if (!data) $this.data('bs.tab', (data = new Tab(this)));
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  var old = $.fn.tab;
+
+  $.fn.tab             = Plugin;
+  $.fn.tab.Constructor = Tab;
+
+
+  // TAB NO CONFLICT
+  // ===============
+
+  $.fn.tab.noConflict = function () {
+    $.fn.tab = old;
+    return this
+  };
+
+
+  // TAB DATA-API
+  // ============
+
+  var clickHandler = function (e) {
+    e.preventDefault();
+    Plugin.call($(this), 'show')
+  };
+
+  $(document)
+    .on('click.bs.tab.data-api', '[data-toggle="tab"]', clickHandler)
+    .on('click.bs.tab.data-api', '[data-toggle="pill"]', clickHandler)
+
+}(jQuery);

pool/shard011/JavaScript/0070416_sigV4Client.js

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+/*
+ * Note: The original sourcecode autogenerated by the Amazon APIGateway has been modified by
+ * Civic.
+ */
+
+var utils = require("./utils");
+var CryptoJS = require("../CryptoJS/rollups/hmac-sha256");
+var axios = require("../axios/dist/axios.standalone");
+
+var sigV4ClientFactory = {};
+sigV4ClientFactory.newClient = function (config) {
+    var AWS_SHA_256 = 'AWS4-HMAC-SHA256';
+    var AWS4_REQUEST = 'aws4_request';
+    var AWS4 = 'AWS4';
+    var X_AMZ_DATE = 'x-amz-date';
+    var X_AMZ_SECURITY_TOKEN = 'x-amz-security-token';
+    var HOST = 'host';
+    var AUTHORIZATION = 'Authorization';
+
+    function hash(value) {
+        return CryptoJS.SHA256(value);
+    }
+
+    function hexEncode(value) {
+        return value.toString(CryptoJS.enc.Hex);
+    }
+
+    function hmac(secret, value) {
+        return CryptoJS.HmacSHA256(value, secret, {asBytes: true});
+    }
+
+    function buildCanonicalRequest(method, path, queryParams, headers, payload) {
+        return method + '\n' +
+            buildCanonicalUri(path) + '\n' +
+            buildCanonicalQueryString(queryParams) + '\n' +
+            buildCanonicalHeaders(headers) + '\n' +
+            buildCanonicalSignedHeaders(headers) + '\n' +
+            hexEncode(hash(payload));
+    }
+
+    function hashCanonicalRequest(request) {
+        return hexEncode(hash(request));
+    }
+
+    function buildCanonicalUri(uri) {
+        return encodeURI(uri);
+    }
+
+    function buildCanonicalQueryString(queryParams) {
+        if (Object.keys(queryParams).length < 1) {
+            return '';
+        }
+
+        var sortedQueryParams = [];
+        for (var property in queryParams) {
+            if (queryParams.hasOwnProperty(property)) {
+                sortedQueryParams.push(property);
+            }
+        }
+        sortedQueryParams.sort();
+
+        var canonicalQueryString = '';
+        for (var i = 0; i < sortedQueryParams.length; i++) {
+            canonicalQueryString += sortedQueryParams[i] + '=' + encodeURIComponent(queryParams[sortedQueryParams[i]]) + '&';
+        }
+        return canonicalQueryString.substr(0, canonicalQueryString.length - 1);
+    }
+
+    function buildCanonicalHeaders(headers) {
+        var canonicalHeaders = '';
+        var sortedKeys = [];
+        for (var property in headers) {
+            if (headers.hasOwnProperty(property)) {
+                sortedKeys.push(property);
+            }
+        }
+        sortedKeys.sort();
+
+        for (var i = 0; i < sortedKeys.length; i++) {
+            canonicalHeaders += sortedKeys[i].toLowerCase() + ':' + headers[sortedKeys[i]] + '\n';
+        }
+        return canonicalHeaders;
+    }
+
+    function buildCanonicalSignedHeaders(headers) {
+        var sortedKeys = [];
+        for (var property in headers) {
+            if (headers.hasOwnProperty(property)) {
+                sortedKeys.push(property.toLowerCase());
+            }
+        }
+        sortedKeys.sort();
+
+        return sortedKeys.join(';');
+    }
+
+    function buildStringToSign(datetime, credentialScope, hashedCanonicalRequest) {
+        return AWS_SHA_256 + '\n' +
+            datetime + '\n' +
+            credentialScope + '\n' +
+            hashedCanonicalRequest;
+    }
+
+    function buildCredentialScope(datetime, region, service) {
+        return datetime.substr(0, 8) + '/' + region + '/' + service + '/' + AWS4_REQUEST
+    }
+
+    function calculateSigningKey(secretKey, datetime, region, service) {
+        return hmac(hmac(hmac(hmac(AWS4 + secretKey, datetime.substr(0, 8)), region), service), AWS4_REQUEST);
+    }
+
+    function calculateSignature(key, stringToSign) {
+        return hexEncode(hmac(key, stringToSign));
+    }
+
+    function buildAuthorizationHeader(accessKey, credentialScope, headers, signature) {
+        return AWS_SHA_256 + ' Credential=' + accessKey + '/' + credentialScope + ', SignedHeaders=' + buildCanonicalSignedHeaders(headers) + ', Signature=' + signature;
+    }
+
+    var awsSigV4Client = { };
+    if(config.accessKey === undefined || config.secretKey === undefined) {
+        return awsSigV4Client;
+    }
+    awsSigV4Client.accessKey = utils.assertDefined(config.accessKey, 'accessKey');
+    awsSigV4Client.secretKey = utils.assertDefined(config.secretKey, 'secretKey');
+    awsSigV4Client.sessionToken = config.sessionToken;
+    awsSigV4Client.serviceName = utils.assertDefined(config.serviceName, 'serviceName');
+    awsSigV4Client.region = utils.assertDefined(config.region, 'region');
+    awsSigV4Client.endpoint = utils.assertDefined(config.endpoint, 'endpoint');
+    awsSigV4Client.host = utils.assertDefined(config.host, 'host');
+
+    awsSigV4Client.makeRequest = function (request) {
+        var verb = utils.assertDefined(request.verb, 'verb');
+        var path = utils.assertDefined(request.path, 'path');
+        var queryParams = utils.copy(request.queryParams);
+        if (queryParams === undefined) {
+            queryParams = {};
+        }
+        var headers = utils.copy(request.headers);
+        if (headers === undefined) {
+            headers = {};
+        }
+
+        //If the user has not specified an override for Content type the use default
+        if(headers['Content-Type'] === undefined) {
+            headers['Content-Type'] = config.defaultContentType;
+        }
+
+        //If the user has not specified an override for Accept type the use default
+        if(headers['Accept'] === undefined) {
+            headers['Accept'] = config.defaultAcceptType;
+        }
+
+        var body = utils.copy(request.body);
+        if (body === undefined || verb === 'GET') { // override request body and set to empty when signing GET requests
+            body = '';
+        }  else {
+            body = JSON.stringify(body);
+        }
+
+        //If there is no body remove the content-type header so it is not included in SigV4 calculation
+        if(body === '' || body === undefined || body === null) {
+            delete headers['Content-Type'];
+        }
+
+        var datetime = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[:\-]|\.\d{3}/g, '');
+        headers[X_AMZ_DATE] = datetime;
+        headers[HOST] = awsSigV4Client.host;
+        var canonicalRequest = buildCanonicalRequest(verb, path, queryParams, headers, body);
+
+        var hashedCanonicalRequest = hashCanonicalRequest(canonicalRequest);
+        var credentialScope = buildCredentialScope(datetime, awsSigV4Client.region, awsSigV4Client.serviceName);
+        var stringToSign = buildStringToSign(datetime, credentialScope, hashedCanonicalRequest);
+        var signingKey = calculateSigningKey(awsSigV4Client.secretKey, datetime, awsSigV4Client.region, awsSigV4Client.serviceName);
+        var signature = calculateSignature(signingKey, stringToSign);
+        headers[AUTHORIZATION] = buildAuthorizationHeader(awsSigV4Client.accessKey, credentialScope, headers, signature);
+        if(awsSigV4Client.sessionToken !== undefined && awsSigV4Client.sessionToken !== '') {
+            headers[X_AMZ_SECURITY_TOKEN] = awsSigV4Client.sessionToken;
+        }
+        delete headers[HOST];
+
+        var url = config.endpoint + path;
+        var queryString = buildCanonicalQueryString(queryParams);
+        if (queryString != '') {
+            url += '?' + queryString;
+        }
+
+        //Need to re-attach Content-Type if it is not specified at this point
+        if(headers['Content-Type'] === undefined) {
+            headers['Content-Type'] = config.defaultContentType;
+        }
+
+        var signedRequest = {
+            method: verb,
+            url: url,
+            headers: headers,
+            data: body
+        };
+        return axios(signedRequest);
+    };
+
+    return awsSigV4Client;
+};
+
+module.exports = sigV4ClientFactory;

pool/shard011/JavaScript/0070417_app.js

@@ -0,0 +1,140 @@
+/*
+ *
+ *   INSPINIA - Responsive Admin Theme
+ *   version 2.7.1
+ *
+ */
+
+$(document).ready(function () {
+
+
+    // Add body-small class if window less than 768px
+    if ($(this).width() < 769) {
+        $('body').addClass('body-small')
+    } else {
+        $('body').removeClass('body-small')
+    }
+
+    // MetsiMenu
+    $('#side-menu').metisMenu();
+
+    // Collapse ibox function
+    $('.collapse-link').on('click', function () {
+        var ibox = $(this).closest('div.ibox');
+        var button = $(this).find('i');
+        var content = ibox.children('.ibox-content');
+        content.slideToggle(200);
+        button.toggleClass('fa-chevron-up').toggleClass('fa-chevron-down');
+        ibox.toggleClass('').toggleClass('border-bottom');
+        setTimeout(function () {
+            ibox.resize();
+            ibox.find('[id^=map-]').resize();
+        }, 50);
+    });
+
+    // Close ibox function
+    $('.close-link').on('click', function () {
+        var content = $(this).closest('div.ibox');
+        content.remove();
+    });
+
+    // Fullscreen ibox function
+    $('.fullscreen-link').on('click', function () {
+        var ibox = $(this).closest('div.ibox');
+        var button = $(this).find('i');
+        $('body').toggleClass('fullscreen-ibox-mode');
+        button.toggleClass('fa-expand').toggleClass('fa-compress');
+        ibox.toggleClass('fullscreen');
+        setTimeout(function () {
+            $(window).trigger('resize');
+        }, 100);
+    });
+
+    // Minimalize menu
+    $('.navbar-minimalize').on('click', function (event) {
+        event.preventDefault();
+        $("body").toggleClass("mini-navbar");
+        SmoothlyMenu();
+
+    });
+
+    // Full height of sidebar
+    function fix_height() {
+        var heightWithoutNavbar = $("body > #wrapper").height() - 61;
+        $(".sidebard-panel").css("min-height", heightWithoutNavbar + "px");
+
+        var navbarHeight = $('nav.navbar-default').height();
+        var wrapperHeight = $('#page-wrapper').height();
+
+        if (navbarHeight > wrapperHeight) {
+            $('#page-wrapper').css("min-height", navbarHeight + "px");
+        }
+
+        if (navbarHeight < wrapperHeight) {
+            $('#page-wrapper').css("min-height", $(window).height() + "px");
+        }
+
+        if ($('body').hasClass('fixed-nav')) {
+            if (navbarHeight > wrapperHeight) {
+                $('#page-wrapper').css("min-height", navbarHeight + "px");
+            } else {
+                $('#page-wrapper').css("min-height", $(window).height() - 60 + "px");
+            }
+        }
+
+    }
+
+    fix_height();
+
+    // Fixed Sidebar
+    $(window).bind("load", function () {
+        if ($("body").hasClass('fixed-sidebar')) {
+            $('.sidebar-collapse').slimScroll({
+                height: '100%',
+                railOpacity: 0.9
+            });
+        }
+    });
+
+    $(window).bind("load resize scroll", function () {
+        if (!$("body").hasClass('body-small')) {
+            fix_height();
+        }
+    });
+
+    // Add slimscroll to element
+    $('.full-height-scroll').slimscroll({
+        height: '100%'
+    })
+});
+
+
+// Minimalize menu when screen is less than 768px
+$(window).bind("resize", function () {
+    if ($(this).width() < 769) {
+        $('body').addClass('body-small')
+    } else {
+        $('body').removeClass('body-small')
+    }
+});
+
+function SmoothlyMenu() {
+    if (!$('body').hasClass('mini-navbar') || $('body').hasClass('body-small')) {
+        // Hide menu in order to smoothly turn on when maximize menu
+        $('#side-menu').hide();
+        // For smoothly turn on menu
+        setTimeout(
+            function () {
+                $('#side-menu').fadeIn(400);
+            }, 200);
+    } else if ($('body').hasClass('fixed-sidebar')) {
+        $('#side-menu').hide();
+        setTimeout(
+            function () {
+                $('#side-menu').fadeIn(400);
+            }, 100);
+    } else {
+        // Remove all inline style from jquery fadeIn function to reset menu state
+        $('#side-menu').removeAttr('style');
+    }
+}

pool/shard011/JavaScript/0070418_Cordova.js

@@ -0,0 +1,90 @@
+/**
+ * @private
+ */
+Ext.define('Ext.device.notification.Cordova', {
+    alternateClassName: 'Ext.device.notification.PhoneGap',
+    extend: 'Ext.device.notification.Abstract',
+    requires: ['Ext.device.Communicator'],
+
+    show: function(config) {
+        config = this.callParent(arguments);
+        this.confirm(config);
+    },
+
+    confirm: function(config) {
+        config = this.callParent(arguments);
+
+        var buttons = config.buttons,
+            ln = config.buttons.length;
+
+        if (ln && typeof buttons[0] != "string") {
+            var newButtons = [],
+                i;
+
+            for (i = 0; i < ln; i++) {
+                newButtons.push(buttons[i].text);
+            }
+            buttons = newButtons;
+        }
+
+        var callback = function(index) {
+            if (config.callback) {
+                config.callback.apply(config.scope, (buttons) ? [buttons[index - 1].toLowerCase()] : []);
+            }
+        };
+
+
+        navigator.notification.confirm(
+            config.message,
+            callback,
+            config.title,
+            buttons
+        );
+    },
+
+    alert: function(config) {
+        navigator.notification.alert(
+            config.message,
+            config.callback,
+            config.title,
+            config.buttonName
+        );
+    },
+
+    prompt: function(config) {
+        config = this.callParent(arguments);
+        var buttons = config.buttons,
+            ln = config.buttons.length;
+
+        if (ln && typeof buttons[0] != "string") {
+            var newButtons = [],
+                i;
+
+            for (i = 0; i < ln; i++) {
+                newButtons.push(buttons[i].text);
+            }
+            buttons = newButtons;
+        }
+
+        var callback = function(result) {
+            if (config.callback) {
+                config.callback.call(config.scope, (buttons) ? buttons[result.buttonIndex - 1].toLowerCase() : null, result.input1);
+            }
+        };
+
+        navigator.notification.prompt(
+            config.message,
+            callback,
+            config.title,
+            buttons
+        );
+    },
+
+    vibrate: function(time) {
+        navigator.notification.vibrate(time);
+    },
+
+    beep: function(times) {
+        navigator.notification.vibrate(times);
+    }
+});