Routes.ns

(*******************************************************************************
* Copyright (c) 2015 IBM Corp.
*
* 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.
*******************************************************************************)

class Routes usingPlatform: platform dataAccess: dataaccess andJSON: JSON andLoader: loader= Value(
  |
  private Kernel = platform kernel.
  private Vector = Kernel Vector.
  private Loader = loader.
  private Session = Loader Session.
  private Date = Kernel Date.
  private DataAccess = dataaccess.
  private Dictionary = platform collections Dictionary.
  private Files = platform files.
  private Booking = Loader Booking.
  private JSON = JSON.
  private SQLException = platform derby SQLException.
  private Set = platform collections Set.
  |
)(

public class Routes new: authService settings: settings = (
  |
  uuid = 0.
  flightCache = TTL_LRU_Cache new. (*'require(ttl-lru-cache)({maxLength:settings.flightDataCacheMaxSize})'.*)
  flightSegmentCache = TTL_LRU_Cache new.(*'require(ttl-lru-cache)({maxLength:settings.flightDataCacheMaxSize})'.*)
  flightDataCacheTTL = 1000000.(*'settings.flightDataCacheTTL == -1 ? null : settings.flightDataCacheTTL'.*)
  dataaccess = DataAccess DataAccess new.
  settings = settings.
  authService = authService.
  |
) (

  public initializeDatabaseConnections: clear callback: callback = (
    dataaccess initializeDatabaseConnections: clear callback: callback.
  )

  public insertOne: collectionname doc: doc callback: callback = (
    dataaccess insertOne: collectionname doc: doc callback: callback.
  )

  public checkForValidSessionCookie = (
    ^ [ :exch | | sessionid |
      sessionid:: exch requestCookie: #sessionid.
      sessionid ifNotNil: [
        (*trim sessionid sessiondid = sessionid.trim();*)
      ].

      ((sessionid = nil) || (sessionid = '')) ifTrue: [
        exch sendResponseStatus: 403.
        ^ self.
      ].

      [ validateSession: sessionid callback: [ :customerid |
          customerid ifNil: [
            (*logger.debug('checkForValidCookie - bad session so returning 403');*)
            exch sendResponseStatus: 403.
            ^ self.
          ] ifNotNil: [
            (*logger debug ('checkForValidCookie - good session so allowing next route handler to be called') *)
            exch at: 'acmeair_login_user' put: customerid.
          ]
        ]
      ] on: SQLException do: [ :error |
        (*logger.debug('checkForValidCookie - system error validating session so returning 500');*)
        'error' println.
        exch sendResponseStatus: 500.
        ^ self.
      ].
    ]
  )

  public login: exch = (
    | login password query|
    (*logger.debug('logging in user');*)
    query:: exch getRequestQuery.
    login:: query at: 'login'.
    password:: query at: 'password'.
    exch responseCookie:'sessionid' with: ''.

    [
      (* replace eventually with call to business logic to validate customer*)
      validateCustomer: login password: password callback: [ :customerValid | 
        customerValid ifTrue: [
          createSession: login callback: [ :sessionid |
            exch responseCookie: 'sessionid' with: sessionid.
            exch sendResponse: 'logged in'.
          ]
        ] ifFalse: [
          exch sendResponseStatus: 403.
        ] 
      ]
    ] on: SQLException do: [ :error |
      (*logger.info(error);*)
      exch sendResponse: (error asString) with: 500.
      ^ self.
    ]
  )

  public logout: exch = (
    | sessionid login |
    (*logger.debug('logging out user');*)
  
    sessionid::  (exch requestCookie: #sessionid).
    invalidateSession: sessionid callback: [
      exch responseCookie: 'sessionid' with: ''.
      exch sendResponse: 'logged out'.
    ]
  )

  public queryflights = (
    ^ [ :exch | | fromAirport toAirport fromDateWeb fromDate oneWay returnDateWeb returnDate options query|
      (* logger.debug('querying flights');*)
      query:: exch getRequestQuery.
      fromAirport:: query at: 'fromAirport'.
      toAirport:: query at: 'toAirport'.
      fromDateWeb:: Date new: (query at: 'fromDate'). (*TODO make Date*)
      
      (*fromDate:: Date new: (fromDateWeb.getFullYear(), fromDateWeb.getMonth(), fromDateWeb.getDate()).*) (*convert date to local timezone*)
      oneWay:: (exch at: 'body.oneWay') = 'true'.(*TODO careful here*)
      returnDateWeb:: Date new: (exch at: 'body.returnDate').

      oneWay ifFalse: [
        (*returnDate:: Date new: (returnDateWeb.getFullYear(), returnDateWeb.getMonth(), returnDateWeb.getDate()).*) (*convert date to local timezone*)
      ].

      getFlightByAirportsAndDepartureDate: fromAirport toAirport: toAirport flightDate: fromDate callback: [ :flightSegmentOutbound :flightsOutbound |
        | _flightsOutbound |
        (*logger.debug('flightsOutbound = ' + flightsOutbound);*)
        flightsOutbound ifNil: [
          _flightsOutbound:: Vector new: 0.
        ] ifNotNil: [
          _flightsOutbound:: flightsOutbound.
          1 to: (_flightsOutbound size) do: [ :ii |
            (_flightsOutbound at: ii) flightSegment: flightSegmentOutbound.
          ]
        ].
        
        oneWay ifTrue: [
          (*TODO serialize flightsOutbound and return*)
          options:: ('{"tripFlights":
            [
            {"numPages":1,"flightsOptions": ' + (VectorToJson: _flightsOutbound) + ',"currentPage":0,"hasMoreOptions":false,"pageSize":10}
            ], "tripLegs":1}').
          exch sendResponse: options.
        ] ifFalse: [
          getFlightByAirportsAndDepartureDate: toAirport toAirport: fromAirport flightDate: returnDate callback: [ :flightSegmentReturn :flightsReturn |
            | _flightsReturn |
            (*logger.debug('flightsReturn = ' + JSON.stringify(flightsReturn));*)
            flightsReturn  ifNil: [
              _flightsReturn:: Vector new: 0.
            ] ifNotNil: [
              _flightsReturn:: flightsReturn.
              1 to: (flightsReturn size) do: [ :ii |
                (_flightsReturn at: ii) flightSegment: flightSegmentReturn.
              ]
            ].

            options:: ('{"tripFlights":
              [
              {"numPages":1,"flightsOptions": ' + (VectorToJson: _flightsOutbound) + ',"currentPage":0,"hasMoreOptions":false,"pageSize":10},
              {"numPages":1,"flightsOptions": ' + (VectorToJson: _flightsReturn) + ',"currentPage":0,"hasMoreOptions":false,"pageSize":10}
              ], "tripLegs":2}').
            exch sendResponse: options.
          ]
        ]
      ]
    ].
  )

  private VectorToJson: aVector = (
    | result |
    result:: '['.

    aVector size > 0 ifTrue: [
      result:: result + ((aVector at: 1) toJSON).
      2 to: (aVector size) do: [ :i |
        result:: result + ', ' + ((aVector at: i) toJSON).
      ]
    ].

    result:: result + ']'.
    ^result
  )

  public bookflights = (
    ^ [ :exch | | query userid toFlight retFlight oneWay bookingInfo|
      (* logger.debug('booking flights'); *)
      
      query:: exch getRequestQuery.
      userid:: query at: 'userid'.
      toFlight:: query at: 'toFlightId'.
      retFlight:: query at: 'retFlightId'.
      oneWay:: (query at: 'oneWayFlight') = 'true'.
      
      (* logger.debug("toFlight:"+toFlight+",retFlight:"+retFlight); *)

      bookFlight: toFlight userid: userid callback: [ :toBookingId |
        oneWay ifTrue: [
          bookingInfo:: ('{"oneWay":true,"departBookingId":' + toBookingId + '};').
          exch responseHeader: 'Cache-Control' value: 'no-cache'.
          exch sendResponse: bookingInfo.
        ] ifFalse: [
          bookFlight: retFlight userid: userid callback: [ :retBookingId |
            bookingInfo:: ('{"oneWay":false,"returnBookingId":' + retBookingId + ',"departBookingId":' + toBookingId + '}').
            exch responseHeader: 'Cache-Control' value: 'no-cache'.
            exch sendResponse: bookingInfo.
          ]
        ]
      ]
    ].
  )

  public cancelBooking = (
    ^ [ :exch | | number userid query|
      (*logger.debug('canceling booking');*)
      query:: (exch getRequestQuery).
      number:: query at: 'number'.
      userid:: query at: 'userid'.
      [ 
        cancelBooking: number userid: userid callback: [ exch sendResponse: '{"status":"success"}' ]
      ] on: SQLException do: [ :error |
        exch sendResponse: '{"status":"error"}'.
      ]
    ].
  )

  public bookingsByUser = (
    ^ [ :exch |
      (*logger.debug('listing booked flights by user ' + req.params.user);*)
      [ 
        getBookingsByUser: (exch at: 'params.user') callback: [ :bookings | exch sendResponse: (VectorToJson: bookings) ]
      ] on: SQLException do: [ :error |
        exch sendResponseStatus: 500.
      ]
    ].
  )

  public getCustomerById = (
    ^ [ :exch|
      (*logger.debug('getting customer by user ' + req.params.user);*)
      [
        getCustomer: (exch at: 'params.user') callback: [ :customer | exch sendResponse: (customer toJSON) ]
      ] on: SQLException do: [ :error |
        exch sendResponseStatus: 500.  
      ]
    ].
  )

  public putCustomerById = (
    ^ [ :exch |
        (*logger.debug('putting customer by user ' + req.params.user);*)
      [
        updateCustomer: (exch at: 'params.user') customer: (exch requestBody) callback: [ :customer | exch sendResponse: (customer toJSON) ]
      ] on: SQLException do: [ :error |
        exch sendResponseStatus: 500.  
      ]
    ]
  )

  public toGMTString = (
    ^ [ :exch | | now |
      (*logger.info('******* running eyecatcher function');*)
      now:: Date new toGMTString
      exch sendResponse: now.
    ].
  )

  public getRuntimeInfo = (
    ^ [ :exch |
      exch responseContentType: 'application/json'.
      exch sendResponse: '[{"name":"Runtime","description":"SOMns"}]'.
    ].
  )
  
  public getDataServiceInfo = (
    ^ [ :exch |
      exch sendResponse: '[{"name":"derby","description":"JRE Integrated DB"}]'.
    ].
  )

  public getActiveDataServiceInfo = (
    ^ [ :exch |
      exch sendResponse: 'derby'.
    ].
  )

  public countBookings = (
    ^ [ :exch |
      [ 
        countItems: #n_booking callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ]
      ] on: SQLException do: [ :error |
        error println.
        exch sendResponse: -1.
      ]
    ].
  )

  public countCustomer = (
    ^ [ :exch |
      [ 
        countItems: #n_customer callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ]
      ] on: SQLException do: [ :error |
        exch sendResponse: -1.
      ]
    ].
  )

  public countCustomerSessions= (
    ^ [ :exch |
      [ 
        countItems: #n_customerSession callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ]
      ] on: SQLException do: [ :error |
        exch sendResponse: -1.
      ]
    ].
  )

  public countFlights = (
    ^ [ :exch |
      [ 
        countItems: #n_flight callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ] 
      ] on: SQLException do: [ :error |
        exch sendResponse: -1.
      ]
    ].
  )

  public countFlightSegments = (
    ^ [ :exch |
      [ 
        countItems: #n_flightSegment callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ]
      ] on: SQLException do: [ :error |
        exch sendResponse: -1.
      ]
    ].
  )

  public countAirports = (
    ^ [ :exch |
      [ 
        countItems: #n_airportCodeMapping callback: [ :count | exch sendResponse: ((count at: 1) at: 1) ]
      ] on: SQLException do: [ :error |
        exch sendResponse: -1.
      ]
    ].
  )

  countItems: dbName callback: callback = (
    (*console.log("Calling count on " + dbName);*)
    dataaccess count: dbName condition: 'true' callback: [ :count |
      (*console.log("Output for "+dbName+" is "+count);*)
      callback value: count.
    ]
  )

  validateCustomer: username password: password callback: callback = (
    dataaccess findOne: #n_customer key: username callback: [ :customer |
      customer ifNil: [
        callback value: false
      ] ifNotNil: [
        callback value: ((customer password) = password)
      ]. 
    ]
  )

  createSession: customerId callback: callback = (
    | now later document docId|
      
    authService ifNotNil: [
      authService createSession callback: callback.
      ^ self.
    ].
    
    now:: Date new.
    later:: Date new: (now getTime + 1000*60*60*24).
      
    docId:: Files getUUIDV4.
    document:: Session new: docId customer: customerId last: now timeout: later.

    dataaccess insertOne: #n_customerSession doc: document callback: [ :doc |
      callback value: docId.
    ] 
  )

  validateSession: sessionId callback: callback = (
    | now |
    authService ifNotNil:[
      authService validateSession: sessionId callback: callback.
      ^ self.
    ].

    now:: Date new.
    dataaccess findOne: #n_customerSession key: sessionId callback: [ :session |
      session ifNil: [
        callback value: nil.
      ] ifNotNil: [
        (now getTime) > (session timeoutTime getTime) ifTrue: [
          dataaccess remove: #n_customerSession condition: 'id=?' conditionParam: {sessionId} callback: [ callback value: nil ]
        ] ifFalse: [
          callback value: (session customerid).
        ]
      ]
    ]
  )

  getCustomer: username callback: callback = (
    dataaccess findOne: #n_customer key: username callback: callback.
  )

  updateCustomer: login customer: customer callback: callback = (
    dataaccess update: #n_customer doc: (Loader Customer fromJSON: customer) callback: callback.
  )

  getBookingsByUser: username callback: callback = (
    dataaccess findBy: #n_booking condition: 'customerId=?' conditionParam: {username} callback: callback
  )

  invalidateSession: sessionId callback: callback = (
    authService ifNotNil: [
      authService invalidateSession: sessionId callback: callback.
      ^ self.
    ].
      
    dataaccess remove: #n_customerSession condition: 'id=?' conditionParam: { sessionId} callback: callback. 
  )

  getFlightByAirportsAndDepartureDate: fromAirport toAirport: toAirport flightDate: flightDate callback: callback = (
    (*logger.debug("getFlightByAirportsAndDepartureDate " + fromAirport + " " + toAirport + " " + flightDate);*)
    
    getFlightSegmentByOriginPortAndDestPort: fromAirport toAirport: toAirport callback: [ :flightsegment | 
    | date flights cacheKey searchCriteria docsEmpty |
      (*logger.debug("flightsegment = " + JSON.stringify(flightsegment));*)

      flightsegment ifNil: [
        callback value: nil with: nil.
      ] ifNotNil: [
        date:: Date new: ((Date new) getTime - ((Date new) getTime % (1000 * 60 * 60 * 24))).
  
        cacheKey:: (flightsegment _id) + '-' + (date getTime). (* TODO *)
        (settings at: #useFlightDataRelatedCaching) ifTrue: [
          flights:: flightCache get: cacheKey.
          flights ifNil: [
            dataaccess findBy: #n_flight condition: 'flightSegmentId=? and scheduledDepartureTime=?' conditionParam: {(flightsegment _id) . date getTime}  callback: [ :docs |
              | docsEmpty cacheValue |
              (*'after cache miss - key = ' + cacheKey + ', docs = ' + JSON stringify: docs*)

              docsEmpty:: false.
              docs ifNil: [
                docsEmpty:: true
              ] ifNotNil: [
                docs size = 0 ifTrue: [
                  docsEmpty:: true.
                ]
              ].

              (settings at: #useFlightDataRelatedCaching) ifTrue: [
                docsEmpty ifTrue: [cacheValue:: 'NULL'] ifFalse: [cacheValue:: docs].

                (*'about to populate the cache with flights key = ' + cacheKey + ' with value of ' + JSON stringify: cacheValue*)
                flightCache set: cacheKey to: cacheValue for: flightDataCacheTTL.
                (*'after cache populate with key = ' + cacheKey + ', flightCacheSize = ' + flightCache size*)
              ].

              callback value: flightsegment with: docs.
            ]
          ] ifNotNil: [
            (*logger.debug("cache hit - flight search, key = " + cacheKey);*)
            
            'NULL' = flights ifTrue: [
              callback value: flightsegment with: nil.
            ] ifFalse: [
              callback value: flightsegment with: flights.
            ].
          ].

          (*logger.debug("cache miss - flight search, key = " + cacheKey + " flightCache size = " + flightCache.size());*)
        ].
      ].
    ]
  )

  getFlightSegmentByOriginPortAndDestPort: fromAirport toAirport: toAirport callback: callback = (
    | segment done |
    done:: false.
    (settings at: #useFlightDataRelatedCaching) ifTrue: [
      segment:: flightSegmentCache get: (fromAirport + toAirport).
      
      segment ifNotNil: [
        (*logger debug ("cache hit - flightsegment search, key = " + fromAirport+toAirport);*)

        ('NULL' = segment) ifTrue: [
          callback value: nil.
          ^ self.
        ] ifFalse: [
          callback value: segment.
          ^ self.
        ]. 
      ]. 
      (*logger debug ('cache miss - flightsegment search, key = ' + fromAirport+toAirport + ', flightSegmentCache size = ' + flightSegmentCache.size());*)
    ].
    
    dataaccess findBy: #n_flightSegment condition: 'originPort=? and destPort=?' conditionParam: {fromAirport . toAirport} callback: [ :docs |
      docs size = 0 ifTrue: [
        segment:: nil.
      ] ifFalse: [
        segment:: docs at: 1.
      ].
      (settings at: #useFlightDataRelatedCaching) ifTrue: [
        (*'about to populate the cache with flightsegment key = ' + fromAirport+toAirport + ' with value of ' + JSON stringify: segment*)
        segment ifNil: [
          flightSegmentCache set: (fromAirport+toAirport) to: 'NULL' for: flightDataCacheTTL.
        ] ifNotNil: [
          flightSegmentCache set: (fromAirport+toAirport) to: segment for: flightDataCacheTTL.
        ].
        (*'after cache populate with key = ' + fromAirport+toAirport + ', flightSegmentCacheSize = ' + (flightSegmentCache size)*)
      ].
      callback value: segment.
    ]
  )

  bookFlight: flightId userid: userid callback: callback = (
    | now docId document |
    now:: Date new.
    docId:: Files getUUIDV4.
    document:: Booking new: docId customer: userid flight: flightId time: now.
    dataaccess insertOne: #n_booking doc: document callback: [ :res |
      callback value: docId ].
  )

  cancelBooking: bookingId userid: userid callback: callback = (
    dataaccess remove: #n_booking condition: 'id=? and customerId=?' conditionParam: {bookingId . userid} callback: callback.
  )
) : (
  
)

public class TTL_LRU_Cache = (
  |
    cache ::= Dictionary new.
    lru ::= Vector new.
    lruId ::= 1.
    gcInterval = 30000. (* How often GC happens*)
    maxLength = 1000. (* Maximum number of items that can be held in the cache by default. *)
    lruWriteCleanup = 100. (* Run the LRU clean up every 'lruWriteCleanUp' writes *)
  |

    (*juse timerprim to periodically call gc*)
)(
  private class MyDict = Dictionary (

  ) (
    public remove: key = (
      | newDict |
      newDict:: MyDict new: self capacity.

      self keys do: [ :k |
        k = key ifFalse: [
                  newDict at: k put: (self at: k)
                ]
      ].

      ^ newDict.
    )
  )

  private class CacheEntry new: value = (
    |
      public value = value.
      public expire
    |
  ) ()

  public clear = (
    (*set cahce and lru empty*)
  )

  public del: key = (
    | item |
    item = cache at: key.
    item ifNotNil: [
      lru removeValue: key.
      cache:: cache remove: key.
    ]
  )

  public garbageCollection = (
    cache keys do: [ :key |
      | item |
      item:: cache at: key.
      item expire <= (Date now) ifTrue: [
        expire: key item: item.
      ]
    ].
    lruClean
  )

  public lruClean = (
    | overage cacheId |
    overage:: cache size - maxLength. 
    (*make new lru und cache, copy stuff that isnt deleted...*)

    (*remove the overage oldest entries*)
    1 to: overage do: [ :i |
      cacheId:: lru removeFirst.
      cache:: cache remove: cacheId.
    ]

    (*remove 1 to overage from lru*)
  )

  public expire: key item: item = (
    del: key.
    (*instance.emit('expired', key, item.value)*)
  )

  public set: key to: value for: ttl = (
    | item |
    key ifNil: [
      (*error*)
    ].

    item:: CacheEntry new: value.
    ttl ifNotNil: [
      item expire: ((Date new) getTime + ttl).
    ].

    cache at: key put: item.
    lru append: key.
    lruId:: lruId + 1.
    
    (lruId % lruWriteCleanup) = 0 ifTrue: [
      lruClean.
    ]
  )

  public get: key = (
    | response item |
    item:: cache at: key.
    item ifNotNil: [
      item expire ifNotNil: [
        item expire < (Date new getTime) ifTrue: [
          expire: key item: item.
          ^ nil.
        ]
      ].

      response:: item value.
      
      lru removeValue: key.
      lru append: key.
      lruId:: lruId + 1.
    ].
    ^ response
  )

  public size = (
      garbageCollection.
      return cache size.
  )

  public dump = (
    ^ cache
  )
    
  public close = (
    (*todo stop timerprim*)
  )
)

)