Class: BaruwaAPI

Inherits:
Object
  • Object
show all
Defined in:
lib/baruwa.rb

Constant Summary collapse

ENDPOINTS = 
{
    :users => {
        :list => {:name => '/users', :method => :get},
        :new => {:name => '/users', :method => :post},
        :get => {:name => '/users/%s', :method => :get},
        :update => {:name => '/users', :method => :put},
        :delete => {:name => '/users/%s', :method => :delete},
        :password => {:name => '/users/chpw/%s', :method => :post}
    },
    :aliases => {
        :get => {:name => '/aliasaddresses/%s', :method => :get},
        :new => {:name => '/aliasaddresses/%s', :method => :post},
        :update => {:name => '/aliasaddresses/%s', :method => :put},
        :delete => {:name => '/aliasaddresses/%s', :method => :delete}
    },
    :domains => {
        :list => {:name => '/domains', :method => :get},
        :new => {:name => '/domains', :method => :post},
        :get => {:name => '/domains/%s', :method => :get},
        :get_by_name => {:name => '/domains/byname/%s', :method => :get},
        :update => {:name => '/domains/%s', :method => :put},
        :delete => {:name => '/domains/%s', :method => :delete}
    },
    :domainaliases => {
        :list => {:name => '/domainaliases/%s', :method => :get},
        :new => {:name => '/domainaliases/%s', :method => :post},
        :get => {:name => '/domainaliases/%s/%s', :method => :get},
        :update => {:name => '/domainaliases/%s/%s', :method => :put},
        :delete => {:name => '/domainaliases/%s/%s', :method => :delete}
    },
    :domainsmarthosts => {
        :list => {:name => '/domains/smarthosts/%s', :method => :get},
        :new => {:name => '/domains/smarthosts/%s', :method => :post},
        :get => {:name => '/domains/smarthosts/%s/%s', :method => :get},
        :update => {:name => '/domains/smarthosts/%s/%s', :method => :put},
        :delete => {:name => '/domains/smarthosts/%s/%s', :method => :delete}
    },
    :deliveryservers => {
        :list => {:name => '/deliveryservers/%s', :method => :get},
        :new => {:name => '/deliveryservers/%s', :method => :post},
        :get => {:name => '/deliveryservers/%s/%s', :method => :get},
        :update => {:name => '/deliveryservers/%s/%s', :method => :put},
        :delete => {:name => '/deliveryservers/%s/%s', :method => :delete}
    },
    :userdeliveryservers => {
        :list => {:name => '/userdeliveryservers/%s', :method => :get},
        :new => {:name => '/userdeliveryservers/%s', :method => :post},
        :get => {:name => '/userdeliveryservers/%s/%s', :method => :get},
        :update => {:name => '/userdeliveryservers/%s/%s', :method => :put},
        :delete => {:name => '/userdeliveryservers/%s/%s', :method => :delete}
    },
    :authservers => {
        :list => {:name => '/authservers/%s', :method => :get},
        :new => {:name => '/authservers/%s', :method => :post},
        :get => {:name => '/authservers/%s/%s', :method => :get},
        :update => {:name => '/authservers/%s/%s', :method => :put},
        :delete => {:name => '/authservers/%s/%s', :method => :delete}
    },
    :ldapsettings => {
        :new => {:name => '/ldapsettings/%s/%s', :method => :post},
        :get => {:name => '/ldapsettings/%s/%s/%s', :method => :get},
        :update => {:name => '/ldapsettings/%s/%s/%s', :method => :put},
        :delete => {:name => '/ldapsettings/%s/%s/%s', :method => :delete}
    },
    :radiussettings => {
        :new => {:name => '/radiussettings/%s/%s', :method => :post},
        :get => {:name => '/radiussettings/%s/%s/%s', :method => :get},
        :update => {:name => '/radiussettings/%s/%s/%s', :method => :put},
        :delete => {:name => '/radiussettings/%s/%s/%s', :method => :delete}
    },
    :organizations => {
        :list => {:name => '/organizations', :method => :get},
        :new => {:name => '/organizations', :method => :post},
        :get => {:name => '/organizations/%s', :method => :get},
        :update => {:name => '/organizations/%s', :method => :put},
        :delete => {:name => '/organizations/%s', :method => :delete}
    },
    :relays => {
        :new => {:name => '/relays/%s', :method => :post},
        :get => {:name => '/relays/%s', :method => :get},
        :update => {:name => '/relays/%s', :method => :put},
        :delete => {:name => '/relays/%s', :method => :delete}
    },
    :fallbackservers => {
        :list => {:name => '/fallbackservers/list/%s', :method => :get},
        :new => {:name => '/fallbackservers/%s', :method => :post},
        :get => {:name => '/fallbackservers/%s', :method => :get},
        :update => {:name => '/fallbackservers/%s', :method => :put},
        :delete => {:name => '/fallbackservers/%s', :method => :delete}
    },
    :orgsmarthosts => {
        :list => {:name => '/organizations/smarthosts/%s', :method => :get},
        :new => {:name => '/organizations/smarthosts/%s', :method => :post},
        :get => {:name => '/organizations/smarthosts/%s/%s', :method => :get},
        :update => {:name => '/organizations/smarthosts/%s/%s', :method => :put},
        :delete => {:name => '/organizations/smarthosts/%s/%s', :method => :delete}
    },
    :status => {:name => '/status', :method => :get}
}

Instance Method Summary collapse

Constructor Details

#initialize(url, token, ssl_verify = false) ⇒ BaruwaAPI

Returns a new instance of BaruwaAPI.



118
119
120
121
122
 
# File 'lib/baruwa.rb', line 118

def initialize (url, token, ssl_verify=false)
  @baruwa_url = "#{url}/api/v1"
  @baruwa_token = token
  @ssl_verify = ssl_verify
end

Instance Method Details

#call_api(endpoint, opts = [], data = false, params = false) ⇒ Object 



564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
 
# File 'lib/baruwa.rb', line 564

def call_api(endpoint, opts=[], data=false, params=false)
    url = parse_url(endpoint, opts, params)
    call = get_request(endpoint, url)
    call.body = get_params(data)
    request = Net::HTTP.new(url.host, url.port)
    usessl = @baruwa_url.match('https')
    request.use_ssl = usessl
    if usessl
        if @ssl_verify == false
            request.verify_mode = OpenSSL::SSL::VERIFY_NONE
        end
    end
    response = request.start {|http| http.request(call)}
    parse_response(response)
end

#create_alias(userid, data) ⇒ Object 



163
164
165
166
 
# File 'lib/baruwa.rb', line 163

def create_alias(userid, data)
    # create an alias address
    call_api(ENDPOINTS[:aliases][:new], [userid], data)
end

#create_authserver(domainid, data) ⇒ Object 



342
343
344
345
 
# File 'lib/baruwa.rb', line 342

def create_authserver(domainid, data)
    # create auth server
    call_api(ENDPOINTS[:authservers][:new], [domainid], data)
end

#create_deliveryserver(domainid, data) ⇒ Object 



284
285
286
287
 
# File 'lib/baruwa.rb', line 284

def create_deliveryserver(domainid, data)
    # create a delivery server
    call_api(ENDPOINTS[:deliveryservers][:new], [domainid], data)
end

#create_domain(data) ⇒ Object 



197
198
199
200
 
# File 'lib/baruwa.rb', line 197

def create_domain(data)
    # create a domain
    call_api(ENDPOINTS[:domains][:new], [], data)
end

#create_domain_smarthost(domainid, data) ⇒ Object 



255
256
257
258
 
# File 'lib/baruwa.rb', line 255

def create_domain_smarthost(domainid, data)
    # create a domain smarthost
    call_api(ENDPOINTS[:domainsmarthosts][:new], [domainid], data)
end

#create_domainalias(domainid, data) ⇒ Object 



226
227
228
229
 
# File 'lib/baruwa.rb', line 226

def create_domainalias(domainid, data)
    # create a domain alias
    call_api(ENDPOINTS[:domainaliases][:new], [domainid], data)
end

#create_fallbackserver(orgid, data) ⇒ Object 



460
461
462
463
 
# File 'lib/baruwa.rb', line 460

def create_fallbackserver(orgid, data)
    # create a fallback server
    call_api(ENDPOINTS[:fallbackservers][:new], [orgid], data)
end

#create_ldapsettings(domainid, serverid, data) ⇒ Object 



362
363
364
365
 
# File 'lib/baruwa.rb', line 362

def create_ldapsettings(domainid, serverid, data)
    # create ldap settings
    call_api(ENDPOINTS[:ldapsettings][:new], [domainid, serverid], data)
end

#create_org_smarthost(orgid, data) ⇒ Object 



489
490
491
492
 
# File 'lib/baruwa.rb', line 489

def create_org_smarthost(orgid, data)
    # create a organization smarthost
    call_api(ENDPOINTS[:orgsmarthosts][:new], [orgid], data)
end

#create_organization(data) ⇒ Object 



411
412
413
414
 
# File 'lib/baruwa.rb', line 411

def create_organization(data)
    # create an organization
    call_api(ENDPOINTS[:organizations][:new], [], data)
end

#create_radiussettings(domainid, serverid, data) ⇒ Object 



382
383
384
385
 
# File 'lib/baruwa.rb', line 382

def create_radiussettings(domainid, serverid, data)
    # create radius settings
    call_api(ENDPOINTS[:radiussettings][:new], [domainid, serverid], data)
end

#create_relay(orgid, data) ⇒ Object 



431
432
433
434
 
# File 'lib/baruwa.rb', line 431

def create_relay(orgid, data)
    # create a relay setting
    call_api(ENDPOINTS[:relays][:new], [orgid], data)
end

#create_user(data) ⇒ Object 



138
139
140
141
 
# File 'lib/baruwa.rb', line 138

def create_user(data)
    # create a user
    call_api(ENDPOINTS[:users][:new], [], data)
end

#create_user_deliveryserver(domainid, data) ⇒ Object 



313
314
315
316
 
# File 'lib/baruwa.rb', line 313

def create_user_deliveryserver(domainid, data)
    # create a delivery server
    call_api(ENDPOINTS[:userdeliveryservers][:new], [domainid], data)
end

#delete_alias(addressid, data) ⇒ Object 



173
174
175
176
 
# File 'lib/baruwa.rb', line 173

def delete_alias(addressid, data)
    # delete an alias address
    call_api(ENDPOINTS[:aliases][:delete], [addressid], data)
end

#delete_authserver(domainid, serverid, data) ⇒ Object 



352
353
354
355
 
# File 'lib/baruwa.rb', line 352

def delete_authserver(domainid, serverid, data)
    # delete an auth server
    call_api(ENDPOINTS[:authservers][:delete], [domainid, serverid], data)
end

#delete_deliveryserver(domainid, serverid, data) ⇒ Object 



294
295
296
297
 
# File 'lib/baruwa.rb', line 294

def delete_deliveryserver(domainid, serverid, data)
    # delete delivery servers
    call_api(ENDPOINTS[:deliveryservers][:delete], [domainid, serverid], data)
end

#delete_domain(domainid) ⇒ Object 



207
208
209
210
 
# File 'lib/baruwa.rb', line 207

def delete_domain(domainid)
    # delete a domain
    call_api(ENDPOINTS[:domains][:delete], [domainid])
end

#delete_domain_smarthost(domainid, smarthostid, data) ⇒ Object 



265
266
267
268
 
# File 'lib/baruwa.rb', line 265

def delete_domain_smarthost(domainid, smarthostid, data)
    # delete a domain smarthost
    call_api(ENDPOINTS[:domainsmarthosts][:delete], [domainid, smarthostid], data)
end

#delete_domainalias(domainid, aliasid, data) ⇒ Object 



236
237
238
239
 
# File 'lib/baruwa.rb', line 236

def delete_domainalias(domainid, aliasid, data)
    # delete a domain alias
    call_api(ENDPOINTS[:domainaliases][:delete], [domainid, aliasid], data)
end

#delete_fallbackserver(serverid, data) ⇒ Object 



470
471
472
473
 
# File 'lib/baruwa.rb', line 470

def delete_fallbackserver(serverid, data)
    # delete a fallback server
    call_api(ENDPOINTS[:fallbackservers][:delete], [serverid], data)
end

#delete_ldapsettings(domainid, serverid, settingsid, data) ⇒ Object 



372
373
374
375
 
# File 'lib/baruwa.rb', line 372

def delete_ldapsettings(domainid, serverid, settingsid, data)
    # delete ldap settings
    call_api(ENDPOINTS[:ldapsettings][:delete], [domainid, serverid, settingsid], data)
end

#delete_org_smarthost(orgid, smarthostid, data) ⇒ Object 



499
500
501
502
 
# File 'lib/baruwa.rb', line 499

def delete_org_smarthost(orgid, smarthostid, data)
    # delete a organization smarthost
    call_api(ENDPOINTS[:orgsmarthosts][:delete], [orgid, smarthostid], data)
end

#delete_organization(orgid) ⇒ Object 



421
422
423
424
 
# File 'lib/baruwa.rb', line 421

def delete_organization(orgid)
    # delete an organization
    call_api(ENDPOINTS[:organizations][:delete], [orgid])
end

#delete_radiussettings(domainid, serverid, settingsid, data) ⇒ Object 



392
393
394
395
 
# File 'lib/baruwa.rb', line 392

def delete_radiussettings(domainid, serverid, settingsid, data)
    # delete radius settings
    call_api(ENDPOINTS[:radiussettings][:delete], [domainid, serverid, settingsid], data)
end

#delete_relay(relayid, data) ⇒ Object 



441
442
443
444
 
# File 'lib/baruwa.rb', line 441

def delete_relay(relayid, data)
    # delete relay settings
    call_api(ENDPOINTS[:relays][:delete], [relayid], data)
end

#delete_user(userid) ⇒ Object 



148
149
150
151
 
# File 'lib/baruwa.rb', line 148

def delete_user(userid)
    # delete a user
    call_api(ENDPOINTS[:users][:delete], [userid])
end

#delete_user_deliveryserver(domainid, serverid, data) ⇒ Object 



323
324
325
326
 
# File 'lib/baruwa.rb', line 323

def delete_user_deliveryserver(domainid, serverid, data)
    # delete delivery servers
    call_api(ENDPOINTS[:userdeliveryservers][:delete], [domainid, serverid], data)
end

#get_aliases(addressid) ⇒ Object 



158
159
160
161
 
# File 'lib/baruwa.rb', line 158

def get_aliases(addressid)
    # get aliases
    call_api(ENDPOINTS[:aliases][:get], [addressid])
end

#get_authserver(domainid, serverid) ⇒ Object 



337
338
339
340
 
# File 'lib/baruwa.rb', line 337

def get_authserver(domainid, serverid)
    # get auth server
    call_api(ENDPOINTS[:authservers][:get], [domainid, serverid])
end

#get_authservers(domainid, page = nil) ⇒ Object 



328
329
330
331
332
333
334
335
 
# File 'lib/baruwa.rb', line 328

def get_authservers(domainid, page=nil)
    # get auth servers
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:authservers][:list], [domainid], false, params)
end

#get_deliveryserver(domainid, serverid) ⇒ Object 



279
280
281
282
 
# File 'lib/baruwa.rb', line 279

def get_deliveryserver(domainid, serverid)
    # get a delivery server
    call_api(ENDPOINTS[:deliveryservers][:get], [domainid, serverid])
end

#get_deliveryservers(domainid, page = nil) ⇒ Object 



270
271
272
273
274
275
276
277
 
# File 'lib/baruwa.rb', line 270

def get_deliveryservers(domainid, page=nil)
    # get delivery servers
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:deliveryservers][:list], [domainid], false, params)
end

#get_domain(domainid) ⇒ Object 



187
188
189
190
 
# File 'lib/baruwa.rb', line 187

def get_domain(domainid)
    # get a domain
    call_api(ENDPOINTS[:domains][:get], [domainid])
end

#get_domain_by_name(domainname) ⇒ Object 



192
193
194
195
 
# File 'lib/baruwa.rb', line 192

def get_domain_by_name(domainname)
    # get a domain by name
    call_api(ENDPOINTS[:domains][:get_by_name], [domainname])
end

#get_domain_smarthost(domainid, smarthostid) ⇒ Object 



250
251
252
253
 
# File 'lib/baruwa.rb', line 250

def get_domain_smarthost(domainid, smarthostid)
    # get domain smarthost
    call_api(ENDPOINTS[:domainsmarthosts][:get], [domainid, smarthostid])
end

#get_domain_smarthosts(domainid, page = nil) ⇒ Object 



241
242
243
244
245
246
247
248
 
# File 'lib/baruwa.rb', line 241

def get_domain_smarthosts(domainid, page=nil)
    # get domain smarthosts
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:domainsmarthosts][:list], [domainid], false, params)
end

#get_domainalias(domainid, aliasid) ⇒ Object 



221
222
223
224
 
# File 'lib/baruwa.rb', line 221

def get_domainalias(domainid, aliasid)
    # get domain alias
    call_api(ENDPOINTS[:domainaliases][:get], [domainid, aliasid])
end

#get_domainaliases(domainid, page = nil) ⇒ Object 



212
213
214
215
216
217
218
219
 
# File 'lib/baruwa.rb', line 212

def get_domainaliases(domainid, page=nil)
    # get domain aliases
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:domainaliases][:list], [domainid], false, params)
end

#get_domains(page = nil) ⇒ Object 



178
179
180
181
182
183
184
185
 
# File 'lib/baruwa.rb', line 178

def get_domains(page=nil)
    # get domains
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:domains][:list], [], false, params)
end

#get_fallbackserver(serverid) ⇒ Object 



455
456
457
458
 
# File 'lib/baruwa.rb', line 455

def get_fallbackserver(serverid)
    # get fallback server
    call_api(ENDPOINTS[:fallbackservers][:get], [serverid])
end

#get_fallbackservers(orgid, page = nil) ⇒ Object 



446
447
448
449
450
451
452
453
 
# File 'lib/baruwa.rb', line 446

def get_fallbackservers(orgid, page=nil)
    # get fallback servers
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:fallbackservers][:list], [orgid], false, params)
end

#get_ldapsettings(domainid, serverid, settingsid) ⇒ Object 



357
358
359
360
 
# File 'lib/baruwa.rb', line 357

def get_ldapsettings(domainid, serverid, settingsid)
    # get ldap settings
    call_api(ENDPOINTS[:ldapsettings][:get], [domainid, serverid, settingsid])
end

#get_org_smarthost(orgid, smarthostid) ⇒ Object 



484
485
486
487
 
# File 'lib/baruwa.rb', line 484

def get_org_smarthost(orgid, smarthostid)
    # get organization smarthost
    call_api(ENDPOINTS[:orgsmarthosts][:get], [orgid, smarthostid])
end

#get_org_smarthosts(orgid, page = nil) ⇒ Object 



475
476
477
478
479
480
481
482
 
# File 'lib/baruwa.rb', line 475

def get_org_smarthosts(orgid, page=nil)
    # get organization smarthosts
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:orgsmarthosts][:list], [orgid], false, params)
end

#get_organization(orgid) ⇒ Object 



406
407
408
409
 
# File 'lib/baruwa.rb', line 406

def get_organization(orgid)
    # get organization
    call_api(ENDPOINTS[:organizations][:get], [orgid])
end

#get_organizations(page = nil) ⇒ Object 



397
398
399
400
401
402
403
404
 
# File 'lib/baruwa.rb', line 397

def get_organizations(page=nil)
    # get organizations
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:organizations][:list], [], false, params)
end

#get_params(params) ⇒ Object 



509
510
511
512
513
514
515
516
 
# File 'lib/baruwa.rb', line 509

def get_params(params)
    # convert params has to string
    if params then
        params.collect {|k,v| "#{k}=#{CGI::escape(v.to_s)}"}.join('&')
    else
        params
    end
end

#get_radiussettings(domainid, serverid, settingsid) ⇒ Object 



377
378
379
380
 
# File 'lib/baruwa.rb', line 377

def get_radiussettings(domainid, serverid, settingsid)
    # get radius settings
    call_api(ENDPOINTS[:radiussettings][:get], [domainid, serverid, settingsid])
end

#get_relay(relayid) ⇒ Object 



426
427
428
429
 
# File 'lib/baruwa.rb', line 426

def get_relay(relayid)
    # get a relay setting
    call_api(ENDPOINTS[:relays][:get], [relayid])
end

#get_request(endpoint, url) ⇒ Object 



537
538
539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/baruwa.rb', line 537

def get_request(endpoint, url)
    case endpoint[:method]
    when :post
        Net::HTTP::Post.new(url.request_uri, set_headers)
    when :get
        Net::HTTP::Get.new(url.request_uri, set_headers)
    when :put
        Net::HTTP::Put.new(url.request_uri, set_headers)
    when :delete
        Net::HTTP::Delete.new(url.request_uri, set_headers)
    else
        throw "Unknown call method #{endpoint[:method]}"
    end
end

#get_status ⇒ Object 



504
505
506
507
 
# File 'lib/baruwa.rb', line 504

def get_status
    # get status
    call_api(ENDPOINTS[:status])
end

#get_user(userid) ⇒ Object 



133
134
135
136
 
# File 'lib/baruwa.rb', line 133

def get_user(userid)
    # get a user
    call_api(ENDPOINTS[:users][:get], [userid])
end

#get_user_deliveryserver(domainid, serverid) ⇒ Object 



308
309
310
311
 
# File 'lib/baruwa.rb', line 308

def get_user_deliveryserver(domainid, serverid)
    # get a delivery server
    call_api(ENDPOINTS[:userdeliveryservers][:get], [domainid, serverid])
end

#get_user_deliveryservers(domainid, page = nil) ⇒ Object 



299
300
301
302
303
304
305
306
 
# File 'lib/baruwa.rb', line 299

def get_user_deliveryservers(domainid, page=nil)
    # get delivery servers
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:userdeliveryservers][:list], [domainid], false, params)
end

#get_users(page = nil) ⇒ Object 



124
125
126
127
128
129
130
131
 
# File 'lib/baruwa.rb', line 124

def get_users(page=nil)
    # get users
    params = {}
    if page.is_a? Integer then
        params[:page] = page
    end
    call_api(ENDPOINTS[:users][:list], [], false, params)
end

#parse_response(response) ⇒ Object 



552
553
554
555
556
557
558
559
560
561
562
 
# File 'lib/baruwa.rb', line 552

def parse_response(response)
    if response.code.to_i == 200 || response.code.to_i == 201
        if response.body.nil? || response.body.empty?
            {:code => response.code.to_i, :message => "Completed successfully"}
        else
            JSON.parse(response.body)
        end
    else
        raise StandardError.new("#{response.code} #{response.body}")
    end
end

#parse_url(endpoint, opts, params = false) ⇒ Object 



518
519
520
521
522
523
524
525
526
527
528
 
# File 'lib/baruwa.rb', line 518

def parse_url(endpoint, opts, params=false)
    if opts.length > 0 then
        endpoint_string = endpoint[:name] % opts
    else
        endpoint_string = endpoint[:name]
    end
    url_string = @baruwa_url + endpoint_string
    url_string = url_string + '?' + get_params(params) if params
    uri = URI.parse(url_string)
    return uri
end

#set_headers ⇒ Object 



530
531
532
533
534
535
 
# File 'lib/baruwa.rb', line 530

def set_headers
    {
        'User-Agent' => 'BaruwaAPI-Ruby',
        'Authorization' => "Bearer #{@baruwa_token}"
    }
end

#set_user_passwd(userid, data) ⇒ Object 



153
154
155
156
 
# File 'lib/baruwa.rb', line 153

def set_user_passwd(userid, data)
    # set a user password
    call_api(ENDPOINTS[:users][:password], [userid], data)
end

#update_alias(addressid, data) ⇒ Object 



168
169
170
171
 
# File 'lib/baruwa.rb', line 168

def update_alias(addressid, data)
    # update an alias address
    call_api(ENDPOINTS[:aliases][:update], [addressid], data)
end

#update_authserver(domainid, serverid, data) ⇒ Object 



347
348
349
350
 
# File 'lib/baruwa.rb', line 347

def update_authserver(domainid, serverid, data)
    # update an auth server
    call_api(ENDPOINTS[:authservers][:update], [domainid, serverid], data)
end

#update_deliveryserver(domainid, serverid, data) ⇒ Object 



289
290
291
292
 
# File 'lib/baruwa.rb', line 289

def update_deliveryserver(domainid, serverid, data)
    # update a delivery server
    call_api(ENDPOINTS[:deliveryservers][:update], [domainid, serverid], data)
end

#update_domain(domainid, data) ⇒ Object 



202
203
204
205
 
# File 'lib/baruwa.rb', line 202

def update_domain(domainid, data)
    # update a domain
    call_api(ENDPOINTS[:domains][:update], [domainid], data)
end

#update_domain_smarthost(domainid, smarthostid, data) ⇒ Object 



260
261
262
263
 
# File 'lib/baruwa.rb', line 260

def update_domain_smarthost(domainid, smarthostid, data)
    # update a domain smarthost
    call_api(ENDPOINTS[:domainsmarthosts][:update], [domainid, smarthostid], data)
end

#update_domainalias(domainid, aliasid, data) ⇒ Object 



231
232
233
234
 
# File 'lib/baruwa.rb', line 231

def update_domainalias(domainid, aliasid, data)
    # update a domain alias
    call_api(ENDPOINTS[:domainaliases][:update], [domainid, aliasid], data)
end

#update_fallbackserver(serverid, data) ⇒ Object 



465
466
467
468
 
# File 'lib/baruwa.rb', line 465

def update_fallbackserver(serverid, data)
    # update a fallback server
    call_api(ENDPOINTS[:fallbackservers][:update], [serverid], data)
end

#update_ldapsettings(domainid, serverid, settingsid, data) ⇒ Object 



367
368
369
370
 
# File 'lib/baruwa.rb', line 367

def update_ldapsettings(domainid, serverid, settingsid, data)
    # update ldap settings
    call_api(ENDPOINTS[:ldapsettings][:update], [domainid, serverid, settingsid], data)
end

#update_org_smarthost(orgid, smarthostid, data) ⇒ Object 



494
495
496
497
 
# File 'lib/baruwa.rb', line 494

def update_org_smarthost(orgid, smarthostid, data)
    # update a organization smarthost
    call_api(ENDPOINTS[:orgsmarthosts][:update], [orgid, smarthostid], data)
end

#update_organization(orgid, data) ⇒ Object 



416
417
418
419
 
# File 'lib/baruwa.rb', line 416

def update_organization(orgid, data)
    # update an organization
    call_api(ENDPOINTS[:organizations][:update], [orgid], data)
end

#update_radiussettings(domainid, serverid, settingsid, data) ⇒ Object 



387
388
389
390
 
# File 'lib/baruwa.rb', line 387

def update_radiussettings(domainid, serverid, settingsid, data)
    # update radius settings
    call_api(ENDPOINTS[:radiussettings][:update], [domainid, serverid, settingsid], data)
end

#update_relay(relayid, data) ⇒ Object 



436
437
438
439
 
# File 'lib/baruwa.rb', line 436

def update_relay(relayid, data)
    # update relay settings
    call_api(ENDPOINTS[:relays][:update], [relayid], data)
end

#update_user(data) ⇒ Object 



143
144
145
146
 
# File 'lib/baruwa.rb', line 143

def update_user(data)
    # update a user
    call_api(ENDPOINTS[:users][:update], [], data)
end

#update_user_deliveryserver(domainid, serverid, data) ⇒ Object 



318
319
320
321
 
# File 'lib/baruwa.rb', line 318

def update_user_deliveryserver(domainid, serverid, data)
    # update a delivery server
    call_api(ENDPOINTS[:userdeliveryservers][:update], [domainid, serverid], data)
end