gooddata 1.0.0-java

data/lib/gooddata/mixins/links.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module Links
+      def links
+        data['links']
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_finders.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdFinders
+      # Finds a specific type of the object by identifier. Returns first match. Returns full object.
+      #
+      # @param title [String] identifier that has to match exactly
+      # @param title [Regexp] regular expression that has to match
+      # @return [Array<GoodData::MdObject>] Array of MdObject
+      def find_first_by_identifier(identifier, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options.merge(full: false)]
+        item = if identifier.is_a?(Regexp)
+                 all.find { |r| r.identifier =~ identifier }
+               else
+                 all.find { |r| r.identifier == identifier }
+               end
+        self[item.uri, options] unless item.nil?
+      end
+
+      # Finds a specific type of the object by identifier. Returns all matches. Returns full object.
+      #
+      # @param title [String] identifier that has to match exactly
+      # @param title [Regexp] regular expression that has to match
+      # @return [Array<GoodData::MdObject>] Array of MdObject
+      def find_by_identifier(identifier, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options]
+        items = if identifier.is_a?(Regexp)
+                  all.select { |r| r.title =~ identifier }
+                else
+                  all.select { |r| r.title == identifier }
+                end
+        items.pmap { |item| self[item.uri, options] unless item.nil? }
+      end
+
+      def find_by_tag(tags, opts = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(opts)
+        tags = tags.split(',').map(&:strip) unless tags.is_a?(Array)
+
+        self[:all, client: client, project: project]
+          .select { |r| (r.tag_set & tags).any? }
+      end
+
+      # Finds a specific type of the object by title. Returns first match. Returns full object.
+      #
+      # @param title [String] title that has to match exactly
+      # @param title [Regexp] regular expression that has to match
+      # @return [Array<GoodData::MdObject>] Array of MdObject
+      def find_first_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options]
+        item = if title.is_a?(Regexp)
+                 all.find { |r| r.title =~ title }
+               else
+                 all.find { |r| r.title == title }
+               end
+        self[item.uri, options] unless item.nil?
+      end
+
+      # Finds a specific type of the object by title. Returns all matches. Returns full object.
+      #
+      # @param title [String] title that has to match exactly
+      # @param title [Regexp] regular expression that has to match
+      # @return [Array<GoodData::MdObject>] Array of MdObject
+      def find_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options]
+        items = if title.is_a?(Regexp)
+                  all.select { |r| r.title =~ title }
+                else
+                  all.select { |r| r.title == title }
+                end
+        items.pmap { |item| self[item.uri, options] unless item.nil? }
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_grantees.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdGrantees
+      def grantees(opts = {})
+        permission = opts[:permission]
+        params = permission ? { permission: permission } : {}
+        client.get(uri + '/grantees', params: params)
+      end
+
+      def grant(opts = {})
+        change_permission(opts.merge(operation: :add))
+      end
+
+      def revoke(opts = {})
+        change_permission(opts.merge(operation: :remove))
+      end
+
+      def change_permission(opts)
+        permission = opts[:permission]
+        member = opts[:member]
+        op = opts[:operation]
+        klasses = [GoodData::Profile, GoodData::UserGroup, GoodData::Membership]
+        fail "Permission has to be set. Current value '#{permission}'" unless permission
+        fail 'Member has to be either user or group' unless klasses.any? { |c| member.is_a?(c) }
+        payload = {
+          granteeURIs: {
+            items: [
+              { aclEntryURI: { permission: permission, grantee: member.uri } }
+            ]
+          }
+        }
+        client.post(uri + '/grantees/' + op.to_s, payload)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_id_to_uri.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdIdToUri
+      IDENTIFIERS_CFG = 'instance-identifiers'
+
+      def identifier_to_uri(opts = { :client => GoodData.connection, :project => GoodData.project }, *ids)
+        client, project = GoodData.get_client_and_project(opts)
+
+        response = nil
+        begin
+          uri = project.md[IDENTIFIERS_CFG]
+          response = client.post(uri, 'identifierToUri' => ids)
+        rescue => ex
+          raise ex
+        end
+
+        if response['identifiers'].empty?
+          nil
+        else
+          identifiers = response['identifiers']
+          ids_lookup = identifiers.reduce({}) do |a, e|
+            a[e['identifier']] = e['uri']
+            a
+          end
+          uris = ids.map { |x| ids_lookup[x] }
+          uris.count == 1 ? uris.first : uris
+        end
+      end
+
+      alias_method :id_to_uri, :identifier_to_uri
+    end
+  end
+end

data/lib/gooddata/mixins/md_json.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdJson
+      def to_json(*args)
+        json.to_json(*args)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_lock.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module Lockable
+      # Locks an object. Locked object cannot be changed by certain users.
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def lock
+        meta['locked'] = 1
+        self
+      end
+
+      # Sames as #lock. Locks an object and immediately saves it.
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def lock!
+        lock
+        save
+      end
+
+      # Unlocks an object.
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def unlock
+        meta.delete('locked')
+        self
+      end
+
+      # Same as #unlock. Unlocks an object and immediately saves it
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def unlock!
+        unlock
+        save
+      end
+
+      # Locks an object with all used objects. The types of objects that are affected by locks
+      # are dashboards, reports and metrics. This means that if you lock a dashboard by this method
+      # all used reports and metrics are also locked. If you lock a report all used metrics are also
+      # locked. The current object is reloaded. This means that the #locked? will return true.
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def lock_with_dependencies!
+        client.post("/gdc/internal/projects/#{project.pid}/objects/setPermissions",
+                    permissions: {
+                      lock: true,
+                      items: [uri]
+                    })
+        reload!
+      end
+
+      # Unlocks an object with all used objects. The types of objects that are affected by locks
+      # are dashboards, reports and metrics. This means that if you unlock a dashboard by this method
+      # all used reports and metrics are also unlocked. If you unlock a report all used metrics are also
+      # unlocked. The current object is unlocked as well. Beware that certain objects might be in use in
+      # multiple contexts. For example one metric can be used in several reports. This method performs no
+      # checks to determine if an object should stay locked or not.
+      #
+      # @return [GoodData::Mixin::Lockable]
+      def unlock_with_dependencies!
+        using('report').pmap { |link| project.reports(link['link']) }.select(&:locked?).pmap(&:unlock!)
+        using('metric').pmap { |link| project.metrics(link['link']) }.select(&:locked?).pmap(&:unlock!)
+        using('projectDashboard').pmap { |link| project.dashboards(link['link']) }.select(&:locked?).pmap(&:unlock!)
+        unlock!
+      end
+
+      # Returns true if an object is locked. False otherwise.
+      #
+      # @return [Boolean]
+      def locked?
+        meta['locked'] == 1
+      end
+
+      # Returns true if an object is unlocked. False otherwise.
+      #
+      # @return [Boolean]
+      def unlocked?
+        !locked?
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_object_id.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdObjId
+      def uri_obj_id(uri)
+        GoodData::Helpers.last_uri_part(uri)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_object_indexer.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdObjectIndexer
+      MD_OBJ_CTG = 'obj'
+
+      # Returns either list of objects or a specific object.
+      # This method is reimplemented in subclasses to leverage specific
+      # implementation for specific type of objects. Options is used in
+      # subclasses specifically to provide shorthand for getting a full
+      # objects after getting a list of hashes from query resource.
+      # @param [Object] id id can be either a number a String (as a URI). Subclasses should also be abel to deal with getting the instance of MdObject already and a :all symbol
+      # @param [Hash] options the options hash
+      # @option options [Boolean] :full if passed true the subclass can decide
+      # to pull in full objects. This is desirable from the usability POV
+      # but unfortunately has negative impact on performance so it is not
+      # the default.
+      # @return [MdObject] if id is a String or number single object is returned
+      # @return [Array] if :all was provided as an id, list of objects should
+      # be returned. Note that this is implemented only in the subclasses.
+      # MdObject does not support this since API has no means to return list
+      # of all types of objects.
+      def [](id, options = { :client => GoodData.connection, :project => GoodData.project })
+        client, project = GoodData.get_client_and_project(options)
+
+        fail "You have to provide an \"id\" to be searched for." unless id
+        fail(NoProjectError, 'Connect to a project before searching for an object') unless project
+        return all(options) if id == :all
+        return id if id.is_a?(MdObject)
+        uri = if id.is_a?(Integer) || id =~ /^\d+$/
+                "#{project.md[MD_OBJ_CTG]}/#{id}"
+              elsif id !~ %r{/}
+                identifier_to_uri options, id
+              elsif id =~ %r{^/}
+                id
+              else
+                fail 'Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash'
+              end
+        # new(GoodData.get uri) unless uri.nil?
+        if uri # rubocop:disable Style/GuardClause
+          raw = client.get(uri)
+          md_class = self
+          case raw.keys.first
+          when 'attribute'
+            md_class = GoodData::Attribute
+          when 'metric'
+            md_class = GoodData::Metric
+          when 'projectDashboard'
+            md_class = GoodData::Dashboard
+          when 'report'
+            md_class = GoodData::Report
+          when 'attributeDisplayForm'
+            md_class = GoodData::Label
+          when 'reportDefinition'
+            md_class = GoodData::ReportDefinition
+          when 'dataSet'
+            md_class = GoodData::Dataset
+          else
+            md_class = self
+          end
+
+          client.create(md_class, raw, client: client, project: project)
+        end
+      end
+
+      alias_method :get_by_id, :[]
+    end
+  end
+end

data/lib/gooddata/mixins/md_object_query.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Mixin
+    module MdObjectQuery
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @param options [Hash] the options hash
+      # @option options [Boolean] :full if passed true the subclass can decide
+      # to pull in full objects. This is desirable from the usability POV
+      # but unfortunately has negative impact on performance so it is not
+      # the default.
+      # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+      def all(_options = { :client => GoodData.connection, :project => GoodData.project })
+        fail NotImplementedError, 'Method should be implemented in subclass. Currently there is no way how to get all metadata objects on API.'
+      end
+
+      # Method intended to be called by individual classes in their all
+      # implementations. It abstracts the way interacting with query resources.
+      # It either returns the array of hashes from query. If asked it also
+      # goes and brings the full objects. Due to performance reasons
+      # :full => false is the default. This will most likely change
+      #
+      # @param query_obj_type [String] string used in URI to distinguish different query resources for different objects
+      # @param klass [Class] A class used for instantiating the returned data
+      # @param options [Hash] the options hash
+      # @option options [Boolean] :full if passed true the subclass can
+      # decide to pull in full objects. This is desirable from the usability
+      # POV but unfortunately has negative impact on performance so it is
+      # not the default.
+      # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+      def query(query_obj_type, klass, options = { :client => GoodData.connection, :project => GoodData.project })
+        client = options[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        p = options[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, options]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        offset = 0
+        page_limit = 50
+        Enumerator.new do |y|
+          loop do
+            result = client.get(project.md['objects'] + '/query', params: { category: query_obj_type, limit: page_limit, offset: offset })
+            result['objects']['items'].each do |item|
+              y << (klass ? client.create(klass, item, project: project) : item)
+            end
+            break if result['objects']['paging']['count'] < page_limit
+            offset += page_limit
+          end
+        end
+      end
+
+      def dependency(uri, key = nil, opts = { :client => GoodData.connection })
+        c = opts[:client]
+        fail ArgumentError, 'No :client specified' if c.nil?
+
+        result = c.get(uri)['entries']
+        if key.nil?
+          result
+        elsif key.respond_to?(:category)
+          result = result.select { |item| item['category'] == key.category }
+        else
+          result = result.select { |item| item['category'] == key }
+        end
+
+        if opts[:full]
+          result = result.map do |res|
+            GoodData::MdObject[res['link'], :client => c, :project => opts[:project]]
+          end
+        end
+
+        result
+      end
+
+      # Checks for dependency
+      def dependency?(type, uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
+        uri = uri.respond_to?(:uri) ? uri.uri : uri
+        objs = case type
+               when :usedby
+                 usedby(uri, nil, opts)
+               when :using
+                 using(uri, nil, opts)
+               end
+
+        target_uri = target_uri.respond_to?(:uri) ? target_uri.uri : target_uri
+        objs.any? do |obj|
+          obj['link'] == target_uri
+        end
+      end
+
+      # Returns which objects uses this MD resource
+      def usedby(uri, key = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
+        dependency("#{project.md['usedby2']}/#{uri_obj_id(uri)}", key, opts)
+      end
+
+      alias_method :used_by, :usedby
+
+      # Returns which objects this MD resource uses
+      def using(uri, key = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
+        dependency("#{project.md['using2']}/#{uri_obj_id(uri)}", key, opts)
+      end
+
+      def usedby?(uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
+        dependency?(:usedby, uri, target_uri, opts)
+      end
+
+      alias_method :used_by?, :usedby?
+
+      # Checks if obj is using this MD resource
+      def using?(uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
+        dependency?(:using, uri, target_uri, opts)
+      end
+    end
+  end
+end