You might know about my most favourite add-in for Microsoft Excel called Fuzzy Lookup. It’s the best, most accurate and fastest tool to compare a string of text against a table of data. For example, I can have a table of songs (my entire music library of 12K+ songs), then in another table I can have a list of songs that a radio station has played over the past week – for example. With Fuzzy lookup, I can compare the two tables. Table A which contains songs played on a radio station and Table B which represents my library. For each song in the Table A, give me the closest match of a song from Table B. It works beautifully and provides me a match score so I know how different the match was.
Trying to automate this using PowerShell has been challenging. I have an example here of a PowerShell which I wrote and pieced together. Some of the PowerShell functions I got from here, but not all. The rest of the script I wrote myself…
It does the following:
- Runs through (2 radio stations as an example) on a continuous loop and captures the now playing song from their website. It has some smarts though for each time it’s run:
- if its the same song, skip it
- if the song has changed, capture it and do other things, keep reading…
- The song just played is cleaned up a little bit using some regular expressions (RegEx). The clean up process is to help with a successful match.
- The just played song is checked against a master library of my existing songs in Azure blob storage by using the various functions to do a Fuzzy Match.
- Once a match is found, three things are written to Azure Table Storage:
- the score of the match
- the song captured from the radio station exactly – the just played song
- the result of the song matched from my library
The screenshot below is taken from a list of songs in my Azure table storage account, the songs on the left are songs just played Vs songs on the right which are songs matched from my library. I have pointed to a few examples.
As you can see, it’s pretty accurate.
By the way, the tool used to access Azure storage accounts (including Azure Blob / Azure Tables / Azure Files) is the free Azure Storage Explorer.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| $RadioFormat = 'Kiis' | |
| $WritetoTableStorage = 'Yes' | |
| $TableName = "JustPlayedKiis" | |
| #Define the storage account and context. | |
| $StorageAccountName = "StorageAccountName" | |
| $StorageAccountKey = "StorageAccountKey" | |
| $Ctx = New-AzureStorageContext $StorageAccountName –StorageAccountKey $StorageAccountKey | |
| #region Clear the cache (variables) | |
| $kiis1065result = @() | |
| $kiis1011result = @() | |
| #endregion | |
| Function CheckSong ($song){ | |
| $Global:Results = @() | |
| $1stResults = @() | |
| $2ndResults = @() | |
| $Global:Library | % { | |
| $h = new-object psObject | select DistanceNumber,Song | |
| $h.DistanceNumber = (Get-LongestCommonSubstring $song ($_ -replace '\(.*\)','')).length | |
| $h.Song = $_ | |
| $1stResults += $h | |
| } | |
| ($1stResults | sort DistanceNumber | select –Last 50).song | % { | |
| $x = new-object psObject | select DistanceNumber,Song | |
| $x.DistanceNumber = Get-FuzzyMatchScore $song ($_ -replace '\(.*\)','') | |
| $x.Song = $_ | |
| $2ndResults += $x | |
| } | |
| if((($2ndResults | sort –Descending DistanceNumber)[0]).DistanceNumber -lt '1600'){ | |
| $null = (($song -split ' – ')[0]) -match '[0-9A-Za-z\x2d]+';$artist = $matches[0] | |
| $title = (($song -split ' – ')[1]) | |
| foreach($2ndresult in $2ndResults){ | |
| if(($2ndresult.Song -split ' – ')[0] -match $artist -and ($2ndresult.Song -split ' – ')[1] -match $title) | |
| {$Global:Results = $2ndresult} | |
| } | |
| } | |
| if((!($Global:Results))) {$Global:Results = $2ndResults} | |
| } | |
| Function Get-ExistingSongLibrary ($Ctx) { | |
| #$Containers = Get-AzureStorageContainer -Context $Ctx -ErrorAction SilentlyContinue | |
| $RawLibrary = Get-AzureStorageBlob –Container music –Context $Ctx | ? {$_.Name -like '*.mp3'} | |
| $Global:Library = @() | |
| foreach($lib in $RawLibrary){ | |
| $Global:Library += ($Lib.Name).Split('/') -replace '.mp3' | select –Last 1 | |
| } | |
| } | |
| Function MissingSongsTable ($song, $songrequest, $RadioFormat, $DistanceNumber){ | |
| $MissingTableName = "MissingSongs" | |
| #Retrieve the table if it already exists. | |
| $table = Get-AzureStorageTable –Name $MissingTableName –Context $Ctx –ErrorAction Ignore | |
| #Create a new table if it does not exist. | |
| if ($table -eq $null) | |
| { | |
| Do{$table = New-AzureStorageTable –Name $MissingTableName –Context $Ctx; Start-Sleep –Seconds 2} until((Get-AzureStorageTable –Name $MissingTableName –Context $Ctx –ErrorAction Ignore) -ne $null) | |
| } | |
| #query table entities | |
| #Create a table query. | |
| $query = New-Object Microsoft.WindowsAzure.Storage.Table.TableQuery | |
| $datenow = (Get-Date).Year.ToString() + (Get-Date).DayOfYear.ToString() + ((Get-Date).DayOfWeek).ToString() | |
| $dateyesterday = (Get-Date).AddDays(-1).Year.ToString() + (Get-Date).AddDays(-1).DayOfYear.ToString() + ((Get-Date).AddDays(-1).DayOfWeek).ToString() | |
| $filterString = "(PartitionKey eq '$datenow' or PartitionKey eq '$dateyesterday')" | |
| $query.FilterString = $filterString | |
| #Execute the query. | |
| $entities = $table.CloudTable.ExecuteQuery($query) | |
| $time = Get-Date –Format yyyyMMdd–HH:mm:ss | |
| $PartitionKey = (Get-Date).Year.ToString() + (Get-Date).DayOfYear.ToString() + ((Get-Date).DayOfWeek).ToString() | |
| # Row Number Variable | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -eq $PartitionKey){ | |
| $rowNumber = ($entities | sort Timestamp | select –Last 1).RowKey -replace("Row");$rowNumber = [INT]$rowNumber;$rowNumber++} | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -ne $PartitionKey){$rowNumber = 1} | |
| # ID number Variable | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -eq $PartitionKey){ | |
| $ID = ($entities | sort Timestamp | select –Last 1).Properties.ID.PropertyAsObject;$ID++} | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -ne $PartitionKey){$ID = 1} | |
| $entity = New-Object –TypeName Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity –ArgumentList $partitionKey, "Row$rowNumber" | |
| $entity.Properties.Add("SongPlayed", $song) | |
| $entity.Properties.Add("SongLookup", $songrequest) | |
| $entity.Properties.Add("DistanceNumber", $DistanceNumber) | |
| $entity.Properties.Add("RadioFormat", $RadioFormat) | |
| $entity.Properties.Add("ID", $id) | |
| $entity.Properties.Add("Time", $time) | |
| $table.CloudTable.Execute([Microsoft.WindowsAzure.Storage.Table.TableOperation]::Insert($entity)) | |
| } | |
| Function SongsTable ($songrequest, $song, $RadioFormat, $DistanceNumber){ | |
| #Create a table query. | |
| $query = New-Object Microsoft.WindowsAzure.Storage.Table.TableQuery | |
| $datenow = (Get-Date).Year.ToString() + (Get-Date).DayOfYear.ToString() + ((Get-Date).DayOfWeek).ToString() | |
| $dateyesterday = (Get-Date).AddDays(-1).Year.ToString() + (Get-Date).AddDays(-1).DayOfYear.ToString() + ((Get-Date).AddDays(-1).DayOfWeek).ToString() | |
| $filterString = "(PartitionKey eq '$datenow' or PartitionKey eq '$dateyesterday')" | |
| $query.FilterString = $filterString | |
| #Execute the query. | |
| $entities = $table.CloudTable.ExecuteQuery($query) | |
| $time = Get-Date –Format yyyyMMdd–HH:mm:ss | |
| $PartitionKey = (Get-Date).Year.ToString() + (Get-Date).DayOfYear.ToString() + ((Get-Date).DayOfWeek).ToString() | |
| # Row Number Variable | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -eq $PartitionKey){ | |
| $rowNumber = ($entities | sort Timestamp | select –Last 1).RowKey -replace("Row");$rowNumber = [INT]$rowNumber;$rowNumber++} | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -ne $PartitionKey){$rowNumber = 1} | |
| # ID number Variable | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -eq $PartitionKey){ | |
| $ID = ($entities | sort Timestamp | select –Last 1).Properties.ID.PropertyAsObject;$ID++} | |
| if(($entities | sort Timestamp | select –Last 1).PartitionKey -ne $PartitionKey){$ID = 1} | |
| $entity = New-Object –TypeName Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity –ArgumentList $partitionKey, "Row$rowNumber" | |
| $entity.Properties.Add("SongPlayed", $song) | |
| $entity.Properties.Add("SongLookup", $songrequest) | |
| $entity.Properties.Add("DistanceNumber", $DistanceNumber) | |
| $entity.Properties.Add("RadioFormat", $RadioFormat) | |
| $entity.Properties.Add("ID", $id) | |
| $entity.Properties.Add("Time", $time) | |
| $table.CloudTable.Execute([Microsoft.WindowsAzure.Storage.Table.TableOperation]::Insert($entity)) | |
| } | |
| function Get-FuzzyMatchScore { | |
| [CmdletBinding()] | |
| param ( | |
| [Parameter(Position = 0)] | |
| [string] $Search, | |
| [Parameter(Position = 1)] | |
| [string] $String | |
| ) | |
| $score = 100 | |
| # Use approximate string matching to get some values needed to calculate the score of the result | |
| $longestCommonSubstring = Get-LongestCommonSubstring –String1 $String –String2 $Search | |
| $levenshteinDistance = Get-LevenshteinDistance –String1 $String –String2 $Search | |
| $commonPrefix = Get-CommonPrefix –String1 $String –String2 $Search | |
| # By running the result through this regex pattern we get the length of the match as well as the | |
| # the index of where the match starts. The shorter the match length and the index, the more | |
| # score will be added for the match. | |
| $regexMatchFilter = $Search.ToCharArray() -join '.*?' | |
| $match = Select-String –InputObject $String –Pattern $regexMatchFilter –AllMatches | |
| $matchLength = ($match.Matches | Sort-Object Length | Select-Object –First 1).Value.Length | |
| $matchIndex = ($match.Matches | Sort-Object Length | Select-Object –First 1).Index | |
| # Calculate score | |
| $score = $score – $levenshteinDistance | |
| $score = $score * $longestCommonSubstring.Length | |
| $score = $score – $matchLength | |
| $score = $score – $matchIndex | |
| if ($commonPrefix) { | |
| $score = $score + $commonPrefix.Length | |
| } | |
| Write-Output $score | |
| } | |
| function Get-HammingDistance { | |
| <# | |
| .SYNOPSIS | |
| Get the Hamming Distance between two strings or two positive integers. | |
| .DESCRIPTION | |
| The Hamming distance between two strings of equal length is the number of positions at which the | |
| corresponding symbols are different. In another way, it measures the minimum number of substitutions | |
| required to change one string into the other, or the minimum number of errors that could have | |
| transformed one string into the other. Note! Even though the original Hamming algorithm only works for | |
| strings of equal length, this function supports strings of unequal length as well. | |
| The function also calculates the Hamming distance between two positive integers (considered as binary | |
| values); that is, it calculates the number of bit substitutions required to change one integer into | |
| the other. | |
| .EXAMPLE | |
| Get-HammingDistance 'karolin' 'kathrin' | |
| Calculate the Hamming distance between the two strings. The result is 3. | |
| .EXAMPLE | |
| Get-HammingDistance 'karolin' 'kathrin' -NormalizedOutput | |
| Calculate the normalized Hamming distance between the two strings. The result is 0.571428571428571. | |
| .EXAMPLE | |
| Get-HammingDistance -Int1 61 -Int2 15 | |
| Calculate the hamming distance between 61 and 15. The result is 3. | |
| .LINK | |
| http://en.wikipedia.org/wiki/Hamming_distance | |
| https://communary.wordpress.com/ | |
| https://github.com/gravejester/Communary.PASM | |
| .NOTES | |
| Author: Øyvind Kallstad | |
| Date: 03.11.2014 | |
| Version: 1.0 | |
| #> | |
| [CmdletBinding(DefaultParameterSetName = 'String')] | |
| param ( | |
| [Parameter(Position = 0, Mandatory = $true, ParameterSetName = 'String')] | |
| [ValidateNotNullOrEmpty()] | |
| [string] $String1, | |
| [Parameter(Position = 1, Mandatory = $true, ParameterSetName = 'String')] | |
| [ValidateNotNullOrEmpty()] | |
| [string] $String2, | |
| [Parameter(Position = 0, Mandatory = $true, ParameterSetName = 'Integer')] | |
| [ValidateNotNullOrEmpty()] | |
| [uint32] $Int1, | |
| [Parameter(Position = 1, Mandatory = $true, ParameterSetName = 'Integer')] | |
| [ValidateNotNullOrEmpty()] | |
| [uint32] $Int2, | |
| # Makes matches case-sensitive. By default, matches are not case-sensitive. | |
| [Parameter(ParameterSetName = 'String')] | |
| [switch] $CaseSensitive, | |
| # Normalize the output value. When the output is not normalized the maximum value is the length of the longest string, and the minimum value is 0, | |
| # meaning that a value of 0 is a 100% match. When the output is normalized you get a value between 0 and 1, where 1 indicates a 100% match. | |
| [Parameter(ParameterSetName = 'String')] | |
| [switch] $NormalizeOutput | |
| ) | |
| try { | |
| if ($PSCmdlet.ParameterSetName -eq 'String') { | |
| # handle case insensitivity | |
| if (-not($CaseSensitive)) { | |
| $String1 = $String1.ToLowerInvariant() | |
| $String2 = $String2.ToLowerInvariant() | |
| } | |
| # set initial distance | |
| $distance = 0 | |
| # get max and min length of the input strings | |
| $maxLength = [Math]::Max($String1.Length,$String2.Length) | |
| $minLength = [Math]::Min($String1.Length,$String2.Length) | |
| # calculate distance for the length of the shortest string | |
| for ($i = 0; $i -lt $minLength; $i++) { | |
| if (-not($String1[$i] -ceq $String2[$i])) { | |
| $distance++ | |
| } | |
| } | |
| # add the remaining length to the distance | |
| $distance = $distance + ($maxLength – $minLength) | |
| if ($NormalizeOutput) { | |
| Write-Output (1 – ($distance / $maxLength)) | |
| } | |
| else { | |
| Write-Output $distance | |
| } | |
| } | |
| else { | |
| $distance = 0 | |
| $value = $Int1 -bxor $Int2 | |
| while ($value -ne 0) { | |
| $distance++ | |
| $value = $value -band ($value – 1) | |
| } | |
| Write-Output $distance | |
| } | |
| } | |
| catch { | |
| Write-Warning $_.Exception.Message | |
| } | |
| } | |
| function Get-LevenshteinDistance { | |
| <# | |
| .SYNOPSIS | |
| Get the Levenshtein distance between two strings. | |
| .DESCRIPTION | |
| The Levenshtein Distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another by counting the minimum number of operations required to transform one string into the other. | |
| .EXAMPLE | |
| Get-LevenshteinDistance 'kitten' 'sitting' | |
| .LINK | |
| http://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C.23 | |
| http://en.wikipedia.org/wiki/Edit_distance | |
| https://communary.wordpress.com/ | |
| https://github.com/gravejester/Communary.PASM | |
| .NOTES | |
| Author: Øyvind Kallstad | |
| Date: 07.11.2014 | |
| Version: 1.0 | |
| #> | |
| [CmdletBinding()] | |
| param( | |
| [Parameter(Position = 0)] | |
| [string]$String1, | |
| [Parameter(Position = 1)] | |
| [string]$String2, | |
| # Makes matches case-sensitive. By default, matches are not case-sensitive. | |
| [Parameter()] | |
| [switch] $CaseSensitive, | |
| # A normalized output will fall in the range 0 (perfect match) to 1 (no match). | |
| [Parameter()] | |
| [switch] $NormalizeOutput | |
| ) | |
| if (-not($CaseSensitive)) { | |
| $String1 = $String1.ToLowerInvariant() | |
| $String2 = $String2.ToLowerInvariant() | |
| } | |
| $d = New-Object 'Int[,]' ($String1.Length + 1), ($String2.Length + 1) | |
| try { | |
| for ($i = 0; $i -le $d.GetUpperBound(0); $i++) { | |
| $d[$i,0] = $i | |
| } | |
| for ($i = 0; $i -le $d.GetUpperBound(1); $i++) { | |
| $d[0,$i] = $i | |
| } | |
| for ($i = 1; $i -le $d.GetUpperBound(0); $i++) { | |
| for ($j = 1; $j -le $d.GetUpperBound(1); $j++) { | |
| $cost = [Convert]::ToInt32((-not($String1[$i–1] -ceq $String2[$j–1]))) | |
| $min1 = $d[($i–1),$j] + 1 | |
| $min2 = $d[$i,($j–1)] + 1 | |
| $min3 = $d[($i–1),($j–1)] + $cost | |
| $d[$i,$j] = [Math]::Min([Math]::Min($min1,$min2),$min3) | |
| } | |
| } | |
| $distance = ($d[$d.GetUpperBound(0),$d.GetUpperBound(1)]) | |
| if ($NormalizeOutput) { | |
| Write-Output (1 – ($distance) / ([Math]::Max($String1.Length,$String2.Length))) | |
| } | |
| else { | |
| Write-Output $distance | |
| } | |
| } | |
| catch { | |
| Write-Warning $_.Exception.Message | |
| } | |
| } | |
| function Get-LongestCommonSubstring { | |
| <# | |
| .SYNOPSIS | |
| Get the longest common substring of two strings. | |
| .DESCRIPTION | |
| Get the longest common substring of two strings. | |
| .EXAMPLE | |
| Get-LongestCommonSubstring 'Karolin' 'kathrin' -CaseSensitive | |
| .LINK | |
| https://fuzzystring.codeplex.com/ | |
| http://en.wikipedia.org/wiki/Longest_common_substring_problem | |
| https://communary.wordpress.com/ | |
| https://github.com/gravejester/Communary.PASM | |
| .NOTES | |
| Adapted to PowerShell from code by Kevin Jones (https://fuzzystring.codeplex.com/) | |
| Author: Øyvind Kallstad | |
| Date: 03.11.2014 | |
| Version: 1.0 | |
| #> | |
| [CmdletBinding()] | |
| param ( | |
| [Parameter(Position = 0)] | |
| [string] $String1, | |
| [Parameter(Position = 1)] | |
| [string] $String2, | |
| [Parameter()] | |
| [switch] $CaseSensitive | |
| ) | |
| if (-not($CaseSensitive)) { | |
| $String1 = $String1.ToLowerInvariant() | |
| $String2 = $String2.ToLowerInvariant() | |
| } | |
| $array = New-Object 'Object[,]' $String1.Length, $String2.Length | |
| $stringBuilder = New-Object System.Text.StringBuilder | |
| $maxLength = 0 | |
| $lastSubsBegin = 0 | |
| for ($i = 0; $i -lt $String1.Length; $i++) { | |
| for ($j = 0; $j -lt $String2.Length; $j++) { | |
| if ($String1[$i] -cne $String2[$j]) { | |
| $array[$i,$j] = 0 | |
| } | |
| else { | |
| if (($i -eq 0) -or ($j -eq 0)) { | |
| $array[$i,$j] = 1 | |
| } | |
| else { | |
| $array[$i,$j] = 1 + $array[($i – 1),($j – 1)] | |
| } | |
| if ($array[$i,$j] -gt $maxLength) { | |
| $maxLength = $array[$i,$j] | |
| $thisSubsBegin = $i – $array[$i,$j] + 1 | |
| if($lastSubsBegin -eq $thisSubsBegin) { | |
| [void]$stringBuilder.Append($String1[$i]) | |
| } | |
| else { | |
| $lastSubsBegin = $thisSubsBegin | |
| $stringBuilder.Length = 0 | |
| [void]$stringBuilder.Append($String1.Substring($lastSubsBegin, (($i + 1) – $lastSubsBegin))) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Write-Output $stringBuilder.ToString() | |
| } | |
| function Get-CommonPrefix { | |
| <# | |
| .SYNOPSIS | |
| Find the common prefix of two strings. | |
| .DESCRIPTION | |
| This function will get the common prefix of two strings; that is, all | |
| the letters that they share, starting from the beginning of the strings. | |
| .EXAMPLE | |
| Get-CommonPrefix 'Card' 'Cartoon' | |
| Will get the common prefix of both string. Should output 'car'. | |
| .LINK | |
| https://communary.wordpress.com/ | |
| https://github.com/gravejester/Communary.PASM | |
| .INPUTS | |
| System.String | |
| .OUTPUTS | |
| System.String | |
| .NOTES | |
| Author: Øyvind Kallstad | |
| Date: 03.11.2014 | |
| Version 1.1 | |
| Dependencies: none | |
| #> | |
| [CmdletBinding()] | |
| param( | |
| [Parameter(Mandatory = $true, Position = 0)] | |
| [ValidateNotNullOrEmpty()] | |
| [string]$String1, | |
| [Parameter(Mandatory = $true, Position = 1)] | |
| [ValidateNotNullOrEmpty()] | |
| [string]$String2, | |
| # Maximum length of the returned prefix. | |
| [Parameter()] | |
| [int]$MaxPrefixLength, | |
| # Makes matches case-sensitive. By default, matches are not case-sensitive. | |
| [Parameter()] | |
| [switch] $CaseSensitive | |
| ) | |
| if (-not($CaseSensitive)) { | |
| $String1 = $String1.ToLowerInvariant() | |
| $String2 = $String2.ToLowerInvariant() | |
| } | |
| $outputString = New-Object 'System.Text.StringBuilder' | |
| $shortestStringLength = [Math]::Min($String1.Length,$String2.Length) | |
| # Let the maximum prefix length be the same as the length of the shortest of | |
| # the two input strings, unless defined by the MaxPrefixLength parameter. | |
| if (($shortestStringLength -lt $MaxPrefixLength) -or ($MaxPrefixLength -eq 0)) { | |
| $MaxPrefixLength = $shortestStringLength | |
| } | |
| # Loop from the start and add any characters found that are equal | |
| for ($i = 0; $i -lt $MaxPrefixLength; $i++) { | |
| if ($String1[$i] -ceq $String2[$i]) { | |
| [void]$outputString.Append($String1[$i]) | |
| } | |
| else { break } | |
| } | |
| Write-Output $outputString.ToString() | |
| } | |
| function FinalActions ($song, $RadioFormat, $eJukeboxHost) { | |
| $songrequest = (($Global:Results | sort –Descending DistanceNumber)[0]).Song | |
| $DistanceNumber = (($Global:Results | sort –Descending DistanceNumber)[0]).DistanceNumber | |
| Write-Host –NoNewline "Song from Lookup: " –ForegroundColor Green; Write-Host $songrequest –ForegroundColor Magenta | |
| Write-Host –NoNewline "Distance Number from Lookup: " –ForegroundColor Green; Write-Host $DistanceNumber –ForegroundColor Magenta | |
| # Song Might be missing, add to Missing Songs Table | |
| if($DistanceNumber -lt '1000'){ | |
| if($WritetoTableStorage -eq 'Yes'){MissingSongsTable $song $songrequest $RadioFormat $DistanceNumber} | |
| } else { # Request the song | |
| if($WritetoTableStorage -eq 'Yes'){SongsTable $songrequest $song $RadioFormat $DistanceNumber} | |
| } | |
| } | |
| while ($true){ | |
| Get-ExistingSongLibrary $Ctx | |
| #endregion | |
| ##################################### | |
| #region Capture Kiis Australia (Sydney/Melbourne) | |
| #Kiis 1065 – Sydney | |
| $matches = @() | |
| Start-Sleep –Seconds 1 | |
| Write-Host "Kiis 1065" | |
| $kiis1065listsong = @() | |
| $uri = (Invoke-WebRequest 'http://media.arn.com.au/xml/mix1065_now.xml').content | |
| Start-Sleep –Seconds 1 | |
| $null = $uri -match '<now_playing>(.|\n)*artist><!\[CDATA\[([^]]*)\]\]></artist(.|\n)*</now_playing>';$artist = $matches[2] | |
| $null = $uri -match '<now_playing>(.|\n)*title\sgeneric="False"><!\[CDATA\[([^]]*)\]\]></title(.|\n)*</now_playing>';$title = $matches[2] | |
| $kiis1065song = "{0} – {1}" -f $artist, $title | |
| Write-Host –NoNewline "Now playing on Kiis 1065 " –ForegroundColor Cyan;Write-Host $kiis1065song –ForegroundColor Yellow | |
| if((!($kiis1065result -eq $kiis1065song)) -and ` | |
| ($kiis1065song -notmatch "Kiis") -and ` | |
| ($kiis1065song -match "..\s-\s..") -and ` | |
| ($kiis1065song -notmatch "Audio Type Changed")){ | |
| $kiis1065result = $kiis1065song | |
| #Write to table | |
| $song = $kiis1065song | |
| #query table entities | |
| #Region Do stuff with the song http://www.ascii-code.com/ | |
| $Cleansong = $kiis1065song -replace '\(.*\)',' ' -replace("&","&") -replace ' ',' ' -replace ' feat. ',' ' ` | |
| -replace ' ft. ',' ' -replace ' ft ',' ' ` | |
| -replace '[\xC0-\xC5]','A' -replace '[\xC8-\xCB]','E' -replace '[\xCC-\xCF]','I' ` | |
| -replace '[\xD2-\xD6]','O' -replace '[\xD9-\xDC]','U' -replace '[\xe8-\xEB]','e' ` | |
| -replace '[\xEC-\xEF]','i' -replace '[\xF2-\xF6]','o' -replace '[\xF9-\xFC]','u' ` | |
| -replace '[\xE0-\xE5]','o' -replace '[\xD1]','N' -replace '[\x91\x92\x60]','\x27' ` | |
| -replace '[\x93\x94]','\x22' -replace '[^\x30-\x39\x41-\x5A\x61-\x7A\x20\x2D\x26\x27\x22\x2E\x2C]+',' ' ` | |
| -replace ' ',' ' -replace 'The ','' | |
| CheckSong $Cleansong | |
| FinalActions $song $RadioFormat $eJukeboxHost | |
| } | |
| ##################################### | |
| ##################################### | |
| #Kiis 1011 – Melbourne | |
| $matches = @() | |
| Start-Sleep –Seconds 1 | |
| Write-Host "Kiis 1011" | |
| $kiis1011listsong = @() | |
| $uri = (Invoke-WebRequest 'http://media.arn.com.au/xml/KIIS1011_now.xml').content | |
| Start-Sleep –Seconds 1 | |
| $null = $uri -match '<now_playing>(.|\n)*artist><!\[CDATA\[([^]]*)\]\]></artist(.|\n)*</now_playing>';$artist = $matches[2] | |
| $null = $uri -match '<now_playing>(.|\n)*title\sgeneric="False"><!\[CDATA\[([^]]*)\]\]></title(.|\n)*</now_playing>';$title = $matches[2] | |
| $kiis1011song = "{0} – {1}" -f $artist, $title | |
| Write-Host –NoNewline "Now playing on Kiis 1011 " –ForegroundColor Cyan;Write-Host $kiis1011song –ForegroundColor Yellow | |
| if((!($kiis1011result -eq $kiis1011song)) -and ` | |
| ($kiis1011song -notmatch "Kiis") -and ` | |
| ($kiis1011song -match "..\s-\s..") -and ` | |
| ($kiis1011song -notmatch "Audio Type Changed")){ | |
| $kiis1011result = $kiis1011song | |
| #Write to table | |
| $song = $kiis1011song | |
| #query table entities | |
| #Region Do stuff with the song http://www.ascii-code.com/ | |
| $Cleansong = $kiis1011song -replace '\(.*\)',' ' -replace("&","&") -replace ' ',' ' -replace ' feat. ',' ' ` | |
| -replace ' ft. ',' ' -replace ' ft ',' ' ` | |
| -replace '[\xC0-\xC5]','A' -replace '[\xC8-\xCB]','E' -replace '[\xCC-\xCF]','I' ` | |
| -replace '[\xD2-\xD6]','O' -replace '[\xD9-\xDC]','U' -replace '[\xe8-\xEB]','e' ` | |
| -replace '[\xEC-\xEF]','i' -replace '[\xF2-\xF6]','o' -replace '[\xF9-\xFC]','u' ` | |
| -replace '[\xE0-\xE5]','o' -replace '[\xD1]','N' -replace '[\x91\x92\x60]','\x27' ` | |
| -replace '[\x93\x94]','\x22' -replace '[^\x30-\x39\x41-\x5A\x61-\x7A\x20\x2D\x26\x27\x22\x2E\x2C]+',' ' ` | |
| -replace ' ',' ' -replace 'The ','' | |
| CheckSong $Cleansong | |
| FinalActions $song $RadioFormat $eJukeboxHost | |
| } | |
| ##################################### | |
| #endregion | |
| } |
Marc Kean 