atlantispro 0.1.2 → 0.2.0

data/lib/Atlantis/portal/commands/logout.rb

@@ -1,12 +1,12 @@
 command :logout do |c|
-  c.syntax = 'testflight logout'
-  c.summary = 'Remove account credentials'
+  c.syntax = 'distribution logout'
+  c.summary = 'Remove stored account credentials'
   c.description = ''
 
   c.action do |args, options|
-    say_error "You are not authenticated" and abort unless Security::InternetPassword.find(:server => Atlantis::Portal::HOST)
+    say_error "You are not authenticated" and abort unless Security::InternetPassword.find(:server => service.host)
 
-    Security::InternetPassword.delete(:server => Atlantis::Portal::HOST)
+    Security::InternetPassword.delete(:server => service.host)
 
     say_ok "Account credentials removed"
   end

data/lib/Atlantis/portal/commands/people.rb

@@ -1,43 +1,13 @@
 command :'people' do |c|
-  c.syntax = 'testflight people [DISTRIBUTION_LIST]'
-  c.summary = 'Lists people currently signed up to TestFlight'
+  c.syntax = 'distribution people'
+  c.summary = 'Lists testers currently signed up to the service'
   c.description = ''
 
   c.action do |args, options|
 
-    distribution_list = args.join(" ").strip
+    people = try{service.list_people(arguments.group)}
+    people = people.values
 
-    if (distribution_list.empty?)
-      distribution_list = 'all'
-    end
-
-    people = try{agent.list_people(distribution_list)}
-
-    if (agent.format == "csv")
-      csv_string = CSV.generate do |csv|
-        csv << ["ID", "User", "Email", "Devices"]
-
-        people.each do |person|
-          csv << [person.id, person.name, person.email, person.devices]
-        end
-      end
-
-      puts csv_string
-
-    else
-      title = "Listing people"
-
-      table = Terminal::Table.new :title => title do |t|
-        t << ["ID", "User", "Email", "Devices"]
-        t.add_separator
-        people.each do |person|
-          t << [person.id, person.name, person.email, person.devices]
-        end
-      end
-
-      #table.align_column 2, :center
-
-      puts table
-    end
+    output('Testers', ["ID", "Name", "Email"], people)
   end
 end

data/lib/Atlantis/portal/crashlytics/crashlyticsservice.rb

@@ -0,0 +1,315 @@
+require 'mechanize'
+require 'security'
+require 'uri'
+require 'json'
+require 'logger'
+require 'nokogiri'
+
+include Atlantis::Portal
+
+module Atlantis
+  module Portal
+    class CrashlyticsService < ::Service
+      attr_accessor :developer_token, :access_token, :csrf_token, :login_data, :team_id
+
+      def initialize
+        super
+
+        self.host = "crashlytics.com"
+      end
+
+      def get(uri, parameters = [], referer = nil, headers = {})
+        uri = ::File.join("https://#{self.host}", uri) unless /^https?/ === uri
+
+        #puts "Requesting: #{uri}"
+
+        unless (self.developer_token.nil?)
+          headers['X-CRASHLYTICS-DEVELOPER-TOKEN'] = self.developer_token
+        end
+
+        unless (self.access_token.nil?)
+          headers['X-CRASHLYTICS-ACCESS-TOKEN'] = self.access_token
+        end
+
+        unless (self.csrf_token.nil?)
+          headers['X-CSRF-Token'] = self.csrf_token
+        end
+
+        headers['X-Requested-With'] = 'XMLHttpRequest'
+
+        3.times do
+
+          agent.get(uri, parameters, referer, headers)
+
+          return agent.page
+        end
+
+        raise NetworkError
+      end
+
+      #
+      # Handles login and CSRF tokens
+      #
+
+      def bootstrap
+
+        if (self.csrf_token.nil?)
+          csrf!
+        end
+        
+        #
+        # First need developer token
+        #
+        if (self.developer_token.nil?)
+          config!
+        end
+        
+        #
+        # Need to login too
+        #
+        if (self.access_token.nil?)
+          login!
+        end
+      end
+
+      def list_devices(distribution_list)
+        people = list_people(distribution_list)
+
+        people_list = []
+
+        people.each do |person|
+          people_list << person.id
+        end
+
+        agent.post('/dashboard/team/export/devices/', { "members" => people_list.join('|'), "csrfmiddlewaretoken" => agent.page.parser.css("[name='csrfmiddlewaretoken']")[0]['value'] } )
+
+        device_list = agent.page.body.split( /\r?\n/ )
+
+        # Remove first one
+        device_list.shift
+
+        devices = []
+
+        device_list.each do |dev|
+          #puts dev
+
+          device = Device.new
+          device.udid = dev.split(/\t/)[0]
+          device.name = dev.split(/\t/)[1]
+
+          devices << device
+        end
+
+        devices
+      end
+
+      def list_apps
+        bootstrap
+
+        page = get("/api/v2/organizations/#{self.team_id}/apps")
+
+        apps = JSON.parse(page.body)
+
+        return apps
+      end
+
+      def list_testers(app_id)
+        bootstrap
+        page = get("/api/v2/organizations/#{self.team_id}/apps/#{app_id}/beta_distribution/testers_in_organization?include_developers=true")
+
+        testers = JSON.parse(page.body)
+
+        return testers['testers']
+      end
+
+      def list_people(group)
+        bootstrap
+
+        apps = list_apps
+
+        all_testers = {}
+
+        apps.each do |app|
+          testers = list_testers (app['id'])
+
+          #
+          # For each tester go through it's devices and add them
+          #
+
+          testers.each do |tester|
+
+            #
+            # If tester is not yet in, create it
+            #
+
+            if all_testers[tester['id']].nil?
+
+              person = Person.new
+              person.id = tester['id']
+              person.name = tester['name']
+              person.email = tester['email']
+              person.groups = []
+              person.devices = {}
+
+              add_group = false
+
+              if tester['groups']
+                groups = tester['groups']
+
+                groups.each do |current_group|
+
+                  person_group = Group.new
+                  person_group.id = current_group['id']
+                  person_group.name = current_group['name']
+                  person_group.alias = current_group['alias']
+
+                  person.groups << person_group
+
+                  if person_group.name == group or person_group.alias == group
+                    add_group = true
+                  end
+                end
+              end
+
+              if (add_group == true or group.nil?) and !person.name.empty?
+                all_testers[person.id] = person
+              end
+            else
+              person = all_testers[tester['id']]
+            end
+
+            append_devices(person, tester['devices'])
+          end
+        end
+
+        return all_testers
+      end
+
+      def list_devices(group)
+        bootstrap
+
+        testers = list_people(group)
+
+        devices = {}
+
+        testers.each do |id, tester|
+          devices = devices.merge (tester.devices)
+        end
+
+        return devices.values
+      end
+
+      def list_groups
+        testers = list_people(nil)
+
+        groups = {}
+
+        testers.each do |id, tester|
+          tester.groups.each do |group|
+            groups[group.id] = group
+          end
+        end
+
+        return groups.values
+      end
+
+      private
+
+      def append_devices (person, devices)
+
+        if devices.nil?
+          return nil
+        end
+
+        devices.each do |device|
+
+          if person.devices[device['identifier']].nil?
+            current_device = Device.new
+            current_device.manufacturer = device['manufacturer']
+            current_device.model = device['model']
+            current_device.os_version = device['os_version']
+            current_device.identifier = device['identifier']
+            current_device.name = device['name']
+            current_device.platform = device['platform']
+            current_device.model_name = device['model_name']
+
+            person.devices[current_device.identifier] = current_device
+          end
+
+        end
+      end
+
+      def csrf!
+        page = get('/login')
+
+        token = page.at('meta[name="csrf-token"]')[:content]
+
+        unless token.nil?
+          self.csrf_token = token
+        end
+      end
+
+      def config!
+        page = get ('/api/v2/client_boot/config_data')
+
+        config_object = JSON.parse(page.body)
+
+        unless config_object['developer_token'].nil?
+          self.developer_token = config_object['developer_token']
+        else
+          raise UnsuccessfulAuthenticationError
+        end
+      end
+
+      def login!
+        begin
+
+          session = agent.post('https://crashlytics.com/api/v2/session', { "email" => self.username, "password" => self.password }, { 'X-CRASHLYTICS-DEVELOPER-TOKEN' => self.developer_token, 'X-CSRF-Token' => self.csrf_token, 'X-Requested-With' => 'XMLHttpRequest' } )
+
+        rescue Mechanize::ResponseCodeError => ex
+          message = JSON.parse(ex.page.body)
+
+          unless message['message'].nil?
+            puts message['message']
+          end
+        end
+
+        self.login_data = JSON.parse(agent.page.body)
+
+        unless self.login_data['token'].nil?
+          self.access_token = self.login_data['token']
+
+          select_team!
+        else
+          raise UnsuccessfulAuthenticationError
+        end
+      end
+
+      def select_team!
+
+        if self.login_data['organizations'].nil?
+          raise UnknownTeamError
+        end
+
+        teams = self.login_data['organizations']
+
+        teams.each do |team|
+          #puts team['name']
+
+          if team['alias'] == self.team or team['name'] == self.team
+            self.team_id = team['id']
+            
+            break
+          end
+        end
+
+        if self.team_id.nil?
+          raise UnknownTeamError
+        end
+
+        #puts "SELECTED TEAM: #{self.team_id}"
+      end
+
+    end
+  end
+end

data/lib/Atlantis/portal/helpers.rb

@@ -16,8 +16,22 @@ end
 module Atlantis
   module Portal
     module Helpers
+
+      def arguments
+        unless @arguments
+          @arguments = Atlantis::Portal::CommandArguments.new
+        end
+
+        @arguments
+      end
+
       def agent
         unless @agent
+
+          #
+          # Web connecting agent
+          #
+
           @agent = Atlantis::Portal::Agent.new
 
           @agent.instance_eval do
@@ -34,6 +48,16 @@ module Atlantis
         @agent
       end
 
+      def service
+
+        unless @service
+          @service = arguments.service.casecmp('crashlytics') == 0 ? Atlantis::Portal::CrashlyticsService.new : Atlantis::Portal::TestFlightService.new
+          @service.arguments = arguments
+        end
+
+        @service
+      end
+
       def pluralize(n, singular, plural = nil)
         n.to_i == 1 ? "1 #{singular}" : "#{n} #{plural || singular + 's'}"
       end
@@ -44,10 +68,59 @@ module Atlantis
         begin
           yield
         rescue UnsuccessfulAuthenticationError
-          say_error "Could not authenticate with TestFlight. Check that your username & password are correct, and that your membership is valid and all pending Terms of Service & agreements are accepted. If this problem continues, try logging into https://testflightapp.com/ from a browser to see what's going on." and abort
+          say_error "Could not authenticate with the service. Check that your username & password are correct, and that your membership is valid and all pending Terms of Service & agreements are accepted. If this problem continues, try logging into the service from a browser to see what's going on." and abort
+        rescue UnknownTeamError
+          say_error "Could not find the specified team. Check if your team parameter is correct."
         end
       end
 
+      def output (title, fields, data)
+
+        if arguments.format == "csv"
+          output_string = CSV.generate do |csv|
+            csv << fields
+
+            data.each do |row|
+              csv << array_for_object(fields, row)
+            end
+          end
+
+        elsif arguments.format == "json"
+          objects = []
+
+          data.each do |row|
+            object = {}
+
+            fields.each do |field|
+              object[field.downcase] = row[field.downcase]
+            end
+
+            objects << object
+          end
+
+          output_string = JSON.generate(objects)
+        else
+          output_string = Terminal::Table.new :title => title do |t|
+            t << fields
+            t.add_separator
+            data.each do |row|
+              t << array_for_object(fields, row)
+            end
+          end
+        end
+
+        puts output_string
+      end
+    end
+
+    def array_for_object(fields, row)
+      properties = []
+
+      fields.each do |field|
+        properties << row[field.downcase]
+      end
+
+      return properties
     end
   end
 end