gts 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gts.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Milan Novota
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Gts
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'gts'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gts
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/gts

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require "gts"
+require "optparse"
+
+options = { :port => 2222, :address => "0.0.0.0" }
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "GPS Tracking Server, v.#{Gts::VERSION}, (c) 2012, Milan Novota" +
+    "\nUsage: gts [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-a","--address IP_ADDRESS","on what address should server run") do |address|
+      options[:address] = address
+  end
+
+  opt.on("-p","--port PORT_NUMBER","on what port should server run") do |port|
+      options[:port] = port
+  end
+
+  opt.on("-d","--daemon","run in daemon mode?") do
+    options[:daemon] = true
+  end
+
+  opt.on("-o","--output FILENAME","output file name; if given csv file with captured data is created") do |filename|
+    options[:output_file] = filename
+  end
+
+  opt.on("-x","--debug","show debugging information") do
+    options[:debug] = true
+  end
+
+  opt.on("-h","--help","help") do
+    puts opt_parser
+    exit
+  end
+
+end
+
+opt_parser.parse!
+
+puts "Starting GTS #{Gts::VERSION} on address #{options[:address]} and port #{options[:port]}"
+if options[:debug]
+  Gts.set_log_level :debug
+  puts "Debugging level logs enabled!"
+end
+puts "Known devices: " + Gts.registered_handlers.map{|k,v| [k] }.join(", ")
+
+Signal.trap("INT")  { Gts::Server.stop! }
+Signal.trap("TERM") { Gts::Server.stop! }
+        
+Gts.server = Gts::Server
+Gts.server.start!(:address => options[:address], :port => options[:port], :output_file => options[:output_file])

data/gts.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/gts/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Milan Novota"]
+  gem.email         = ["milan.novota@gmail.com"]
+  gem.description   = ["GPS Tracking Server"]
+  gem.summary       = ["GPS Tracking Server"]
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "gts"
+  gem.require_paths = ["lib"]
+  gem.version       = Gts::VERSION
+
+  gem.add_dependency "eventmachine"
+  gem.add_dependency "json"
+  gem.add_dependency "awesome_print"
+  gem.add_development_dependency "rspec"
+
+end

data/lib/gts/abstract_gps_tracker_handler.rb

@@ -0,0 +1,21 @@
+module Gts
+
+  class AbstractGPSTrackerHandler
+
+    class CantParseGPSData < StandardError; end
+
+    def self.register!
+      Gts.register_handler(self)
+    end
+
+    def parse(raw_data)
+      raise "Abstract!"
+    end
+
+    def devices
+      raise "Abstract!"
+    end
+
+  end
+
+end

data/lib/gts/command.rb

@@ -0,0 +1,35 @@
+require "gts/command_parser"
+
+module Gts
+
+  class Command
+
+    class CommandError < StandardError; end
+    class UnknownCommand < CommandError; end
+
+    @@known_commands = {}
+    attr_reader :args
+
+    def self.register(name, handler)
+      @@known_commands[name] = handler
+    end
+
+    def self.execute(command_str)
+      parser = Gts::CommandParser.new
+      command_name, @args = *parser.parse(command_str)
+      command_handler(command_name.to_sym).execute
+    end
+
+    private
+
+    def self.command_handler(command_name)
+      @handler = @@known_commands[command_name]
+      raise UnknownCommand if !@handler
+      @handler.new
+    end
+
+  end
+
+end
+
+Dir[File.dirname(__FILE__) +"/commands/*.rb"].each {|file| require file }

data/lib/gts/command_parser.rb

@@ -0,0 +1,25 @@
+module Gts
+  
+  class CommandParser
+
+    attr_reader :command, :args
+
+    def iniialize
+      @command = nil
+      @args = [] 
+    end
+
+    # zatial vieme parsovat iba primitivne veci
+    # status 
+    # last_data
+    # known_imeis
+    # uptime
+    def parse(str)
+      command, *@args = str.split(/\s+/)
+      @command = command.to_sym
+      [@command, @args]
+    end
+
+  end
+
+end

data/lib/gts/commands/list_known_devices_command.rb

@@ -0,0 +1,16 @@
+require "gts/command"
+
+module Gts
+
+  class ListKnownDevicesCommand < Command
+
+    Gts::Command.register :list_known_devices, self
+    Gts::Command.register :ld, self
+
+    def execute
+      Gts.server.list_known_devices
+    end
+
+  end
+
+end

data/lib/gts/commands/uptime_command.rb

@@ -0,0 +1,15 @@
+require "gts/command"
+
+module Gts
+
+  class UptimeCommand < Command
+
+    Gts::Command.register :uptime, self
+
+    def execute
+      Gts.server.uptime 
+    end
+
+  end
+
+end

data/lib/gts/handlers/tk102_handler.rb

@@ -0,0 +1,70 @@
+module Gts
+
+  class TK102Handler < AbstractGPSTrackerHandler
+    
+    def parse(raw_data)
+      raw_data = raw_data.gsub( /(^[\s\t\r\n]+|[\s\t\r\n]+$)/, '' )
+      attrs = raw_data.split(",")
+      raise CantParseGPSData if attrs.size != 18 || attrs[2] != "GPRMC"
+      datetime = parse_datetime attrs[0]
+      begin
+        phone = PhoneSystem::PhoneNumber.new(attrs[1]).long
+      rescue PhoneSystem::PhoneSystemError
+        phone = attrs[1]
+      end
+      gps_time = attrs[3].scan(/(\d{2})(\d{2})(\d{2})\.(\d{3})/).first
+      gps_time = "#{gps_time[0]}:#{gps_time[1]}:#{gps_time[2]}.#{gps_time[3]}"
+      gps_date = attrs[11].scan(/([0-9]{2})([0-9]{2})([0-9]{2})/).first
+      gps_year = Time.now.year.to_s[0..1] + gps_date[2]
+      gps_date = "#{gps_year}-#{gps_date[1]}-#{gps_date[0]}"
+      {
+        :raw => raw_data,
+        :datetime => datetime,
+        :phone => phone,
+        :gps_date => gps_date,
+        :gps_time => gps_time,
+        :gps_signal => (attrs[15] == 'F' ? 'full' : 'low'),
+        :gps_fix => (attrs[4] == 'A' ? 'active' : 'invalid'),
+        :lat => convert_nmea_coordinates(attrs[5], attrs[6]),
+        :lng => convert_nmea_coordinates(attrs[7], attrs[8]),
+        :bearing => attrs[10].to_i,
+        :speed_knots => (attrs[9].to_f * 1000 ).round / 1000,
+        :speed_kmh => ( attrs[9].to_f * 1.852 * 1000 ).round / 1000,
+        :speed_mph => ( attrs[9].to_f * 1.151 * 1000 ).round / 1000,
+        :imei => attrs[16].gsub('imei:', '')
+      }
+    end
+
+    def self.devices
+      %w( TK-102 TK-102B )
+    end
+
+    private
+
+    # Vrati rozumnejsiu stringovu verziu casu 
+    def parse_datetime(str)
+      parts = str.scan(/.{2}/)
+      year = Time.now.year.to_s[0..1] + parts[0]
+      month = parts[1]
+      day = parts[2]
+      hour = parts[3]
+      minute = parts[3]
+      "#{year}-#{month}-#{day} #{hour}:#{minute}"
+    end
+
+
+    def convert_nmea_coordinates(one, two)
+      minutes = one[-7..-1]
+      degrees = one.gsub(minutes, "")
+      one = degrees.to_i + minutes.to_f/60
+      if two == "S" || two == "W"
+        one = -one
+      end
+      one
+    end
+
+  end
+
+end
+
+Gts::TK102Handler.register!

data/lib/gts/server.rb

@@ -0,0 +1,173 @@
+require 'eventmachine'
+require 'open-uri'
+require 'json'
+require 'gts'
+
+DEFAULT_IMEI_HANDLERS = { "359585017718724" => "TK-102" } # IMEI nasej TK-102jky 
+DEFAULT_IMEI_HANDLER_SOURCE = nil
+ 
+module Gts
+
+  module Server # TCP server
+
+    @@tracker_requests_count = 0
+    @@started_at = nil
+
+    def logger
+      Gts.logger
+    end
+
+    def self.logger
+      Gts.logger
+    end
+
+    class GtsError < StandardError; end;
+    class CantDetermineIMEI < GtsError; end;
+    class DontKnowHowToHandleThisDevice < GtsError; end;
+
+    def initialize
+      @@imei_handlers ||= DEFAULT_IMEI_HANDLERS
+      @@imei_handlers_source ||= DEFAULT_IMEI_HANDLER_SOURCE
+      @@device_handlers = Gts.registered_handlers
+      @@started_at ||= Time.now
+      load_imei_handlers!
+    end
+
+    def post_init
+      logger.info "New connection from #{client_ip_address}"
+    end
+    
+    def receive_data data
+      if data =~ /^%/
+        handle_command(data.gsub(/^%\s*?/, ''))
+      else
+        handle_tracker_data(data)
+      end
+    end
+
+    def self.start!(opts={})
+      @@address = opts[:address]
+      @@port = opts[:port]
+      @@output_file = opts[:output_file]
+      EventMachine::run {
+        EventMachine::start_server @@address, @@port, self
+        puts "Server started. Press Ctrl+C to stop."
+        puts "Hunting for data..."
+      }
+      self
+    end
+
+    def self.stop!
+      EventMachine::stop
+      puts "Bye!"
+    end
+
+    def self.uptime
+      sum =  Time.now - @@started_at
+      days = (sum / (3600 * 24)).to_i
+      hours = (sum / 3600 - (days * (3600 * 24))).to_i
+      minutes = (sum / 60 - hours * 60).to_i
+      seconds = (sum % 60).to_i
+      "#{days}d #{hours}h #{minutes}m #{seconds}s"
+    end
+
+    def self.list_known_devices
+      @@imei_handlers.map{ |k,v| "#{k}: #{v}" }.join "\n"
+    end
+
+    private
+
+    def handle_command(command)
+      begin
+        command = command.strip
+        output = Gts::Command.execute(command)
+        send_data output + "\n"
+        logger.info "Executed '#{command}' [from #{client_ip_address}]"
+        logger.debug "Command output:\n#{output}"
+      rescue Gts::Command::UnknownCommand
+        send_data "Error: Unknown command\n"
+        logger.error "Unknown command '#{command}' [from #{client_ip_address}]"
+      end
+    end
+
+    def handle_tracker_data(data)
+      begin
+        parsed_data = parse_data(data)
+        logger.info "Got correct data from #{client_ip_address}"
+        formatted_data = parsed_data.map{|k,v| "\t#{k}: #{v}\n" }.join
+        logger.debug "Parsed data:\n" + formatted_data
+        log_data_to_csv_file(parsed_data)
+      rescue GtsError => e
+        logger.error "Got incorrect data from #{client_ip_address}. Exception: #{e.to_s}"
+        logger.debug "Incorrect data: #{data}"
+      end
+      close_connection
+    end
+
+
+    def client_ip_address
+      get_peername[2,6].unpack('nC4')[1,4].join(".")
+    end
+
+    def log_data_to_csv_file(parsed_data)
+      if @@output_file
+        if !File.exists?(@@output_file) 
+          File.open(@@output_file, "w") do |f|
+            f.puts parsed_data.keys.map{ |k| k.to_s }.sort.join("\t") # hlavicka
+          end
+        end
+        File.open(@@output_file, "a") do |f|
+          pd = parsed_data.keys.map{ |k| k.to_s }.sort.map{|k| parsed_data[k.to_sym]}.join("\t")
+          f.puts pd
+        end
+      end
+    end
+
+    def parse_data(data)
+       imei = get_imei(data)
+       if !known_imei?(imei)
+         logger.info "Unknown IMEI, reloading IMEI handlers index."
+         load_imei_handlers!
+       end
+       if known_imei?(imei)
+         handler = determine_handler(imei).new
+         handler.parse(data)
+       else
+         raise DontKnowHowToHandleThisDevice, "Don't know what handler to use for IMEI# #{imei}"
+       end
+    end
+
+    def known_imei?(imei)
+      !@@imei_handlers[imei].nil?
+    end
+
+    def determine_handler(imei)
+      imei_handler_str = @@imei_handlers[imei]
+      @@device_handlers[imei_handler_str]
+    end
+
+    # mozno by sme mohli priamo hadat typ zariadenia ked uz hadame imei,
+    # no imei_handlers tabulka a imei je bezpecnejsia cesta
+    def get_imei(data)
+      if data =~ /imei:(\d{15}),/
+        return $1
+      else
+        raise CantDetermineIMEI
+      end
+    end
+
+    def load_imei_handlers!
+      src = @@imei_handlers_source
+      @@imei_handlers = {} unless @@imei_handlers.is_a? Hash
+      return if src.nil? || src == ""
+      if File.exists?(src) 
+        json = File.open(src).read
+      else
+        json = open(src).read
+      end
+      @@imei_handlers.merge!(JSON.parse(json))
+    end
+
+  end
+
+end 

data/lib/gts/utils/phone_codes.yml

@@ -0,0 +1,67 @@
+36:
+  country: Maďarsko
+  area_codes:
+    1: Budapešť
+48:
+  country: Poľsko
+  area_codes:
+    22: Varšava
+420:
+  country: Česká republika
+  area_codes:
+    2: Praha
+    5: Brno    
+421:
+  country: Slovensko
+  format: ^(\+|0)[\d\s\(\)-\/]+$
+  min_size: 3
+  max_size: 9 
+  area_codes:
+    2: Bratislava
+    31: Dunajská Streda
+    32: Trenčín
+    33: Trnava
+    34: Senica
+    35: Nové Zámky
+    36: Levice
+    37: Nitra
+    38: Topoľčany
+    41: Žilina
+    42: Považská Bystrica
+    43: Martin
+    44: Liptovský Mikuláš
+    45: Zvolen
+    46: Prievidza
+    47: Lučenec
+    48: Banská Bystrica
+    51: Prešov
+    52: Poprad
+    53: Spišská Nová Ves
+    54: Bardejov
+    55: Košice
+    56: Michalovce
+    57: Humenné
+    58: Rožňava
+    901: T-Mobile Slovensko
+    902: T-Mobile Slovensko    
+    903: T-Mobile Slovensko
+    904: T-Mobile Slovensko    
+    905: Orange Slovensko
+    906: Orange Slovensko (VPN)
+    907: Orange Slovensko
+    908: Orange Slovensko    
+    910: T-Mobile Slovensko
+    911: T-Mobile Slovensko
+    912: T-Mobile Slovensko (CVPN)
+    913: Unient Communications
+    914: T-Mobile Slovensko (UMTS)
+    915: Orange Slovensko
+    916: Orange Slovensko (VPN)
+    917: Orange Slovensko (UMTS)
+    918: Orange Slovensko
+    919: Orange Slovensko
+    940: Telefónica O2 Slovakia
+    944: Telefónica O2 Slovakia
+    948: Telefónica O2 Slovakia
+    949: Telefónica O2 Slovakia        
+    959: ŽSR (železničná mobilná sieť)

data/lib/gts/utils/phone_system.rb

@@ -0,0 +1,239 @@
+require "yaml"
+
+module PhoneSystem
+  
+  # Exceptions
+  class PhoneSystemError < StandardError; end
+  class CannotParsePhoneNumberString < PhoneSystemError; end 
+  class CannotDetermineCountryCode < CannotParsePhoneNumberString; end   
+  class AreaCodeNotValidForGivenCountry < CannotParsePhoneNumberString; end     
+  class NumberTooShort < CannotParsePhoneNumberString; end
+  class NumberTooLong < CannotParsePhoneNumberString; end  
+  
+  # For future use, not implemented, yet
+  class PhoneNode; end    
+  class PhoneCountryNode < PhoneNode; end
+  class PhoneAreaNode < PhoneNode; end  
+
+  class Parser
+    
+    @@phone_codes_file_path = File.join(File.dirname(__FILE__), "phone_codes.yml")
+    @@phone_codes = YAML.load(File.read(@@phone_codes_file_path))      
+
+    def parse(pstring, options)
+      self.class.parse(pstring, options)
+    end
+    
+    # Return hash, that represents valid international phone number with 
+    # country code, area code, number, country, area/operator.
+    # 
+    # String that do not begin with "+" or "0" are considered invalid.
+    # because we want to get absolute phone numbers, not relative, ie.
+    # the output will contain country code, area/mobile operator code and number.
+    # 
+    # Country code is by default set to 421 (Slovakia), so we can leave it
+    # when inputting Slovak phone numbers and just start with area code.
+    # 
+    # Constraints:
+    #   - the number that do not start with "+" or "0" are considered invalid 
+    #     (since we are not able to determine the area/operator code).
+    #   - the country code MUST be separated from the rest of the number by means
+    #     of " " or "-".
+    # 
+	  # Arguments: 
+    #   - pstring : string with phone number to parse
+    #	options:
+    #		- country_code : implicit country phone code, if none found 
+	  # 		  in pstring, defaults to 421 (Slovakia)
+    #		- strict : if set to true, the pstring is checked against the list of 
+	  #		  area/operator codes found in phone_codes.yml. If none of the area/operator 
+	  #		  code matches pstring, exception is raised. Use only if you have complete 
+	  #         list of the area/operator codes for given country. Defaults to false.
+    def self.parse(pstring, options = {})
+      
+      options = {
+        :country_code => 421, # Slovakia
+        :strict => false
+      }.merge(options)
+
+      text_number = pstring
+      # if it starts with "+" or "00" then the country code should be given and we will
+      # try to get it.
+      if pstring =~ /^(\+|00)/
+        cc_match = pstring.match(/^(?:\+|00)(\d*)[ -\(]+/)
+        unless  cc_match
+        then    raise(CannotParsePhoneNumberString, "The string \"#{text_number}\" does not seem to be valid international phone number."); end
+        pstring             = pstring.match(/^[\+0\d]*[ -\(]+(.*)$/)[1] # chop the country code off 
+        country_code        = cc_match[1].to_i
+      else
+        # if the country code is not set, fall to default
+        # and chop the first zero, so the area/operator code will be at the first place
+        unless  options[:country_code]
+        then    raise(CannotDetermineCountryCode, "The string \"#{text_number}\" does not seem to be valid phone number. Cannot determine country code."); end
+        pstring       = pstring.sub("0","") # remove the leading zero, to get the area code to the first place
+        country_code  = options[:country_code]
+      end
+      
+      # do some cleaning - remove all the remaining characters, that are not digits
+      pstring = remove_other_than_digits(pstring)
+      
+      area_code   = nil
+      area_name   = nil
+      
+      # let's try to identify the country, area/operator and get the correct format for the country
+      # if possible
+      if @@phone_codes.include? country_code
+        country     = @@phone_codes[country_code]["country"]
+        area_codes  = @@phone_codes[country_code]["area_codes"]
+        pn_format   = Regexp.new(@@phone_codes[country_code]["format"]) if @@phone_codes[country_code].include? "format"
+        area_codes.each do |code, name|
+          if pstring =~ /^#{code}/
+            area_code = code
+            area_name = name
+            pstring   = pstring.sub(/#{code}/, "") # chop the area code off
+            break
+          end
+        end
+        # if not area code found and in strict mode, raise exception
+        if    !area_code && options[:strict]
+        then  raise(AreaCodeNotValidForGivenCountry, "The string \"#{text_number}\" does not seem to be valid phone number. Area code was not recognized."); end
+
+        # set the number size boundaries if found for given country
+        min_size  = @@phone_codes[country_code].include?("min_size") ? @@phone_codes[country_code]["min_size"] : nil
+        max_size  = @@phone_codes[country_code].include?("max_size") ? @@phone_codes[country_code]["max_size"] : nil
+      end
+        
+      # if not specific format of numbers for given country set, then 
+      # use general format
+      pn_format           ||= /^(\+|0)[\d\s\(\)-\/]+$/
+      unless text_number  =~  pn_format
+      then   raise(CannotParsePhoneNumberString, "The string \"#{text_number}\" does not seem to be valid international phone number."); end
+        
+      # if no size boundaries set, set them to reasonable defaults
+      min_size  ||= 6
+      max_size  ||= 15
+      # and check the remaining number against them
+      if  pstring.size < min_size
+      then raise(NumberTooShort, "Cannot parse the string \"#{text_number}\" to phone number. The phone number would be too short."); end
+      if  pstring.size > max_size
+      then raise(NumberTooLong, "Cannot parse the string \"#{text_number}\" to phone number. The phone number would be too long."); end
+
+      # if we made it here, we have the line number
+      number = pstring
+      
+      out = {
+        :text         => text_number,
+        :country_code => country_code,
+        :country      => country,
+        :area_code    => area_code,
+        :area_name    => area_name,
+        :number       => number
+      }
+      return out
+    rescue PhoneSystemError
+      false
+    end
+    
+    private
+    
+    # my way to remove other chars than digits from a string
+    # any better idea?
+    def self.remove_other_than_digits(numbers_and_stuff)
+      out = [] 
+      numbers_and_stuff.each_char{|c| out << c if c=~/\d/ }
+      out.join
+    end
+    
+  end
+  
+  class PhoneNumber
+  
+    def self.valid?(pstring, options = {})
+      !!PhoneSystem::Parser.parse(pstring, options)
+    end
+    
+    def valid?
+      PhoneNumber.valid? self.long
+    end
+  
+    def initialize(pstring = nil, options = {})
+      @phone_number = {}
+      @phone_number = PhoneSystem::Parser.parse(pstring,options) unless (pstring == "" || pstring.nil?)
+    end
+    
+    def country_code
+      @phone_number[:country_code]
+    end
+    
+    def country
+      @phone_number[:country]
+    end  
+    
+    def area_code
+      @phone_number[:area_code]
+    end
+    
+    def area_name
+      @phone_number[:area_name]
+    end
+    
+    def area_name
+      @phone_number[:area_name]
+    end
+    
+    def number
+      @phone_number[:number]
+    end
+    
+    def text
+      @phone_number[:text]
+    end
+    
+    def [](attr)
+      @phone_number[attr]
+    end
+  
+    def long
+      "+#{country_code} #{area_code} #{number}"
+    end
+
+    def self.parse_and_format_long(pstring, options={})
+      if nr = PhoneSystem::Parser.parse(pstring, options)
+        return "+#{nr[:country_code]} #{nr[:area_code]} #{nr[:number]}"
+      else
+        return false
+      end
+    end
+  
+    def short
+      "0#{area_code}/#{number}"      
+    end
+    
+    def text=(pstring)
+      @phone_number = PhoneSystem::Parser.new.parse(pstring)
+    end
+    
+    def to_hash
+      {
+        :text         => text,
+        :country_code => country_code,
+        :country      => country,
+        :area_code    => area_code,
+        :area_name    => area_name,
+        :number       => number,
+        :long         => long,
+        :short        => short
+      }
+    end
+    
+    def ==(other_phone_number)
+      self.long = other_phone_number.long
+    end
+  
+  end
+
+end
+
+# pn = PhoneSystem::PhoneNumber.new "0908420120"
+# puts pn.inspect
+

data/lib/gts/version.rb

@@ -0,0 +1,3 @@
+module Gts
+  VERSION = "0.1.0"
+end

data/lib/gts.rb

@@ -0,0 +1,63 @@
+require "logger"
+
+module Gts
+
+  def self.register_handler(klass)
+    @@registered_handlers ||= {}
+    klass.devices.each do |d|
+      @@registered_handlers[d] = klass
+    end
+  end
+  
+  def self.registered_handlers
+    @@registered_handlers
+  end
+
+  def self.set_log_level(level=:info)
+    case level
+    when :debug
+      @@log_level = Logger::DEBUG
+    else 
+      @@log_level = Logger::INFO
+    end
+  end
+
+  def self.log_level
+    begin
+      @@log_level
+    rescue
+      set_log_level
+      @@log_level
+    end
+  end
+
+  def self.logger
+    begin 
+      @@logger
+    rescue
+      @@logger = Logger.new(STDOUT)
+      @@logger.datetime_format = "%d.%m.%Y %H:%M:%S"
+      @@logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{datetime} #{severity}: #{msg}\n"
+      end
+      @@logger.level = log_level
+      @@logger
+    end
+  end
+
+  def self.server=(server_instance)
+    @@server = server_instance
+  end
+
+  def self.server
+    @@server
+  end
+
+end
+
+require "gts/version"
+require "gts/utils/phone_system"
+require "gts/abstract_gps_tracker_handler"
+require "gts/handlers/tk102_handler"
+require "gts/command"
+require "gts/server"

data/spec/command_spec.rb

@@ -0,0 +1,15 @@
+# require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "gts"
+
+describe Gts::Command  do
+
+  class SomeCommand < Gts::Command
+  end
+
+  it "allows to register new commands" do
+    expect {
+      SomeCommand.register :some, SomeCommand
+    }.not_to raise_exception
+  end
+
+end

data/spec/test_data/tk102_sample_data.txt

@@ -0,0 +1,20 @@
+1207272308,0907532880,GPRMC,220856.000,A,4809.6585,N,01708.0085,E,0.00,,270712,,,A*72,F,imei:359585017718724,98&?
+1207272309,0907532880,GPRMC,220957.000,A,4809.6526,N,01707.9981,E,0.00,,270712,,,A*70,F,imei:359585017718724,98?n
+1207272311,0907532880,GPRMC,221108.000,A,4809.6540,N,01708.0022,E,2.32,,270712,,,A*76,F,imei:359585017718724,98|?
+1207272311,0907532880,GPRMC,205559.000,A,4809.6760,N,01708.0389,E,0.00,,270712,,,A*71,L,imei:359585017718724,98??
+1207272315,0907532880,GPRMC,221510.000,A,4809.7429,N,01707.9160,E,7.81,352.81,270712,,,A*6B,F,imei:359585017718724,104?
+1207272316,0907532880,GPRMC,221634.000,A,4809.6799,N,01707.8709,E,1.60,208.30,270712,,,A*62,F,imei:359585017718724,104?/
+1207272317,0907532880,GPRMC,221751.000,A,4809.6481,N,01707.8410,E,2.20,229.80,270712,,,A*6E,F,imei:359585017718724,104?
+1207272318,0907532880,GPRMC,221846.000,A,4809.6214,N,01707.8074,E,2.42,240.02,270712,,,A*6A,F,imei:359585017718724,104?
+1207272320,0907532880,GPRMC,222001.000,A,4809.5866,N,01707.7769,E,0.79,65.09,270712,,,A*5E,F,imei:359585017718724,103u?
+1207272321,0907532880,GPRMC,222120.000,A,4809.5363,N,01707.7398,E,4.65,185.29,270712,,,A*6C,F,imei:359585017718724,104X?
+1207272322,0907532880,GPRMC,222221.000,A,4809.5087,N,01707.7280,E,0.00,291.23,270712,,,A*64,F,imei:359585017718724,104V?
+1207272323,0907532880,GPRMC,222335.000,A,4809.4998,N,01707.8916,E,1.16,140.35,270712,,,A*63,F,imei:359585017718724,104ݙ
+1207272325,0907532880,GPRMC,222505.000,A,4809.4882,N,01707.8748,E,5.91,74.16,270712,,,A*55,F,imei:359585017718724,103O
+1207272326,0907532880,GPRMC,222605.000,A,4809.5271,N,01707.7184,E,11.52,28.57,270712,,,A*6E,F,imei:359585017718724,104?}
+1207272327,0907532880,GPRMC,222733.000,A,4809.5048,N,01707.7301,E,1.41,,270712,,,A*78,F,imei:359585017718724,98`?
+1207272329,0907532880,GPRMC,222952.000,A,4809.4744,N,01707.6298,E,0.00,253.21,270712,,,A*66,F,imei:359585017718724,104??
+1207272330,0907532880,GPRMC,223049.000,A,4809.4793,N,01707.5970,E,1.76,,270712,,,A*79,F,imei:359585017718724,98?
+1207272331,0907532880,GPRMC,223124.000,A,4809.4821,N,01707.5665,E,1.10,,270712,,,A*7E,F,imei:359585017718724,98E\330
+1207272332,0907532880,GPRMC,223202.000,A,4809.4943,N,01707.5553,E,2.32,342.78,270712,,,A*6D,F,imei:359585017718724,104\021\370\n
+1207272332,0907532880,GPRMC,223239.000,A,4809.4987,N,01707.5872,E,1.92,34.17,270712,,,A*51,F,imei:359585017718724,103C

data/spec/tk102_handler_spec.rb

@@ -0,0 +1,21 @@
+# require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "gts"
+
+CORRECT_LINE = "1207272321,0907532880,GPRMC,222120.000,A,4809.5363,N,01707.7398,E,4.65,185.29,270712,,,A*6C,F,imei:359585017718724,104X?"
+INCORRECT_LINE = "blah"
+
+describe Gts::TK102Handler  do
+
+  let(:handler) { Gts::TK102Handler.new }
+
+  it "parses GPS data when data is correct" do
+    handler.parse(CORRECT_LINE).should be_a Hash
+  end
+
+  it "throws an exception when GPS data is incorrect" do
+    expect {
+      handler.parse(INCORRECT_LINE)
+    }.to raise_exception(Gts::TK102Handler::CantParseGPSData)
+  end
+  
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: gts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Milan Novota
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! '["GPS Tracking Server"]'
+email:
+- milan.novota@gmail.com
+executables:
+- gts
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/gts
+- gts.gemspec
+- lib/gts.rb
+- lib/gts/abstract_gps_tracker_handler.rb
+- lib/gts/command.rb
+- lib/gts/command_parser.rb
+- lib/gts/commands/list_known_devices_command.rb
+- lib/gts/commands/uptime_command.rb
+- lib/gts/handlers/tk102_handler.rb
+- lib/gts/server.rb
+- lib/gts/utils/phone_codes.yml
+- lib/gts/utils/phone_system.rb
+- lib/gts/version.rb
+- spec/command_spec.rb
+- spec/test_data/tk102_sample_data.txt
+- spec/tk102_handler_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: ! '["GPS Tracking Server"]'
+test_files:
+- spec/command_spec.rb
+- spec/test_data/tk102_sample_data.txt
+- spec/tk102_handler_spec.rb