Badgerati / Pode / #84

pending completion

Build # #84

Build Type

push

appveyor

Committed by

web-flow

Commit Message

<a href="https://github.com/Badgerati/Pode/commit/<a class=hub.com/Badgerati/Pode/commit/7aeac83d779e5346569ab6f2b8209f3ac3f7bda7">7aeac83d7<a href="https://github.com/Badgerati/Pode/commit/7aeac83d779e5346569ab6f2b8209f3ac3f7bda7">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/8093ba82d94c9cca33df8d7ed27951e5912288b9">8093ba82d</a>">8093ba82d</a><a href="https://github.com/Badgerati/Pode/commit/7aeac83d779e5346569ab6f2b8209f3ac3f7bda7"> into b0bd9543e">b0bd9543e</a>

Run Details

148 of 148 new or added lines in 10 files covered. (100.0%)

1856 of 3502 relevant lines covered (53.0%)

0.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

57.61

/src/Tools/Responses.ps1

# write data to http response stream, using a specific content-type
function Text
{
    param (
        [Parameter()]
        [Alias('v')]
        $Value,

        [Parameter()]
        [Alias('ctype', 'ct')]
        [string]
        $ContentType = $null,

        [Parameter()]
        [Alias('a')]
        [int]
        $MaxAge = 3600,

        [switch]
        [Alias('c')]
        $Cache
    )

    # if there's nothing to write, return
    if (Test-Empty $Value) {
        return
    }

    # if the value isn't a string/byte[] then error
    $valueType = $Value.GetType().Name
    if (@('string', 'byte[]') -inotcontains $valueType) {
        throw "Value to write to stream must be a String or Byte[], but got: $($valueType)"
    }

    # if the response stream isn't writable, return
    $res = $WebEvent.Response
    if (($null -eq $res) -or ($null -eq $res.OutputStream) -or !$res.OutputStream.CanWrite) {
        return
    }

    # set a cache value
    if ($Cache) {
        $res.AddHeader('Cache-Control', "max-age=$($MaxAge), must-revalidate")
        $res.AddHeader('Expires', [datetime]::UtcNow.AddSeconds($MaxAge).ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'"))
    }

    # specify the content-type if supplied (adding utf-8 if missing)
    if (!(Test-Empty $ContentType)) {
        $charset = 'charset=utf-8'
        if ($ContentType -inotcontains $charset) {
            $ContentType = "$($ContentType); $($charset)"
        }

        $res.ContentType = $ContentType
    }

    # convert string to bytes
    if ($valueType -ieq 'string') {
        $Value = ConvertFrom-PodeValueToBytes -Value $Value
    }

    # write the content to the response stream
    $res.ContentLength64 = $Value.Length

    try {
        $ms = New-Object -TypeName System.IO.MemoryStream
        $ms.Write($Value, 0, $Value.Length)
        $ms.WriteTo($res.OutputStream)
        $ms.Close()
    }
    catch {
        if ((Test-PodeValidNetworkFailure $_.Exception)) {
            return
        }

        $_.Exception | Out-Default
        throw
    }
}

function File
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNull()]
        [Alias('p')]
        [string]
        $Path,

        [Parameter()]
        [Alias('d')]
        $Data = @{},

        [Parameter()]
        [Alias('ctype', 'ct')]
        [string]
        $ContentType = $null,

        [Parameter()]
        [Alias('a')]
        [int]
        $MaxAge = 3600,

        [switch]
        [Alias('c')]
        $Cache
    )

    # test the file path, and set status accordingly
    if (!(Test-PodePath $Path -FailOnDirectory)) {
        return
    }

    # are we dealing with a dynamic file for the view engine? (ignore html)
    $mainExt = Get-PodeFileExtension -Path $Path -TrimPeriod

    # generate dynamic content
    if (!(Test-Empty $mainExt) -and (($mainExt -ieq 'pode') -or ($mainExt -ieq $PodeContext.Server.ViewEngine.Extension))) {
        $content = Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data

        # get the sub-file extension, if empty, use original
        $subExt = Get-PodeFileExtension -Path (Get-PodeFileName -Path $Path -WithoutExtension) -TrimPeriod
        $subExt = (coalesce $subExt $mainExt)

        $ContentType = (coalesce $ContentType (Get-PodeContentType -Extension $subExt))
        Text -Value $content -ContentType $ContentType
    }

    # this is a static file
    else {
        if (Test-IsPSCore) {
            $content = (Get-Content -Path $Path -Raw -AsByteStream)
        }
        else {
            $content = (Get-Content -Path $Path -Raw -Encoding byte)
        }

        $ContentType = (coalesce $ContentType (Get-PodeContentType -Extension $mainExt))
        Text -Value $content -ContentType $ContentType -MaxAge $MaxAge -Cache:$Cache
    }
}

function Attach
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [Alias('p')]
        [string]
        $Path
    )

    # only attach files from public/static-route directories
    $Path = Get-PodeStaticRoutePath -Route $Path

    # test the file path, and set status accordingly
    if (!(Test-PodePath $Path)) {
        return
    }

    $filename = Get-PodeFileName -Path $Path
    $ext = Get-PodeFileExtension -Path $Path -TrimPeriod

    # open up the file as a stream
    $fs = (Get-Item $Path).OpenRead()

    # setup the response details and headers
    $WebEvent.Response.ContentLength64 = $fs.Length
    $WebEvent.Response.SendChunked = $false
    $WebEvent.Response.ContentType = (Get-PodeContentType -Extension $ext)
    $WebEvent.Response.AddHeader('Content-Disposition', "attachment; filename=$($filename)")

    # set file as an attachment on the response
    $buffer = [byte[]]::new(64 * 1024)
    $read = 0

    while (($read = $fs.Read($buffer, 0, $buffer.Length)) -gt 0) {
        $WebEvent.Response.OutputStream.Write($buffer, 0, $read)
    }

    dispose $fs
}

function Save
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [Alias('n')]
        [string]
        $Name,

        [Parameter()]
        [Alias('p')]
        [string]
        $Path = '.'
    )

    # if path is '.', replace with server root
    if ($Path -match '^\.[\\/]{0,1}') {
        $Path = $Path -replace '^\.[\\/]{0,1}', ''
        $Path = Join-Path $PodeContext.Server.Root $Path
    }

    # ensure the parameter name exists in data
    $fileName = $WebEvent.Data[$Name]
    if (Test-Empty $fileName) {
        throw "A parameter called '$($Name)' was not supplied in the request"
    }

    # ensure the file data exists
    if (!$WebEvent.Files.ContainsKey($fileName)) {
        throw "No data for file '$($fileName)' was uploaded in the request"
    }

    # if the path is a directory, add the filename
    if (Test-PodePathIsDirectory -Path $Path) {
        $Path = Join-Path $Path $fileName
    }

    # save the file
    [System.IO.File]::WriteAllBytes($Path, $WebEvent.Files[$fileName].Bytes)
}

function Status
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNull()]
        [Alias('c')]
        [int]
        $Code,

        [Parameter()]
        [Alias('d')]
        [string]
        $Description,

        [Parameter()]
        [Alias('e')]
        $Exception,

        [Parameter()]
        [Alias('ctype', 'ct')]
        [string]
        $ContentType = $null,

        [switch]
        [Alias('nopage')]
        $NoErrorPage
    )

    # set the code
    $WebEvent.Response.StatusCode = $Code

    # set an appropriate description (mapping if supplied is blank)
    if (Test-Empty $Description) {
        $Description = (Get-PodeStatusDescription -StatusCode $Code)
    }

    if (!(Test-Empty $Description)) {
        $WebEvent.Response.StatusDescription = $Description
    }

    # if the status code is >=400 then attempt to load error page
    if (!$NoErrorPage -and ($Code -ge 400)) {
        Show-PodeErrorPage -Code $Code -Description $Description -Exception $Exception -ContentType $ContentType
    }
}

function Redirect
{
    param (
        [Parameter()]
        [Alias('u')]
        [string]
        $Url,

        [Parameter()]
        [Alias('p')]
        [int]
        $Port = 0,

        [Parameter()]
        [ValidateSet('', 'HTTP', 'HTTPS')]
        [Alias('pr')]
        [string]
        $Protocol,

        [Parameter()]
        [Alias('e')]
        [string]
        $Endpoint,

        [switch]
        [Alias('m')]
        $Moved
    )

    if (Test-Empty $Url) {
        $uri = $WebEvent.Request.Url

        # set the protocol
        $Protocol = $Protocol.ToLowerInvariant()
        if (Test-Empty $Protocol) {
            $Protocol = $uri.Scheme
        }

        # set the endpoint
        if (Test-Empty $Endpoint) {
            $Endpoint = $uri.Host
        }

        # set the port
        if ($Port -le 0) {
            $Port = $uri.Port
        }

        $PortStr = [string]::Empty
        if ($Port -ne 80 -and $Port -ne 443) {
            $PortStr = ":$($Port)"
        }

        # combine to form the url
        $Url = "$($Protocol)://$($Endpoint)$($PortStr)$($uri.PathAndQuery)"
    }

    $WebEvent.Response.RedirectLocation = $Url

    if ($Moved) {
        status 301 'Moved'
    }
    else {
        status 302 'Redirect'
    }
}

function Json
{
    param (
        [Parameter()]
        [Alias('v')]
        $Value,

        [switch]
        $File
    )

    if ($File) {
        # test the file path, and set status accordingly
        if (!(Test-PodePath $Value)) {
            return
        }
        else {
            $Value = Get-PodeFileContent -Path $Value
        }
    }
    elseif (Test-Empty $Value) {
        $Value = '{}'
    }
    elseif ((Get-PodeType $Value).Name -ine 'string') {
        $Value = ($Value | ConvertTo-Json -Depth 10 -Compress)
    }

    Text -Value $Value -ContentType 'application/json'
}

function Csv
{
    param (
        [Parameter(Mandatory=$true)]
        [Alias('v')]
        $Value,

        [switch]
        $File
    )

    if ($File) {
        # test the file path, and set status accordingly
        if (!(Test-PodePath $Value)) {
            return
        }
        else {
            $Value = Get-PodeFileContent -Path $Value
        }
    }
    elseif (Test-Empty $Value) {
        $Value = [string]::Empty
    }
    elseif ((Get-PodeType $Value).Name -ine 'string') {
        $Value = ($Value | ForEach-Object {
            New-Object psobject -Property $_
        })

        if (Test-IsPSCore) {
            $Value = ($Value | ConvertTo-Csv -Delimiter ',' -IncludeTypeInformation:$false)
        }
        else {
            $Value = ($Value | ConvertTo-Csv -Delimiter ',' -NoTypeInformation)
        }
    }

    Text -Value $Value -ContentType 'text/csv'
}

function Xml
{
    param (
        [Parameter(Mandatory=$true)]
        [Alias('v')]
        $Value,

        [switch]
        $File
    )

    if ($File) {
        # test the file path, and set status accordingly
        if (!(Test-PodePath $Value)) {
            return
        }
        else {
            $Value = Get-PodeFileContent -Path $Value
        }
    }
    elseif (Test-Empty $value) {
        $Value = [string]::Empty
    }
    elseif ((Get-PodeType $Value).Name -ine 'string') {
        $Value = ($value | ForEach-Object {
            New-Object psobject -Property $_
        })

        $Value = ($Value | ConvertTo-Xml -Depth 10 -As String -NoTypeInformation)
    }

    Text -Value $Value -ContentType 'text/xml'
}

function Html
{
    param (
        [Parameter(Mandatory=$true)]
        [Alias('v')]
        $Value,

        [switch]
        $File
    )

    if ($File) {
        # test the file path, and set status accordingly
        if (!(Test-PodePath $Value)) {
            return
        }
        else {
            $Value = Get-PodeFileContent -Path $Value
        }
    }
    elseif (Test-Empty $value) {
        $Value = [string]::Empty
    }
    elseif ((Get-PodeType $Value).Name -ine 'string') {
        $Value = ($Value | ConvertTo-Html)
    }

    Text -Value $Value -ContentType 'text/html'
}

# include helper to import the content of a view into another view
function Include
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [Alias('p')]
        [string]
        $Path,

        [Parameter()]
        [Alias('d')]
        $Data = @{}
    )

    # default data if null
    if ($null -eq $Data) {
        $Data = @{}
    }

    # add view engine extension
    $ext = Get-PodeFileExtension -Path $Path
    if (Test-Empty $ext) {
        $Path += ".$($PodeContext.Server.ViewEngine.Extension)"
    }

    # only look in the view directory
    $Path = (Join-Path $PodeContext.Server.InbuiltDrives['views'] $Path)

    # test the file path, and set status accordingly
    if (!(Test-PodePath $Path -NoStatus)) {
        throw "File not found at path: $($Path)"
    }

    # run any engine logic
    return (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)
}

function Show-PodeErrorPage
{
    param (
        [Parameter()]
        [int]
        $Code,

        [Parameter()]
        [string]
        $Description,

        [Parameter()]
        $Exception,

        [Parameter()]
        [string]
        $ContentType
    )

    # error page info
    $errorPage = Find-PodeErrorPage -Code $Code -ContentType $ContentType

    # if no page found, return
    if (Test-Empty $errorPage) {
        return
    }

    # if exception trace showing enabled then build the exception details object
    $ex = $null
    if (!(Test-Empty $Exception) -and $PodeContext.Server.Web.ErrorPages.ShowExceptions) {
        $ex = @{
            'Message' = [System.Web.HttpUtility]::HtmlEncode($Exception.Exception.Message);
            'StackTrace' = [System.Web.HttpUtility]::HtmlEncode($Exception.ScriptStackTrace);
            'Line' = [System.Web.HttpUtility]::HtmlEncode($Exception.InvocationInfo.PositionMessage);
            'Category' = [System.Web.HttpUtility]::HtmlEncode($Exception.CategoryInfo.ToString());
        }
    }

    # setup the data object for dynamic pages
    $data = @{
        'Url' = (Get-PodeUrl);
        'Status' = @{
            'Code' = $Code;
            'Description' = $Description;
        };
        'Exception' = $ex;
        'ContentType' = $errorPage.ContentType;
    }

    # write the error page to the stream
    File -Path $errorPage.Path -Data $data -ContentType $errorPage.ContentType
}

function View
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNull()]
        [Alias('p')]
        $Path,

        [Parameter()]
        [Alias('d')]
        $Data = @{},

        [switch]
        [Alias('fm')]
        $FlashMessages
    )

    # default data if null
    if ($null -eq $Data) {
        $Data = @{}
    }

    # add path to data as "pagename" - unless key already exists
    if (!$Data.ContainsKey('pagename')) {
        $Data['pagename'] = $Path
    }

    # load all flash messages if needed
    if ($FlashMessages -and !(Test-Empty $WebEvent.Session.Data.Flash)) {
        $Data['flash'] = @{}

        foreach ($key in (flash keys)) {
            $Data.flash[$key] = (flash get $key)
        }
    }
    elseif (Test-Empty $Data['flash']) {
        $Data['flash'] = @{}
    }

    # add view engine extension
    $ext = Get-PodeFileExtension -Path $Path
    if (Test-Empty $ext) {
        $Path += ".$($PodeContext.Server.ViewEngine.Extension)"
    }

    # only look in the view directory
    $Path = (Join-Path $PodeContext.Server.InbuiltDrives['views'] $Path)

    # test the file path, and set status accordingly
    if (!(Test-PodePath $Path)) {
        return
    }

    # run any engine logic and render it
    html -Value (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)
}

function Close-PodeTcpConnection
{
    param (
        [Parameter()]
        $Client,

        [switch]
        $Quit
    )

    if ($null -eq $Client) {
        $Client = $TcpEvent.Client
    }

    if ($null -ne $Client) {
        if ($Quit -and $Client.Connected) {
            tcp write '221 Bye'
        }

        dispose $Client -Close
    }
}

function Tcp
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateSet('write', 'read')]
        [Alias('a')]
        [string]
        $Action,

        [Parameter()]
        [Alias('m')]
        [string]
        $Message,

        [Parameter()]
        [Alias('c')]
        $Client
    )

    if ($null -eq $Client) {
        $Client = $TcpEvent.Client
    }

    switch ($Action.ToLowerInvariant())
    {
        'write' {
            $encoder = New-Object System.Text.ASCIIEncoding
            $buffer = $encoder.GetBytes("$($Message)`r`n")
            $stream = $Client.GetStream()
            await $stream.WriteAsync($buffer, 0, $buffer.Length)
            $stream.Flush()
        }

        'read' {
            $bytes = New-Object byte[] 8192
            $encoder = New-Object System.Text.ASCIIEncoding
            $stream = $Client.GetStream()
            $bytesRead = (await $stream.ReadAsync($bytes, 0, 8192))
            return $encoder.GetString($bytes, 0, $bytesRead)
        }
    }
}

1	# write data to http response stream, using a specific content-type
2	function Text
3	{
4	param (
5	[Parameter()]
6	[Alias('v')]
7	$Value,
8
9	[Parameter()]
10	[Alias('ctype', 'ct')]
11	[string]
12	$ContentType = $null,
13
14	[Parameter()]
15	[Alias('a')]
16	[int]
17	$MaxAge = 3600,
18
19	[switch]
20	[Alias('c')]
21	$Cache
22	)
23
24	# if there's nothing to write, return
25	if (Test-Empty $Value) {	1✔
26	return
27	}
28
29	# if the value isn't a string/byte[] then error
30	$valueType = $Value.GetType().Name	1✔
31	if (@('string', 'byte[]') -inotcontains $valueType) {	2✔
32	throw "Value to write to stream must be a String or Byte[], but got: $($valueType)"	2✔
33	}
34
35	# if the response stream isn't writable, return
36	$res = $WebEvent.Response	1✔
37	if (($null -eq $res) -or ($null -eq $res.OutputStream) -or !$res.OutputStream.CanWrite) {	3✔
38	return
39	}
40
41	# set a cache value
42	if ($Cache) {	×
43	$res.AddHeader('Cache-Control', "max-age=$($MaxAge), must-revalidate")	×
44	$res.AddHeader('Expires', [datetime]::UtcNow.AddSeconds($MaxAge).ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'"))	×
45	}
46
47	# specify the content-type if supplied (adding utf-8 if missing)
48	if (!(Test-Empty $ContentType)) {	×
49	$charset = 'charset=utf-8'	×
50	if ($ContentType -inotcontains $charset) {	×
51	$ContentType = "$($ContentType); $($charset)"	×
52	}
53
54	$res.ContentType = $ContentType	×
55	}
56
57	# convert string to bytes
58	if ($valueType -ieq 'string') {	×
59	$Value = ConvertFrom-PodeValueToBytes -Value $Value	×
60	}
61
62	# write the content to the response stream
63	$res.ContentLength64 = $Value.Length	×
64
65	try {
66	$ms = New-Object -TypeName System.IO.MemoryStream	×
67	$ms.Write($Value, 0, $Value.Length)	×
68	$ms.WriteTo($res.OutputStream)	×
69	$ms.Close()	×
70	}
71	catch {
72	if ((Test-PodeValidNetworkFailure $_.Exception)) {	×
73	return
74	}
75
76	$_.Exception \| Out-Default	×
77	throw
78	}
79	}
80
81	function File
82	{
83	param (
84	[Parameter(Mandatory=$true)]
85	[ValidateNotNull()]
86	[Alias('p')]
87	[string]
88	$Path,
89
90	[Parameter()]
91	[Alias('d')]
92	$Data = @{},
93
94	[Parameter()]
95	[Alias('ctype', 'ct')]
96	[string]
97	$ContentType = $null,
98
99	[Parameter()]
100	[Alias('a')]
101	[int]
102	$MaxAge = 3600,
103
104	[switch]
105	[Alias('c')]
106	$Cache
107	)
108
109	# test the file path, and set status accordingly
110	if (!(Test-PodePath $Path -FailOnDirectory)) {	2✔
111	return
112	}
113
114	# are we dealing with a dynamic file for the view engine? (ignore html)
115	$mainExt = Get-PodeFileExtension -Path $Path -TrimPeriod	1✔
116
117	# generate dynamic content
118	if (!(Test-Empty $mainExt) -and (($mainExt -ieq 'pode') -or ($mainExt -ieq $PodeContext.Server.ViewEngine.Extension))) {	5✔
119	$content = Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data	1✔
120
121	# get the sub-file extension, if empty, use original
122	$subExt = Get-PodeFileExtension -Path (Get-PodeFileName -Path $Path -WithoutExtension) -TrimPeriod	2✔
123	$subExt = (coalesce $subExt $mainExt)	2✔
124
125	$ContentType = (coalesce $ContentType (Get-PodeContentType -Extension $subExt))	3✔
126	Text -Value $content -ContentType $ContentType	1✔
127	}
128
129	# this is a static file
130	else {
131	if (Test-IsPSCore) {	×
132	$content = (Get-Content -Path $Path -Raw -AsByteStream)	×
133	}
134	else {
135	$content = (Get-Content -Path $Path -Raw -Encoding byte)	×
136	}
137
138	$ContentType = (coalesce $ContentType (Get-PodeContentType -Extension $mainExt))	×
139	Text -Value $content -ContentType $ContentType -MaxAge $MaxAge -Cache:$Cache	×
140	}
141	}
142
143	function Attach
144	{
145	param (
146	[Parameter(Mandatory=$true)]
147	[ValidateNotNullOrEmpty()]
148	[Alias('p')]
149	[string]
150	$Path
151	)
152
153	# only attach files from public/static-route directories
154	$Path = Get-PodeStaticRoutePath -Route $Path	×
155
156	# test the file path, and set status accordingly
157	if (!(Test-PodePath $Path)) {	×
158	return
159	}
160
161	$filename = Get-PodeFileName -Path $Path	×
162	$ext = Get-PodeFileExtension -Path $Path -TrimPeriod	×
163
164	# open up the file as a stream
165	$fs = (Get-Item $Path).OpenRead()	×
166
167	# setup the response details and headers
168	$WebEvent.Response.ContentLength64 = $fs.Length	×
169	$WebEvent.Response.SendChunked = $false	×
170	$WebEvent.Response.ContentType = (Get-PodeContentType -Extension $ext)	×
171	$WebEvent.Response.AddHeader('Content-Disposition', "attachment; filename=$($filename)")	×
172
173	# set file as an attachment on the response
174	$buffer = [byte[]]::new(64 * 1024)	×
175	$read = 0	×
176
177	while (($read = $fs.Read($buffer, 0, $buffer.Length)) -gt 0) {	×
178	$WebEvent.Response.OutputStream.Write($buffer, 0, $read)	×
179	}
180
181	dispose $fs	×
182	}
183
184	function Save
185	{
186	param (
187	[Parameter(Mandatory=$true)]
188	[ValidateNotNullOrEmpty()]
189	[Alias('n')]
190	[string]
191	$Name,
192
193	[Parameter()]
194	[Alias('p')]
195	[string]
196	$Path = '.'
197	)
198
199	# if path is '.', replace with server root
200	if ($Path -match '^\.[\\/]{0,1}') {	×
201	$Path = $Path -replace '^\.[\\/]{0,1}', ''	×
202	$Path = Join-Path $PodeContext.Server.Root $Path	×
203	}
204
205	# ensure the parameter name exists in data
206	$fileName = $WebEvent.Data[$Name]	×
207	if (Test-Empty $fileName) {	×
208	throw "A parameter called '$($Name)' was not supplied in the request"	×
209	}
210
211	# ensure the file data exists
212	if (!$WebEvent.Files.ContainsKey($fileName)) {	×
213	throw "No data for file '$($fileName)' was uploaded in the request"	×
214	}
215
216	# if the path is a directory, add the filename
217	if (Test-PodePathIsDirectory -Path $Path) {	×
218	$Path = Join-Path $Path $fileName	×
219	}
220
221	# save the file
222	[System.IO.File]::WriteAllBytes($Path, $WebEvent.Files[$fileName].Bytes)	×
223	}
224
225	function Status
226	{
227	param (
228	[Parameter(Mandatory=$true)]
229	[ValidateNotNull()]
230	[Alias('c')]
231	[int]
232	$Code,
233
234	[Parameter()]
235	[Alias('d')]
236	[string]
237	$Description,
238
239	[Parameter()]
240	[Alias('e')]
241	$Exception,
242
243	[Parameter()]
244	[Alias('ctype', 'ct')]
245	[string]
246	$ContentType = $null,
247
248	[switch]
249	[Alias('nopage')]
250	$NoErrorPage
251	)
252
253	# set the code
254	$WebEvent.Response.StatusCode = $Code	1✔
255
256	# set an appropriate description (mapping if supplied is blank)
257	if (Test-Empty $Description) {	1✔
258	$Description = (Get-PodeStatusDescription -StatusCode $Code)	2✔
259	}
260
261	if (!(Test-Empty $Description)) {	2✔
262	$WebEvent.Response.StatusDescription = $Description	1✔
263	}
264
265	# if the status code is >=400 then attempt to load error page
266	if (!$NoErrorPage -and ($Code -ge 400)) {	2✔
267	Show-PodeErrorPage -Code $Code -Description $Description -Exception $Exception -ContentType $ContentType	1✔
268	}
269	}
270
271	function Redirect
272	{
273	param (
274	[Parameter()]
275	[Alias('u')]
276	[string]
277	$Url,
278
279	[Parameter()]
280	[Alias('p')]
281	[int]
282	$Port = 0,
283
284	[Parameter()]
285	[ValidateSet('', 'HTTP', 'HTTPS')]
286	[Alias('pr')]
287	[string]
288	$Protocol,
289
290	[Parameter()]
291	[Alias('e')]
292	[string]
293	$Endpoint,
294
295	[switch]
296	[Alias('m')]
297	$Moved
298	)
299
300	if (Test-Empty $Url) {	1✔
301	$uri = $WebEvent.Request.Url	1✔
302
303	# set the protocol
304	$Protocol = $Protocol.ToLowerInvariant()	1✔
305	if (Test-Empty $Protocol) {	1✔
306	$Protocol = $uri.Scheme	1✔
307	}
308
309	# set the endpoint
310	if (Test-Empty $Endpoint) {	1✔
311	$Endpoint = $uri.Host	1✔
312	}
313
314	# set the port
315	if ($Port -le 0) {	1✔
316	$Port = $uri.Port	1✔
317	}
318
319	$PortStr = [string]::Empty	1✔
320	if ($Port -ne 80 -and $Port -ne 443) {	1✔
321	$PortStr = ":$($Port)"	2✔
322	}
323
324	# combine to form the url
325	$Url = "$($Protocol)://$($Endpoint)$($PortStr)$($uri.PathAndQuery)"	5✔
326	}
327
328	$WebEvent.Response.RedirectLocation = $Url	1✔
329
330	if ($Moved) {	1✔
331	status 301 'Moved'	1✔
332	}
333	else {
334	status 302 'Redirect'	1✔
335	}
336	}
337
338	function Json
339	{
340	param (
341	[Parameter()]
342	[Alias('v')]
343	$Value,
344
345	[switch]
346	$File
347	)
348
349	if ($File) {	1✔
350	# test the file path, and set status accordingly
351	if (!(Test-PodePath $Value)) {	2✔
352	return
353	}
354	else {
355	$Value = Get-PodeFileContent -Path $Value	1✔
356	}
357	}
358	elseif (Test-Empty $Value) {	1✔
359	$Value = '{}'	1✔
360	}
361	elseif ((Get-PodeType $Value).Name -ine 'string') {	2✔
362	$Value = ($Value \| ConvertTo-Json -Depth 10 -Compress)	3✔
363	}
364
365	Text -Value $Value -ContentType 'application/json'	1✔
366	}
367
368	function Csv
369	{
370	param (
371	[Parameter(Mandatory=$true)]
372	[Alias('v')]
373	$Value,
374
375	[switch]
376	$File
377	)
378
379	if ($File) {	1✔
380	# test the file path, and set status accordingly
381	if (!(Test-PodePath $Value)) {	2✔
382	return
383	}
384	else {
385	$Value = Get-PodeFileContent -Path $Value	1✔
386	}
387	}
388	elseif (Test-Empty $Value) {	1✔
389	$Value = [string]::Empty	1✔
390	}
391	elseif ((Get-PodeType $Value).Name -ine 'string') {	2✔
392	$Value = ($Value \| ForEach-Object {	3✔
393	New-Object psobject -Property $_	1✔
394	})
395
396	if (Test-IsPSCore) {	1✔
397	$Value = ($Value \| ConvertTo-Csv -Delimiter ',' -IncludeTypeInformation:$false)	×
398	}
399	else {
400	$Value = ($Value \| ConvertTo-Csv -Delimiter ',' -NoTypeInformation)	3✔
401	}
402	}
403
404	Text -Value $Value -ContentType 'text/csv'	1✔
405	}
406
407	function Xml
408	{
409	param (
410	[Parameter(Mandatory=$true)]
411	[Alias('v')]
412	$Value,
413
414	[switch]
415	$File
416	)
417
418	if ($File) {	1✔
419	# test the file path, and set status accordingly
420	if (!(Test-PodePath $Value)) {	2✔
421	return
422	}
423	else {
424	$Value = Get-PodeFileContent -Path $Value	1✔
425	}
426	}
427	elseif (Test-Empty $value) {	1✔
428	$Value = [string]::Empty	1✔
429	}
430	elseif ((Get-PodeType $Value).Name -ine 'string') {	2✔
431	$Value = ($value \| ForEach-Object {	3✔
432	New-Object psobject -Property $_	1✔
433	})
434
435	$Value = ($Value \| ConvertTo-Xml -Depth 10 -As String -NoTypeInformation)	3✔
436	}
437
438	Text -Value $Value -ContentType 'text/xml'	1✔
439	}
440
441	function Html
442	{
443	param (
444	[Parameter(Mandatory=$true)]
445	[Alias('v')]
446	$Value,
447
448	[switch]
449	$File
450	)
451
452	if ($File) {	1✔
453	# test the file path, and set status accordingly
454	if (!(Test-PodePath $Value)) {	2✔
455	return
456	}
457	else {
458	$Value = Get-PodeFileContent -Path $Value	1✔
459	}
460	}
461	elseif (Test-Empty $value) {	1✔
462	$Value = [string]::Empty	1✔
463	}
464	elseif ((Get-PodeType $Value).Name -ine 'string') {	2✔
465	$Value = ($Value \| ConvertTo-Html)	3✔
466	}
467
468	Text -Value $Value -ContentType 'text/html'	1✔
469	}
470
471	# include helper to import the content of a view into another view
472	function Include
473	{
474	param (
475	[Parameter(Mandatory=$true)]
476	[ValidateNotNullOrEmpty()]
477	[Alias('p')]
478	[string]
479	$Path,
480
481	[Parameter()]
482	[Alias('d')]
483	$Data = @{}
484	)
485
486	# default data if null
487	if ($null -eq $Data) {	1✔
488	$Data = @{}	×
489	}
490
491	# add view engine extension
492	$ext = Get-PodeFileExtension -Path $Path	1✔
493	if (Test-Empty $ext) {	1✔
494	$Path += ".$($PodeContext.Server.ViewEngine.Extension)"	2✔
495	}
496
497	# only look in the view directory
498	$Path = (Join-Path $PodeContext.Server.InbuiltDrives['views'] $Path)	2✔
499
500	# test the file path, and set status accordingly
501	if (!(Test-PodePath $Path -NoStatus)) {	2✔
502	throw "File not found at path: $($Path)"	2✔
503	}
504
505	# run any engine logic
506	return (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)	2✔
507	}
508
509	function Show-PodeErrorPage
510	{
511	param (
512	[Parameter()]
513	[int]
514	$Code,
515
516	[Parameter()]
517	[string]
518	$Description,
519
520	[Parameter()]
521	$Exception,
522
523	[Parameter()]
524	[string]
525	$ContentType
526	)
527
528	# error page info
529	$errorPage = Find-PodeErrorPage -Code $Code -ContentType $ContentType	1✔
530
531	# if no page found, return
532	if (Test-Empty $errorPage) {	1✔
533	return
534	}
535
536	# if exception trace showing enabled then build the exception details object
537	$ex = $null	1✔
538	if (!(Test-Empty $Exception) -and $PodeContext.Server.Web.ErrorPages.ShowExceptions) {	2✔
539	$ex = @{	1✔
540	'Message' = [System.Web.HttpUtility]::HtmlEncode($Exception.Exception.Message);	1✔
541	'StackTrace' = [System.Web.HttpUtility]::HtmlEncode($Exception.ScriptStackTrace);	1✔
542	'Line' = [System.Web.HttpUtility]::HtmlEncode($Exception.InvocationInfo.PositionMessage);	1✔
543	'Category' = [System.Web.HttpUtility]::HtmlEncode($Exception.CategoryInfo.ToString());	1✔
544	}
545	}
546
547	# setup the data object for dynamic pages
548	$data = @{	1✔
549	'Url' = (Get-PodeUrl);	2✔
550	'Status' = @{	1✔
551	'Code' = $Code;	1✔
552	'Description' = $Description;	1✔
553	};
554	'Exception' = $ex;	1✔
555	'ContentType' = $errorPage.ContentType;	1✔
556	}
557
558	# write the error page to the stream
559	File -Path $errorPage.Path -Data $data -ContentType $errorPage.ContentType	1✔
560	}
561
562	function View
563	{
564	param (
565	[Parameter(Mandatory=$true)]
566	[ValidateNotNull()]
567	[Alias('p')]
568	$Path,
569
570	[Parameter()]
571	[Alias('d')]
572	$Data = @{},
573
574	[switch]
575	[Alias('fm')]
576	$FlashMessages
577	)
578
579	# default data if null
580	if ($null -eq $Data) {	×
581	$Data = @{}	×
582	}
583
584	# add path to data as "pagename" - unless key already exists
585	if (!$Data.ContainsKey('pagename')) {	×
586	$Data['pagename'] = $Path	×
587	}
588
589	# load all flash messages if needed
590	if ($FlashMessages -and !(Test-Empty $WebEvent.Session.Data.Flash)) {	×
591	$Data['flash'] = @{}	×
592
593	foreach ($key in (flash keys)) {	×
594	$Data.flash[$key] = (flash get $key)	×
595	}
596	}
597	elseif (Test-Empty $Data['flash']) {	×
598	$Data['flash'] = @{}	×
599	}
600
601	# add view engine extension
602	$ext = Get-PodeFileExtension -Path $Path	×
603	if (Test-Empty $ext) {	×
604	$Path += ".$($PodeContext.Server.ViewEngine.Extension)"	×
605	}
606
607	# only look in the view directory
608	$Path = (Join-Path $PodeContext.Server.InbuiltDrives['views'] $Path)	×
609
610	# test the file path, and set status accordingly
611	if (!(Test-PodePath $Path)) {	×
612	return
613	}
614
615	# run any engine logic and render it
616	html -Value (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)	×
617	}
618
619	function Close-PodeTcpConnection
620	{
621	param (
622	[Parameter()]
623	$Client,
624
625	[switch]
626	$Quit
627	)
628
629	if ($null -eq $Client) {	1✔
630	$Client = $TcpEvent.Client	1✔
631	}
632
633	if ($null -ne $Client) {	1✔
634	if ($Quit -and $Client.Connected) {	1✔
635	tcp write '221 Bye'	1✔
636	}
637
638	dispose $Client -Close	1✔
639	}
640	}
641
642	function Tcp
643	{
644	param (
645	[Parameter(Mandatory=$true)]
646	[ValidateSet('write', 'read')]
647	[Alias('a')]
648	[string]
649	$Action,
650
651	[Parameter()]
652	[Alias('m')]
653	[string]
654	$Message,
655
656	[Parameter()]
657	[Alias('c')]
658	$Client
659	)
660
661	if ($null -eq $Client) {	×
662	$Client = $TcpEvent.Client	×
663	}
664
665	switch ($Action.ToLowerInvariant())	×
666	{
667	'write' {
668	$encoder = New-Object System.Text.ASCIIEncoding	×
669	$buffer = $encoder.GetBytes("$($Message)`r`n")	×
670	$stream = $Client.GetStream()	×
671	await $stream.WriteAsync($buffer, 0, $buffer.Length)	×
672	$stream.Flush()	×
673	}
674
675	'read' {
676	$bytes = New-Object byte[] 8192	×
677	$encoder = New-Object System.Text.ASCIIEncoding	×
678	$stream = $Client.GetStream()	×
679	$bytesRead = (await $stream.ReadAsync($bytes, 0, 8192))	×
680	return $encoder.GetString($bytes, 0, $bytesRead)	×
681	}
682	}
683	}

Badgerati / Pode / #84

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous