activesp 0.0.1

data/lib/activesp/permission_set.rb

@@ -0,0 +1,29 @@
+module ActiveSP
+  
+  class PermissionSet
+    
+    include Util
+    
+    attr_reader :scope
+    
+    def initialize(scope)
+      @scope = scope
+    end
+    
+    def permissions
+      @scope.send(:permissions)
+    end
+    
+    def key
+      encode_key("P", [@scope.key])
+    end
+    
+    def to_s
+      "#<ActiveSP::PermissionSet scope=#{@scope}>"
+    end
+    
+    alias inspect to_s
+    
+  end
+  
+end

data/lib/activesp/persistent_caching.rb

@@ -0,0 +1,52 @@
+module ActiveSP
+  
+  module PersistentCaching
+    
+    def persistent(&blk)
+      class << self ; self ; end.instance_eval do
+        alias_method :old_new, :new
+        define_method(:new) do |*a|
+          cache_scope, indices = *blk.call(a)
+          if cache_scope.respond_to?(:persistent_cache)
+            cache_scope.persistent_cache.lookup(indices) { old_new(*a) }
+          else
+            old_new(*a)
+          end
+        end
+      end
+    end
+    
+  end
+  
+  class PersistentCache
+    
+    def initialize
+      @cache = {}
+    end
+    
+    def lookup(indices)
+      if o = @cache[indices]
+        # puts "  Cache hit for #{indices.inspect}"
+      else
+        o = @cache[indices] ||= yield
+        # puts "  Cache miss for #{indices.inspect}"
+      end
+      o
+    end
+    
+  end
+  
+  module PersistentCachingConfig
+    
+    def configure_persistent_cache(&blk)
+      @last_persistent_cache_object = PersistentCache.new
+      class << self ; self ; end.send(:define_method, :persistent_cache) do
+        cache = blk.call(@last_persistent_cache_object)
+        @last_persistent_cache_object = PersistentCache.new unless cache == @last_persistent_cache_object
+        cache
+      end
+    end
+    
+  end
+  
+end

data/lib/activesp/role.rb

@@ -0,0 +1,75 @@
+module ActiveSP
+  
+  class Role < Base
+    
+    extend Caching
+    extend PersistentCaching
+    include Util
+    include InSite
+    
+    attr_reader :name
+    
+    persistent { |site, name, *a| [site.connection, [:role, name]] }
+    def initialize(site, name)
+      @site, @name = site, name
+    end
+    
+    def key
+      encode_key("R", [@name])
+    end
+    
+    def users
+      call("UserGroup", "get_user_collection_from_role", "roleName" => @name).xpath("//spdir:User", NS).map do |row|
+        attributes = clean_attributes(row.attributes)
+        User.new(@site, attributes["LoginName"])
+      end
+    end
+    cache :users, :dup => true
+    
+    def groups
+      call("UserGroup", "get_group_collection_from_role", "roleName" => @name).xpath("//spdir:Group", NS).map do |row|
+        attributes = clean_attributes(row.attributes)
+        Group.new(@site, attributes["Name"])
+      end
+    end
+    cache :groups, :dup => true
+    
+    def to_s
+      "#<ActiveSP::Role name=#{@name}>"
+    end
+    
+    alias inspect to_s
+    
+    def is_role?
+      true
+    end
+    
+  private
+    
+    def data
+      call("UserGroup", "get_role_info", "roleName" => @name).xpath("//spdir:Role", NS).first
+    end
+    cache :data
+    
+    def attributes_before_type_cast
+      clean_attributes(data.attributes)
+    end
+    cache :attributes_before_type_cast
+    
+    def original_attributes
+      type_cast_attributes(@site, nil, internal_attribute_types, attributes_before_type_cast)
+    end
+    cache :original_attributes
+    
+    def internal_attribute_types
+      @@internal_attribute_types ||= {
+        "Description" => GhostField.new("Description", "Text", false, true),
+        "ID" => GhostField.new("ID", "Text", false, true),
+        "Name" => GhostField.new("Name", "Text", false, true),
+        "Type" => GhostField.new("Type", "Integer", false, true)
+      }
+    end
+    
+  end
+  
+end

data/lib/activesp/root.rb

@@ -0,0 +1,64 @@
+module ActiveSP
+  
+  NS = {
+    "sp" => "http://schemas.microsoft.com/sharepoint/soap/",
+    "z" => "#RowsetSchema",
+    "spdir" => "http://schemas.microsoft.com/sharepoint/soap/directory/"
+  }
+  
+  module Root
+    
+    extend Caching
+    
+    def root
+      Site.new(self, @root_url)
+    end
+    cache :root
+    
+    def users
+      root.send(:call, "UserGroup", "get_user_collection_from_site").xpath("//spdir:User", NS).map do |row|
+        attributes = clean_attributes(row.attributes)
+        User.new(root, attributes["LoginName"])
+      end
+    end
+    cache :users, :dup => true
+    
+    def groups
+      root.send(:call, "UserGroup", "get_group_collection_from_site").xpath("//spdir:Group", NS).map do |row|
+        attributes = clean_attributes(row.attributes)
+        Group.new(root, attributes["Name"])
+      end
+    end
+    cache :groups, :dup => true
+    
+    def roles
+      root.send(:call, "UserGroup", "get_role_collection_from_web").xpath("//spdir:Role", NS).map do |row|
+        attributes = clean_attributes(row.attributes)
+        Role.new(root, attributes["Name"])
+      end
+    end
+    cache :roles, :dup => true
+    
+  end
+  
+  class Connection
+    
+    include Root
+    
+  end
+  
+  module InSite
+    
+  private
+    
+    def call(*a, &b)
+      @site.send(:call, *a, &b)
+    end
+    
+    def fetch(url)
+      @site.send(:fetch, url)
+    end
+    
+  end
+  
+end

data/lib/activesp/site.rb

@@ -0,0 +1,215 @@
+module ActiveSP
+  
+  class Site < Base
+    
+    extend Caching
+    extend PersistentCaching
+    include Util
+    
+    attr_reader :url, :connection
+    
+    persistent { |connection, url, *a| [connection, [:site, url]] }
+    def initialize(connection, url, depth = 0)
+      @connection, @url, @depth = connection, url, depth
+      @services = {}
+    end
+    
+    def relative_url(url = @url)
+      url[@connection.root_url.rindex("/") + 1..-1]
+    end
+    
+    def supersite
+      if @depth > 0
+        Site.new(@connection, File.dirname(@url), @depth - 1)
+      end
+    end
+    cache :supersite
+    
+    def rootsite
+      @depth > 0 ? supersite.rootsite : self
+    end
+    cache :rootsite
+    
+    def is_root_site?
+      @depth == 0
+    end
+    
+    def key
+      encode_key("S", [@url[@connection.root_url.length + 1..-1], @depth])
+    end
+    
+    def sites
+      result = call("Webs", "get_web_collection")
+      result.xpath("//sp:Web", NS).map { |web| Site.new(connection, web["Url"].to_s, @depth + 1) }
+    end
+    cache :sites, :dup => true
+    
+    def site(name)
+      result = call("Webs", "get_web", "webUrl" => File.join(@url, name))
+      Site.new(connection, result.xpath("//sp:Web", NS).first["Url"].to_s, @depth + 1)
+    rescue Savon::SOAPFault
+      nil
+    end
+    
+    def lists
+      result1 = call("Lists", "get_list_collection")
+      result2 = call("SiteData", "get_list_collection")
+      result2_by_id = {}
+      result2.xpath("//sp:_sList", NS).each do |element|
+        data = {}
+        element.children.each do |ch|
+          data[ch.name] = ch.inner_text
+        end
+        result2_by_id[data["InternalName"]] = data
+      end
+      result1.xpath("//sp:List", NS).select { |list| list["Title"] != "User Information List" }.map do |list|
+        List.new(self, list["ID"].to_s, list["Title"].to_s, clean_attributes(list.attributes), result2_by_id[list["ID"].to_s])
+      end
+    end
+    cache :lists, :dup => true
+    
+    def list(name)
+      lists.find { |list| File.basename(list.attributes["RootFolder"]) == name }
+    end
+    
+    def /(name)
+      list(name) || site(name)
+    end
+    
+    def content_types
+      result = call("Webs", "get_content_types", "listName" => @id)
+      result.xpath("//sp:ContentType", NS).map do |content_type|
+        supersite && supersite.content_type(content_type["ID"]) || ContentType.new(self, nil, content_type["ID"], content_type["Name"], content_type["Description"], content_type["Version"], content_type["Group"])
+      end
+    end
+    cache :content_types, :dup => true
+    
+    def content_type(id)
+      content_types.find { |t| t.id == id }
+    end
+    
+    def permission_set
+      if attributes["InheritedSecurity"]
+        supersite.permission_set
+      else
+        PermissionSet.new(self)
+      end
+    end
+    cache :permission_set
+    
+    def fields
+      call("Webs", "get_columns").xpath("//sp:Field", NS).map do |field|
+        attributes = clean_attributes(field.attributes)
+        supersite && supersite.field(attributes["ID"].downcase) || Field.new(self, attributes["ID"].downcase, attributes["StaticName"], attributes["Type"], nil, attributes) if attributes["ID"] && attributes["StaticName"]
+      end.compact
+    end
+    cache :fields, :dup => true
+    
+    def fields_by_name
+      fields.inject({}) { |h, f| h[f.attributes["StaticName"]] = f ; h }
+    end
+    cache :fields_by_name, :dup => true
+    
+    def field(id)
+      fields.find { |f| f.ID == id }
+    end
+    
+    def to_s
+      "#<ActiveSP::Site url=#{@url}>"
+    end
+    
+    alias inspect to_s
+    
+  private
+    
+    def call(service, m, *args, &blk)
+      result = service(service).call(m, *args, &blk)
+      Nokogiri::XML.parse(result.http.body)
+    end
+    
+    def fetch(url)
+      @connection.fetch(url)
+    end
+    
+    def service(name)
+      @services[name] ||= Service.new(self, name)
+    end
+    
+    def data
+      call("SiteData", "get_web")
+    end
+    cache :data
+    
+    def attributes_before_type_cast
+      element = data.xpath("//sp:sWebMetadata", NS).first
+      result = {}
+      element.children.each do |ch|
+        result[ch.name] = ch.inner_text
+      end
+      result
+    end
+    cache :attributes_before_type_cast
+    
+    def original_attributes
+      type_cast_attributes(self, nil, internal_attribute_types, attributes_before_type_cast)
+    end
+    cache :original_attributes
+    
+    def internal_attribute_types
+      @@internal_attribute_types ||= {
+        "AllowAnonymousAccess" => GhostField.new("AllowAnonymousAccess", "Bool", false, true),
+        "AnonymousViewListItems" => GhostField.new("AnonymousViewListItems", "Bool", false, true),
+        "Author" => GhostField.new("Author", "InternalUser", false, true),
+        "Description" => GhostField.new("Description", "Text", false, true),
+        "ExternalSecurity" => GhostField.new("ExternalSecurity", "Bool", false, true),
+        "InheritedSecurity" => GhostField.new("InheritedSecurity", "Bool", false, true),
+        "IsBucketWeb" => GhostField.new("IsBucketWeb", "Bool", false, true),
+        "Language" => GhostField.new("Language", "Integer", false, true),
+        "LastModified" => GhostField.new("LastModified", "XMLDateTime", false, true),
+        "LastModifiedForceRecrawl" => GhostField.new("LastModifiedForceRecrawl", "XMLDateTime", false, true),
+        "Permissions" => GhostField.new("Permissions", "Text", false, true),
+        "Title" => GhostField.new("Title", "Text", false, true),
+        "UsedInAutocat" => GhostField.new("UsedInAutocat", "Bool", false, true),
+        "ValidSecurityInfo" => GhostField.new("ValidSecurityInfo", "Bool", false, true),
+        "WebID" => GhostField.new("WebID", "Text", false, true)
+      }
+    end
+    
+    def permissions
+      result = call("Permissions", "get_permission_collection", "objectName" => File.basename(@url), "objectType" => "Web")
+      result.xpath("//spdir:Permission", NS).map do |row|
+        accessor = row["MemberIsUser"][/true/i] ? User.new(rootsite, row["UserLogin"]) : Group.new(rootsite, row["GroupName"])
+        { :mask => Integer(row["Mask"]), :accessor => accessor }
+      end
+    end
+    cache :permissions, :dup => true
+    
+    class Service
+      
+      def initialize(site, name)
+        @site, @name = site, name
+        @client = Savon::Client.new(File.join(site.url, "_vti_bin", name + ".asmx?WSDL"))
+        @client.request.ntlm_auth(site.connection.login, site.connection.password) if site.connection.login
+      end
+      
+      def call(m, *args)
+        t1 = Time.now
+        if Hash === args[-1]
+          body = args.pop
+        end
+        @client.send(m, *args) do |soap|
+          if body
+            soap.body = body.inject({}) { |h, (k, v)| h["wsdl:#{k}"] = v ; h }
+          end
+          yield soap if block_given?
+        end
+      ensure
+        t2 = Time.now
+        puts "SP - time: %.3fs, site: %s, service: %s, method: %s, body: %s" % [t2 - t1, @site.url, @name, m, body.inspect] if @site.connection.trace
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/activesp/url.rb

@@ -0,0 +1,119 @@
+def URL(*args)
+  case args.length
+  when 1
+    url = args[0]
+    if URL === url
+      url
+    else
+      URL.parse(url)
+    end
+  when 2..6
+    URL.new(*args)
+  else
+    raise ArgumentError, "wrong number of arguments (#{args.length} for 1..6)"
+  end
+end
+
+class URL < Struct.new(:protocol, :host, :port, :path, :query, :fragment)
+  
+  def self.parse(url)
+    if /^(?:([^:\/?#]+):)?(?:\/\/([^\/?#:]*)(?::(\d+))?)?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/ === url.strip
+      new($1 ? $1.downcase : nil, $2 ? $2.downcase : nil, $3 ? $3.to_i : nil, $4, $5, $6)
+    else
+      nil
+    end
+  end
+  
+  def to_s
+    "%s://%s%s" % [protocol, authority, full_path]
+  end
+  
+  def authority
+    "%s%s" % [host, (!port || port == (protocol == "http" ? 80 : 443)) ? "" : ":#{port}"]
+  end
+  
+  def full_path
+    result = path.dup
+    result << "?" << query if query
+    result << "#" << fragment if fragment
+    result
+  end
+  
+  def join(url)
+    url = URL(url)
+    if url
+      if url.protocol == protocol
+        url.protocol = nil
+      end
+      unless url.protocol
+        url.protocol = protocol
+        unless url.host
+          url.host = host
+          url.port = port
+          if url.path.empty?
+            url.path = path
+            unless url.query
+              url.query = query
+            end
+          else
+            url.path = join_url_paths(url.path, path)
+          end
+        end
+      end
+      url.complete
+    else
+      nil
+    end
+  end
+  
+  def complete
+    self.protocol ||= "http"
+    self.port ||= self.protocol == "http" ? 80 : 443
+    self.path = "/" if self.path.empty?
+    self
+  end
+  
+  def self.unescape(s)
+    s.gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+  end
+  
+  def self.escape(s)
+    s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+    end
+  end
+  
+  def self.parse_query(qs, d = '&;')
+    params = {}
+    (qs || '').split(/[&;] */n).inject(params) do |h, p|
+      k, v = unescape(p).split('=', 2)
+      if cur = params[k]
+        if Array === cur
+          params[k] << v
+        else
+          params[k] = [cur, v]
+        end
+      else
+        params[k] = v
+      end
+    end
+    params
+  end
+  
+  def self.construct_query(hash)
+    hash.map { |k, v| "%s=%s" % [k, escape(v)] }.join('&')
+  end
+  
+private
+  
+  def join_url_paths(url, base)
+    if url[0] == ?/
+      url
+    else
+      base[0..base.rindex("/")] + url
+    end
+  end
+  
+end