Class: GoodData::Domain

Inherits:
Rest::Resource show all
Defined in:
lib/gooddata/models/domain.rb

Constant Summary collapse

USER_LANGUAGES = 
{
  'en-US' => 'English',
  'nl-NL' => 'Dutch',
  'es-ES' => 'Spanish',
  'pt-BR' => 'Portuguese/Brazil',
  'pt-PT' => 'Portuguese/Portugal',
  'fr-FR' => 'French',
  'de-DE' => 'German',
  'ja-JP' => 'Japanese',
  'it-IT' => 'Italian',
  'es-419' => 'Spanish/Latin America',
  'fr-CA' => 'French/Canada',
  'en-GB' => 'English/UK',
  'en-AU' => 'English/Australian',
  'fi-FI' => 'Finnish',
  'zh-Hant' => 'Traditional Chinese',
  'zh-HK' => 'Cantonese'
}

Instance Attribute Summary collapse

Attributes inherited from Rest::Object

#client, #json, #project

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Mixin::ObjId

#obj_id

Methods inherited from Rest::Object

client, default_client, #saved?

Methods included from Mixin::DataPropertyReader

#data_property_reader

Methods included from Mixin::DataPropertyWriter

#data_property_writer

Methods included from Mixin::MetaPropertyReader

#metadata_property_reader

Methods included from Mixin::MetaPropertyWriter

#metadata_property_writer

Methods included from Mixin::MetaGetter

#meta

Methods included from Mixin::DataGetter

#data

Methods included from Mixin::RootKeyGetter

#root_key

Methods included from Mixin::ContentGetter

#content

Constructor Details

#initialize(domain_name) ⇒ Domain

Returns a new instance of Domain.



315
316
317
 
# File 'lib/gooddata/models/domain.rb', line 315

def initialize(domain_name)
  @name = domain_name
end

Instance Attribute Details

#name ⇒ Object

Returns the value of attribute name.



15
16
17
 
# File 'lib/gooddata/models/domain.rb', line 15

def name
  @name
end

Class Method Details

.[](domain_name, options = { :client => GoodData.connection }) ⇒ String

Looks for domain

Parameters:

  • domain_name (String) —

    Domain name

Returns:

  • (String) —

    Domain object instance



41
42
43
44
45
46
 
# File 'lib/gooddata/models/domain.rb', line 41

def [](domain_name, options = { :client => GoodData.connection })
  return domain_name if domain_name.is_a?(Domain)
  c = client(options)
  fail "Using pseudo-id 'all' is not supported by GoodData::Domain" if domain_name.to_s == 'all'
  c.create(GoodData::Domain, domain_name)
end

.add_user(user_data, name = nil, opts = { :client => GoodData.connection }) ⇒ Object

Adds user to domain

Parameters:

  • domain (String) —

    Domain name

  • login (String) —

    Login of user to be invited

  • password (String) —

    Default preset password

Returns:



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/gooddata/models/domain.rb', line 54

def add_user(user_data, name = nil, opts = { :client => GoodData.connection })
  generated_pass = GoodData::Helpers::CryptoHelper.generate_password
  domain_name = name || user_data[:domain]
  user_data = user_data.to_hash
  data = {
    :login => user_data[:login] || user_data[:email],
    :firstName => user_data[:first_name] || 'FirstName',
    :lastName => user_data[:last_name] || 'LastName',
    :password => user_data[:password] || generated_pass,
    :verifyPassword => user_data[:password] || generated_pass,
    :email => user_data[:email] || user_data[:login],
    :language => ensure_user_language(user_data)
  }

  # Optional authentication modes
  tmp = user_data[:authentication_modes]
  if tmp
    if tmp.is_a? Array
      data[:authenticationModes] = tmp
    elsif tmp.is_a? String
      data[:authenticationModes] = [tmp]
    end
  end

  # Optional company
  tmp = user_data[:company_name]
  tmp = user_data[:company] if tmp.nil? || tmp.empty?
  data[:companyName] = tmp if tmp && !tmp.empty?

  # Optional country
  tmp = user_data[:country]
  data[:country] = tmp if tmp && !tmp.empty?

  # Optional phone number
  tmp = user_data[:phone]
  tmp = user_data[:phone_number] if tmp.nil? || tmp.empty?
  data[:phoneNumber] = tmp if tmp && !tmp.empty?

  # Optional position
  tmp = user_data[:position]
  data[:position] = tmp if tmp && !tmp.empty?

  # Optional sso provider
  tmp = user_data[:sso_provider]
  data['ssoProvider'] = tmp if tmp && !tmp.empty?

  # Optional timezone
  tmp = user_data[:timezone]
  data[:timezone] = tmp if tmp && !tmp.empty?

  # Optional ip whitelist
  tmp = user_data[:ip_whitelist]
  data[:ipWhitelist] = tmp if tmp

  c = client(opts)

  # TODO: It will be nice if the API will return us user just newly created
  begin
    url = "/gdc/account/domains/#{domain_name}/users"
    response = c.post(url, :accountSetting => data)
  rescue RestClient::BadRequest => e
    error = MultiJson.load(e.response)
    error_type = GoodData::Helpers.get_path(error, %w(error errorClass))
    case error_type
    when 'com.gooddata.webapp.service.userprovisioning.LoginNameAlreadyRegisteredException'
      u = Domain.(domain_name, data[:login])
      if u
        response = { 'uri' => u.uri }
      else
        raise GoodData::UserInDifferentDomainError, "User #{data[:login]} is already in different domain"
      end
    when 'com.gooddata.json.validator.exception.MalformedMessageException'
      raise GoodData::MalformedUserError, "User #{data[:login]} is malformed. The message from API is #{GoodData::Helpers.interpolate_error_message(error)}"
    else
      raise GoodData::Helpers.interpolate_error_message(error)
    end
  end

  url = response['uri']
  raw = c.get url

  # TODO: Remove this hack when POST /gdc/account/domains/{domain-name}/users returns full profile
  raw['accountSetting']['links'] = {} unless raw['accountSetting']['links']
  raw['accountSetting']['links']['self'] = response['uri'] unless raw['accountSetting']['links']['self']
  c.create(GoodData::Profile, raw)
end

.create_users(list, default_domain = nil, opts = { :client => GoodData.connection, :project => GoodData.project }) ⇒ Array<GoodData::User>

Create users specified in list

Parameters:

  • list (Array<GoodData::Membership>) —

    List of users

  • default_domain_name (String) —

    Default domain name used when no specified in user

Returns:

  • (Array<GoodData::User>) —

    List of users created



259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'lib/gooddata/models/domain.rb', line 259

def create_users(list, default_domain = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
  default_domain_name = default_domain.respond_to?(:name) ? default_domain.name : default_domain
  domain = client.domain(default_domain_name)

  # Prepare cache for domain users
  domain_users_cache = Hash[domain.users.map { |u| [u..downcase, u] }]

  list.pmapcat do |user|
    begin
      user_data = user.to_hash.tap { |uh| uh[:login].downcase! }
      domain_user = domain_users_cache[user_data[:login]]
       = user_data[:login]
      if !domain_user
        added_user = domain.add_user(user_data, opts)
        GoodData.logger.info("Added new user=#{} to domain=#{default_domain_name}.")
        [{ type: :successful, :action => :user_added_to_domain, user: added_user }]
      else
        domain_user_data = domain_user.to_hash
        fields_to_check = opts[:fields_to_check] || user_data.keys
        diff = GoodData::Helpers.diff([domain_user.to_hash], [user_data], key: :login, fields: fields_to_check)
        next [] if diff[:changed].empty?
        updated_user = domain.update_user(domain_user.to_hash.merge(user_data.compact), opts)
        GoodData.logger.debug "Updated user=#{} from old properties \
(email=#{domain_user_data[:email]}, sso_provider=#{domain_user_data[:sso_provider]}) \
to new properties (email=#{user_data[:email]}, sso_provider=#{user_data[:sso_provider]}) in domain=#{default_domain_name}."
        [{ type: :successful, :action => :user_changed_in_domain, user: updated_user }]
      end
    rescue RuntimeError => e
      error_message = e.message
      user.delete(:password)
      if !domain_user
        GoodData.logger.error("Failed to add user=#{} to domain=#{default_domain_name}. Error: #{error_message}")
      else
        error_message = 'Invalid user data or update new password cannot be the same as old password' if error_message == '400 Bad Request'

        GoodData.logger.error("Failed to update user=#{} in domain=#{default_domain_name}. Error: #{error_message}")
      end
      [{ type: :failed, :user => user, message: error_message }]
    end
  end
end

.find_user_by_login(domain, login, opts = { :client => GoodData.connection, :project => GoodData.project }) ⇒ GoodData::Profile

Finds user in domain by login

Parameters:

  • domain (String) —

    Domain name

  • login (String) —

    User login

Returns:



210
211
212
213
214
215
216
217
218
219
 
# File 'lib/gooddata/models/domain.rb', line 210

def (domain, , opts = { :client => GoodData.connection, :project => GoodData.project })
  c = client(opts)
   = CGI.escape()
  domain = c.domain(domain)
  GoodData.logger.warn("Retrieving particular user \"#{.inspect}\" from domain #{domain.name}")
  url = "#{domain.uri}/users?login=#{}"
  tmp = c.get url
  items = tmp['accountSettings']['items'] if tmp['accountSettings']
  items && !items.empty? ? c.factory.create(GoodData::Profile, items.first) : nil
end

.update_user(user_data, options = { client: GoodData.connection }) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/gooddata/models/domain.rb', line 141

def update_user(user_data, options = { client: GoodData.connection })
  user_data = user_data.to_hash if user_data.is_a?(GoodData::Profile)
  client = client(options)
  user_data = user_data.to_hash
  data = {
    :firstName => user_data[:first_name] || 'FirstName',
    :lastName => user_data[:last_name] || 'LastName',
    :email => user_data[:email],
    :language => ensure_user_language(user_data)
  }

  # Optional authentication modes
  tmp = user_data[:authentication_modes]
  if tmp
    if tmp.is_a? Array
      data[:authenticationModes] = tmp
    elsif tmp.is_a? String
      data[:authenticationModes] = [tmp]
    end
  end

  # Optional company
  tmp = user_data[:company_name]
  tmp = user_data[:company] if tmp.nil? || tmp.empty?
  data[:companyName] = tmp if tmp && !tmp.empty?

  # Optional pass
  tmp = user_data[:password]
  tmp = user_data[:password] if tmp.nil? || tmp.empty?
  data[:password] = tmp if tmp && !tmp.empty?
  data[:verifyPassword] = tmp if tmp && !tmp.empty?

  # Optional country
  tmp = user_data[:country]
  data[:country] = tmp if tmp && !tmp.empty?

  # Optional phone number
  tmp = user_data[:phone]
  tmp = user_data[:phone_number] if tmp.nil? || tmp.empty?
  data[:phoneNumber] = tmp if tmp && !tmp.empty?

  # Optional position
  tmp = user_data[:position]
  data[:position] = tmp if tmp && !tmp.empty?

  # Optional sso provider
  tmp = user_data[:sso_provider]
  data['ssoProvider'] = tmp if tmp

  # Optional timezone
  tmp = user_data[:timezone]
  data[:timezone] = tmp if tmp && !tmp.empty?

  # TODO: It will be nice if the API will return us user just newly created
  url = user_data.delete(:uri)
  data.delete(:password) if client.user.uri == url
  response = client.put(url, :accountSetting => data)

  # TODO: Remove this hack when POST /gdc/account/domains/{domain-name}/users returns full profile
  response['accountSetting']['links'] = {} unless response['accountSetting']['links']
  response['accountSetting']['links']['self'] = url unless response['accountSetting']['links']['self']
  client.create(GoodData::Profile, response)
end

.users(domain, id = :all, opts = {}) ⇒ Object

Returns list of users for domain specified TODO: Review opts[:limit] functionality

Parameters:

  • domain (String) —

    Domain to list the users for

  • opts (Hash) (defaults to: {}) —

    Options.

Options Hash (opts):

  • :offset (Number) —

    The subject

  • :limit (Number) —

    From address



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/gooddata/models/domain.rb', line 227

def users(domain, id = :all, opts = {})
  client = client(opts)
  domain = client.domain(domain)
  if id == :all
    GoodData.logger.warn("Retrieving all users from domain #{domain.name}")
    all_users = []
    page_limit = opts[:page_limit] || 1000
    offset = opts[:offset] || 0
    loop do
      begin
        tmp = client(opts).get("#{domain.uri}/users", params: { offset: offset, limit: page_limit })
      end

      tmp['accountSettings']['items'].each do |user_data|
        user = client.create(GoodData::Profile, user_data)
        all_users << user if user
      end
      break if tmp['accountSettings']['items'].count < page_limit

      offset += page_limit
    end

    all_users
  else
    (domain, id, opts)
  end
end

Instance Method Details

#add_user(data, opts = {}) ⇒ Object Also known as: create_user

Adds user to domain

Example

GoodData.connect '[email protected]' 'your-password' domain = project.domain('domain-name') domain.add_user 'joe.doe@example', 'sup3rS3cr3tP4ssW0rtH'

Parameters:

  • login (String) —

    Login of user to be invited

  • password (String) —

    Default preset password

Returns:



331
332
333
334
 
# File 'lib/gooddata/models/domain.rb', line 331

def add_user(data, opts = {})
  # data[:domain] = name
  GoodData::Domain.add_user(data, name, { client: client }.merge(opts))
end

#clients(id = :all, data_product = nil) ⇒ Object

Returns all the clients defined in all segments defined in domain. Alternatively id of a client can be provided in which case it returns just that client if it exists.

Parameters:

  • id (String) (defaults to: :all) —

    Id of client that you are looking for

  • data_product (DataProduct) (defaults to: nil) —

    data product object in which the clients are located

Returns:



344
345
346
 
# File 'lib/gooddata/models/domain.rb', line 344

def clients(id = :all, data_product = nil)
  GoodData::Client[id, data_product: data_product, domain: self]
end

#create_data_product(data) ⇒ Object 



358
359
360
361
 
# File 'lib/gooddata/models/domain.rb', line 358

def create_data_product(data)
  data_product = GoodData::DataProduct.create(data, domain: self, client: client)
  data_product.save
end

#create_segment(data) ⇒ GoodData::Segment

Creates new segment in current domain from parameters passed

Parameters:

  • data (Hash) —

    Data for segment namely :segment_id and :master_project is accepted. Master_project can be given as either a PID or a Project instance

Returns:



371
372
373
374
 
# File 'lib/gooddata/models/domain.rb', line 371

def create_segment(data)
  segment = GoodData::Segment.create(data, domain: self, client: client)
  segment.save
end

#create_users(list, options = {}) ⇒ Object 



350
351
352
 
# File 'lib/gooddata/models/domain.rb', line 350

def create_users(list, options = {})
  GoodData::Domain.create_users(list, name, { client: client }.merge(options))
end

#data_products(id = :all) ⇒ Object 



354
355
356
 
# File 'lib/gooddata/models/domain.rb', line 354

def data_products(id = :all)
  GoodData::DataProduct[id, domain: self]
end

#find_user_by_login(login) ⇒ GoodData::Profile

Finds user in domain by login

Parameters:

  • login (String) —

    User login

Returns:



402
403
404
 
# File 'lib/gooddata/models/domain.rb', line 402

def ()
  GoodData::Domain.(self, , client: client)
end

#get_user(name, user_list = users) ⇒ GoodDta::Membership

Gets user by its login or uri in various shapes It does not find by other information because that is not unique. If you want to search by name or email please use fuzzy_get_user.

Optional cached list of users used for look-ups. WARNING: If not specified, in the worst case the method gets all users from the domain!

Parameters:

  • name (String) —

    Name to look for

  • user_list (Array<GoodData::User>) (defaults to: users)

Returns:

  • (GoodDta::Membership) —

    User



386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/gooddata/models/domain.rb', line 386

def get_user(name, user_list = users)
  return member(name, user_list) if name.instance_of?(GoodData::Membership)
  return member(name, user_list) if name.instance_of?(GoodData::Profile)
  name = name.is_a?(Hash) ? name[:login] || name[:uri] : name
  return nil unless name
  name.downcase!
  user_list.find do |user|
    user.uri && user.uri.downcase == name ||
      user. && user..downcase == name
  end
end

#member(profile, list = members) ⇒ GoodData::Profile

Gets membership for profile specified

Parameters:

Returns:



411
412
413
414
415
416
417
418
 
# File 'lib/gooddata/models/domain.rb', line 411

def member(profile, list = members)
  if profile.is_a? String
    return list.find do |m|
      m.uri == profile || m. == profile
    end
  end
  list.find { |m| m. == profile. }
end

#member?(profile, list = members) ⇒ Boolean

Checks if the profile is member of project

Parameters:

Returns:

  • (Boolean) —

    true if is member else false



425
426
427
 
# File 'lib/gooddata/models/domain.rb', line 425

def member?(profile, list = members)
  !member(profile, list).nil?
end

#members?(profiles, list = members) ⇒ Boolean

Returns:

  • (Boolean) 


429
430
431
 
# File 'lib/gooddata/models/domain.rb', line 429

def members?(profiles, list = members)
  profiles.map { |p| member?(p, list) }
end

#provision_client_projects(segments = nil) ⇒ Enumerator

Runs async process that walks through segments and provisions projects if necessary.

Returns:

  • (Enumerator) —

    Returns Enumerator of results



450
451
452
453
454
455
456
 
# File 'lib/gooddata/models/domain.rb', line 450

def provision_client_projects(segments = nil)
  segments = segments.is_a?(Array) ? segments : [segments]
  segments.each do |segment_id|
    segment = segments(segment_id)
    segment.provision_client_projects
  end
end

#segments(id = :all, data_product = nil) ⇒ Object 



363
364
365
 
# File 'lib/gooddata/models/domain.rb', line 363

def segments(id = :all, data_product = nil)
  GoodData::Segment[id, data_product: data_product, domain: self]
end

#segments_uri ⇒ String

Returns uri for segments on the domain. This will be removed soon. It is here that for segments the "account" portion of the URI was removed. And not for the rest

Returns:

  • (String) —

    Uri of the segments



436
437
438
 
# File 'lib/gooddata/models/domain.rb', line 436

def segments_uri
  "/gdc/domains/#{name}"
end

#synchronize_clients ⇒ Array

Calls Segment#synchronize_clients on all segments and concatenates the results

Returns:

  • (Array) —

    Returns array of results



443
444
445
 
# File 'lib/gooddata/models/domain.rb', line 443

def synchronize_clients
  segments.flat_map(&:synchronize_clients)
end

#update_clients(data, options = {}) ⇒ Object 



470
471
472
473
474
475
476
477
 
# File 'lib/gooddata/models/domain.rb', line 470

def update_clients(data, options = {})
  results = []
  data.group_by(&:data_product_id).each do |data_product_id, client_update_data|
    data_product = data_products(data_product_id)
    results.concat data_product.update_clients(client_update_data, options)
  end
  results
end

#update_clients_settings(data) ⇒ Object Also known as: add_clients_settings 



458
459
460
461
462
463
464
465
466
467
 
# File 'lib/gooddata/models/domain.rb', line 458

def update_clients_settings(data)
  data.each do |datum|
    client_id = datum[:id]
    settings = datum[:settings]
    settings.each do |setting|
      GoodData::Client.update_setting(setting[:name], setting[:value], domain: self, client_id: client_id, data_product_id: datum[:data_product_id])
    end
  end
  nil
end

#update_user(data, options = {}) ⇒ Object

Update user in domain

Parameters:

  • opts (Hash) —

    Data of the user to be updated

Returns:



484
485
486
 
# File 'lib/gooddata/models/domain.rb', line 484

def update_user(data, options = {})
  GoodData::Domain.update_user(data, { client: client }.merge(options))
end

#uri ⇒ String

Returns uri for the domain.

Returns:

  • (String) —

    Uri of the segments



510
511
512
 
# File 'lib/gooddata/models/domain.rb', line 510

def uri
  "/gdc/account/domains/#{name}"
end

#users(id = :all, opts = {}) ⇒ Array<GoodData::Profile> Also known as: members

List users in domain

Example

GoodData.connect '[email protected]' 'your-password' domain = GoodData::Domain['gooddata-tomas-korcak'] pp domain.users

Parameters:

  • opts (Hash) (defaults to: {}) —

    Additional user listing options.

Options Hash (opts):

  • :offset (Number) —

    Offset to start listing from

  • :limit (Number) —

    Limit of users to be listed

Returns:



501
502
503
 
# File 'lib/gooddata/models/domain.rb', line 501

def users(id = :all, opts = {})
  GoodData::Domain.users(name, id, opts.merge(client: client))
end