API വഴി PowerShell-ൽ നിന്ന് Google ഉപയോക്താക്കളെ സൃഷ്ടിക്കുന്നു

ഹലോ!

G Suite ഉപയോക്താക്കളെ കൈകാര്യം ചെയ്യുന്നതിനായി Google API-യുമായുള്ള PowerShell ഇടപെടൽ നടപ്പിലാക്കുന്നതിനെ ഈ ലേഖനം വിവരിക്കും.

സ്ഥാപനത്തിലുടനീളം ഞങ്ങൾ നിരവധി ഇന്റേണൽ, ക്ലൗഡ് സേവനങ്ങൾ ഉപയോഗിക്കുന്നു. മിക്കവാറും, അവയിലെ അംഗീകാരം ഗൂഗിളിലോ ആക്റ്റീവ് ഡയറക്‌ടറിയിലോ വരുന്നു, അതിനിടയിൽ ഞങ്ങൾക്ക് ഒരു പകർപ്പ് നിലനിർത്താൻ കഴിയില്ല; അതനുസരിച്ച്, ഒരു പുതിയ ജീവനക്കാരൻ പോകുമ്പോൾ, ഈ രണ്ട് സിസ്റ്റങ്ങളിലും നിങ്ങൾ ഒരു അക്കൗണ്ട് സൃഷ്‌ടിക്കേണ്ടതുണ്ട്/പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട്. പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിന്, വിവരങ്ങൾ ശേഖരിച്ച് രണ്ട് സേവനങ്ങളിലേക്കും അയയ്ക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതാൻ ഞങ്ങൾ തീരുമാനിച്ചു.

അംഗീകാരം

ആവശ്യകതകൾ തയ്യാറാക്കുമ്പോൾ, അംഗീകാരത്തിനായി യഥാർത്ഥ മാനുഷിക അഡ്മിനിസ്ട്രേറ്റർമാരെ ഉപയോഗിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു; ആകസ്മികമോ മനഃപൂർവമോ ആയ വലിയ മാറ്റങ്ങളുണ്ടായാൽ പ്രവർത്തനങ്ങളുടെ വിശകലനം ഇത് ലളിതമാക്കുന്നു.

പ്രാമാണീകരണത്തിനും അംഗീകാരത്തിനുമായി Google API-കൾ OAuth 2.0 പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നു. ഉപയോഗ കേസുകളും കൂടുതൽ വിശദമായ വിവരണങ്ങളും ഇവിടെ കാണാം: Google API-കൾ ആക്‌സസ് ചെയ്യാൻ OAuth 2.0 ഉപയോഗിക്കുന്നു.

ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകളിൽ അംഗീകാരത്തിനായി ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റ് ഞാൻ തിരഞ്ഞെടുത്തു. ഒരു സേവന അക്കൗണ്ട് ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഓപ്ഷനും ഉണ്ട്, അത് ഉപയോക്താവിൽ നിന്ന് അനാവശ്യ ചലനങ്ങൾ ആവശ്യമില്ല.

ചുവടെയുള്ള ചിത്രം Google പേജിൽ നിന്ന് തിരഞ്ഞെടുത്ത സാഹചര്യത്തിന്റെ സ്കീമാറ്റിക് വിവരണമാണ്.

1. ആദ്യം, GET പാരാമീറ്ററുകൾ വ്യക്തമാക്കിക്കൊണ്ട് ഞങ്ങൾ ഉപയോക്താവിനെ Google അക്കൗണ്ട് പ്രാമാണീകരണ പേജിലേക്ക് അയയ്ക്കുന്നു:
   • ആപ്ലിക്കേഷൻ ഐഡി
   • അപ്ലിക്കേഷന് ആക്‌സസ് ആവശ്യമുള്ള മേഖലകൾ
   • നടപടിക്രമം പൂർത്തിയാക്കിയ ശേഷം ഉപയോക്താവിനെ റീഡയറക്‌ട് ചെയ്യുന്ന വിലാസം
   • ഞങ്ങൾ ടോക്കൺ അപ്ഡേറ്റ് ചെയ്യുന്ന രീതി
   • സുരക്ഷാ കോഡ്
   • സ്ഥിരീകരണ കോഡ് ട്രാൻസ്മിഷൻ ഫോർമാറ്റ്

2. അംഗീകാരം പൂർത്തിയാക്കിയ ശേഷം, ആദ്യ അഭ്യർത്ഥനയിൽ വ്യക്തമാക്കിയ പേജിലേക്ക് ഉപയോക്താവിനെ റീഡയറക്‌ടുചെയ്യും, ഒരു പിശക് അല്ലെങ്കിൽ GET പാരാമീറ്ററുകൾ പാസ്സാക്കിയ അംഗീകാര കോഡ്
3. ആപ്ലിക്കേഷന് (സ്ക്രിപ്റ്റ്) ഈ പാരാമീറ്ററുകൾ ലഭിക്കേണ്ടതുണ്ട്, കൂടാതെ കോഡ് ലഭിക്കുകയാണെങ്കിൽ, ടോക്കണുകൾ ലഭിക്കുന്നതിന് ഇനിപ്പറയുന്ന അഭ്യർത്ഥന നടത്തുക
4. അഭ്യർത്ഥന ശരിയാണെങ്കിൽ, Google API നൽകുന്നു:
   • ഞങ്ങൾക്ക് അഭ്യർത്ഥനകൾ നടത്താൻ കഴിയുന്ന ആക്സസ് ടോക്കൺ
   • ഈ ടോക്കണിന്റെ സാധുത കാലയളവ്
   • ആക്‌സസ് ടോക്കൺ പുതുക്കാൻ ടോക്കൺ പുതുക്കേണ്ടതുണ്ട്.

ആദ്യം നിങ്ങൾ Google API കൺസോളിലേക്ക് പോകേണ്ടതുണ്ട്: ക്രെഡൻഷ്യലുകൾ - Google API കൺസോൾ, ആവശ്യമുള്ള ആപ്ലിക്കേഷൻ തിരഞ്ഞെടുത്ത് ക്രെഡൻഷ്യൽ വിഭാഗത്തിൽ ഒരു ക്ലയന്റ് OAuth ഐഡന്റിഫയർ സൃഷ്ടിക്കുക. അവിടെ (അല്ലെങ്കിൽ പിന്നീട്, സൃഷ്ടിച്ച ഐഡന്റിഫയറിന്റെ സവിശേഷതകളിൽ) റീഡയറക്ഷൻ അനുവദിച്ചിരിക്കുന്ന വിലാസങ്ങൾ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ കാര്യത്തിൽ, ഇവ വ്യത്യസ്ത പോർട്ടുകളുള്ള നിരവധി ലോക്കൽഹോസ്റ്റ് എൻട്രികളായിരിക്കും (ചുവടെ കാണുക).

സ്‌ക്രിപ്റ്റ് അൽ‌ഗോരിതം വായിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാക്കുന്നതിന്, നിങ്ങൾക്ക് ആദ്യ ഘട്ടങ്ങൾ ഒരു പ്രത്യേക ഫംഗ്‌ഷനിൽ പ്രദർശിപ്പിക്കാൻ കഴിയും, അത് ആക്‌സസ് നൽകുകയും ആപ്ലിക്കേഷനായി ടോക്കണുകൾ പുതുക്കുകയും ചെയ്യും:

$client_secret = 'Our Client Secret'
$client_id = 'Our Client ID'
function Get-GoogleAuthToken {
  if (-not [System.Net.HttpListener]::IsSupported) {
    "HttpListener is not supported."
    exit 1
  }
  $codeverifier = -join ((65..90) + (97..122) + (48..57) + 45 + 46 + 95 + 126 |Get-Random -Count 60| % {[char]$_})
  $hasher = new-object System.Security.Cryptography.SHA256Managed
  $hashByteArray = $hasher.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($codeverifier))
  $base64 = ((([System.Convert]::ToBase64String($hashByteArray)).replace('=','')).replace('+','-')).replace('/','_')
  $ports = @(10600,15084,39700,42847,65387,32079)
  $port = $ports[(get-random -Minimum 0 -maximum 5)]
  Write-Host "Start browser..."
  Start-Process "https://accounts.google.com/o/oauth2/v2/auth?code_challenge_method=S256&code_challenge=$base64&access_type=offline&client_id=$client_id&redirect_uri=http://localhost:$port&response_type=code&scope=https://www.googleapis.com/auth/admin.directory.user https://www.googleapis.com/auth/admin.directory.group"
  $listener = New-Object System.Net.HttpListener
  $listener.Prefixes.Add("http://localhost:"+$port+'/')
  try {$listener.Start()} catch {
    "Unable to start listener."
    exit 1
  }
  while (($code -eq $null)) {
    $context = $listener.GetContext()
    Write-Host "Connection accepted" -f 'mag'
    $url = $context.Request.RawUrl
    $code = $url.split('?')[1].split('=')[1].split('&')[0]
    if ($url.split('?')[1].split('=')[0] -eq 'error') {
      Write-Host "Error!"$code -f 'red'
      $buffer = [System.Text.Encoding]::UTF8.GetBytes("Error!"+$code)
      $context.Response.ContentLength64 = $buffer.Length
      $context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
      $context.Response.OutputStream.Close()
      $listener.Stop()
      exit 1
    }
    $buffer = [System.Text.Encoding]::UTF8.GetBytes("Now you can close this browser tab.")
    $context.Response.ContentLength64 = $buffer.Length
    $context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
    $context.Response.OutputStream.Close()
    $listener.Stop()
  }
  Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -Body @{
    code = $code
    client_id = $client_id
    client_secret = $client_secret
    redirect_uri = 'http://localhost:'+$port
    grant_type = 'authorization_code'
    code_verifier   = $codeverifier
  }
  $code = $null

OAuth ക്ലയന്റ് ഐഡന്റിഫയർ പ്രോപ്പർട്ടികളിൽ നിന്ന് ലഭിച്ച ക്ലയന്റ് ഐഡിയും ക്ലയന്റ് രഹസ്യവും ഞങ്ങൾ സജ്ജീകരിച്ചു, കൂടാതെ കോഡ് വെരിഫയർ എന്നത് റിസർവ് ചെയ്യാത്ത പ്രതീകങ്ങളിൽ നിന്ന് ക്രമരഹിതമായി ജനറേറ്റ് ചെയ്യേണ്ട 43 മുതൽ 128 പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് ആണ്: [AZ] / [az] / [0-9 ] / "-" / "." / "_" / "~".

ഈ കോഡ് പിന്നീട് വീണ്ടും കൈമാറും. ഉപയോക്തൃ അംഗീകാരത്തിന് ശേഷം ഒരു റീഡയറക്‌ടായി മടങ്ങിയ ഒരു പ്രതികരണത്തെ ആക്രമണകാരിക്ക് തടസ്സപ്പെടുത്താൻ കഴിയുന്ന അപകടസാധ്യത ഇത് ഇല്ലാതാക്കുന്നു.
നിലവിലെ അഭ്യർത്ഥനയിൽ നിങ്ങൾക്ക് വ്യക്തമായ വാചകത്തിൽ ഒരു കോഡ് വെരിഫയർ അയയ്‌ക്കാൻ കഴിയും (അത് അർത്ഥശൂന്യമാക്കുന്നു - ഇത് SHA256-നെ പിന്തുണയ്‌ക്കാത്ത സിസ്റ്റങ്ങൾക്ക് മാത്രമേ അനുയോജ്യമാകൂ), അല്ലെങ്കിൽ SHA256 അൽഗോരിതം ഉപയോഗിച്ച് ഒരു ഹാഷ് സൃഷ്‌ടിക്കുന്നതിലൂടെ, അത് BASE64Url-ൽ എൻകോഡ് ചെയ്യണം (വ്യത്യസ്‌തമാണ് Base64-ൽ നിന്ന് രണ്ട് പട്ടിക പ്രതീകങ്ങൾ) കൂടാതെ പ്രതീക വരി അവസാനങ്ങൾ നീക്കം ചെയ്യുന്നു: =.

അടുത്തതായി, അംഗീകാരത്തിന് ശേഷം ഒരു പ്രതികരണം ലഭിക്കുന്നതിന് ഞങ്ങൾ ലോക്കൽ മെഷീനിൽ http കേൾക്കുന്നത് ആരംഭിക്കേണ്ടതുണ്ട്, അത് റീഡയറക്‌ടായി തിരികെ നൽകും.

അഡ്മിനിസ്ട്രേറ്റീവ് ജോലികൾ ഒരു പ്രത്യേക സെർവറിൽ നിർവഹിക്കപ്പെടുന്നു, ഒരേ സമയം നിരവധി അഡ്മിനിസ്ട്രേറ്റർമാർ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാനുള്ള സാധ്യത തള്ളിക്കളയാനാവില്ല, അതിനാൽ നിലവിലെ ഉപയോക്താവിനായി ഇത് ക്രമരഹിതമായി ഒരു പോർട്ട് തിരഞ്ഞെടുക്കും, പക്ഷേ ഞാൻ മുൻകൂട്ടി നിശ്ചയിച്ച പോർട്ടുകൾ വ്യക്തമാക്കിയതിനാൽ അവയും API കൺസോളിൽ വിശ്വസനീയമായി ചേർത്തിരിക്കണം.

access_type=ഓഫ്‌ലൈൻ ബ്രൗസറുമായുള്ള ഉപയോക്തൃ ഇടപെടൽ കൂടാതെ തന്നെ കാലഹരണപ്പെട്ട ടോക്കൺ അപ്‌ഡേറ്റ് ചെയ്യാൻ അപ്ലിക്കേഷന് കഴിയും എന്നാണ് അർത്ഥമാക്കുന്നത്,
പ്രതികരണം_തരം=കോഡ് കോഡ് എങ്ങനെ തിരികെ നൽകുമെന്നതിന്റെ ഫോർമാറ്റ് സജ്ജമാക്കുന്നു (പഴയ അംഗീകാര രീതിയെക്കുറിച്ചുള്ള ഒരു റഫറൻസ്, ബ്രൗസറിൽ നിന്ന് കോഡ് സ്ക്രിപ്റ്റിലേക്ക് ഉപയോക്താവ് പകർത്തിയപ്പോൾ),
സ്കോപ്പ് പ്രവേശനത്തിന്റെ വ്യാപ്തിയും തരവും സൂചിപ്പിക്കുന്നു. അവ സ്‌പെയ്‌സുകളാൽ വേർതിരിക്കേണ്ടതാണ് അല്ലെങ്കിൽ% 20 (URL എൻകോഡിംഗ് അനുസരിച്ച്). തരങ്ങളുള്ള ആക്സസ് ഏരിയകളുടെ ഒരു ലിസ്റ്റ് ഇവിടെ കാണാം: Google API-കൾക്കുള്ള OAuth 2.0 സ്കോപ്പുകൾ.

അംഗീകാര കോഡ് ലഭിച്ചതിന് ശേഷം, ആപ്ലിക്കേഷൻ ബ്രൗസറിലേക്ക് ഒരു അടുത്ത സന്ദേശം നൽകും, പോർട്ടിൽ കേൾക്കുന്നത് നിർത്തുകയും ടോക്കൺ ലഭിക്കുന്നതിന് ഒരു POST അഭ്യർത്ഥന അയയ്ക്കുകയും ചെയ്യും. കൺസോൾ API-യിൽ നിന്ന് മുമ്പ് വ്യക്തമാക്കിയ ഐഡിയും രഹസ്യവും ഞങ്ങൾ അതിൽ സൂചിപ്പിക്കുന്നു, ഉപയോക്താവിനെ റീഡയറക്‌ടുചെയ്യുന്ന വിലാസവും പ്രോട്ടോക്കോൾ സ്പെസിഫിക്കേഷൻ അനുസരിച്ച് ഗ്രാൻറ്_ടൈപ്പും നൽകുന്നു.

പ്രതികരണമായി, ഞങ്ങൾക്ക് ഒരു ആക്‌സസ് ടോക്കണും അതിന്റെ സാധുത സെക്കൻഡിനുള്ള കാലയളവും ഒരു പുതുക്കിയ ടോക്കണും ലഭിക്കും, അതിലൂടെ നമുക്ക് ആക്‌സസ് ടോക്കൺ അപ്‌ഡേറ്റ് ചെയ്യാൻ കഴിയും.

ആപ്ലിക്കേഷൻ ദീർഘായുസ്സുള്ള ഒരു സുരക്ഷിത സ്ഥലത്ത് ടോക്കണുകൾ സംഭരിച്ചിരിക്കണം, അതിനാൽ ഞങ്ങൾ സ്വീകരിച്ച ആക്സസ് അസാധുവാക്കുന്നത് വരെ, ആപ്ലിക്കേഷൻ പുതുക്കിയ ടോക്കൺ തിരികെ നൽകില്ല. അവസാനം, ടോക്കൺ അസാധുവാക്കാനുള്ള ഒരു അഭ്യർത്ഥന ഞാൻ ചേർത്തു; ആപ്ലിക്കേഷൻ വിജയകരമായി പൂർത്തിയാക്കിയില്ലെങ്കിൽ, പുതുക്കിയ ടോക്കൺ തിരികെ ലഭിച്ചില്ലെങ്കിൽ, അത് വീണ്ടും നടപടിക്രമം ആരംഭിക്കും (ടെർമിനലിൽ പ്രാദേശികമായി ടോക്കണുകൾ സംഭരിക്കുന്നത് സുരക്ഷിതമല്ലെന്ന് ഞങ്ങൾ കരുതി. ക്രിപ്റ്റോഗ്രഫി ഉപയോഗിച്ച് കാര്യങ്ങൾ സങ്കീർണ്ണമാക്കാനോ ബ്രൗസർ ഇടയ്ക്കിടെ തുറക്കാനോ ആഗ്രഹിക്കുന്നില്ല).

do {
  $token_result = Get-GoogleAuthToken
  $token = $token_result.access_token
  if ($token_result.refresh_token -eq $null) {
    Write-Host ("Session is not destroyed. Revoking token...")
    Invoke-WebRequest -Uri ("https://accounts.google.com/o/oauth2/revoke?token="+$token)
  }
} while ($token_result.refresh_token -eq $null)
$refresh_token = $token_result.refresh_token
$minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Minute)-2
if ($minute -lt 0) {$minute += 60}
elseif ($minute -gt 59) {$minute -=60}
$token_expire = @{
  hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Hour)
  minute = $minute
}

നിങ്ങൾ ഇതിനകം ശ്രദ്ധിച്ചതുപോലെ, ഒരു ടോക്കൺ അസാധുവാക്കുമ്പോൾ, Invoke-WebRequest ഉപയോഗിക്കുന്നു. Invoke-RestMethod പോലെയല്ല, ഇത് സ്വീകരിച്ച ഡാറ്റ ഉപയോഗയോഗ്യമായ ഫോർമാറ്റിൽ തിരികെ നൽകുന്നില്ല കൂടാതെ അഭ്യർത്ഥനയുടെ നില കാണിക്കുന്നു.

അടുത്തതായി, ഒരു ലോഗിൻ + ഇമെയിൽ സൃഷ്ടിച്ചുകൊണ്ട് ഉപയോക്താവിന്റെ പേരിന്റെ ആദ്യഭാഗവും അവസാന നാമവും നൽകാൻ സ്ക്രിപ്റ്റ് നിങ്ങളോട് ആവശ്യപ്പെടുന്നു.

അഭ്യർത്ഥനകൾ

അടുത്ത അഭ്യർത്ഥനകൾ ഇതായിരിക്കും - ഒന്നാമതായി, പുതിയൊരെണ്ണം സൃഷ്ടിക്കുന്നതിനോ നിലവിലുള്ളത് പ്രവർത്തനക്ഷമമാക്കുന്നതിനോ ഒരു തീരുമാനം ലഭിക്കുന്നതിന്, അതേ ലോഗിൻ ഉള്ള ഒരു ഉപയോക്താവ് ഇതിനകം നിലവിലുണ്ടോ എന്ന് നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്.

സ്വിച്ച് ഉപയോഗിച്ച് എല്ലാ അഭ്യർത്ഥനകളും ഒരു ഫംഗ്‌ഷന്റെ ഫോർമാറ്റിൽ ഒരു തിരഞ്ഞെടുപ്പ് ഉപയോഗിച്ച് നടപ്പിലാക്കാൻ ഞാൻ തീരുമാനിച്ചു:

function GoogleQuery {
  param (
    $type,
    $query
  )
  switch ($type) {
    "SearchAccount" {
      Return Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body @{
        domain = 'rocketguys.com'
        query  = "email:$query"
      }
    }
    "UpdateAccount" {
      $body = @{
        name  = @{
          givenName = $query['givenName']
          familyName = $query['familyName']
        }
        suspended = 'false'
        password = $query['password']
        changePasswordAtNextLogin = 'true'
        phones = @(@{
          primary = 'true'
          value = $query['phone']
          type = "mobile"
        })
        orgUnitPath = $query['orgunit']
      }
      Return Invoke-RestMethod -Method Put -Uri ("https://www.googleapis.com/admin/directory/v1/users/"+$query['email']) -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
    }
    
    "CreateAccount" {
      $body = @{
        primaryEmail = $query['email']
        name  = @{
          givenName = $query['givenName']
          familyName = $query['familyName']
        }
        suspended = 'false'
        password = $query['password']
        changePasswordAtNextLogin = 'true'
        phones = @(@{
          primary = 'true'
          value = $query['phone']
          type = "mobile"
        })
        orgUnitPath = $query['orgunit']
      }
      Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
    }
    "AddMember" {
      $body = @{
        userKey = $query['email']
      }
      $ifrequest = Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/groups" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body $body
      $array = @()
      foreach ($group in $ifrequest.groups) {$array += $group.email}
      if ($array -notcontains $query['groupkey']) {
        $body = @{
          email = $query['email']
          role = "MEMBER"
        }
        Return Invoke-RestMethod -Method Post -Uri ("https://www.googleapis.com/admin/directory/v1/groups/"+$query['groupkey']+"/members") -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
      } else {
        Return ($query['email']+" now is a member of "+$query['groupkey'])
      }
    }
  }
}

ഓരോ അഭ്യർത്ഥനയിലും, ടോക്കൺ തരവും ആക്‌സസ് ടോക്കണും അടങ്ങുന്ന ഒരു ഓതറൈസേഷൻ ഹെഡർ നിങ്ങൾ അയയ്‌ക്കേണ്ടതുണ്ട്. നിലവിൽ, ടോക്കൺ തരം എപ്പോഴും ബെയററാണ്. കാരണം ടോക്കൺ കാലഹരണപ്പെട്ടിട്ടില്ലെന്ന് ഞങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്, അത് ഇഷ്യൂ ചെയ്ത നിമിഷം മുതൽ ഒരു മണിക്കൂറിന് ശേഷം അത് അപ്‌ഡേറ്റ് ചെയ്യണം, ഒരു ആക്‌സസ് ടോക്കൺ തിരികെ നൽകുന്ന മറ്റൊരു ഫംഗ്‌ഷനുള്ള ഒരു അഭ്യർത്ഥന ഞാൻ വ്യക്തമാക്കി. ആദ്യ ആക്സസ് ടോക്കൺ ലഭിക്കുമ്പോൾ അതേ കോഡ് സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിലാണ്:

function Get-GoogleToken {
  if (((Get-date).Hour -gt $token_expire.hour) -or (((Get-date).Hour -ge $token_expire.hour) -and ((Get-date).Minute -gt $token_expire.minute))) {
  Write-Host "Token Expired. Refreshing..."
    $request = (Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -ContentType 'application/x-www-form-urlencoded' -Body @{
      client_id = $client_id
      client_secret = $client_secret
      refresh_token = $refresh_token
      grant_type = 'refresh_token'
    })
    $token = $request.access_token
    $minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Minute)-2
    if ($minute -lt 0) {$minute += 60}
    elseif ($minute -gt 59) {$minute -=60}
    $script:token_expire = @{
      hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Hour)
      minute = $minute
    }
  }
  return $token
}

അസ്തിത്വത്തിനായി ലോഗിൻ പരിശോധിക്കുന്നു:

function Check_Google {
  $query = (GoogleQuery 'SearchAccount' $username)
  if ($query.users -ne $null) {
    $user = $query.users[0]
    Write-Host $user.name.fullName' - '$user.PrimaryEmail' - suspended: '$user.Suspended
    $GAresult = $user
  }
  if ($GAresult) {
      $return = $GAresult
  } else {$return = 'gg'}
  return $return
}

ഇമെയിൽ:$query അഭ്യർത്ഥന, അപരനാമങ്ങൾ ഉൾപ്പെടെ, കൃത്യമായി ആ ഇമെയിൽ ഉള്ള ഒരു ഉപയോക്താവിനെ തിരയാൻ API-യോട് ആവശ്യപ്പെടും. നിങ്ങൾക്ക് വൈൽഡ്കാർഡും ഉപയോഗിക്കാം: =, :, :{PREFIX}*.

ഡാറ്റ നേടുന്നതിന്, GET അഭ്യർത്ഥന രീതി ഉപയോഗിക്കുക, ഡാറ്റ തിരുകാൻ (ഒരു അക്കൗണ്ട് സൃഷ്‌ടിക്കുക അല്ലെങ്കിൽ ഒരു ഗ്രൂപ്പിലേക്ക് ഒരു അംഗത്തെ ചേർക്കുക) - POST, നിലവിലുള്ള ഡാറ്റ അപ്‌ഡേറ്റ് ചെയ്യാൻ - PUT, ഒരു റെക്കോർഡ് ഇല്ലാതാക്കാൻ (ഉദാഹരണത്തിന്, ഒരു ഗ്രൂപ്പിൽ നിന്നുള്ള ഒരു അംഗം) - ഇല്ലാതാക്കുക.

സ്ക്രിപ്റ്റ് ഒരു ഫോൺ നമ്പറിനും (സാധുതയില്ലാത്ത ഒരു സ്ട്രിംഗ്) ഒരു പ്രാദേശിക വിതരണ ഗ്രൂപ്പിൽ ഉൾപ്പെടുത്താനും ആവശ്യപ്പെടും. തിരഞ്ഞെടുത്ത ആക്റ്റീവ് ഡയറക്‌ടറി OU അടിസ്ഥാനമാക്കി ഉപയോക്താവിന് ഏത് സംഘടനാ യൂണിറ്റ് ഉണ്ടായിരിക്കണമെന്ന് ഇത് തീരുമാനിക്കുകയും ഒരു പാസ്‌വേഡുമായി വരികയും ചെയ്യുന്നു:

do {
  $phone = Read-Host "Телефон в формате +7хххххххх"
} while (-not $phone)
do {
    $moscow = Read-Host "В Московский офис? (y/n) "
} while (-not (($moscow -eq 'y') -or ($moscow -eq 'n')))
$orgunit = '/'
if ($OU -like "*OU=Delivery,OU=Users,OU=ROOT,DC=rocket,DC=local") {
    Write-host "Будет создана в /Team delivery"
    $orgunit = "/Team delivery"
}
$Password =  -join ( 48..57 + 65..90 + 97..122 | Get-Random -Count 12 | % {[char]$_})+"*Ba"

തുടർന്ന് അവൻ അക്കൗണ്ട് കൈകാര്യം ചെയ്യാൻ തുടങ്ങുന്നു:

$query = @{
  email = $email
  givenName = $firstname
  familyName = $lastname
  password = $password
  phone = $phone
  orgunit = $orgunit
}
if ($GMailExist) {
  Write-Host "Запускаем изменение аккаунта" -f mag
  (GoogleQuery 'UpdateAccount' $query) | fl
  write-host "Не забудь проверить группы у включенного $Username в Google."
} else {
  Write-Host "Запускаем создание аккаунта" -f mag
  (GoogleQuery 'CreateAccount' $query) | fl
}
if ($moscow -eq "y"){
  write-host "Добавляем в группу moscowoffice"
  $query = @{
    groupkey = '[email protected]'
    email = $email
  }
  (GoogleQuery 'AddMember' $query) | fl
}

ഒരു അക്കൗണ്ട് അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനും സൃഷ്ടിക്കുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾക്ക് സമാനമായ വാക്യഘടനയുണ്ട്; എല്ലാ അധിക ഫീൽഡുകളും ആവശ്യമില്ല; ഫോൺ നമ്പറുകളുള്ള വിഭാഗത്തിൽ, നമ്പറും അതിന്റെ തരവും ഉള്ള ഒരു റെക്കോർഡ് വരെ ഉൾക്കൊള്ളാൻ കഴിയുന്ന ഒരു അറേ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്.

ഒരു ഗ്രൂപ്പിലേക്ക് ഒരു ഉപയോക്താവിനെ ചേർക്കുമ്പോൾ ഒരു പിശക് വരാതിരിക്കാൻ, ഉപയോക്താവിൽ നിന്ന് തന്നെ ഗ്രൂപ്പ് അംഗങ്ങളുടെ അല്ലെങ്കിൽ കോമ്പോസിഷനുകളുടെ ഒരു ലിസ്‌റ്റ് ലഭ്യമാക്കി, അയാൾ ഇതിനകം ഈ ഗ്രൂപ്പിൽ അംഗമാണോ എന്ന് നമുക്ക് ആദ്യം പരിശോധിക്കാം.

ഒരു നിർദ്ദിഷ്‌ട ഉപയോക്താവിന്റെ ഗ്രൂപ്പ് അംഗത്വം അന്വേഷിക്കുന്നത് ആവർത്തനപരമാകില്ല കൂടാതെ നേരിട്ടുള്ള അംഗത്വം മാത്രമേ കാണിക്കൂ. ഉപയോക്താവ് അംഗമായ ഒരു ചൈൽഡ് ഗ്രൂപ്പ് ഇതിനകം ഉള്ള ഒരു പാരന്റ് ഗ്രൂപ്പിലെ ഒരു ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുന്നത് വിജയിക്കും.

തീരുമാനം

പുതിയ അക്കൗണ്ടിനായുള്ള പാസ്‌വേഡ് ഉപയോക്താവിന് അയയ്ക്കുക മാത്രമാണ് അവശേഷിക്കുന്നത്. ഞങ്ങൾ ഇത് SMS മുഖേന ചെയ്യുന്നു, കൂടാതെ നിർദ്ദേശങ്ങൾക്കൊപ്പം പൊതുവായ വിവരങ്ങൾ അയയ്‌ക്കുകയും ഒരു വ്യക്തിഗത ഇമെയിലിലേക്ക് ലോഗിൻ ചെയ്യുകയും ചെയ്യുക, അത് ഒരു ഫോൺ നമ്പറിനൊപ്പം റിക്രൂട്ട്‌മെന്റ് വകുപ്പ് നൽകിയിട്ടുണ്ട്. ഒരു ബദലായി, നിങ്ങൾക്ക് പണം ലാഭിക്കാനും നിങ്ങളുടെ രഹസ്യവാക്ക് ഒരു രഹസ്യ ടെലിഗ്രാം ചാറ്റിലേക്ക് അയയ്ക്കാനും കഴിയും, അത് രണ്ടാമത്തെ ഘടകമായി കണക്കാക്കാം (മാക്ബുക്കുകൾ ഒരു അപവാദമായിരിക്കും).

അവസാനം വരെ വായിച്ചതിന് നന്ദി. ലേഖനങ്ങൾ എഴുതുന്ന ശൈലി മെച്ചപ്പെടുത്തുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ കാണുന്നതിൽ എനിക്ക് സന്തോഷമുണ്ട്, കൂടാതെ സ്ക്രിപ്റ്റുകൾ എഴുതുമ്പോൾ കുറച്ച് പിശകുകൾ കണ്ടെത്താനും ഞാൻ ആഗ്രഹിക്കുന്നു =)

വിഷയപരമായി ഉപയോഗപ്രദമായ അല്ലെങ്കിൽ ചോദ്യങ്ങൾക്ക് ലളിതമായി ഉത്തരം നൽകുന്ന ലിങ്കുകളുടെ ലിസ്റ്റ്:

• മൊബൈൽ, ഡെസ്ക്ടോപ്പ് ആപ്പുകൾക്കുള്ള OAuth 2.0
• വെബ് സെർവർ ആപ്ലിക്കേഷനുകൾക്കായി OAuth 2.0 ഉപയോഗിക്കുന്നു
• OAuth പബ്ലിക് ക്ലയന്റുകളുടെ കോഡ് എക്സ്ചേഞ്ചിനുള്ള പ്രൂഫ് കീ
• PowerShell ഉപയോഗിച്ച് ക്രമരഹിതമായ അക്ഷരങ്ങൾ സൃഷ്ടിക്കുക
• ASCII പട്ടികയും വിവരണവും
• പവർഷെൽ: ഒരു സ്‌ട്രിങ്ങിന് ഹാഷ് മൂല്യം ലഭിക്കുന്നു
• Base64Url എൻകോഡ്/ഡീകോഡ് ചെയ്യുക
• Base64 എൻകോഡിംഗ് vs Base64url എൻകോഡിംഗ്
• PowerShell 5.1-ലെ ഇൻവോക്ക്-റെസ്റ്റ് രീതി
• step1-ൽ access_type ഓഫ്‌ലൈനാണെങ്കിലും പുതുക്കിയ ടോക്കൺ ലഭിക്കുന്നില്ല
• താരതമ്യം ഓപ്പറേറ്റർമാരെ കുറിച്ച്
• ഡയറക്ടറി API: ഉപയോക്തൃ അക്കൗണ്ടുകൾ
• ഉപയോക്താക്കൾക്കായി തിരയുക
• ഡയറക്ടറി API: ഗ്രൂപ്പുകൾ
• ഇൻവോക്ക്-റെസ്റ്റ് മെത്തഡിനായി കൈകാര്യം ചെയ്യുന്നതിൽ പിശക് - പവർഷെൽ

അവലംബം: www.habr.com