$('#schedule_data .t-fht-tbody td:nth-child(1)').css('position','relative');
$('#schedule_data .t-fht-thead.js-stickyTableHeader th:nth-child(1)').css('position','relative');

// border
$('#schedule_data .t-fht-thead.js-stickyTableHeader th:nth-child(1)').css('border-right','1px solid rgba(0, 0, 0, .5)');
$('#schedule_data .t-fht-tbody td:nth-child(1)').css('border-right','1px solid rgba(0, 0, 0, .5)');

$(document).ready(function() {
  $('#schedule_data .t-fht-tbody').scroll(function(e) { //detect a scroll event on the tbody
    $('#schedule_data .t-fht-thead.js-stickyTableHeader th:nth-child(1)').css("left", $("#schedule_data .t-fht-tbody").scrollLeft()); //fix the first cell of the header
    $('#schedule_data .t-fht-tbody td:nth-child(1)').css("left", $("#schedule_data .t-fht-tbody").scrollLeft()); //fix the first column of tdbody
  });
});

freezeColumnsIR('schedule_data',4);


function freezeColumnsIR(reportId,nroColumns){

   var borderHeader = '#'+ reportId +' .t-fht-thead.js-stickyTableHeader th:nth-child('+nroColumns+')';
   var borderBody = '#'+  reportId+' .t-fht-tbody td:nth-child('+nroColumns+')';

   var headerReport = '#'+  reportId+' .t-fht-thead.js-stickyTableHeader th:lt('+nroColumns+')';
   var bodyTrReport = '#'+  reportId+' tbody tr';

   // set border
   $(borderHeader).css('border-right','1px solid rgba(0, 0, 0, .5)');
   $(borderBody).css('border-right','1px solid rgba(0, 0, 0, .5)');

   // fix the header
   $(headerReport).css('position','relative');

   // fix body
   $(bodyTrReport).each(function(e) {
      $(this).find('td:lt('+nroColumns+')').css('position','relative');
   });

   // controll the scroll

   $(document).ready(function() {
     var bodyReport = '#'+ reportId + ' .t-fht-tbody';
    console.log(bodyReport);
     
     $(bodyReport).scroll(function(e) { //detect a scroll event on the tbody
      
         //console.log(e);
         var left_size = $(bodyReport).scrollLeft();
         $(headerReport).css("left", left_size); //fix the first cell of the header

         $(bodyTrReport).each(function(e) {
            $(this).find('td:lt('+nroColumns+')').css("left", left_size);
         });

      //$('#schedule_data .t-fht-tbody td:nth-child(1)').css("left", left_size); //fix the first column of tdbody
   });
   });
}

/**
		 * Wait until condition become 'false' and run function.
		 *
		 * @param {Function} condition - function that should return needed condition
		 * @param {Number} waitMs - timeout between re-check
		 * @param {Function} func - called when condition isn't 'false'
		 * @param {Object} [context] - context passed to main function
		 * @param {Array} [args] - arguments passed to main function
		 */
		function waitAndRun(condition, waitMs, func, context, args) {
			if (condition.call(null, null)) {
				setTimeout(function () {
					waitAndRun(condition, waitMs, func);
				}, waitMs);
				return;
			}
			func.apply(context, args);
		}

var LoanerUtils = Class.create();
LoanerUtils.prototype = {
  /**********
   * Initialization stuff here...
   *
   **********/
  initialize : function() {
    this.overdueRemindTime = gs.getProperty('x_cdltd_loaner_req.overdue.remindtime', 24) * 60 * 60 * 1000;
    this.pickupLeadTime    = gs.getProperty('x_cdltd_loaner_req.pickup.leadtime', 24) * 60 * 60 * 1000;
    this.returnRemindTime  = gs.getProperty('x_cdltd_loaner_req.return.remindtime', 24) * 60 * 60 * 1000;
	  
	this.appScopeName = gs.getCurrentScopeName();
	this.loanerTableName = this.appScopeName + '_loaner_request';
	this.pickupEvent = this.appScopeName + '.pickup';
	this.returnEvent = this.appScopeName + '.return';
	this.remindEvent = this.appScopeName + '.reminder';
	this.overdueEvent = this.appScopeName + '.overdue';
  },

  /**********
   *
   * getOverdueRequests - retrieve a list of overdue records
   *
   * @param - None
   * @return: array of sys_ids
   *
   **********/
  getOverdueRequests : function() {

    var a = [];
    var gr = new GlideRecord(this.loanerTableName);
    
	var rightNow = new GlideDateTime().getDisplayValue();
    gr.addQuery('end_date', '<=', rightNow);
    gr.addQuery('state', 17);
    gr.query();

    while (gr.next()) {
      a.push(gr.sys_id.toString());
    }
    return a;
  },

  /**********
   *
   * timeToRemindOverdue - Use the passed in ID to check if the record is time to remind again
   *
   * @param - id: sys_id of the loaner record to check
   * @return - boolean: true = time to remind
   *
   **********/
  timeToRemindOverdue : function(id) {

    var gr = new GlideRecord(this.loanerTableName);
	  
	  var noticeTime = new GlideDateTime();
	  var tempDate = noticeTime.add(this.overdueRemindTime) + '';

    if (!gr.get(id)) {
      gs.log('>>>DEBUG: LoanerUtils: timeToRemindOverdue(): FAILED TO RETRIEVE RECORD');
      return false;
    }
    var baseDate = (gr.last_overdue_reminder == '') ? gr.end_date : gr.last_overdue_reminder;

    return (baseDate <= tempDate) ? true : false;
  },

  /**********
   *
   * sendOverdueReminder - Queue an event to send a reminder and update the necessary
   *                       record fields to indicate they've been reminded
   *
   * @param - id: sys_id of the loaner record to check
   * @return - None
   *
   **********/
  sendOverdueReminder : function(id) {

    var gr = new GlideRecord(this.loanerTableName);

    if (!gr.get(id)) {
      gs.log('>>>DEBUG: LoanerUtils: setLastOverdueReminder(): FAILED TO RETRIEVE RECORD');
      return;
    }
    ++gr.overdue_count;

    // Record the last time a reminder was sent
    gr.last_overdue_reminder = new GlideDateTime().getDisplayValue();
    gr.update();

    // Send the overdue reminder
    gs.eventQueue(this.overdueEvent, gr, gr.start_date, gr.end_date);
  },

  /**********
   *
   * getNullPickupReminders - Get a list of records in state 'Ready for Pickup'
   *                          that haven't been reminded before
   *
   * @param - None
   * @return - array of sys_ids
   *
   **********/
  getNullPickupReminders : function() {

    var a = [];
    var gr = new GlideRecord(this.loanerTableName);
	var noticeTime = new GlideDateTime();
	noticeTime.add(this.pickupLeadTime);
	
    gr.addQuery('state', 16);
    gr.addQuery('pick_up_reminder', '');
    gr.addQuery('start_date', '<=', noticeTime);
    gr.query();

    while (gr.next()) {
      a.push(gr.sys_id.toString());
    }
    return a;
  },

  /**********
   *
   * sendPickupReminder - Queue an event to send a reminder and update the pickup reminder field
   *
   * @param - id: sys_id of the loaner record to check
   * @return - None
   *
   **********/
  sendPickupReminder : function(id) {

    var gr = new GlideRecord(this.loanerTableName);

    if (!gr.get(id)) {
      gs.debug('>>>DEBUG: LoanerUtils: sendPickupReminder(): FAILED TO RETRIEVE RECORD');
      return;
    }

    // Log the time the pickup reminder was sent and avoid sending again
    gr.pick_up_reminder = new GlideDateTime().getDisplayValue();
    gr.update();

    // Send the pickup reminder
    gs.eventQueue(this.pickupEvent, gr, gr.start_date, gr.end_date);
    return;
  },

  /**********
   *
   * getNullReturnReminders - Get a list of records that need reminding to bring their item back
   *
   * @param - None
   * @return - array of sys_ids
   *
   **********/
  getNullReturnReminders : function() {

    var a = [];
    var gr = new GlideRecord(this.loanerTableName);
	  
	var noticeTime = new GlideDateTime();
	var tempDate = noticeTime.add(this.returnRemindTime) + '';

    gr.addQuery('state', 17);
    gr.addQuery('return_reminder', '');
    gr.addQuery('end_date', '<=', tempDate);
    gr.query();

    while (gr.next()) {
      a.push(gr.sys_id.toString());
    }
    return a;
  },

  /**********
   *
   * setReturnReminder - Queue a return reminder and update field when reminder was sent
   *
   * @param - id: sys_id of the loaner record to check
   * @return - None
   *
   **********/
  sendReturnReminder : function(id) {

    var gr = new GlideRecord(this.loanerTableName);

    if (!gr.get(id)) {
      gs.debug('>>>DEBUG: LoanerUtils: sendReturnReminder(): FAILED TO RETRIEVE RECORD');
      return;
    }

    // Set this record to never remind again
    gr.return_reminder = new GlideDateTime().getDisplayValue();
    gr.update();

    // Send the return reminder
    gs.eventQueue(this.returnEvent, gr, gr.start_date, gr.end_date);
  },

  type: 'LoanerUtils'
};

	
	var gr = new GlideRecord('x_cdltd_loaner_req_loaner_request');
	var pickUpLeadTime = gs.getProperty('x_cdltd_loaner_req.pickup.leadtime',24) * 60 * 60 * 1000;
	
	var noticeTime = new GlideDateTime();
	noticeTime.add(pickUpLeadTime);
	
	gr.addQuery('state',16);
	gr.addQuery('pick_up_reminder','');
	gr.addQuery('start_date', '<=',noticeTime);
	gr.query();
	
	var rightNow = new GlideDateTime();
	
	while (gr.next()) {
		gr.pick_up_reminder = rightNow;
		gr.update();
		gs.eventQueue('x_cdltd_loaner_req.pickUp',gr,gr.number,gs.getUserName());
	}

// Requires official MongoShell 3.6+
use webapp;
db.getCollection("schools").aggregate(
    [
        { 
            "$match" : {
                "status" : "active", 
                "country" : "Reino Unido", 
                "city" : "Londres"
            }
        }, 
        { 
            "$group" : {
                "_id" : "$_id", 
                "school" : {
                    "$push" : "$$ROOT"
                }
            }
        }, 
        { 
            "$unwind" : {
                "path" : "$school"
            }
        }, 
        { 
            "$lookup" : {
                "from" : "hosting", 
                "localField" : "_id", 
                "foreignField" : "schoolId", 
                "as" : "hosting"
            }
        }, 
        { 
            "$lookup" : {
                "from" : "courses", 
                "as" : "courses", 
                "let" : {
                    "schoolId" : "$_id"
                }, 
                "pipeline" : [
                    {
                        "$match" : {
                            "$expr" : {
                                "$and" : [
                                    {
                                        "$eq" : [
                                            "$schoolId", 
                                            "$$schoolId"
                                        ]
                                    }, 
                                    {
                                        "$eq" : [
                                            "$program", 
                                            "Intensivo"
                                        ]
                                    }
                                ]
                            }
                        }
                    }
                ]
            }
        }
    ], 
    { 
        "allowDiskUse" : false
    }
);

jQuery('#menu-main-navigation-3 a').on('click', function(){
jQuery(this).parents('div.oxy-modal-backdrop').removeClass('live');
});

const process = require('process');

process.on('uncaughtException', (err, origin) => {
  console.log('uncaughtException', err);
});

import * as actionTypes from './actions';

const initialState = {
    persons: []
};

const reducer = ( state = initialState, action ) => {
    switch ( action.type ) {
        case actionTypes.ADD_PERSON:
            const newPerson = {
                id: Math.random(), // not really unique but good enough here!
                name: action.personData.name,
                age: action.personData.age
            }
            return {
                ...state,
                persons: state.persons.concat( newPerson )
            }
        case actionTypes.REMOVE_PERSON:
            return {
                ...state,
                persons: state.persons.filter(person => person.id !== action.personId)
            }
    }
    return state;
};

export default reducer;

import React, { Component } from 'react';
import { connect } from 'react-redux';

import Person from '../components/Person/Person';
import AddPerson from '../components/AddPerson/AddPerson';
import * as actionTypes from '../store/actions';

class Persons extends Component {
    
    render () {
        return (
            <div>
                <AddPerson personAdded={this.props.onAddedPerson} />
                {this.props.prs.map(person => (
                    <Person 
                        key={person.id}
                        name={person.name} 
                        age={person.age} 
                        clicked={() => this.props.onRemovedPerson(person.id)}/>
                ))}
            </div>
        );
    }
}

const mapStateToProps = state => {
    return {
        prs: state.persons
    };
};

const mapDispatchToProps = dispatch => {
    return {
        onAddedPerson: (name, age) => dispatch({type: actionTypes.ADD_PERSON, personData: {name: name, age: age}}),
        onRemovedPerson: (id) => dispatch({type: actionTypes.REMOVE_PERSON, personId: id})
    }
};

export default connect(mapStateToProps, mapDispatchToProps)(Persons);

import React, { Component } from 'react';

import './AddPerson.css';

class AddPerson extends Component {
    state = {
        name: '',
        age: ''
    }

    nameChangedHandler = (event) => {
        this.setState({name: event.target.value});
    }

    ageChangedHandler = (event) => {
        this.setState({age: event.target.value});
    }

    render () {
        return (
            <div className="AddPerson">
                <input 
                    type="text" 
                    placeholder="Name" 
                    onChange={this.nameChangedHandler}
                    value={this.state.name} />
                <input 
                    type="number" 
                    placeholder="Age"
                    onChange={this.ageChangedHandler}
                    value={this.state.age} />
                <button onClick={() => this.props.personAdded(this.state.name, this.state.age)}>Add Person</button>
            </div>
        );
    }
}

export default AddPerson;

import React from 'react';

import './Person.css';

const person = (props) => (
    <div className="Person" onClick={props.clicked}>
        <h1>{props.name}</h1>
        <p>Age: {props.age}</p>
    </div>
);

export default person;

exports.getAllTours = async (req, res) => {
  
  try{
    const tours = await Tour.find()
      .where('duration')
      .equals(5)
      .where('difficulty')
      .equals('easy');
  }
  catch(err){}
}

const mongoose = require('mongoose');
const dotenv = require('dotenv');
 
dotenv.config({ path: './config.env' }); // Load the dev environmnet variables
const DB = process.env.DATABASE.replace(
  '<PASSWORD>',
  process.env.DATABASE_PASSWORD
);
 
mongoose
  .connect(DB, {
    useNewUrlParser: true,
    useCreateIndex: true,
    useFindAndModify: false
  })
  .then(con => console.log('DB connection successful!'));