dencity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15c325015a579f5731901814dd2e70d850f436e0
+  data.tar.gz: aa12fc419b0af227e1991337bf9828165beb0420
+SHA512:
+  metadata.gz: dcc65b80b293093023dab072673e5a925e3f997213f879f97d2c6a139966f2f0710f0f080110e72229041a6a38e4d2c3f8fe1dcd99e7e326337865e2272b206f
+  data.tar.gz: 88a940ed12da942654fb532e880b69dda1714ae15494a21898dd4c2673b5ad34f41a1f62d11889c2b771ab290be24e6a712bd56cce1fbf8f0ba5fd84427c77b0

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+.DS_Store
+dencity*.gem
+/data/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,139 @@
+AllCops:
+  Exclude:
+    - 'measures/**/*'
+    - 'spec/files/**/measures/**/*'
+    - '**/measure.rb'
+    - 'spec/files/mongoid/models/**/*'
+    - 'spec/files/pat_project/data_point_*/**/*'
+    - 'spec/files/pat_project/run/**/*'
+    - 'spec/files/mongo_pat1/run/**/*'
+
+# ==================== Linters ====================
+Lint/AmbiguousOperator:
+  Enabled: true
+
+Lint/BlockAlignment:
+  Enabled: true
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: true
+
+Lint/RequireParentheses:
+  Enabled: true
+
+# Offense count: 1
+Lint/UnreachableCode:
+  Enabled: false
+
+# Offense count: 51
+Lint/UselessAssignment:
+  Enabled: true
+
+# ==================== Styles / Metrics====================
+# Offense count: 4
+Metrics/BlockNesting:
+  Max: 4
+
+# Offense count: 18
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 500
+
+# Offense count: 27
+Metrics/CyclomaticComplexity:
+  Max: 48
+
+# Offense count: 974
+Metrics/LineLength:
+  Max: 1200
+
+# Offense count: 87
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 350
+
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs.
+Metrics/ParameterLists:
+  Max: 8
+
+# ==================== Disabled on Purpose ====================
+# Offense count: 3
+Style/AccessorMethodName:
+  Enabled: true
+
+# Need to allow indented case statements
+# Offense count: 9
+# Configuration parameters: IndentWhenRelativeTo, SupportedStyles, IndentOneStep.
+Style/CaseIndentation:
+  Enabled: false
+
+# Offense count: 18
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# Offense count: 2
+Style/ClassVars:
+  Enabled: false
+
+# Offense count: 42
+Style/Documentation:
+  Enabled: false
+
+# Offense count: 1
+Style/EachWithObject:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: AllowedVariables.
+Style/GlobalVars:
+  Enabled: false
+
+# Offense count: 7
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Enabled: true
+
+# Offense count: 17
+# Configuration parameters: MaxLineLength.
+Style/IfUnlessModifier:
+  Enabled: false
+
+# Do NOT enable.  For some reason this is catchy any next which I feel are okay.
+# Offense count: 18
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/Next:
+  Enabled: false
+
+# Do NOT enable this because it appears $? is different than $CHILD_STATUS.
+# Offense count: 7
+# Cop supports --auto-correct.
+Style/SpecialGlobalVars:
+  Enabled: false
+
+# More Changes per DLM -- pulled from https://github.com/bbatsov/rubocop/blob/master/config/enabled.yml
+Style/RedundantReturn:
+  Description: 'Do not use return where it is not required.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-explicit-return'
+  Enabled: false
+
+Style/NumericLiterals:
+  Description: 'Add underscores to large numeric literals to improve readability.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscores-in-numerics'
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Description: 'Checks for unused block arguments.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars'
+  Enabled: false
+
+Lint/UnusedMethodArgument:
+  Description: 'Checks for unused method arguments.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars'
+  Enabled: false
+
+Lint/UselessAssignment:
+  Description: 'Checks for useless assignment to a local variable.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars'
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.6

data/Gemfile

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

data/README.md

@@ -0,0 +1,164 @@
+# Dencity Gem
+
+This gem is an API client for DEnCity.org.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dencity'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dencity
+
+## Usage
+
+
+### Connect to DEnCity
+
+Without authentication:
+
+```ruby
+dencity_client = Dencity.connect
+```
+
+On a different host (for development purposes):
+
+```ruby
+dencity_client = Dencity.connect({host_name: <host_name>})
+```
+
+With authentication:
+```ruby
+dencity_client = Dencity.connect({username: <username>, password: <password>})
+```
+
+To authenticate an existing connection:
+```ruby
+dencity_client.login(<username>, <password>)
+```
+
+To authenticate using stored credentials in ~/.dencity/config.yml, call the login method without arguments. The gem will generate the config.yml for you to fill out.
+```ruby
+dencity_client.login
+```
+
+### Search
+The search method accepts 3 optional parameters: *filters*, *return_only*, and *page*. *filters* is used to narrow the search results.  The format is an array of hashes containing 3 keys: name, value, and operator. The list of operators is as follows:
+- =  -  *Equal to* operator accepts string or number values.
+- ne -  *Not equal to* operator accepts string or number values.
+- lt -  *Less than* operator accepts number values.
+- lte - *Less than or equal to* operator accepts number values.
+- gt - *Greater than* operator accepts number values.
+- gte - *Greater than or equal to* operator accepts number values.
+- exists - *Exists* operator is used to return structure records where the specified metadatum exists in the structure record metadata. The value key can be left blank or nil for this operator.
+- in - *In* operator accepts an array of values (strings or numbers).
+- nin - * Not in* operator accepts an array of values (strings or numbers).
+
+If *filters* is nil, all results will be returned.
+
+The *return_only* parameter limits the data within each structure record to be returned.  All fields specified in the filters will be returned as well as the fields listed in the *return_only* array.  If *return_only* is nil, all fields will be returned.
+
+Since only 100 results are return per call, the *page* parameter allows you to step through the result set.  With each search call, the total number of results as well as total number of pages are returned.  You can use that information to make additional calls. The *page* parameter is 0-based:  set ```page=0``` to retrieve the first page of results.  If *page* is nil, the first page of results will be returned by default.
+
+Example:
+```ruby
+filters = []
+filters << { name: 'building_area', value: 2800, operator: 'lt' }
+filters << { name: 'building_type', value: ['Community Center'], operator: 'in' }
+return_only = ['related_files']
+page = 3
+results = dencity_client.search(filters, return_only, page)
+```
+
+### Retrieve an Analysis
+There are two methods of retrieving an analysis:  by ID, or by name + userID.
+
+Retrieve an analysis by ID:
+```ruby
+analysis = dencity_client.retrieve_analysis_by_id(<id>)
+```
+Retrieve by analysis name and userID:
+```ruby
+analysis = dencity_client.retrieve_analysis_by_name(<analysis_name>, <user_id>)
+```
+You have access to your own user_id from the response object returned once you login to DEnCity, or from your account page on DEnCity.org.
+
+### Upload an Analysis
+First load an analysis from a json file, then upload to DEnCity.org.
+```ruby
+analysis = dencity_client.load_analysis(<json_file_path>)
+analysis_response = analysis.push
+```
+To catch the response and ensure that the analysis was uploaded to DEnCity.org correctly, you may want to use a begin-end block:
+```ruby
+analysis = dencity_client.load_analysis(<json_file_path>)
+begin
+  analysis_response = analysis.push
+rescue StandardError => e
+  printf "%-40s %s\n", 'Upload Analysis', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Upload Analysis', 'SUCCESS'
+  puts analysis_response
+end
+```
+When uploading an analysis, the combination of user_id and user_defined_id will be checked.
+If an analysis with the same user_id and user_defined_id already exists on DEnCity.org, it will be updated; otherwise, a new analysis will be created.
+
+### Upload a Structure
+To upload a structure, you will need an analysis_id.  You can also specify a user_defined_id to identify your structure for future retrieving.
+```ruby
+structure = dencity_client.load_structure(<analysis_id>, <user_defined_id> <json_file_path>)
+structure_response = structure.push
+```
+When uploading a structure, the combination of user_id and user_defined_id will be checked.
+If a structure with the same user_id and user_defined_id already exists on DEnCity.org, it will be updated; otherwise, a new structure will be created.
+
+### Bulk Structures Upload
+Each time a structure is loaded, it is appended to the structures array defined on the Dencity Client: ```dencity_client.structures```.  You can bulk upload all structures to DenCity.org:
+```ruby
+dencity_client.bulk_upload_structures
+```
+
+### Upload a file
+Files can be attached to an uploaded structure.  You will need to pass in the filepath as well as the desired filename on DEnCity.org.  If no filename is specified, the file's current name will be used.
+
+```ruby
+ response = structure.upload_file(<file_path>, <file_name>)
+```
+
+### Delete an uploaded file
+Uploaded files can also be deleted from DEncity.org:
+```ruby
+ response = structure.delete_file(<file_name>)
+ ```
+
+### Additional Examples
+
+You can also do simple GETs using the dencity_get method.
+
+Get all analyses:
+```ruby
+response = dencity_client.dencity_get('analyses')
+```
+Get structure by ID:
+```ruby
+response = dencity_client.dencity_get('structures/<structure_id>')
+```
+
+The file example_script.rb contains many usage examples.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'dencity'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dencity.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dencity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dencity'
+  spec.version       = Dencity::VERSION
+  spec.authors       = %w(kflemin nlong)
+  spec.email         = ['katherine.fleming@nrel.gov']
+
+  spec.summary       = 'Client library for DEnCity.org.'
+  # spec.description   = %q{}
+  spec.homepage      = 'https://github.com/NREL/dencity-gem'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    fail 'RubyGems 2.0 or newer is required to protect against public '\
+    'gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_dependency('faraday')
+  spec.add_dependency('faraday_middleware')
+  spec.add_dependency('multi_json')
+  spec.add_dependency('parallel')
+  spec.add_dependency('hashie')
+end

data/example_script.rb

@@ -0,0 +1,152 @@
+require 'dencity'
+
+d = Dencity.connect(host_name: 'http://localhost:3000/')
+
+# to login using stored credentials:
+# begin
+#   login = d.login
+# rescue StandardError => e
+#   printf "%-40s %s\n", 'Login', 'FAIL'
+#   puts e
+# else
+#   printf "%-40s %s\n", 'Login', 'SUCCESS'
+#   puts login
+# end
+
+puts '****** SEARCH ********'
+filters = []
+filters << { name: 'building_area', value: 2737.26, operator: 'lt' }
+filters << { name: 'building_type', value: ['Community Center'], operator: 'in' }
+return_only = ['related_files']
+page = 0 # pages are 0-based
+begin
+  results = d.search(filters, return_only, page)
+rescue StandardError => e
+  printf "%-40s %s\n", 'Search', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Search', 'SUCCESS'
+end
+# puts "RESULTS: #{results}"
+puts "Total number of pages in results set: #{results.total_pages}"
+puts "Number of results: #{results.results.size}"
+
+puts '********  GET ANALYSIS BY NAME & USER_ID *********'
+begin
+  analysis = d.retrieve_analysis_by_name('test_analysis', '53a3656d986ffba2c5000001')
+rescue StandardError => e
+  printf "%-40s %s\n", 'Retrieve Analysis', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Retrieve Analysis', 'SUCCESS'
+end
+
+puts '******** GET ANALYSIS BY ID ************'
+begin
+  analysis = d.retrieve_analysis_by_id(analysis.id)
+rescue StandardError => e
+  printf "%-40s %s\n", 'Retrieve Analysis', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Retrieve Analysis', 'SUCCESS'
+end
+
+puts '********* GET ANALYSES *************'
+begin
+  analyses = d.dencity_get('analyses')
+ rescue StandardError => e
+   printf "%-40s %s\n", 'Get Analyses', 'FAIL'
+   puts e
+ else
+   printf "%-40s %s\n", 'Get Analyses', 'SUCCESS'
+  # puts analyses
+end
+
+puts '********* LOGIN ************'
+begin
+  login = d.login('nicholas.long@nrel.gov', 'testing123')
+rescue StandardError => e
+  printf "%-40s %s\n", 'Login', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Login', 'SUCCESS'
+  puts login
+end
+
+puts '********* Upload ANALYSIS **********'
+
+analysis = d.load_analysis('./spec/data/analysis.json')
+begin
+  a_response = analysis.push
+rescue StandardError => e
+  printf "%-40s %s\n", 'Upload Analysis', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Upload Analysis', 'SUCCESS'
+  puts a_response
+end
+
+puts '********* Upload STRUCTURE *********'
+structure = d.load_structure(analysis.analysis.id, 'testing!', './spec/data/structure.json')
+puts "STRUCTURE: #{structure}"
+begin
+  s_response = structure.push
+  rescue StandardError => e
+    printf "%-40s %s\n", 'Upload Structure', 'FAIL'
+    puts e
+  else
+    printf "%-40s %s\n", 'Upload Structure', 'SUCCESS'
+    puts s_response
+end
+
+puts '******* Upload RELATED FILE *******'
+begin
+  response = structure.upload_file('./spec/data/related_file.txt', 'test-related-file.txt')
+rescue StandardError => e
+  printf "%-40s %s\n", 'Upload RelatedFile', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Upload RelatedFile', 'SUCCESS'
+  puts response
+end
+
+puts '********** GET STRUCTURE *************'
+begin
+  new_structure = d.dencity_get("structures/#{structure.structure.id}")
+rescue StandardError => e
+  printf "%-40s %s\n", 'Retrieve Structure', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Retrieve Structure', 'SUCCESS'
+end
+puts new_structure
+
+puts '******* Delete a RELATED FILE *******'
+begin
+  response = structure.delete_file('test-related-file.txt')
+rescue StandardError => e
+  printf "%-40s %s\n", 'Delete File', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Delete File', 'SUCCESS'
+  puts response
+end
+
+puts '********** BULK UPLOAD ***********'
+d.load_structure(analysis.analysis.id, 'testing_bulk_1', './spec/data/structure.json')
+d.load_structure(analysis.analysis.id, 'testing_bulk_2', './spec/data/structure.json')
+d.load_structure(analysis.analysis.id, 'testing_bulk_3', './spec/data/structure.json')
+
+puts "structures: #{d.structures.size}"
+begin
+  b_response = d.bulk_upload_structures
+rescue StandardError => e
+  printf "%-40s %s\n", 'Upload Structure', 'FAIL'
+  puts e
+else
+  printf "%-40s %s\n", 'Upload Structure', 'SUCCESS'
+  puts b_response
+end
+
+puts '******* LOGOUT *******'
+d.logout

data/lib/dencity.rb

@@ -0,0 +1,18 @@
+require 'dencity/version'
+require_relative 'dencity/client'
+require_relative 'dencity/response'
+require_relative 'dencity/error'
+
+require 'multi_json'
+require 'hashie'
+require 'faraday'
+require 'faraday_middleware'
+require 'parallel'
+
+# Main module
+module Dencity
+  # initialize / connect
+  def self.connect(options = {})
+    Dencity::Client.new(options)
+  end
+end

data/lib/dencity/client.rb

@@ -0,0 +1,162 @@
+require_relative 'request'
+require_relative 'client/search'
+require_relative 'client/analysis'
+require_relative 'client/structure'
+require_relative '../faraday/raise_http_exception'
+
+require 'fileutils'
+require 'yaml'
+
+module Dencity
+  # API Client class
+  class Client
+    # connection options
+    attr_accessor :options
+    attr_accessor :analysis
+    attr_accessor :structures
+
+    include Request
+    include Dencity::Search
+
+    # connect to DEnCity (unauthenticated)
+    def initialize(options = {})
+      puts 'Initializing...'
+      defaults = {
+        username: nil,
+        password: nil,
+        host_name: 'https://dencity.org',
+        user_agent: "DEnCity Ruby Client #{Dencity::VERSION}".freeze,
+        logging: nil
+      }
+
+      @options = Hashie::Mash.new(defaults.merge(options))
+      # connection to site
+      @connection = connect
+
+      @default_number_threads = 4
+
+      # initialize analysis and structures
+      # array of structures
+      @structures = []
+      @analysis = nil
+    end
+
+    # for authenticated actions
+    def login(username = nil, password = nil)
+      # check config.yml
+      if !username.nil? && !password.nil?
+        @options.username = username
+        @options.password = password
+      else
+        # load login info from config file
+        config_path = File.expand_path('~') + '/.dencity'
+        config_name = 'config.yml'
+        if File.exist?(config_path + '/' + config_name)
+          puts "loading config settings from #{config_path + '/' + config_name}"
+
+          config = YAML.load_file(config_path + '/' + config_name)
+          puts "HEY! #{Hashie::Mash.new(config).inspect}"
+          puts "CONFIG: #{config.inspect}"
+          @options.username = config[:username]
+          @options.password = config[:password]
+          @options.host_name = config[:host_name]
+
+        else
+          # location of template file
+          FileUtils.mkdir_p(config_path)
+          puts default_yaml
+          File.open(config_path + '/' + config_name, 'w') do |file|
+            file << default_yaml.to_yaml
+          end
+          fail "******** Please fill in user credentials in #{config_path}/#{config_name} file.  DO NOT COMMIT THIS FILE. **********"
+        end
+
+      end
+
+      @connection = connect
+      post('api/login')
+    end
+
+    def logout
+      # @cookie = nil
+      @options.username = nil
+      @options.password = nil
+      @connection = nil
+    end
+
+    def connected?
+      @connection != nil
+    end
+
+    # load structure
+    def load_structure(analysis_id = nil, user_defined_id = nil, path = nil)
+      @structures << Dencity::Structure.new(analysis_id, user_defined_id, path, @connection)
+      @structures.last
+    end
+
+    # bulk upload structures
+    def bulk_upload_structures(number_of_threads = @default_number_threads)
+      Parallel.each(@structures, number_of_threads: number_of_threads) do |structure|
+        structure.push
+      end
+    end
+
+    # load analysis
+    # this function is needed to pass @connection at least
+    def load_analysis(path = nil)
+      @analysis = Dencity::Analysis.new(path, @connection)
+    end
+
+    # retrieve analysis
+    # must pass in @connection
+    def retrieve_analysis_by_name(name, user_id)
+      @analysis = Dencity::Analysis.new(nil, @connection)
+      @analysis.retrieve_by_name(name, user_id)
+    end
+
+    # retrieve analysis by ID
+    # must pass in @connection
+    def retrieve_analysis_by_id(id)
+      @analysis = Dencity::Analysis.new(nil, @connection)
+      @analysis.retrieve_by_id(id)
+    end
+
+    # generic GET action to retrieve from DEnCity
+    # example paths:  'analyses', 'structures/<structure_id>'
+    def dencity_get(path)
+      get(path)
+    end
+
+    private
+
+    def connect(raw = false)
+      options = set_options
+      puts "CONNECTING TO: #{@options.host_name}, USER: #{@options.username}"
+      Faraday::Connection.new(options) do |c|
+        c.use FaradayMiddleware::Mashify unless raw
+        # basic auth
+        c.basic_auth(@options.username, @options.password) unless @options.username.nil? || @options.password.nil?
+        c.use FaradayMiddleware::RaiseHttpException
+        c.response :json, content_type: /\bjson$/
+        c.response :logger if @logging
+        c.adapter Faraday.default_adapter
+      end
+    end
+
+    def set_options
+      { headers: {
+        'Accept' => 'application/json; charset=utf-8',
+        'User-Agent' => @options.user_agent,
+        # 'Cookie' => @options.cookie,
+        # 'X-CSRF-Token' => @options.access_token
+      }.reject { |_k, v| v.nil? },
+        ssl: { verify: false },
+        url: @options.host_name
+      }
+    end
+
+    def default_yaml
+      settings = { host_name: 'http://localhost:3000', username: 'ENTER_DENCITY_USERNAME', password: 'ENTER_DENCITY_PASSWORD' }
+    end
+  end
+end

data/lib/dencity/client/analysis.rb

@@ -0,0 +1,91 @@
+module Dencity
+  # Analysis methods
+  class Analysis
+    include Request
+
+    attr_accessor :analysis
+    attr_accessor :measure_definitions
+
+    # initialize
+    def initialize(path = nil, connection)
+      # for analysis, user_defined_id is created in @analysis (not a separate variable)
+      @analysis = Hashie::Mash.new
+      @measure_definitions = Hashie::Mash.new
+
+      @connection = connection
+
+      # initialize with JSON
+      unless path.nil?
+        load_from_file(path)
+      end
+
+      @upload_retries = nil
+    end
+
+    # get analysis by id
+    def retrieve_by_id(id)
+      response = get("api/analyses/#{id}")
+      @analysis = Hashie::Mash.new(response) unless response.error?
+      response
+    end
+
+    # get analysis by name and user_id
+    def retrieve_by_name(name, user_id)
+      data = { name: name, user_id: user_id }
+      response = get('api/retrieve_analysis', data)
+      @analysis = Hashie::Mash.new(response) unless response.error?
+      response
+    end
+
+    # load analysis from JSON file
+    def load_from_file(path)
+      return unless File.exist?(path)
+      json_data = File.read(path)
+      load_raw_json(json_data)
+    end
+
+    # load analysis from raw JSON
+    def load_raw_json(json_data)
+      temp = Hashie::Mash.new(MultiJson.load(json_data))
+      @analysis = temp.analysis ? temp.analysis : Hashie::Mash.new
+      @measure_definitions = temp.measure_definitions ? temp.measure_definitions : Hashie::Mash.new
+    end
+
+    def push
+      begin
+        @upload_retries ||= 0
+
+        response = post('api/analysis', format_analysis)
+        @analysis.id = response.analysis.id if (response.analysis && response.analysis.id)
+        return response if response
+      rescue StandardError => se
+        # Decide if we should fail based on number of retries
+        if @upload_retries < 3
+
+          raise 'could not upload'
+        else
+          # or here: @upload_retries = nil
+          return se
+        end
+      end
+    rescue => e
+      @upload_retries += 1
+      sleep 2
+      retry
+    ensure
+      # always do this
+      # verify that this is only called if the retry is not triggered
+      @upload_retries = nil
+    end
+
+    private
+
+    # format analysis for uploading
+    def format_analysis
+      data_hash = Hashie::Mash.new
+      data_hash.analysis = @analysis
+      data_hash.measure_definitions = @measure_definitions
+      MultiJson.dump(data_hash)
+    end
+  end
+end

data/lib/dencity/client/search.rb

@@ -0,0 +1,20 @@
+module Dencity
+  # Search methods
+  module Search
+    # filters: array of hashes with keys: name, value, operator
+    # return_only: array of metadata to return
+    # If blank, all metadata will be returned
+    # for iterating over results set (100 per page)
+    def search(filters = [{ name: 'building_type', value: 'Office', operator: '=' }], return_only = [], page = 0)
+      # must have 1 filter or search won't work
+      object = {}
+      object['filters'] = filters
+      object['return_only'] = return_only unless return_only.nil?
+      object['page'] = page
+
+      data = MultiJson.dump(object)
+      puts "DATA: #{data}"
+      post('api/search', data)
+    end
+  end
+end

data/lib/dencity/client/structure.rb

@@ -0,0 +1,158 @@
+module Dencity
+  # Structure methods
+  class Structure
+    include Request
+
+    attr_accessor :analysis_id
+    attr_accessor :user_defined_id
+    attr_accessor :structure
+    attr_accessor :measure_instances
+
+    # initialize
+    def initialize(analysis_id = nil, user_defined_id = nil, path = nil, connection)
+      @analysis_id = analysis_id
+      @user_defined_id = user_defined_id
+      @structure = Hashie::Mash.new
+      @measure_instances = Hashie::Mash.new
+
+      @connection = connection
+
+      # initialize with json file
+      unless path.nil?
+        load_from_file(path)
+      end
+
+      @upload_retries = nil
+    end
+
+    def push
+      begin
+        @upload_retries ||= 0
+
+        response = post('api/structure', format_structure)
+        @structure.id = response['id'] if response['id']
+        return response if response
+      rescue StandardError => se
+        # Decide if we should fail based on number of retries
+        if @upload_retries < 3
+
+          raise 'could not upload'
+        else
+          # or here: @upload_retries = nil
+          return se
+        end
+      end
+    rescue => e
+      @upload_retries += 1
+      sleep 2
+      retry
+    ensure
+      # always do this
+      # verify that this is only called if the retry is not triggered
+      @upload_retries = nil
+    end
+
+    # load structure from json file into a mash
+    def load_from_file(path)
+      return unless File.exist?(path)
+      json_data = File.read(path)
+      load_raw_json(json_data)
+    end
+
+    # load structure from raw json
+    def load_raw_json(json_data)
+      temp = Hashie::Mash.new(MultiJson.load(json_data))
+      @structure =  temp.structure ? temp.structure : Hashie::Mash.new
+      @measure_instances = temp.measure_instances ? temp.measure_instances : Hashie::Mash.new
+      # these could be set in the file
+      @analysis_id = temp.structure.analysis_id if temp.structure.analysis_id
+      @user_defined_id = temp.structure.user_defined_id if temp.structure.user_defined_id
+
+      return true
+    end
+
+    # upload file
+    def upload_file(path, file_name = nil)
+      fail 'No Structure ID defined for structure. Can\'t upload file' if @structure.id.nil?
+
+      file = File.open(path, 'rb')
+      the_file = Base64.strict_encode64(file.read)
+      file.close
+
+      # file_data param
+      file_data = {}
+      file_data['file_name'] = file_name.nil? ? File.basename(path) : file_name
+      file_data['file'] = the_file
+
+      data = Hashie::Mash.new
+      data.structure_id = @structure.id
+      data.file_data = file_data
+
+      push_file('api/related_file', MultiJson.dump(data))
+    end
+
+    # delete an uploaded file
+    # if structure_id is nil, will use @structure.id
+    def delete_file(file_name)
+      fail 'No Structure ID defined for structure. Can\'t delete file' if @structure.id.nil?
+
+      data = Hashie::Mash.new
+      data.structure_id = @structure.id
+      data.file_name = file_name
+
+      push_file('api/remove_file', MultiJson.dump(data))
+    end
+
+    # push file w/ retry
+    def push_file(path, data)
+      begin
+        @upload_retries ||= 0
+        response = post(path, data)
+        return response if response
+      rescue StandardError => se
+        # Decide if we should fail based on number of retries
+        if @upload_retries < 3
+          if path.include? 'remove'
+            raise 'could not delete file'
+          else
+            raise 'could not upload file'
+          end
+        else
+          return se
+        end
+      end
+    rescue => e
+      @upload_retries += 1
+      sleep 2
+      retry
+    ensure
+      # verify that this is only called if the retry is not triggered
+      @upload_retries = nil
+    end
+
+    private
+
+    # formats structure parameters for posting
+    def format_structure
+      # generate name/value pairs for structure metadata
+      formatted_meta = []
+      @structure.each do |k, v|
+        formatted_meta << { name: k, value: v } unless %w(id user_defined_id analysis_id).include?(k)
+      end
+      new_struct = Hashie::Mash.new
+      new_struct.metadata = formatted_meta
+
+      # TODO: what if it's already in the structure hash?
+      # add user_defined_id to structure
+      new_struct.user_defined_id = @user_defined_id
+      new_struct.analysis_id = @analysis_id
+
+      data_hash = Hashie::Mash.new
+      data_hash.structure = new_struct
+      data_hash.measure_instances = @measure_instances ? @measure_instances : []
+
+      # convert to json
+      MultiJson.dump(data_hash)
+    end
+  end
+end

data/lib/dencity/error.rb

@@ -0,0 +1,18 @@
+module Dencity
+  class Error < StandardError; end
+
+  # For 400's
+  class BadRequest < Error; end
+
+  # For 401's
+  class Unauthorized < Error; end
+
+  # For 404's.
+  class NotFound < Error; end
+
+  # For 406's.
+  class NotAcceptable < Error; end
+
+  # For 500's
+  class InternalServerError < Error; end
+end

data/lib/dencity/related_file.rb

@@ -0,0 +1,2 @@
+
+#

data/lib/dencity/request.rb

@@ -0,0 +1,46 @@
+module Dencity
+  # Request module
+  module Request
+    # Perform an HTTP GET request (options should not be in JSON)
+    def get(path, options = {}, raw = false,
+      unformatted = false, no_response_wrapper = false)
+      request(:get, path, options, raw, unformatted, no_response_wrapper)
+    end
+
+    # Perform an HTTP POST request (options should be in JSON already)
+    def post(path, options = {}, raw = false,
+      unformatted = false, no_response_wrapper = false)
+      request(:post, path, options, raw, unformatted, no_response_wrapper)
+    end
+
+    private
+
+    # Perform an HTTP request
+    def request(method, path, options, raw = false,
+      unformatted = false, no_response_wrapper = false)
+      response = @connection.send(method) do |request|
+        path = formatted_path(path) unless unformatted
+        puts "PATH: #{path}"
+
+        case method
+          when :get, :delete
+            request.url(path, options)
+        when :post, :put
+          request.path = path
+          request.body = options unless options.empty?
+        end
+
+        request.headers['Content-Type'] = 'application/json'
+
+      end
+
+      return response if raw
+      return response.body if no_response_wrapper
+      Response.create(response.body, response.status)
+    end
+
+    def formatted_path(path)
+      [path, 'json'].compact.join('.')
+    end
+  end
+end

data/lib/dencity/response.rb

@@ -0,0 +1,18 @@
+# Response Format
+
+module Dencity
+  # Response module
+  module Response
+    def self.create(response_hash, status)
+      if response_hash.class.name == 'Array'
+        data = Hashie::Mash.new
+        data.data = response_hash
+      else
+        data = response_hash.dup rescue response_hash
+      end
+      data.extend(self)
+      data.status = status
+      data
+    end
+  end
+end

data/lib/dencity/version.rb

@@ -0,0 +1,4 @@
+# Dencity version
+module Dencity
+  VERSION = '0.1.0'
+end

data/lib/faraday/raise_http_exception.rb

@@ -0,0 +1,45 @@
+require 'faraday'
+
+# Yeah, this is almost a carbon copy of the way the Instagram gem does it.
+# But screw it. It's open source, and it works. :P
+
+module FaradayMiddleware
+  class RaiseHttpException < Faraday::Middleware
+    def call(env)
+      @app.call(env).on_complete do |response|
+        case response[:status].to_i
+          when 400
+            fail Dencity::BadRequest, error_message_400(response)
+          when 401
+            fail Dencity::Unauthorized, error_message_400(response)
+          when 404
+            fail Dencity::NotFound, error_message_400(response)
+          when 406
+            fail Dencity::NotAcceptable, error_message_400(response)
+          when 500
+            fail Dencity::InternalServerError, error_message_500(response, 'Internal Server Error.')
+        end
+      end
+    end
+
+    def initialize(app)
+      super app
+      @parser = nil
+    end
+
+    private
+
+    def error_message_400(response)
+      "#{response[:method].to_s.upcase} #{response[:url]}: #{response[:status]} #{error_body(response[:body])}"
+    end
+
+    def error_body(body)
+      return unless !body.nil? && !body.empty? && body.is_a?(String)
+      body = ::MultiJson.load(body)
+    end
+
+    def error_message_500(response, body = nil)
+      "#{response[:method].to_s.upcase} #{response[:url]}: #{[response[:status].to_s + ':', body].compact.join(' ')}"
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: dencity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kflemin
+- nlong
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- katherine.fleming@nrel.gov
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rubocop.yml
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dencity.gemspec
+- example_script.rb
+- lib/dencity.rb
+- lib/dencity/client.rb
+- lib/dencity/client/analysis.rb
+- lib/dencity/client/search.rb
+- lib/dencity/client/structure.rb
+- lib/dencity/error.rb
+- lib/dencity/related_file.rb
+- lib/dencity/request.rb
+- lib/dencity/response.rb
+- lib/dencity/version.rb
+- lib/faraday/raise_http_exception.rb
+homepage: https://github.com/NREL/dencity-gem
+licenses: []
+metadata:
+  allowed_push_host: 'TODO: Set to ''http://mygemserver.com'''
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Client library for DEnCity.org.
+test_files: []
+has_rdoc: