Web Development rasprave/preporuke/problemi

@foggy i @Fico
Hej ekipa, evo detaljnije objasnjena:

POLJE 1
Email
Date

POLJE 1 ENRICHED IZ AD-a
Date
SamAccountName
RealName
Office
Email

POLJE 2
ControllerId
EventTime
Username
UserToken
EventId

Znaci tek kada "obogatim" POLJE 1 sa podacima iz ADa, mogu raditi usporedbu po SamAccountNameu (username):

foreach ($Entry in $POLJE1) {
if ($POLJE2.username -notcontains $Entry.SamAccountName) {
$Difference += $Entry.Email
}
}

Problem je upravo to "obogacivanje" POLJA1, gdje koristenje "where-object", "contains" ili bilo cega drugog traje predugo, jer je AD uz sve filtere prevelik i to vrti jako dugo.

Ja sam sam tu potrebu koristio Binary Search algoritam:

function BinarySearch {

Param ($SortedArray, $Attribute, $SearchedObject)

$startIndex = 0
$endIndex = $SortedArray.length - 1
$Output = @()

if ( ( $SortedArray[$startIndex].$Attribute -gt $SearchedObject ) -or ($SortedArray[$endIndex].$Attribute -lt $SearchedObject ) ) {
    return "Out of scope!"
}
while ($startIndex -le $endIndex) {   
    $middleIndex = $startIndex + [Math]::floor(($endIndex - $startIndex) / 2)
    if ($SortedArray[$middleIndex].$Attribute -eq $SearchedObject) {
            $Output += $SortedArray[$middleIndex]
            for ($n=$middleIndex - 1;$SortedArray[$n].$Attribute -eq $SearchedObject;$n--) {
                $Output += $SortedArray[$n]
            }
            for ($n=$middleIndex + 1;$SortedArray[$n].$Attribute -eq $SearchedObject;$n++) {
                $Output += $SortedArray[$n]
            }
    }
    if ($SortedArray[$middleIndex].$Attribute -lt $SearchedObject) {
        $startIndex = $middleIndex + 1
    }
    else {
        $endIndex = $middleIndex - 1
    }
}
return $Output

}

Medutim, da bi binary radio, on mora operirati sa sortiranim poljem, a upravo to sortiranje u Powershellu ne radi kako spada:

UPOTREBA BINARY SEARCH da bi se obogatilo POLJE1 sa podacima iz ADa:

foreach ($Entry in $POLJE1) {
$UserEntry = BinarySearch -SortedArray $ADExport -Attribute Mail -SearchedObject $Entry.Email

AD Export i sortiranje PWS cmdletom "Sort-Object":

$ADExport = Get-ADUser -Filter 'Mail -like "XXX" -and Enabled -eq "True"' -SearchBase $Path -Properties Mail, extensionAttribute8 | Select-Object SamAccountName, Mail, Name | Sort-Object -Property Mail

Ono sto meni treba je Quicksort funkcija koja operira nad ADExportom i poslozi po propertyu (kolumni) Mail, ali isto to napravi nad propertyima SamAccountName, Name. Ovo je kako trenutno izgleda moja quicksort funkcija:

function quicksort($array) {
$less, $equal, $greater = @(), @(), @()
if( $array.Count -gt 1 ) {
$pivot = $array[0]
foreach( $x in $array) {
if($x -lt $pivot) { $less += @($x) }
elseif ($x -eq $pivot) { $equal += @($x)}
else { $greater += @($x) }
}
$array = (@(quicksort $less) + @($equal) + @(quicksort $greater))
}
$array
}

foggy Možda Fićo ima nešto u prstima

Imam gorčinu i razočaranje.

Inače, Python je bolestan za obradu podataka, zato sam spomenuo da svoje varijable možeš pohraniti kao jenkins varijablu, pa ih onda možemo doslovno poslati u koji framework želimo u narednom ili istom koraku.

Znači, čitam ovo kaj @chono piše i krenem pisati da bi možda najpraktičnije bilo napraviti Python skripticu za ovo, on je super s velikom količinom podataka. I onda vidim i ti spomeneš Python.

Ukratko, prošao sam kroz ovo što je napisano zadnjih dana i meni se jednostavno čini kao problem koji traži jako puno fine tuninga za nešto što je izvedivo van okvira Powershella. Kažem da mi se čini zato što s Powershellom nemam iskustva. Igrao sam se s Jenkins skriptama, ali nikada nisam radio detaljniju obradu podataka, uvijek se to pokušavalo svesti na provjere flagova i konkateniranje ili pozivanje složenijih funkcija.

Još ću proučiti, malo razmisliti pa vidjeti hoće li mi pasti neki alternativni pristup.

Jedino kaj trenutno mogu je vratiti se na ideju korištenja Pythona za ovo. Lagan je za savladati, takoreći se pišu rečenice i ovakvo što bi mogao pojesti. Na tebi bi bilo da složiš skriptu koja dovlači podatke iz AD-a i onda sve predaje kao argument toj .py skripti. I onda pustiti da Python odradi svoje i negdje ti spremi gotove podatke.

U tom bih slučaju išao u smjeru:

1. Dohvati mi podatke iz POLJA 1
2. Dohvati mi podatke iz AD-a
3. Pozovi .py skriptu kojoj se predaju podaci iz koraka 1 i 2, u njoj raditi enrichment

Sada dobivaš više slobode za eksperimentiranje i igranje s vremenom izvođenja. Možeš, recimo, napraviti u istoj toj skripti i da se predaje POLJE 2 i zatim radiš čitavu logiku unutra. Možeš i izbaciti dobiveno enrichano polje i onda izvesti običnu usporedbu između dva polja jer si sada riješio problem enrichmenta. Ili pak možeš napraviti zasebnu .py skriptu koja vrši usporedbu oba polja i pozvati ju nakon izvođenja prve .py skripte.

Ako odeš u ovom smjeru i iz kojeg god se razloga ne budeš snalazio, javi se pa nastavimo.

EDIT: Ili još bolje, sve samo hiti u Python. Nisam ovoliko shillao Python od... Nikad...

Fico da, sve mi se vise cini da cu morati prosiriti okvire ovo trenutno dela, sporo, ali dela. Tako da selim u Python glavni dio koda i napravit cu to elegantnije i bolje.
Da budem iskren, malo sam razocaran u powershell nakon ovog...
I ovo sto @foggy pise, stavis AD import podataka u Jenk env varijablu i delas s njom u Pythonu, samo je pozoves.

@foggy @Fico rijesio kompletno u pwsu i to sada radi u par sekundi, cijela skripta.

Quicksort funkcija starta na pola polja, tako da ide lijevo i desno i sortira:

function quicksort($Array) {
    $Less = @()
    $Equal = @()
    $Greater = @()
    if( $Array.Count -gt 1 ) { 
        $Pivot = $Array[$Array.count / 2]
        foreach( $x in $Array) {
            if($x -lt $Pivot) { 
                $Less += @($x) 
            }
            elseif ($x -eq $Pivot) { 
                $Equal += @($x)
            }
            else { 
                $Greater += @($x) 
            }
        }    
        $Array = (@(quicksort $Less) + @($Equal) + @(quicksort $Greater))
    }
    $Array
}

Pomocu zamjenskog polja kreirao zavrsno, popunio prethodno konstruiranu klasu i voila:

[System.Collections.ArrayList]$ArraySorted = quicksort $POLJE1.Mail
$FinalArray = @()
foreach ($Email in $ArraySorted) {
    if ($POLJE1.Mail -eq $Email) {
        $index = [array]::indexof($POLJE1.Mail,$Email)
        $ThisVar = [ADUSER]::new()
        $ThisVar.SamAccountName = $POLJE1[$index].SamAccountName
        $ThisVar.Mail = $Email
        $ThisVar.Name = $POLJE1[$index].Name
        $ThisVar.extensionAttribute8 = $POLJE1[$index].extensionAttribute8
        $FinalArray += $ThisVar
    }
}

Sada se bacam da sve ovo odradim unutar funkcije quicksort, da sortira polje i zadrzi sve kolumne sa vrijednostima.

Ovo mi je draze nego video gdje Tuhy kolje Melaniu! Uspio sam napisati kompletnu quicksort funkciju kojoj das polje, das joj ime kolumne, ona sortira po toj kolumni i vrati ti natrag kompletno sortirano polje sa svim kolumnama:

function quicksort($Array, $Property) {
    $Less = @()
    $Equal = @()
    $Greater = @()
    if( $Array.Count -gt 1 ) { 
        $Pivot = $Array[$Array.count / 2].$Property
        foreach( $x in $Array) {
            if($x.$Property -lt $Pivot) { 
                $Less += $x
            }
            elseif ($x.$Property -eq $Pivot) { 
                $Equal += $x
            }
            else { 
                $Greater += $x
            }
        }   
        $Array = (@(quicksort $Less $Property) + @($Equal) + @(quicksort $Greater $Property))
    }
    $Array
}

Treba 2 sekunde za polje od cca 4000 entrya sto je odlicno!

Brijac Iskreno, preporučio bih ti da sam radiš od nule. Dakle HTML i CSS pa dodaj na to JavaScript i/ili malo PHP-a. Sve se to spoji na bazu pa se malo poigraš SQL-om. Onda fino kreni na Angular jer ima odličnu dokumentaciju i stvarno vrhunski složen uvodni projektić na njihovoj stranici (Angular Hero App). Navodno i Vue ima solidnu dokumentaciju, no nisam ga koristio. React ćeš pišati krv ako kreneš prvoga ga raditi jer je Facebook uložio truda u pristupačnost koliko i u zaštitu podataka svojih korisnika. Kad poloviš jedan od ta tri, ostali se pretvore u hvatanje njihovih posebnosti, no osnovne principe ćeš razumijeti i lakše se u njima i snaći. Također, nemoj podcijeniti znanje OOP-a.