proof-sharepoint-ruby 1.0.0

data/lib/sharepoint-properties.rb

@@ -0,0 +1,96 @@
+require 'sharepoint-stringutils'
+
+module Sharepoint
+  class ObjectProperties
+    attr_accessor :site, :data, :updated_data
+
+    def initialize site, data
+      @site                      = site
+      @data                      = data
+      @updated_data              = Hash.new
+      @properties                = Hash.new
+      @properties_names          = Array.new
+      @properties_original_names = Array.new
+      initialize_properties
+    end
+
+    def add_property property, value = nil
+      editable                = is_property_editable? property
+      property                = property.to_s
+      @data[property]         = nil   if @data[property].nil?
+      @data[property]         = value unless value.nil?
+      @updated_data[property] = value if (@initialize_properties == false) and (editable == true)
+      unless @properties_original_names.include? property
+        @properties_names          << property.underscore.to_sym
+        @properties_original_names << property
+        define_singleton_method property.underscore do
+          get_property property
+        end
+        define_singleton_method property.underscore + '=' do |new_value|
+          @data[property]         = new_value
+          @updated_data[property] = new_value
+        end if editable == true
+      end
+    end
+
+    def add_properties properties
+      properties.each do |property|
+        add_property property
+      end
+    end
+
+    def available_properties
+      @properties_names
+    end
+
+    private
+
+    def initialize_properties
+      @initialize_properties = true
+      # Create the properties defined for the Sharepoint type used
+      self.class.fields.each do |field|
+        add_property field[:name], field[:default] if field[:access].include? :read
+      end
+      # Set the values and create any missing properties from the OData object
+      @data.dup.each do |key,value|
+        add_property key, value
+      end
+      @initialize_properties = false
+    end
+
+    def get_property property_name
+      data = @data[property_name]
+      if not @properties[property_name].nil?
+        @properties[property_name]
+      elsif data.class == Hash
+        if not data['__deferred'].nil?
+          @properties[property_name] = get_deferred_property property_name
+        elsif not data['__metadata'].nil?
+          @properties[property_name] = @site.class.make_object_from_data @site, data
+        else
+          @properties[property_name] = data
+        end
+      elsif not data.nil?
+        @properties[property_name]   = data
+      else
+        @properties[property_name]   = nil
+      end
+    end
+
+    def get_deferred_property property_name
+      deferred_data = @data[property_name]['__deferred']
+      uri           = deferred_data['uri'].gsub /^http.*\/_api\/web\//i, ''
+      @site.query :get, uri
+    end
+
+    def is_property_editable? property_name
+      # We don't know a priori what the fields are for a generic object, so leave the validation work to the user
+      return true if self.is_a?(GenericSharepointObject)
+
+      self.class.fields.each do |field|
+        return field[:access].include? :write if field[:name] == property_name
+      end
+      false
+    end
+  end
+end

data/lib/sharepoint-ruby.rb

@@ -0,0 +1,152 @@
+require 'curb'
+require 'json'
+require 'sharepoint-error'
+require 'sharepoint-session'
+require 'sharepoint-object'
+require 'sharepoint-types'
+
+module Sharepoint
+  class SPException < SharepointError
+    def initialize data, uri = nil, body = nil
+      @data = data['error']
+      @uri  = uri
+      @body = body
+    end
+
+    def lang         ; @data['message']['lang']  ; end
+    def message      ; @data['message']['value'] ; end
+    def code         ; @data['code'] ; end
+    def uri          ; @uri ; end
+    def request_body ; @body ; end
+
+    def inspect
+      "#<Sharepoint::SPException: #{{'error'=>@data}}>"
+    end
+  end
+
+  class Site
+    attr_reader   :server_url
+    attr_accessor :url, :protocol
+    attr_accessor :session
+    attr_accessor :name
+    attr_accessor :verbose
+
+    class << self
+      def make_object_from_response instance, data
+        if data['d']['results'].nil?
+          data['d'] = data['d'][data['d'].keys.first] if data['d']['__metadata'].nil?
+          if not data['d'].nil?
+            make_object_from_data instance, data['d']
+          else
+            nil
+          end
+        else
+          array = Array.new
+          data['d']['results'].each do |result|
+            array << (make_object_from_data instance, result)
+          end
+          array
+        end
+      end
+
+      # Uses sharepoint's __metadata field to solve which Ruby class to instantiate,
+    # and return the corresponding Sharepoint::Object.
+    def make_object_from_data instance, data
+      return data unless data.is_a? Hash
+
+      type_name  = data['__metadata']['type'].gsub(/^SP\./, '')
+                                             .gsub(/^Collection\(Edm\.String\)/, 'CollectionString')
+                                             .gsub(/^Collection\(Edm\.Int32\)/, 'CollectionInteger')
+      type_parts = type_name.split '.'
+      type_name  = type_parts.pop
+      constant   = Sharepoint
+      type_parts.each do |part| constant = constant.const_get part end
+
+      klass      = constant.const_get type_name rescue nil
+      if klass
+        klass.new instance, data
+      # Patch for Sharepoint 2013 on-prem, missing period between list name
+      # and object type.
+      elsif data['__metadata']['type'] =~ /SP\.Data\..+Item/
+        Sharepoint::ListItem.new instance, data
+      else
+        Sharepoint::GenericSharepointObject.new type_name, instance, data
+      end
+    end
+    end
+
+    def initialize server_url, site_name
+      @server_url  = server_url
+      @name        = site_name
+      @url         = "#{@server_url}/#{@name}"
+      @session     = Session.new self
+      @web_context = nil
+      @protocol    = 'https'
+      @verbose     = false
+    end
+
+    def authentication_path
+      "#{@protocol}://#{@server_url}/_forms/default.aspx?wa=wsignin1.0"
+    end
+
+    def api_path uri
+      "#{@protocol}://#{@url}/_api/web/#{uri}"
+    end
+
+    def filter_path uri
+      uri
+    end
+
+    def context_info
+      query :get, ''
+    end
+
+    # Sharepoint uses 'X-RequestDigest' as a CSRF security-like.
+    # The form_digest method acquires a token or uses a previously acquired
+    # token if it is still supposed to be valid.
+    def form_digest
+      if @web_context.nil? or (not @web_context.is_up_to_date?)
+        @getting_form_digest = true
+        @web_context         = query :post, "#{@protocol}://#{@url}/_api/contextinfo"
+        @getting_form_digest = false
+      end
+      @web_context.form_digest_value
+    end
+
+    def query method, uri, body = nil, skip_json=false, &block
+      uri        = if uri =~ /^http/ then uri else api_path(uri) end
+      arguments  = [ uri ]
+      arguments << body if method != :get
+      result = Curl::Easy.send "http_#{method}", *arguments do |curl|
+        curl.headers["Cookie"]          = @session.cookie
+        curl.headers["Accept"]          = "application/json;odata=verbose"
+        if method != :get
+          curl.headers["Content-Type"]    = curl.headers["Accept"]
+          if session.instance_of?(Sharepoint::HttpAuth::Session)
+            curl.headers["X-RequestDigest"] = form_digest unless @getting_form_digest == true
+          else
+            curl.headers["X-RequestDigest"] = form_digest unless @getting_form_digest == true
+            curl.headers["Authorization"] = "Bearer " + form_digest unless @getting_form_digest == true
+          end
+        end
+        curl.verbose = @verbose
+        @session.send :curl, curl unless not @session.methods.include? :curl
+        block.call curl           unless block.nil?
+      end
+      if !(skip_json || (result.body_str.nil? || result.body_str.empty?))
+        begin
+          data = JSON.parse result.body_str
+          raise Sharepoint::SPException.new data, uri, body unless data['error'].nil?
+          self.class.make_object_from_response self, data
+        rescue JSON::ParserError => e
+          raise SharepointError.new("Exception with body=#{body}, e=#{e.inspect}, #{e.backtrace.inspect}, response=#{result.body_str}")
+        end
+      elsif result.status.to_i >= 400
+        raise SharepointError.new("#{method.to_s.upcase} #{uri} responded with #{result.status}")
+      else
+        result.body_str
+      end
+    end
+  end
+end
+

data/lib/sharepoint-session.rb

@@ -0,0 +1,92 @@
+require 'erb'
+require 'curb'
+
+module Sharepoint
+  MICROSOFT_STS_URL = "https://login.microsoftonline.com/extSTS.srf"
+
+  module Soap
+    class Authenticate
+      SOURCE = "soap/authenticate.xml.erb"
+
+      attr_accessor :username, :password, :login_url
+
+      def self.initialize
+        return if @initialized == true
+        @erb          = ERB.new(::File.read ::File.dirname(__FILE__) + '/' + SOURCE)
+        @erb.filename = SOURCE
+        @erb.def_method self, 'render()'
+        @initialized  = true
+      end
+
+      def initialize params = {}
+        Authenticate.initialize
+        @username  = params[:username]
+        @password  = params[:password]
+        @login_url = params[:url]
+      end
+    end
+  end
+
+  class Session
+    class ConnexionToStsFailed < Exception ; end
+    class ConnexionToSharepointFailed < Exception; end
+    class UnknownAuthenticationError  < Exception; end
+    class AuthenticationFailed < Exception
+      def initialize message ; super message ; end
+    end
+
+    attr_accessor :site
+
+    def initialize site
+      @site = site
+    end
+
+    def authenticate user, password, sts_url = nil
+      sts_url ||= MICROSOFT_STS_URL
+      authenticate_to_sts user, password, sts_url
+      get_access_token
+    end
+
+    def cookie
+      "FedAuth=#{@fed_auth};rtFa=#{@rtFa}"
+    end
+
+  private
+    def authenticate_to_sts user, password, sts_url
+      query    = Soap::Authenticate.new username: user, password: password, url: @site.authentication_path
+      response = Curl::Easy.http_post sts_url, query.render rescue raise ConnexionToStsFailed.new
+
+      response.body_str.scan(/<wsse:BinarySecurityToken[^>]*>([^<]+)</) do
+        offset          = ($~.offset 1)
+        @security_token = response.body[offset[0]..offset[1] - 1]
+      end
+      authentication_failed response.body_str if @security_token.nil?
+    end
+
+    def get_cookie_from_header header, cookie_name
+      result = nil
+      header.scan(/#{cookie_name}=([^;]+);/) do
+        offset = $~.offset 1
+        result = header[offset[0]..offset[1] - 1]
+      end
+      result
+    end
+
+    def get_access_token
+      http = Curl::Easy.http_post @site.authentication_path, @security_token
+      @rtFa     = get_cookie_from_header http.header_str, 'rtFa'
+      @fed_auth = get_cookie_from_header http.header_str, 'FedAuth'
+      raise UnknownAuthenticationError.new if @fed_auth.nil? or @rtFa.nil?
+    end
+
+    def authentication_failed xml
+      message   = 'Unknown authentication error'
+      xml.scan(/<psf:text[^>]*>([^<]+)</) do
+        offset  = ($~.offset 1)
+        message = xml[offset[0]..offset[1] - 1]
+      end
+      raise AuthenticationFailed.new message
+    end
+  end
+end
+

data/lib/sharepoint-stringutils.rb

@@ -0,0 +1,37 @@
+# Defines underscore and pluralize methods
+# unless they've already been defined by another script.
+
+unless String.new.methods.include? :underscore
+  class String
+    def underscore
+      self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end
+
+unless String.new.methods.include? :camelize
+  class String
+    def camelize
+      self.split("_").each {|s| s.capitalize! }.join("")
+    end
+  end
+end
+
+unless String.new.methods.include? :pluralize
+  class String
+    def pluralize
+      if self.match /y$/
+        self.gsub /y$/, 'ies'
+      elsif self.match /us$/
+        self.gsub /us$/, 'i'
+      else
+        self + 's'
+      end
+    end
+  end
+end
+

data/lib/sharepoint-types.rb

@@ -0,0 +1,84 @@
+require 'sharepoint-error'
+require 'sharepoint-object'
+
+module Sharepoint
+  class UnsupportedType < SharepointError
+    attr_accessor :type_name
+
+    def initialize type_name
+      @type_name = type_name
+    end
+
+    def message
+      "unsupported type '#{@type_name}'"
+    end
+  end
+
+  module Type
+    def initialize site, data = nil
+      data               ||= Hash.new
+      data['__metadata'] ||= {
+        'type' => "SP.#{self.class.name.split('::').last}"
+      }
+      super site, data
+    end
+  end
+end
+
+require 'sharepoint-users'
+require 'sharepoint-lists'
+require 'sharepoint-files'
+require 'sharepoint-fields'
+require 'date'
+
+module Sharepoint
+  ##
+  ## Sharepoint Management
+  ##
+  class Web < Sharepoint::Object
+    include Sharepoint::Type
+
+    field 'CustomMasterUrl'
+    field 'Description'
+    field 'EnableMinimalDownload'
+    field 'MasterUrl'
+    field 'QuickLaunchEnabled'
+    field 'SaveSiteAsTemplateEnabled'
+    field 'SyndicationEnabled'
+    field 'Title'
+    field 'TreeViewEnabled'
+    field 'UiVersion'
+    field 'UiVersionConfigurationEnabled'
+
+    method :apply_theme
+    method :break_role_inheritance, default_params: ({ clearsubscopes: true })
+  end
+
+  class ContextWebInformation < Sharepoint::Object
+    include Sharepoint::Type
+
+    def issued_time
+      strtime = (form_digest_value.split ',').last
+      DateTime.strptime strtime, '%d %b %Y %H:%M:%S %z'
+    end
+
+    def timeout_time
+      issued_time + Rational(form_digest_timeout_seconds, 86400)
+    end
+
+    def is_up_to_date?
+      DateTime.now < timeout_time
+    end
+  end
+
+  class FeatureCollection < Sharepoint::Object
+    include Sharepoint::Type
+  end
+
+  ##
+  ## Other types
+  ##
+  class PropertyValues < Sharepoint::Object
+    include Sharepoint::Type
+  end
+end