Hi!
แแก แกแขแแขแแ แแฆแฌแแ แก PowerShell-แแก แฃแ แแแแ แแฅแแแแแแแก แแแแฎแแ แชแแแแแแแก Google API-แกแแแ G Suite แแแแฎแแแ แแแแแแแก แแแแแแฃแแแ แแแแกแแแแก.
แฉแแแ แแแงแแแแแ แ แแแแแแแแ แจแแแ แแ แฆแ แฃแแแแแแ แกแแ แแแกแก แแ แแแแแแแชแแแก แแแกแจแขแแแแ. แฃแแแขแแกแฌแแแแ, แแแแจแ แแแขแแ แแแแชแแ แแแแแก Google-แแ แแ Active Directory-แแ, แ แแแแแแ แจแแ แแกแแช แฉแแแ แแแ แแแแแฎแแแ แ แแแแแแแก; แจแแกแแแแแแกแแ, แ แแแแกแแช แแฎแแแ แแแแแแจแ แแแแแ แแแแแก, แแฅแแแ แฃแแแ แจแแฅแแแแ/แฉแแ แแแ แแแแแ แแจแ แแ แแ แกแแกแขแแแแจแ. แแ แแชแแกแแก แแแขแแแแขแแแแชแแแกแแแแก, แแแแแแฌแงแแแขแแ แแแแแแฌแแ แ แกแแ แแแขแ, แ แแแแแแช แแแ แแแแแก แแแคแแ แแแชแแแก แแ แแแแแแแแก แแ แแแ แกแแ แแแกแก.
แแแขแแ แแแแชแแ
แแแแฎแแแแแแแก แจแแแแแแแกแแก แแแแแแฌแงแแแขแแ แแแแแแแงแแแแ แ แแแแฃแ แ แแแแแแแกแขแ แแขแแ แแแ แแแขแแ แแแแชแแแกแแแแก, แ แแช แแแแ แขแแแแแก แฅแแแแแแแแแก แแแแแแแก แจแแแแฎแแแแแแ แแ แแแแแ แแฎ แแแกแแฃแ แ แชแแแแแแแแแแก แจแแแแฎแแแแแจแ.
Google API แแงแแแแแก OAuth 2.0 แแ แแขแแแแแก แแแแแแขแแคแแแแชแแแกแ แแ แแแขแแ แแแแชแแแกแแแแก. แแแแแงแแแแแแก แจแแแแฎแแแแแแ แแ แฃแคแ แ แแแขแแแฃแ แ แแฆแฌแแ แ แจแแแแซแแแแ แแฎแแแแ แแฅ: .
แแ แแแแ แฉแแ แกแแ แแแขแ, แ แแแแแแช แแแแแแงแแแแแ แแแกแแขแแแแก แแแแแแแชแแแแจแ แแแขแแ แแแแชแแแกแแแแก. แแกแแแ แแ แกแแแแแก แกแแ แแแกแแก แแแแแ แแจแแก แแแแแงแแแแแแก แแแ แแแแขแ, แ แแแแแแช แแ แกแแญแแ แแแแก แแแแฎแแแ แแแแแกแแแ แแแแแแข แแแซแ แแแแแก.
แฅแแแแแ แแแงแแแแแแ แกแฃแ แแแ แแ แแก แแ แฉแแฃแแ แกแชแแแแ แแก แกแฅแแแแขแฃแ แ แแฆแฌแแ แ Google-แแก แแแแ แแแแแ.
- แแแ แแแ แ แแแจแ, แฉแแแ แแฃแแแแแแแ แแแแฎแแแ แแแแแก Google แแแแแ แแจแแก แแแขแแ แแแแชแแแก แแแแ แแแ, แกแแแแช แแแแแแแแฃแแแ GET แแแ แแแแขแ แแแ:
- แแแแแชแฎแแแแก ID
- แกแคแแ แแแแ, แ แแแแแแแแช แแแแแแแชแแแก แกแญแแ แแแแ แฌแแแแแ
- แแแกแแแแ แแ, แ แแแแแแแช แแแแฎแแแ แแแแแ แแแแแแแกแแแแ แแแแแ แแ แแชแแแฃแ แแก แแแกแ แฃแแแแแก แจแแแแแ
- แ แแแแ แแแแแแแฎแแแแ แแแขแแแก
- แฒฃแกแแคแ แแฎแแแแแก แแแแ
- แแแแแแแฌแแแแแก แแแแแก แแแแแชแแแแก แคแแ แแแขแ
- แแแขแแ แแแแชแแแก แแแกแ แฃแแแแแก แจแแแแแ, แแแแฎแแแ แแแแแ แแแแแแแกแแแแ แแแแแ แแแ แแแ แแแแฎแแแแแจแ แแแแแแแแฃแ แแแแ แแแ, แจแแชแแแแแ แแ แแแขแแ แแแแชแแแก แแแแแ, แ แแแแแกแแช แแแแแกแชแแแก GET แแแ แแแแขแ แแแ.
- แแแแแแแชแแแ (แกแแ แแแขแแ) แฃแแแ แแแแฆแแก แแก แแแ แแแแขแ แแแ แแ, แแฃ แแแแ แแแแฆแ, แแแแแแแแก แจแแแแแแ แแแแฎแแแแ แขแแแแแแแแก แแแกแแฆแแแแ
- แแฃ แแแแฎแแแแ แกแฌแแ แแ, Google API แแแ แฃแแแแก:
- แฌแแแแแแก แแแขแแแ, แ แแแแแแแช แจแแแแแซแแแ แแแแฎแแแแแแแก แแแแแแแแ
- แแ แแแจแแแก แแแฅแแแแแแแก แแแแ
- แฌแแแแแแก แแแขแแแแก แแแแแฎแแแแแกแแแแก แกแแญแแ แแ แแแแแฎแแแแแก แแแขแแแ.
แฏแแ แฃแแแ แแแแแฎแแแแแ Google API แแแแกแแแแ: , แแแ แฉแแแ แกแแกแฃแ แแแแ แแแแแแแชแแ แแ Credentials แแแแงแแคแแแแแแจแ แจแแฅแแแแแ แแแแแแขแแก OAuth แแแแแขแแคแแแแขแแ แ. แแฅ (แแ แแแแแแแแแแแ, แจแแฅแแแแแ แแแแแขแแคแแแแขแแ แแก แแแแกแแแแแจแ) แแฅแแแ แฃแแแ แแแฃแแแแแ แแแกแแแแ แแแแ, แ แแแแแแแแช แแแแแแแ แแฃแแแ แแแแแแแกแแแแ แแแแ. แฉแแแแก แจแแแแฎแแแแแจแ, แแก แแฅแแแแ แ แแแแแแแแ แแแแแแฐแแกแขแแก แฉแแแแฌแแ แ แกแฎแแแแแกแฎแแ แแแ แขแแ (แแฎ. แฅแแแแแ).
แแแแกแแแแแก, แ แแ แฃแคแ แ แแแกแแฎแแ แฎแแแแแ แแงแแก แกแแ แแแขแแก แแแแแ แแแแแก แฌแแแแแฎแแ, แจแแแแซแแแแ แแฉแแแแแ แแแ แแแแ แแแแแฏแแแ แชแแแแ แคแฃแแฅแชแแแจแ, แ แแแแแแช แแแแแ แฃแแแแก Access-แก แแ แแแแแแฎแแแแก แแแแแแแชแแแก แขแแแแแแแก:
$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
แฉแแแ แแแแแงแแแแ แแแแแแขแแก ID แแ แแแแแแขแแก แกแแแแฃแแแ, แแแฆแแแฃแแ OAuth แแแแแแขแแก แแแแแขแแคแแแแขแแ แแก แแแแกแแแแแจแ, แฎแแแ แแแแแก แแแแแแแกแขแฃแ แแแแแ แแ แแก 43-แแแ 128-แแแ แกแแแแแแแกแแแ แจแแแแแแ แ แกแขแ แแฅแแแ, แ แแแแแแช แจแแแแฎแแแแแ แฃแแแ แแงแแก แแแแแ แแ แแแฃแแ แแ แแ แแแแ แแแ แแแฃแแ แกแแแแแแแแแแแแ: [AZ] / [az] / [0-9 ] / "-" / "." / "_" / "~".
แจแแแแแ แแก แแแแ แแแแแ แแแแแแชแแแ. แแก แแแแแ แแชแฎแแแก แแแฃแชแแแแแแแก, แ แแแแแก แแ แแกแแช แแแแแแแกแฎแแแแก แจแแฃแซแแแ แแแแฎแแแ แแแแแก แแแขแแ แแแแชแแแก แจแแแแแ แแแแแแแกแแแแ แแแแแก แกแแฎแแ แแแแ แฃแแแแฃแแ แแแกแฃแฎแแก แฉแแญแ แ.
แแฅแแแ แจแแแแซแแแแ แแแแแแแแแ แแแแแก แจแแแแแฌแแแแแแ แแแแแแแแ แ แแแแฎแแแแแจแ แแแแคแแ แขแแฅแกแขแแ (แ แแช แแแก แฃแแแ แ แฎแแแก - แแก แจแแกแแคแแ แแกแแ แแฎแแแแ แกแแกแขแแแแแแกแแแแก, แ แแแแแแกแแช แแ แฃแญแแ แแ แแฎแแ แก SHA256), แแ แฐแแจแแก แจแแฅแแแแ SHA256 แแแแแ แแแแแก แแแแแงแแแแแแ, แ แแแแแแช แฃแแแ แแงแแก แแแแแ แแแฃแแ BASE64Url-แจแ (แแแแกแฎแแแแแแฃแแ Base64-แแแ แแ แ แชแฎแ แแแแก แกแแแแแแแแ) แแ แแแแแฆแแ แกแแแแแแแแแแก แฎแแแแก แแแแแแแแแแแ: =.
แจแแแแแแ, แฉแแแ แฃแแแ แแแแแฌแงแแ http-แแก แแแกแแแแ แแแแแแแแ แแ แแแแ แแขแแ, แ แแแ แแแแแฆแแ แแแกแฃแฎแ แแแขแแ แแแแชแแแก แจแแแแแ, แ แแแแแแช แแแแ แฃแแแแแ แแแแแแแกแแแแ แแแแแก แกแแฎแแ.
แแแแแแแกแขแ แแชแแฃแแ แแแแแแแแแแ แจแแกแ แฃแแแแฃแแแ แกแแแชแแแแฃแ แกแแ แแแ แแ, แฉแแแ แแ แแแแแแ แแชแฎแแแ แจแแกแแซแแแแแแแแก, แ แแ แ แแแแแแแแ แแแแแแแกแขแ แแขแแ แแ แแ แแแ แแฃแแแ แแแฃแจแแแก แกแแ แแแขแ, แแแแขแแ แแก แจแแแแฎแแแแแ แจแแแ แฉแแแก แแแ แขแก แแแแแแแแ แ แแแแฎแแแ แแแแแกแแแแก, แแแแ แแ แแ แแแแฃแแแแ แฌแแแแกแฌแแ แแแแกแแแฆแแ แฃแแ แแแ แขแแแ, แ แแแแแ แแกแแแ แแกแแแ แฃแแแ แแแแแแขแแก แ แแแแ แช แกแแแแ API แแแแกแแแจแ.
แฌแแแแแ_แขแแแ=แฎแแแแแ แแจแ แแแจแแแแก, แ แแ แแแแแแแชแแแก แจแแฃแซแแแ แแแแแแฎแแแก แแแแแแแกแฃแแ แแแขแแแ แแแแแฃแแแแแแแแ แแแแฎแแแ แแแแแก แแ แแฃแแแ แแแ แฃแ แแแแ แแฅแแแแแแแก แแแ แแจแ,
แแแกแฃแฎแ_แขแแแ=แแแแ แแแแแแก แแแแแก แแแแ แฃแแแแแก แคแแ แแแขแก (แแแแแจแแแแ แซแแแแ แแแขแแ แแแแชแแแก แแแแแแแ, แ แแแแกแแช แแแแฎแแแ แแแแแแ แแแแแแแแ แ แแแแ แแ แแฃแแแ แแแแ แกแแ แแแขแจแ),
แคแแ แแแแแจแ แแแฃแแแแแแก แฌแแแแแแก แคแแ แแแแแกแ แแ แขแแแแ. แแกแแแ แแแแแงแแคแแแ แฃแแแ แแงแแก แแแขแแ แแแแแ แแ %20 (URL แแแแแ แแแแก แแแฎแแแแแ). แฌแแแแแแก แแแแแแแก แกแแ แขแแแแแแ แจแแแแซแแแแ แแฎแแแแ แแฅ: .
แแแขแแ แแแแชแแแก แแแแแก แแแฆแแแแก แจแแแแแ, แแแแแแแชแแ แแ แแฃแแแ แก แฃแแ แฃแแแแก แแฎแแ แจแแขแงแแแแแแแแก, แจแแฌแงแแแขแก แแแ แขแแ แแแกแแแแแก แแ แแแแแแแแก POST แแแแฎแแแแแก แขแแแแแแก แแแกแแฆแแแแ. แฉแแแ แแฆแแแแจแแแแ แแแกแจแ แแแ แ แแแแแแแแฃแ ID-แก แแ แกแแแแฃแแแแก แแแแกแแแแก 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'])
}
}
}
}แแแแแแฃแ แแแแฎแแแแแจแ แแฅแแแ แฃแแแ แแแแแแแแแแแแ แแแขแแ แแแแชแแแก แกแแแแฃแ แ, แ แแแแแแช แจแแแชแแแก แแแขแแแแก แขแแแก แแ แแแแแ แฌแแแแแแก แแแขแแแก. แแแแแแแ, แแแขแแแแก แขแแแ แงแแแแแแแแก แแ แแก Bearer. แแแแขแแ แ แแ แฉแแแ แฃแแแ แจแแแแแแฌแแแ, แ แแ แแแขแแแก แแแแ แแ แแแฃแแแแ แแ แแแแแแฎแแแ แแแ แแแชแแแแก แแแแแแขแแแแ แแ แแ แกแแแแแก แจแแแแแ, แแ แแแแแแฃแกแขแ แแแแฎแแแแ แกแฎแแ แคแฃแแฅแชแแแกแแแแก, แ แแแแแแช แแแ แฃแแแแก Access แขแแแแแก. แแแแแก แแแแแ แแแฌแแแ แแ แแก แกแแ แแแขแแก แแแกแแฌแงแแกแจแ แแแ แแแแ Access แแแจแแแก แแแฆแแแแกแแก:
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
}email:$query แแแแฎแแแแ แกแแฎแแแก API-แก แแแซแแแแแก แแแแฎแแแ แแแแแ แแฃแกแขแแ แแ แแแคแแกแขแแ, แแแขแกแแฎแแแแแแก แฉแแแแแแ. แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแแแแงแแแแ wildcard: =, :, :{PREFIX}*.
แแแแแชแแแแแแก แแแกแแฆแแแแ แแแแแแงแแแแ GET แแแแฎแแแแแก แแแแแแ, แแแแแชแแแแแแก แฉแแกแแ (แแแแแ แแจแแก แจแแฅแแแ แแ แฏแแฃแคแจแ แฌแแแ แแก แแแแแขแแแ) - POST, แแ แกแแแฃแแ แแแแแชแแแแแแก แแแแแฎแแแแแกแแแแก - PUT, แฉแแแแฌแแ แแก แฌแแกแแจแแแแแ (แแแแแแแแแ, แฌแแแ แ แฏแแฃแคแแแแ) - แฌแแจแแ.
แกแแ แแแขแ แแกแแแ แแแฎแแแก แขแแแแคแแแแก แแแแแ แก (แแ แแแแแแแแ แแแฃแแ แกแขแ แแฅแแแ) แแ แฉแแ แแแแก แ แแแแแแฃแ แแแแแฌแแแแแแก แฏแแฃแคแจแ. แแก แฌแงแแแขแก แ แแแแแ แแ แแแแแแแชแแฃแแ แแ แแแฃแแ แฃแแแ แฐแฅแแแแแก แแแแฎแแแ แแแแแก แแ แฉแแฃแแ Active Directory 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-แแก แกแแจแฃแแแแแแ แแ แแฃแแแแแแแ แแแแแ แแแคแแ แแแชแแแก แแแกแขแ แฃแฅแชแแแแแ แแ แจแแกแแแแแ แแแ แแ แแแคแแกแขแแแ, แ แแแแแแช แขแแแแคแแแแก แแแแแ แแแ แแ แแแ แแแแแแฌแแแ แแแกแแฅแแแแแก แแแแงแแคแแแแแแ. แ แแแแ แช แแแขแแ แแแขแแแ, แจแแแแซแแแแ แแแแแแแ แคแฃแแ แแ แแแแแแแแแ แแฅแแแแ แแแ แแแ แกแแแแฃแแแ แขแแแแแ แแแแก แฉแแขแจแ, แ แแช แแกแแแ แจแแแซแแแแ แฉแแแแแแแแก แแแแ แ แคแแฅแขแแ แแ (แแแแแแแแแแกแ แแฅแแแแ MacBooks).
แแแแแแแแ, แ แแ แแแแแแแ แฌแแแแแแฎแแ. แกแแแแแแแแแแ แแแฎแแแแ แฌแแแแแแแแแแแก แกแขแแขแแแแแก แฌแแ แแก แกแขแแแแก แแแกแแฃแแฏแแแแกแแแแแ แแ แแแกแฃแ แแแ, แ แแ แแแแแแแ แจแแชแแแแ แแแแญแแ แ แกแแ แแแขแแแแก แฌแแ แแกแแก =)
แแแฃแแแแแก แกแแ, แ แแแแแแแช แจแแแซแแแแ แแงแแก แแแแแขแฃแ แแ แกแแกแแ แแแแแ แแ แฃแแ แแแแ แฃแแแกแฃแฎแแก แแแแฎแแแแก:
แฌแงแแ แ: www.habr.com