@blickwerk/n8n-nodes-microsoft-planner 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Blickwerk Media UG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# n8n-nodes-microsoft-planner
+
+This is an n8n community node that allows you to interact with Microsoft Planner in your n8n workflows.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.
+
+[Microsoft Planner](https://www.microsoft.com/en-us/microsoft-365/business/task-management-software) is a task management tool that helps teams organize, assign, and collaborate on tasks.
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+### Community Node
+
+1. Go to **Settings > Community Nodes** in your n8n instance
+2. Select **Install**
+3. Enter `n8n-nodes-microsoft-planner` in **Enter npm package name**
+4. Agree to the [risks](https://docs.n8n.io/integrations/community-nodes/risks/) of using community nodes
+5. Select **Install**
+
+After installing the node, you can use it like any other node in your workflows.
+
+### Manual Installation
+
+To install manually from source:
+
+```bash
+npm install n8n-nodes-microsoft-planner
+```
+
+## Prerequisites
+
+You need to have:
+- An active Microsoft 365 subscription
+- A Microsoft Planner plan created
+- Azure AD App Registration with the following API permissions:
+  - `Tasks.ReadWrite` - Read and write tasks
+  - `Group.ReadWrite.All` - Read and write all groups (required for Planner)
+
+## Setting up Azure AD App
+
+1. Go to [Azure Portal](https://portal.azure.com/)
+2. Navigate to **Azure Active Directory > App registrations**
+3. Click **New registration**
+4. Give it a name (e.g., "n8n Microsoft Planner Integration")
+5. Select **Accounts in this organizational directory only**
+6. Add redirect URI: `https://your-n8n-instance.com/rest/oauth2-credential/callback`
+7. Click **Register**
+
+### Configure API Permissions
+
+1. Go to **API permissions**
+2. Click **Add a permission**
+3. Select **Microsoft Graph**
+4. Select **Delegated permissions**
+5. Add the following permissions:
+   - `Tasks.ReadWrite`
+   - `Group.ReadWrite.All`
+6. Click **Grant admin consent**
+
+### Create Client Secret
+
+1. Go to **Certificates & secrets**
+2. Click **New client secret**
+3. Add a description and select expiration
+4. Copy the **Value** (you won't see it again!)
+
+### Get Application Details
+
+- **Client ID**: Found on the app overview page
+- **Client Secret**: The value you copied in the previous step
+
+## Credentials
+
+Configure the Microsoft Planner OAuth2 API credentials in n8n:
+
+1. In n8n, go to **Credentials > New**
+2. Search for **Microsoft Planner OAuth2 API**
+3. Enter your **Client ID** and **Client Secret**
+4. Click **Connect my account**
+5. Complete the OAuth flow
+
+## Operations
+
+### Task
+
+- **Create** - Create a new task
+- **Get** - Get a task by ID
+- **Get Many** - Get multiple tasks from a plan or bucket
+- **Update** - Update an existing task
+- **Delete** - Delete a task
+
+## Usage
+
+### Creating a Task
+
+To create a task, you need:
+- **Plan ID**: The ID of the plan
+- **Bucket ID**: The ID of the bucket within the plan
+- **Title**: The task title
+
+Optional fields:
+- Description
+- Priority (0-10, where 0 is most urgent)
+- Due Date Time
+- Start Date Time
+- Percent Complete
+
+### Getting Tasks
+
+You can retrieve tasks by:
+- **Task ID**: Get a specific task
+- **Plan ID**: Get all tasks in a plan
+- **Bucket ID**: Get all tasks in a bucket
+
+### Updating a Task
+
+To update a task, provide the Task ID and the fields you want to update.
+
+### Finding Plan and Bucket IDs
+
+You can find Plan IDs and Bucket IDs using the Microsoft Graph Explorer:
+
+1. Go to [Microsoft Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer)
+2. Sign in with your Microsoft account
+3. Use these queries:
+   - Get all plans: `GET https://graph.microsoft.com/v1.0/me/planner/plans`
+   - Get buckets in a plan: `GET https://graph.microsoft.com/v1.0/planner/plans/{plan-id}/buckets`
+
+## Compatibility
+
+Tested with n8n version 1.0.0 and above.
+
+## Resources
+
+- [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
+- [Microsoft Graph Planner API documentation](https://docs.microsoft.com/en-us/graph/api/resources/planner-overview)
+- [Microsoft Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer)
+
+## Version History
+
+### 1.0.0
+- Initial release
+- Support for creating and retrieving Planner tasks
+- OAuth2 authentication
+
+## License
+
+[MIT](LICENSE.md)
+
+## Author
+
+Developed by **Blickwerk Media UG**
+
+## Support
+
+For issues, questions, or contributions, please visit the [GitHub repository](https://github.com/blickwerk/n8n-nodes-microsoft-planner).

package/dist/credentials/MicrosoftPlannerOAuth2Api.credentials.d.ts

@@ -0,0 +1,10 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class MicrosoftPlannerOAuth2Api implements ICredentialType {
+    name: string;
+    extends: string[];
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/MicrosoftPlannerOAuth2Api.credentials.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftPlannerOAuth2Api = void 0;
+class MicrosoftPlannerOAuth2Api {
+    constructor() {
+        this.name = 'microsoftPlannerOAuth2Api';
+        this.extends = ['oAuth2Api'];
+        this.displayName = 'Microsoft Planner OAuth2 API';
+        this.documentationUrl = 'https://docs.microsoft.com/en-us/graph/auth-v2-user';
+        this.properties = [
+            {
+                displayName: 'Grant Type',
+                name: 'grantType',
+                type: 'hidden',
+                default: 'authorizationCode',
+            },
+            {
+                displayName: 'Authorization URL',
+                name: 'authUrl',
+                type: 'hidden',
+                default: 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize',
+                required: true,
+            },
+            {
+                displayName: 'Access Token URL',
+                name: 'accessTokenUrl',
+                type: 'hidden',
+                default: 'https://login.microsoftonline.com/common/oauth2/v2.0/token',
+                required: true,
+            },
+            {
+                displayName: 'Scope',
+                name: 'scope',
+                type: 'hidden',
+                default: 'openid offline_access Tasks.ReadWrite Group.ReadWrite.All',
+            },
+            {
+                displayName: 'Auth URI Query Parameters',
+                name: 'authQueryParameters',
+                type: 'hidden',
+                default: 'response_mode=query',
+            },
+            {
+                displayName: 'Authentication',
+                name: 'authentication',
+                type: 'hidden',
+                default: 'body',
+            },
+            {
+                displayName: 'Client ID',
+                name: 'clientId',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Client Secret',
+                name: 'clientSecret',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '={{$credentials.tokenType}} {{$credentials.accessToken}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://graph.microsoft.com/v1.0',
+                url: '/me',
+            },
+        };
+    }
+}
+exports.MicrosoftPlannerOAuth2Api = MicrosoftPlannerOAuth2Api;

package/dist/nodes/MicrosoftPlanner/GenericFunctions.d.ts

@@ -0,0 +1,4 @@
+import { IDataObject, IExecuteFunctions, IHookFunctions, IHttpRequestMethods, ILoadOptionsFunctions } from 'n8n-workflow';
+export declare function microsoftApiRequest(this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions, method: IHttpRequestMethods, resource: string, body?: IDataObject, qs?: IDataObject, uri?: string, headers?: IDataObject): Promise<any>;
+export declare function microsoftApiRequestAllItems(this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions, propertyName: string, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, query?: IDataObject): Promise<any>;
+export declare function cleanETag(eTag: string): string;

package/dist/nodes/MicrosoftPlanner/GenericFunctions.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microsoftApiRequest = microsoftApiRequest;
+exports.microsoftApiRequestAllItems = microsoftApiRequestAllItems;
+exports.cleanETag = cleanETag;
+const n8n_workflow_1 = require("n8n-workflow");
+async function microsoftApiRequest(method, resource, body = {}, qs = {}, uri, headers = {}) {
+    const options = {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method,
+        body,
+        qs,
+        url: uri || `https://graph.microsoft.com/v1.0${resource}`,
+        json: true,
+    };
+    try {
+        if (Object.keys(headers).length !== 0) {
+            options.headers = Object.assign({}, options.headers, headers);
+        }
+        if (Object.keys(body).length === 0) {
+            delete options.body;
+        }
+        return await this.helpers.requestOAuth2.call(this, 'microsoftPlannerOAuth2Api', options);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+async function microsoftApiRequestAllItems(propertyName, method, endpoint, body = {}, query = {}) {
+    const returnData = [];
+    let responseData;
+    let uri;
+    do {
+        responseData = await microsoftApiRequest.call(this, method, endpoint, body, query, uri);
+        uri = responseData['@odata.nextLink'];
+        returnData.push.apply(returnData, responseData[propertyName]);
+    } while (responseData['@odata.nextLink'] !== undefined);
+    return returnData;
+}
+function cleanETag(eTag) {
+    if (eTag.startsWith('W/"') || eTag.startsWith("W/'")) {
+        return eTag.substring(2);
+    }
+    return eTag;
+}

package/dist/nodes/MicrosoftPlanner/MicrosoftPlanner.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class MicrosoftPlanner implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/MicrosoftPlanner/MicrosoftPlanner.node.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftPlanner = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+const TaskDescription_1 = require("./TaskDescription");
+class MicrosoftPlanner {
+    constructor() {
+        this.description = {
+            displayName: 'Microsoft Planner',
+            name: 'microsoftPlanner',
+            icon: 'file:planner.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Create and retrieve tasks in Microsoft Planner',
+            defaults: {
+                name: 'Microsoft Planner',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'microsoftPlannerOAuth2Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Task',
+                            value: 'task',
+                        },
+                    ],
+                    default: 'task',
+                },
+                ...TaskDescription_1.taskOperations,
+                ...TaskDescription_1.taskFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'task') {
+                    // ----------------------------------
+                    //         task:create
+                    // ----------------------------------
+                    if (operation === 'create') {
+                        const planId = this.getNodeParameter('planId', i);
+                        const bucketId = this.getNodeParameter('bucketId', i);
+                        const title = this.getNodeParameter('title', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = {
+                            planId,
+                            bucketId,
+                            title,
+                        };
+                        if (additionalFields.priority !== undefined) {
+                            body.priority = additionalFields.priority;
+                        }
+                        if (additionalFields.dueDateTime) {
+                            body.dueDateTime = additionalFields.dueDateTime;
+                        }
+                        if (additionalFields.startDateTime) {
+                            body.startDateTime = additionalFields.startDateTime;
+                        }
+                        if (additionalFields.percentComplete !== undefined) {
+                            body.percentComplete = additionalFields.percentComplete;
+                        }
+                        const responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'POST', '/planner/tasks', body);
+                        // Add description if provided
+                        if (additionalFields.description) {
+                            const details = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${responseData.id}/details`);
+                            const eTag = (0, GenericFunctions_1.cleanETag)(details['@odata.etag']);
+                            await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/planner/tasks/${responseData.id}/details`, {
+                                description: additionalFields.description,
+                            }, {}, undefined, {
+                                'If-Match': eTag,
+                            });
+                            responseData.description = additionalFields.description;
+                        }
+                        returnData.push(responseData);
+                    }
+                    // ----------------------------------
+                    //         task:get
+                    // ----------------------------------
+                    if (operation === 'get') {
+                        const taskId = this.getNodeParameter('taskId', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${taskId}`);
+                        if (additionalFields.includeDetails) {
+                            const details = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${taskId}/details`);
+                            responseData.details = details;
+                        }
+                        returnData.push(responseData);
+                    }
+                    // ----------------------------------
+                    //         task:getAll
+                    // ----------------------------------
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const filters = this.getNodeParameter('filters', i);
+                        let endpoint = '';
+                        if (filters.planId) {
+                            endpoint = `/planner/plans/${filters.planId}/tasks`;
+                        }
+                        else if (filters.bucketId) {
+                            endpoint = `/planner/buckets/${filters.bucketId}/tasks`;
+                        }
+                        else {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'You must specify either a Plan ID or Bucket ID to retrieve tasks', { itemIndex: i });
+                        }
+                        if (returnAll) {
+                            const responseData = await GenericFunctions_1.microsoftApiRequestAllItems.call(this, 'value', 'GET', endpoint);
+                            returnData.push(...responseData);
+                        }
+                        else {
+                            const limit = this.getNodeParameter('limit', i);
+                            const responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', endpoint, {}, {
+                                $top: limit,
+                            });
+                            returnData.push(...responseData.value);
+                        }
+                    }
+                    // ----------------------------------
+                    //         task:update
+                    // ----------------------------------
+                    if (operation === 'update') {
+                        const taskId = this.getNodeParameter('taskId', i);
+                        const updateFields = this.getNodeParameter('updateFields', i);
+                        // Get current task to retrieve eTag
+                        const currentTask = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${taskId}`);
+                        const eTag = (0, GenericFunctions_1.cleanETag)(currentTask['@odata.etag']);
+                        const body = {};
+                        if (updateFields.title) {
+                            body.title = updateFields.title;
+                        }
+                        if (updateFields.priority !== undefined) {
+                            body.priority = updateFields.priority;
+                        }
+                        if (updateFields.dueDateTime) {
+                            body.dueDateTime = updateFields.dueDateTime;
+                        }
+                        if (updateFields.startDateTime) {
+                            body.startDateTime = updateFields.startDateTime;
+                        }
+                        if (updateFields.percentComplete !== undefined) {
+                            body.percentComplete = updateFields.percentComplete;
+                        }
+                        if (updateFields.bucketId) {
+                            body.bucketId = updateFields.bucketId;
+                        }
+                        const responseData = await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/planner/tasks/${taskId}`, body, {}, undefined, {
+                            'If-Match': eTag,
+                        });
+                        // Update description if provided
+                        if (updateFields.description) {
+                            const details = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${taskId}/details`);
+                            const detailsETag = (0, GenericFunctions_1.cleanETag)(details['@odata.etag']);
+                            await GenericFunctions_1.microsoftApiRequest.call(this, 'PATCH', `/planner/tasks/${taskId}/details`, {
+                                description: updateFields.description,
+                            }, {}, undefined, {
+                                'If-Match': detailsETag,
+                            });
+                        }
+                        returnData.push(responseData);
+                    }
+                    // ----------------------------------
+                    //         task:delete
+                    // ----------------------------------
+                    if (operation === 'delete') {
+                        const taskId = this.getNodeParameter('taskId', i);
+                        // Get current task to retrieve eTag
+                        const currentTask = await GenericFunctions_1.microsoftApiRequest.call(this, 'GET', `/planner/tasks/${taskId}`);
+                        const eTag = (0, GenericFunctions_1.cleanETag)(currentTask['@odata.etag']);
+                        await GenericFunctions_1.microsoftApiRequest.call(this, 'DELETE', `/planner/tasks/${taskId}`, {}, {}, undefined, {
+                            'If-Match': eTag,
+                        });
+                        returnData.push({ success: true, taskId });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    returnData.push({ error: errorMessage });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [this.helpers.returnJsonArray(returnData)];
+    }
+}
+exports.MicrosoftPlanner = MicrosoftPlanner;

package/dist/nodes/MicrosoftPlanner/TaskDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const taskOperations: INodeProperties[];
+export declare const taskFields: INodeProperties[];

package/dist/nodes/MicrosoftPlanner/TaskDescription.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskFields = exports.taskOperations = void 0;
+exports.taskOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['task'],
+            },
+        },
+        options: [
+            {
+                name: 'Create',
+                value: 'create',
+                description: 'Create a new task',
+                action: 'Create a task',
+            },
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a task',
+                action: 'Get a task',
+            },
+            {
+                name: 'Get Many',
+                value: 'getAll',
+                description: 'Get many tasks',
+                action: 'Get many tasks',
+            },
+            {
+                name: 'Update',
+                value: 'update',
+                description: 'Update a task',
+                action: 'Update a task',
+            },
+            {
+                name: 'Delete',
+                value: 'delete',
+                description: 'Delete a task',
+                action: 'Delete a task',
+            },
+        ],
+        default: 'create',
+    },
+];
+exports.taskFields = [
+    // ----------------------------------
+    //         task:create
+    // ----------------------------------
+    {
+        displayName: 'Plan ID',
+        name: 'planId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['create'],
+            },
+        },
+        default: '',
+        description: 'The ID of the plan to which the task belongs',
+    },
+    {
+        displayName: 'Bucket ID',
+        name: 'bucketId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['create'],
+            },
+        },
+        default: '',
+        description: 'The ID of the bucket to which the task belongs',
+    },
+    {
+        displayName: 'Title',
+        name: 'title',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['create'],
+            },
+        },
+        default: '',
+        description: 'Title of the task',
+    },
+    {
+        displayName: 'Additional Fields',
+        name: 'additionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['create'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Description',
+                name: 'description',
+                type: 'string',
+                typeOptions: {
+                    rows: 5,
+                },
+                default: '',
+                description: 'Description of the task',
+            },
+            {
+                displayName: 'Priority',
+                name: 'priority',
+                type: 'number',
+                default: 5,
+                description: 'Priority of the task (0-10, where 0 is most urgent)',
+            },
+            {
+                displayName: 'Due Date Time',
+                name: 'dueDateTime',
+                type: 'dateTime',
+                default: '',
+                description: 'Due date and time for the task',
+            },
+            {
+                displayName: 'Start Date Time',
+                name: 'startDateTime',
+                type: 'dateTime',
+                default: '',
+                description: 'Start date and time for the task',
+            },
+            {
+                displayName: 'Percent Complete',
+                name: 'percentComplete',
+                type: 'number',
+                default: 0,
+                description: 'Percentage of task completion (0-100)',
+            },
+        ],
+    },
+    // ----------------------------------
+    //         task:get
+    // ----------------------------------
+    {
+        displayName: 'Task ID',
+        name: 'taskId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['get', 'delete', 'update'],
+            },
+        },
+        default: '',
+        description: 'The ID of the task',
+    },
+    {
+        displayName: 'Additional Fields',
+        name: 'additionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['get'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Include Details',
+                name: 'includeDetails',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include task details (description, checklist, etc.)',
+            },
+        ],
+    },
+    // ----------------------------------
+    //         task:getAll
+    // ----------------------------------
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['getAll'],
+            },
+        },
+        default: false,
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['getAll'],
+                returnAll: [false],
+            },
+        },
+        typeOptions: {
+            minValue: 1,
+            maxValue: 500,
+        },
+        default: 100,
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['getAll'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Plan ID',
+                name: 'planId',
+                type: 'string',
+                default: '',
+                description: 'Filter tasks by plan ID',
+            },
+            {
+                displayName: 'Bucket ID',
+                name: 'bucketId',
+                type: 'string',
+                default: '',
+                description: 'Filter tasks by bucket ID',
+            },
+        ],
+    },
+    // ----------------------------------
+    //         task:update
+    // ----------------------------------
+    {
+        displayName: 'Update Fields',
+        name: 'updateFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['task'],
+                operation: ['update'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Title',
+                name: 'title',
+                type: 'string',
+                default: '',
+                description: 'Title of the task',
+            },
+            {
+                displayName: 'Description',
+                name: 'description',
+                type: 'string',
+                typeOptions: {
+                    rows: 5,
+                },
+                default: '',
+                description: 'Description of the task',
+            },
+            {
+                displayName: 'Priority',
+                name: 'priority',
+                type: 'number',
+                default: 5,
+                description: 'Priority of the task (0-10, where 0 is most urgent)',
+            },
+            {
+                displayName: 'Due Date Time',
+                name: 'dueDateTime',
+                type: 'dateTime',
+                default: '',
+                description: 'Due date and time for the task',
+            },
+            {
+                displayName: 'Start Date Time',
+                name: 'startDateTime',
+                type: 'dateTime',
+                default: '',
+                description: 'Start date and time for the task',
+            },
+            {
+                displayName: 'Percent Complete',
+                name: 'percentComplete',
+                type: 'number',
+                default: 0,
+                description: 'Percentage of task completion (0-100)',
+            },
+            {
+                displayName: 'Bucket ID',
+                name: 'bucketId',
+                type: 'string',
+                default: '',
+                description: 'Move task to a different bucket',
+            },
+        ],
+    },
+];

package/dist/nodes/MicrosoftPlanner/planner.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="a" x1="16" y1="2.5" x2="16" y2="29.5" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#31ad5f"/>
+      <stop offset="1" stop-color="#1d6f42"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2.5" width="28" height="27" rx="1.5" fill="url(#a)"/>
+  <path d="M7 9h7v2H7zm0 4h10v2H7zm0 4h8v2H7z" fill="#fff"/>
+  <circle cx="22" cy="10" r="2.5" fill="#fff"/>
+  <circle cx="22" cy="15" r="2.5" fill="#fff"/>
+  <circle cx="22" cy="20" r="2.5" fill="#fff"/>
+</svg>

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@blickwerk/n8n-nodes-microsoft-planner",
+  "version": "1.0.0",
+  "description": "n8n node for Microsoft Planner - Create and retrieve tasks",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "microsoft",
+    "planner",
+    "tasks"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/blickwerk/n8n-nodes-microsoft-planner",
+  "author": {
+    "name": "Blickwerk Media UG",
+    "email": "info@blickwerk-media.de"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blickwerk/n8n-nodes-microsoft-planner.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes credentials package.json",
+    "lintfix": "eslint nodes credentials package.json --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/MicrosoftPlannerOAuth2Api.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/MicrosoftPlanner/MicrosoftPlanner.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^5.59.0",
+    "eslint": "^8.40.0",
+    "eslint-plugin-n8n-nodes-base": "^1.12.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^2.8.8",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "n8n-core": "^1.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "^1.0.0"
+  }
+}