11th November 2023
Creación de un módulo Notion PowerShell: Parte 3
Sobre la base de los dos tutoriales anteriores de Notion, ha aprendido cómo crear un token de integración de Notion y recuperar, actualizar y eliminar bloques de Notion a través de PowerShell y la API de Notion.
Aún más poderosas son las bases de datos de Notion. Las bases de datos relacionales ayudan a organizar los datos de forma lógica y brindan oportunidades de análisis. Con Notion, almacene páginas dentro de Bases de datos con propiedades adicionales. En este tutorial, aprenderá a crear una página, una base de datos y un elemento de base de datos. Aproveche el módulo Notion PowerShell para continuar ampliando la funcionalidad.
Requisitos previos
Para seguir este tutorial, solo necesita una cuenta de Notion y Potencia Shell; aquí, se utiliza PowerShell v7.3.7.
El poder de las bases de datos de nociones
Aunque puede pensar que las páginas son independientes, en Notion también son parte integral de las bases de datos. Por tanto, combinar las operaciones de la Página con las de las Bases de Datos ayuda a comprender el vínculo. En Notion, las bases de datos pueden tener propiedades de muchos tipos diferentes, como selecciones, casillas de verificación o números.
Creando una página
Primero, necesita un lugar para colocar la base de datos. Para demostrar esto, crear una nueva página usando el /pages punto final. La resultante id será el GUID utilizado como parent_id de la nueva Base de Datos.
$APIKey = 'secret_sK5Qir0UAgkLF1iauP5iMsq1vq3YW5S9o5GvF7M8PjK'
$APIURI = 'https://api.notion.com/v1'
$APIVersion = '2022-06-28'
$GUID = 'a2b3646d-e941-4df4-874d-56153139b618'
$Params = @{
"Headers" = @{
"Authorization" = "Bearer {0}" -F $APIKey
"Content-type" = "application/json"
"Notion-Version" = "{0}" -F $APIVersion
}
"Method" = 'POST'
"URI" = ("{0}/pages" -F $APIURI, [GUID]::new($GUID))
"Body" = @{
"parent" = @{
"type" = 'page_id'
"page_id" = $GUID
}
"properties" = @{
"title" = @(
@{
"text" = @{"content" = "Test" }
}
)
}
"children" = @()
} | ConvertTo-JSON -Depth 100
}
$Result = Invoke-RestMethod @ParamsCreando la base de datos
Con la página recién creada, utilizará el page_id padre con el /databases punto final para crear una nueva base de datos con un título único requerido propiedad. Hay un requerido title propiedad que también le da a la base de datos su nombre único.
$Params = @{
"Headers" = @{
"Authorization" = "Bearer {0}" -F $APIKey
"Content-type" = "application/json"
"Notion-Version" = "{0}" -F $APIVersion
}
"Method" = 'POST'
"URI" = ("{0}/databases" -F $APIURI)
"Body" = @{
"parent" = @{
"type" = "page_id"
"page_id" = $Result.id
}
"title" = @(
@{
"type" = "text"
"text" = @{
"content" = "Test"
"link" = $null
}
}
)
"properties" = @{
"Name" = @{
"type" = "title"
"title" = @{}
}
"Checkbox" = @{
"type" = "checkbox"
"checkbox" = @{}
}
"Number" = @{
"type" = "number"
"number" = @{
"format" = "number_with_commas"
}
}
}
} | ConvertTo-Json -Depth 100
}
$Result = Invoke-RestMethod @Params
Crear una página en la base de datos
Finalmente, para almacenar datos dentro de la base de datos, debe crear un nuevo elemento: una página de Notion completa. Como el elemento de la página existe en la base de datos, tiene el beneficio adicional de tener propiedades adicionales. En el ejemplo anterior, creó un caja y número propiedad.
$Params = @{
"Headers" = @{
"Authorization" = "Bearer {0}" -F $APIKey
"Content-type" = "application/json"
"Notion-Version" = "{0}" -F $APIVersion
}
"Method" = 'POST'
"URI" = ("{0}/pages" -F $APIURI)
"Body" = @{
"parent" = @{
"type" = "database_id"
"database_id" = $Result.id
}
"properties" = @{
"Name" = @{
"title" = @(
@{
"text" = @{"content" = "This is a Test Task"}
}
)
}
"Checkbox" = @{
"checkbox" = $True
}
"Number" = @{
"number" = 1000
}
}
} | ConvertTo-Json -Depth 100
}
$Result = Invoke-RestMethod @Params
Agregar al módulo
Para completar el módulo, se crearán tres nuevas funciones. Estas funciones serán:
New-NotionPageNew-NotionDatabase
Quizás te preguntes por qué no hay un New-NotionDatabase. Como técnicamente estás llamando al mismo punto final, /pagestanto para Bases de datos como para Páginas, puede ampliar su New-NotionPage función para cubrir ambos casos de uso.
En esta función se introduce el concepto de conjuntos de parámetros. Los conjuntos de parámetros ofrecen una manera de separar los parámetros en agrupaciones lógicas y solo permiten aquellos que van juntos. A continuación se define el DefaultParameterSetName dentro de CmdletBinding declaración. Esto proporciona un valor predeterminado para la función.
Es necesario definir todos los conjuntos de parámetros a los que pertenece cada parámetro. Si un parámetro debe estar en ambos, entonces se deben utilizar múltiples declaraciones.
Nueva página de nociones
Function New-NotionPage {
[CmdletBinding(SupportsShouldProcess = $True, DefaultParameterSetName="Page")]
Param(
[String]$APIKey,
[String]$APIVersion,
[ValidateScript( { [System.URI]::IsWellFormedUriString( $_ ,[System.UriKind]::Absolute ) } )][String]$APIURI,
[Parameter(ValueFromPipelineByPropertyName = $True)]
[Alias("ID")]
[ValidateScript( { Try { If ( [GUID]::Parse( $_ ) ) { $True } } Catch { $False } } )][String]$GUID,
[Parameter(Mandatory, ParameterSetName="Page")]
$Title,
$Content,
[Parameter(ParameterSetName="Database")]
$Properties,
[Parameter(ParameterSetName="Database")]
[Switch]$Database
)
Process {
$Body = @{
"parent" = $Null
"properties" = $Null
}
If ($Database) {
$Body.properties = $Properties
$Body.parent = @{
"type" = 'database_id'
"database_id" = [GUID]::New($GUID)
}
} Else {
$Body.parent = @{
"type" = 'page_id'
"page_id" = [GUID]::New($GUID)
}
$Body.properties = @{
"title" = @(
@{
"text" = @{ "content" = $Title }
}
)
}
}
If ($Content) {
$Body.Add("children", $content)
}
Write-Verbose ($Body | Out-String)
$Params = @{
"Headers" = @{
"Authorization" = "Bearer {0}" -F $APIKey
"Content-type" = "application/json"
"Notion-Version" = "{0}" -F $APIVersion
}
"Method" = 'POST'
"URI" = ("{0}/pages" -F $APIURI)
"Body" = $Body | ConvertTo-JSON -Depth 100
}
Write-Verbose "[Process] Params: $($Params | Out-String)"
If ($PSCmdlet.ShouldProcess($GUID,"Adding Page")) {
Try {
$Result = Invoke-RestMethod @Params -ErrorAction 'Stop'
} Catch {
$Message = ($Error[0].ErrorDetails.Message | ConvertFrom-JSON).message
Write-Error "Command Failed to Run: $Message"
}
If ($Result) {
$Result
}
}
}
}Nueva base de datos de nociones
Function New-NotionDatabase {
[CmdletBinding(SupportsShouldProcess = $True)]
Param(
[String]$APIKey,
[String]$APIVersion,
[ValidateScript( { [System.URI]::IsWellFormedUriString( $_ ,[System.UriKind]::Absolute ) } )][String]$APIURI,
[Parameter(ValueFromPipelineByPropertyName = $True)]
[Alias("ID")]
[ValidateScript( { Try { If ( [GUID]::Parse( $_ ) ) { $True } } Catch { $False } } )][String]$GUID,
[Parameter(Mandatory)]
$Title,
$Properties
)
Process {
$Params = @{
"Headers" = @{
"Authorization" = "Bearer {0}" -F $APIKey
"Content-type" = "application/json"
"Notion-Version" = "{0}" -F $APIVersion
}
"Method" = 'POST'
"URI" = ("{0}/databases" -F $APIURI)
"Body" = @{
"parent" = @{
"type" = 'page_id'
"page_id" = [GUID]::New($GUID)
}
"title" = @(
@{
"type" = "text"
"text" = @{
"content" = $Title
"link" = $Null
}
}
)
"properties" = $Properties
} | ConvertTo-JSON -Depth 100
}
Write-Verbose "[Process] Params: $($Params | Out-String)"
If ($PSCmdlet.ShouldProcess($GUID,"Adding Database")) {
Try {
$Result = Invoke-RestMethod @Params -ErrorAction 'Stop'
} Catch {
$Message = ($Error[0].ErrorDetails.Message | ConvertFrom-JSON).message
Write-Error "Command Failed to Run: $Message"
}
If ($Result) {
$Result
}
}
}
}Cuando se ejecutan juntos, puede ver que los resultados son los mismos que si ejecutara las llamadas API individuales, pero en una nomenclatura más fácil de usar. Al pasar los objetos resultantes de las llamadas anteriores, puede simplificar la creación de páginas y objetos secundarios.
$Parent="a2b3646de9414df4874d56153139b618"
$Result = New-NotionPage -GUID $Parent -Title "Database Page"
$Database = New-NotionDatabase -GUID $Result.id -Title "Test Database" -Properties @{
"Name" = @{
"type" = "title"
"title" = @{}
}
"Checkbox" = @{
"type" = "checkbox"
"checkbox" = @{}
}
"Number" = @{
"type" = "number"
"number" = @{
"format" = "number_with_commas"
}
}
}
$Item = New-NotionPage -Database -GUID $Database.id -Properties @{
"Name" = @{
"title" = @(
@{
"text" = @{"content" = "This is a Test Task"}
}
)
}
"Checkbox" = @{
"checkbox" = $True
}
"Number" = @{
"number" = 1000
}
}
Próximos pasos
El siguiente paso es agregar algunas funciones de soporte al módulo para crear una escritura más sólida de los tipos de bloques disponibles y una usabilidad adicional. ¡Los siguientes artículos resumirán la función y terminarán de crear un módulo utilizable y con todas las funciones!
Leave a comment