mudhorn/n8n
1
0
Fork 0
mirror of https://github.com/n8n-io/n8n.git synced 2024-11-10 14:44:05 -08:00
Code Issues Actions Packages Projects Releases Wiki Activity
n8n/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts

2288 lines
57 KiB
TypeScript
Raw Blame History

import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
ILoadOptionsFunctions,
INodeExecutionData,
INodePropertyOptions,
INodeType,
INodeTypeDescription,
} from 'n8n-workflow';
import {
campaignFieldsMetadata,
mailchimpApiRequest,
mailchimpApiRequestAllItems,
validateJSON,
} from './GenericFunctions';
import moment from 'moment';
enum Status {
subscribe = 'subscribe',
unsubscribed = 'unsubscribe',
cleaned = 'cleaned',
pending = 'pending',
transactional = 'transactional',
}
interface ILocation {
latitude?: number;
longitude?: number;
}
interface ICreateMemberBody {
listId: string;
email_address: string;
email_type?: string;
status?: Status;
language?: string;
vip?: boolean;
location?: ILocation;
ip_signup?: string;
timestamp_signup?: string;
ip_opt?: string;
timestamp_opt?: string;
tags?: string[];
merge_fields?: IDataObject;
interests?: IDataObject;
}
export class Mailchimp implements INodeType {
description: INodeTypeDescription = {
displayName: 'Mailchimp',
name: 'mailchimp',
icon: 'file:mailchimp.svg',
group: ['output'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Consume Mailchimp API',
defaults: {
name: 'Mailchimp',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'mailchimpApi',
required: true,
displayOptions: {
show: {
authentication: [
'apiKey',
],
},
},
},
{
name: 'mailchimpOAuth2Api',
required: true,
displayOptions: {
show: {
authentication: [
'oAuth2',
],
},
},
},
],
properties: [
{
displayName: 'Authentication',
name: 'authentication',
type: 'options',
options: [
{
name: 'API Key',
value: 'apiKey',
},
{
name: 'OAuth2',
value: 'oAuth2',
},
],
default: 'apiKey',
},
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Campaign',
value: 'campaign',
},
{
name: 'List Group',
value: 'listGroup',
},
{
name: 'Member',
value: 'member',
},
{
name: 'Member Tag',
value: 'memberTag',
},
],
default: 'member',
required: true,
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
required: true,
displayOptions: {
show: {
resource: [
'member',
],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a new member on list',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete a member on list',
},
{
name: 'Get',
value: 'get',
description: 'Get a member on list',
},
{
name: 'Get All',
value: 'getAll',
description: 'Get all members on list',
},
{
name: 'Update',
value: 'update',
description: 'Update a new member on list',
},
],
default: 'create',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
required: true,
displayOptions: {
show: {
resource: [
'memberTag',
],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Add tags from a list member',
},
{
name: 'Delete',
value: 'delete',
description: 'Remove tags from a list member',
},
],
default: 'create',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
required: true,
displayOptions: {
show: {
resource: [
'listGroup',
],
},
},
options: [
{
name: 'Get All',
value: 'getAll',
description: 'Get all groups',
},
],
default: 'getAll',
},
{
displayName: 'Operation',
name: 'operation',
type:'options',
noDataExpression: true,
required: true,
displayOptions : {
show: {
resource: [
'campaign',
],
},
},
options: [
{
name: 'Delete',
value: 'delete',
description: 'Delete a campaign',
},
{
name: 'Get',
value: 'get',
description: 'Get a campaign',
},
{
name: 'Get All',
value: 'getAll',
description: 'Get all the campaigns',
},
{
name: 'Replicate',
value: 'replicate',
description: 'Replicate a campaign',
},
{
name: 'Resend',
value: 'resend',
description: 'Creates a Resend to Non-Openers version of this campaign',
},
{
name: 'Send',
value: 'send',
description: 'Send a campaign',
},
],
default: 'getAll',
},
/* -------------------------------------------------------------------------- */
/* member:create */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'create',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Email',
name: 'email',
type: 'string',
placeholder: 'name@email.com',
required: true,
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'create',
],
},
},
default: '',
description: 'Email address for a subscriber',
},
{
displayName: 'Status',
name: 'status',
type: 'options',
required: true,
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'create',
],
},
},
options: [
{
name: 'Cleaned',
value: 'cleaned',
},
{
name: 'Pending',
value: 'pending',
},
{
name: 'Subscribed',
value: 'subscribed',
},
{
name: 'Transactional',
value: 'transactional',
},
{
name: 'Unsubscribed',
value: 'unsubscribed',
},
],
default: '',
description: 'Subscriber\'s current status',
},
{
displayName: 'JSON Parameters',
name: 'jsonParameters',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
},
},
options: [
{
displayName: 'Email Type',
name: 'emailType',
type: 'options',
options: [
{
name: 'HTML',
value: 'html',
},
{
name: 'Text',
value: 'text',
},
],
default: '',
description: 'Type of email this member asked to get',
},
{
displayName: 'Language',
name: 'language',
type: 'string',
default: '',
description: 'If set/detected, the subscriber\'s language',
},
{
displayName: 'Opt-in IP',
name: 'ipOptIn',
type: 'string',
default: '',
description: 'The IP address the subscriber used to confirm their opt-in status',
},
{
displayName: 'Signup IP',
name: 'ipSignup',
type: 'string',
default: '',
description: 'IP address the subscriber signed up from',
},
{
displayName: 'Signup Timestamp',
name: 'timestampSignup',
type: 'dateTime',
default: '',
description: 'The date and time the subscriber signed up for the list in ISO 8601 format',
},
{
displayName: 'Tags',
name: 'tags',
type: 'string',
default: '',
description: 'The tags that are associated with a member separeted by ,',
},
{
displayName: 'Vip',
name: 'vip',
type: 'boolean',
default: false,
// eslint-disable-next-line n8n-nodes-base/node-param-description-boolean-without-whether
description: 'Vip status for subscribers',
},
{
displayName: 'Opt-in Timestamp',
name: 'timestampOpt',
type: 'dateTime',
default: '',
description: 'The date and time the subscribe confirmed their opt-in status in ISO 8601 format',
},
],
},
{
displayName: 'Location',
name: 'locationFieldsUi',
type: 'fixedCollection',
placeholder: 'Add Location',
default: {},
description: 'Subscriber location information.n',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
false,
],
},
},
options: [
{
name: 'locationFieldsValues',
displayName: 'Location',
values: [
{
displayName: 'Latitude',
name: 'latitude',
type: 'string',
required: true,
description: 'The location latitude',
default: '',
},
{
displayName: 'Longitude',
name: 'longitude',
type: 'string',
required: true,
description: 'The location longitude',
default: '',
},
],
},
],
},
{
displayName: 'Merge Fields',
name: 'mergeFieldsUi',
placeholder: 'Add Merge Fields',
type: 'fixedCollection',
default: {},
typeOptions: {
multipleValues: true,
},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
false,
],
},
},
description: 'An individual merge var and value for a member',
options: [
{
name: 'mergeFieldsValues',
displayName: 'Field',
typeOptions: {
multipleValueButtonText: 'Add Field',
},
values: [
{
displayName: 'Field Name or ID',
name: 'name',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getMergeFields',
loadOptionsDependsOn: [
'list',
],
},
required: true,
description: 'Merge Field name. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
default: '',
},
{
displayName: 'Field Value',
name: 'value',
required: true,
type: 'string',
default: '',
description: 'Merge field value',
},
],
},
],
},
{
displayName: 'Merge Fields',
name: 'mergeFieldsJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
true,
],
},
},
},
{
displayName: 'Location',
name: 'locationJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
true,
],
},
},
},
{
displayName: 'Interest Groups',
name: 'groupsUi',
placeholder: 'Add Interest Group',
type: 'fixedCollection',
default: {},
typeOptions: {
multipleValues: true,
},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
false,
],
},
},
options: [
{
name: 'groupsValues',
displayName: 'Group',
typeOptions: {
multipleValueButtonText: 'Add Interest Group',
},
values: [
{
displayName: 'Category Name or ID',
name: 'categoryId',
type: 'options',
description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>',
typeOptions: {
loadOptionsMethod: 'getGroupCategories',
loadOptionsDependsOn: [
'list',
],
},
default: '',
},
{
displayName: 'Category Field ID',
name: 'categoryFieldId',
type: 'string',
default: '',
},
{
displayName: 'Value',
name: 'value',
type: 'boolean',
default: false,
},
],
},
],
},
{
displayName: 'Interest Groups',
name: 'groupJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'create',
],
jsonParameters: [
true,
],
},
},
},
/* -------------------------------------------------------------------------- */
/* member:delete */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'delete',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Email',
name: 'email',
type: 'string',
placeholder: 'name@email.com',
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'delete',
],
},
},
default: '',
required: true,
description: 'Member\'s email',
},
/* -------------------------------------------------------------------------- */
/* member:get */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'get',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Email',
name: 'email',
type: 'string',
placeholder: 'name@email.com',
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'get',
],
},
},
default: '',
required: true,
description: 'Member\'s email',
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'get',
],
},
},
options: [
{
displayName: 'Fields',
name: 'fields',
type: 'string',
default: '',
description: 'A comma-separated list of fields to return',
},
{
displayName: 'Exclude Fields',
name: 'excludeFields',
type: 'string',
default: '',
description: 'A comma-separated list of fields to exclude',
},
],
},
/* -------------------------------------------------------------------------- */
/* member:getAll */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'getAll',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
displayOptions: {
show: {
resource: [
'member',
],
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: [
'member',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
typeOptions: {
minValue: 1,
maxValue: 1000,
},
default: 500,
description: 'Max number of results to return',
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'getAll',
],
},
},
options: [
{
displayName: 'Before Last Changed',
name: 'beforeLastChanged',
type: 'dateTime',
default: '',
description: 'Restrict results to subscribers whose information changed before the set timeframe',
},
{
displayName: 'Before Timestamp Opt',
name: 'beforeTimestampOpt',
type: 'dateTime',
default: '',
description: 'Restrict results to subscribers who opted-in before the set timeframe',
},
// {
// displayName: 'Fields',
// name: 'fields',
// type: 'string',
// default: '',
// description: 'A comma-separated list of fields to return.',
// },
// {
// displayName: 'Exclude Fields',
// name: 'excludeFields',
// type: 'string',
// default: '',
// description: 'A comma-separated list of fields to exclude.',
// },
{
displayName: 'Email Type',
name: 'emailType',
type: 'options',
options: [
{
name: 'HTML',
value: 'html',
},
{
name: 'Text',
value: 'text',
},
],
default: '',
description: 'Type of email this member asked to get',
},
{
displayName: 'Status',
name: 'status',
type: 'options',
options: [
{
name: 'Cleaned',
value: 'cleaned',
},
{
name: 'Pending',
value: 'pending',
},
{
name: 'Subscribed',
value: 'subscribed',
},
{
name: 'Transactional',
value: 'transactional',
},
{
name: 'Unsubscribed',
value: 'unsubscribed',
},
],
default: '',
description: 'Subscriber\'s current status',
},
{
displayName: 'Since Last Changed',
name: 'sinceLastChanged',
type: 'dateTime',
default: '',
description: 'Restrict results to subscribers whose information changed after the set timeframe',
},
],
},
/* -------------------------------------------------------------------------- */
/* member:update */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'update',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Email',
name: 'email',
type: 'string',
placeholder: 'name@email.com',
required: true,
displayOptions: {
show: {
resource: [
'member',
],
operation: [
'update',
],
},
},
default: '',
description: 'Email address of the subscriber',
},
{
displayName: 'JSON Parameters',
name: 'jsonParameters',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Update Fields',
name: 'updateFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'update',
],
},
},
options: [
{
displayName: 'Email Type',
name: 'emailType',
type: 'options',
options: [
{
name: 'HTML',
value: 'html',
},
{
name: 'Text',
value: 'text',
},
],
default: '',
description: 'Type of email this member asked to get',
},
{
displayName: 'Interest Groups',
name: 'groupsUi',
placeholder: 'Add Interest Group',
type: 'fixedCollection',
default: {},
typeOptions: {
multipleValues: true,
},
displayOptions: {
show: {
'/resource':[
'member',
],
'/operation':[
'update',
],
'/jsonParameters': [
false,
],
},
},
options: [
{
name: 'groupsValues',
displayName: 'Group',
typeOptions: {
multipleValueButtonText: 'Add Interest Group',
},
values: [
{
displayName: 'Category Name or ID',
name: 'categoryId',
type: 'options',
description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>',
typeOptions: {
loadOptionsMethod: 'getGroupCategories',
loadOptionsDependsOn: [
'list',
],
},
default: '',
},
{
displayName: 'Category Field ID',
name: 'categoryFieldId',
type: 'string',
default: '',
},
{
displayName: 'Value',
name: 'value',
type: 'boolean',
default: false,
},
],
},
],
},
{
displayName: 'Language',
name: 'language',
type: 'string',
default: '',
description: 'If set/detected, the subscriber\'s language',
},
{
displayName: 'Merge Fields',
name: 'mergeFieldsUi',
placeholder: 'Add Merge Fields',
type: 'fixedCollection',
default: {},
typeOptions: {
multipleValues: true,
},
displayOptions: {
show: {
'/resource':[
'member',
],
'/operation':[
'update',
],
'/jsonParameters': [
false,
],
},
},
description: 'An individual merge var and value for a member',
options: [
{
name: 'mergeFieldsValues',
displayName: 'Field',
typeOptions: {
multipleValueButtonText: 'Add Field',
},
values: [
{
displayName: 'Field Name or ID',
name: 'name',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getMergeFields',
loadOptionsDependsOn: [
'list',
],
},
required: true,
description: 'Merge Field name. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
default: '',
},
{
displayName: 'Field Value',
name: 'value',
required: true,
type: 'string',
default: '',
description: 'Merge field value',
},
],
},
],
},
{
displayName: 'Opt-in IP',
name: 'ipOptIn',
type: 'string',
default: '',
description: 'The IP address the subscriber used to confirm their opt-in status',
},
{
displayName: 'Signup IP',
name: 'ipSignup',
type: 'string',
default: '',
description: 'IP address the subscriber signed up from',
},
{
displayName: 'Signup Timestamp',
name: 'timestampSignup',
type: 'dateTime',
default: '',
description: 'The date and time the subscriber signed up for the list in ISO 8601 format',
},
{
displayName: 'Skip Merge Validation',
name: 'skipMergeValidation',
type: 'boolean',
default: false,
description: 'Whether member data will be accepted without merge field values, even if the merge field is usually required',
},
{
displayName: 'Status',
name: 'status',
type: 'options',
options: [
{
name: 'Cleaned',
value: 'cleaned',
},
{
name: 'Pending',
value: 'pending',
},
{
name: 'Subscribed',
value: 'subscribed',
},
{
name: 'Transactional',
value: 'transactional',
},
{
name: 'Unsubscribed',
value: 'unsubscribed',
},
],
default: '',
description: 'Subscriber\'s current status',
},
{
displayName: 'Vip',
name: 'vip',
type: 'boolean',
default: false,
// eslint-disable-next-line n8n-nodes-base/node-param-description-boolean-without-whether
description: 'Vip status for subscribers',
},
{
displayName: 'Location',
name: 'locationFieldsUi',
type: 'fixedCollection',
placeholder: 'Add Location',
default: {},
description: 'Subscriber location information.n',
displayOptions: {
show: {
'/resource':[
'member',
],
'/operation':[
'update',
],
'/jsonParameters': [
false,
],
},
},
options: [
{
name: 'locationFieldsValues',
displayName: 'Location',
values: [
{
displayName: 'Latitude',
name: 'latitude',
type: 'string',
required: true,
description: 'The location latitude',
default: '',
},
{
displayName: 'Longitude',
name: 'longitude',
type: 'string',
required: true,
description: 'The location longitude',
default: '',
},
],
},
],
},
{
displayName: 'Opt-in Timestamp',
name: 'timestampOpt',
type: 'dateTime',
default: '',
description: 'The date and time the subscribe confirmed their opt-in status in ISO 8601 format',
},
],
},
{
displayName: 'Merge Fields',
name: 'mergeFieldsJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'update',
],
jsonParameters: [
true,
],
},
},
},
{
displayName: 'Location',
name: 'locationJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'update',
],
jsonParameters: [
true,
],
},
},
},
{
displayName: 'Interest Groups',
name: 'groupJson',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
displayOptions: {
show: {
resource:[
'member',
],
operation: [
'update',
],
jsonParameters: [
true,
],
},
},
},
/* -------------------------------------------------------------------------- */
/* memberTag:create */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'memberTag',
],
operation: [
'create',
'delete',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Email',
name: 'email',
type: 'string',
placeholder: 'name@email.com',
required: true,
displayOptions: {
show: {
resource: [
'memberTag',
],
operation: [
'create',
'delete',
],
},
},
default: '',
description: 'Email address of the subscriber',
},
{
displayName: 'Tags',
name: 'tags',
type: 'string',
typeOptions: {
multipleValues: true,
multipleValueButtonText: 'Add Tag',
},
displayOptions: {
show: {
resource:[
'memberTag',
],
operation: [
'create',
'delete',
],
},
},
default: [],
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource:[
'memberTag',
],
operation: [
'create',
'delete',
],
},
},
options: [
{
displayName: 'Is Syncing',
name: 'isSyncing',
type: 'boolean',
default: false,
description: 'Whether automations based on the tags in the request will not fire',
},
],
},
/* -------------------------------------------------------------------------- */
/* member:getAll */
/* -------------------------------------------------------------------------- */
{
displayName: 'List Name or ID',
name: 'list',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
displayOptions: {
show: {
resource: [
'listGroup',
],
operation: [
'getAll',
],
},
},
default: '',
options: [],
required: true,
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Group Category Name or ID',
name: 'groupCategory',
type: 'options',
description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>',
typeOptions: {
loadOptionsMethod: 'getGroupCategories',
loadOptionsDependsOn: [
'list',
],
},
displayOptions: {
show: {
resource: [
'listGroup',
],
operation: [
'getAll',
],
},
},
default: '',
options: [],
required: true,
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
displayOptions: {
show: {
resource: [
'listGroup',
],
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: [
'listGroup',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
typeOptions: {
minValue: 1,
maxValue: 1000,
},
default: 500,
description: 'Max number of results to return',
},
/* -------------------------------------------------------------------------- */
/* campaign:getAll */
/* -------------------------------------------------------------------------- */
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
displayOptions: {
show: {
resource: [
'campaign',
],
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: [
'campaign',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
typeOptions: {
minValue: 1,
maxValue: 1000,
},
default: 10,
description: 'Max number of results to return',
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource:[
'campaign',
],
operation: [
'getAll',
],
},
},
options: [
{
displayName: 'Before Create Time',
name: 'beforeCreateTime',
type: 'dateTime',
default: '',
description: 'Restrict the response to campaigns created before the set time',
},
{
displayName: 'Before Send Time',
name: 'beforeSendTime',
type: 'dateTime',
default: '',
description: 'Restrict the response to campaigns sent before the set time',
},
{
displayName: 'Exclude Field Names or IDs',
name: 'excludeFields',
type: 'multiOptions',
typeOptions: {
loadOptionsMethod: 'getCampaignsFields',
},
default: [],
description: 'A comma-separated list of fields to exclude. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Field Names or IDs',
name: 'fields',
type: 'multiOptions',
typeOptions: {
loadOptionsMethod: 'getCampaignsFields',
},
default: [
'campaigns.id',
'campaigns.status',
'campaigns.tracking',
'campaigns.settings.from_name',
'campaigns.settings.reply_to',
'campaigns.settings.title',
],
description: 'A comma-separated list of fields to return. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'List Name or ID',
name: 'listId',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getLists',
},
default: '',
description: 'List of lists. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/nodes/expressions.html#expressions">expression</a>.',
},
{
displayName: 'Since Create Time',
name: 'sinceCreateTime',
type: 'dateTime',
default: '',
description: 'Restrict the response to campaigns created after the set time',
},
{
displayName: 'Since Send Time',
name: 'sinceSendTime',
type: 'dateTime',
default: '',
description: 'Restrict the response to campaigns sent after the set time',
},
{
displayName: 'Sort Direction',
name: 'sortDirection',
type: 'options',
options: [
{
name: 'ASC',
value: 'ASC',
},
{
name: 'DESC',
value: 'DESC',
},
],
default: '',
description: 'Determines the order direction for sorted results',
},
{
displayName: 'Sort Field',
name: 'sortField',
type: 'options',
options: [
{
name: 'Create Time',
value: 'create_time',
},
{
name: 'Send Time',
value: 'send_time',
},
],
default: '',
description: 'Returns files sorted by the specified field',
},
{
displayName: 'Status',
name: 'status',
type: 'options',
options: [
{
name: 'Save',
value: 'save',
},
{
name: 'Sending',
value: 'sending',
},
{
name: 'Sent',
value: 'sent',
},
{
name: 'Schedule',
value: 'schedule',
},
],
default: '',
description: 'The status of the campaign',
},
],
},
/* -------------------------------------------------------------------------- */
/* campaign:send */
/* -------------------------------------------------------------------------- */
{
displayName: 'Campaign ID',
name: 'campaignId',
type: 'string',
displayOptions: {
show: {
resource: [
'campaign',
],
operation: [
'send',
'get',
'delete',
'replicate',
'resend',
],
},
},
required: true,
default: '',
description: 'List of Campaigns',
options:[],
},
],
};
methods = {
loadOptions: {
// Get all the available lists to display them to user so that he can
// select them easily
async getLists(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
const lists = await mailchimpApiRequestAllItems.call(this, '/lists', 'GET', 'lists');
for (const list of lists) {
const listName = list.name;
const listId = list.id;
returnData.push({
name: listName,
value: listId,
});
}
return returnData;
},
// Get all the available merge fields to display them to user so that he can
// select them easily
async getMergeFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
const listId = this.getCurrentNodeParameter('list');
const { merge_fields } = await mailchimpApiRequest.call(this, `/lists/${listId}/merge-fields`, 'GET');
for (const mergeField of merge_fields) {
const mergeFieldName = mergeField.name;
const mergeFieldId = mergeField.tag;
returnData.push({
name: mergeFieldName,
value: mergeFieldId,
});
}
return returnData;
},
// Get all the interest fields to display them to user so that he can
// select them easily
async getGroupCategories(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
const listId = this.getCurrentNodeParameter('list');
const { categories } = await mailchimpApiRequest.call(this, `/lists/${listId}/interest-categories`, 'GET');
for (const category of categories) {
const categoryName = category.title;
const categoryId = category.id;
returnData.push({
name: categoryName,
value: categoryId,
});
}
return returnData;
},
// Get all the available campaigns to display them to users so that they can select them easily
async getCampaigns(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
const campaigns = await mailchimpApiRequestAllItems.call(this, '/campaigns', 'GET', 'campaigns');
for (const campaign of campaigns) {
const campaignName = campaign.settings.title;
const campaignId = campaign.id;
returnData.push({
name: campaignName,
value: campaignId,
});
}
return returnData;
},
// Get all the available fields to display them to users so that they can select them easily
async getCampaignsFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
for (const campaignFields of campaignFieldsMetadata) {
returnData.push({
name: campaignFields,
value: campaignFields,
});
}
return returnData;
},
},
};
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
const items = this.getInputData();
const returnData: IDataObject[] = [];
const length = items.length;
let responseData;
const qs: IDataObject = {};
const resource = this.getNodeParameter('resource', 0) as string;
const operation = this.getNodeParameter('operation', 0) as string;
for (let i = 0; i < length; i++) {
try {
if (resource === 'listGroup') {
//https://mailchimp.com/developer/reference/lists/interest-categories/#get_/lists/-list_id-/interest-categories/-interest_category_id-
if (operation === 'getAll') {
const listId = this.getNodeParameter('list', i) as string;
const categoryId = this.getNodeParameter('groupCategory', i) as string;
const returnAll = this.getNodeParameter('returnAll', i) as boolean;
if (returnAll === true) {
responseData = await mailchimpApiRequestAllItems.call(this, `/lists/${listId}/interest-categories/${categoryId}/interests`, 'GET', 'interests', {}, qs);
} else {
qs.count = this.getNodeParameter('limit', i) as number;
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/interest-categories/${categoryId}/interests`, 'GET', {}, qs);
responseData = responseData.interests;
}
}
}
if (resource === 'member') {
//https://mailchimp.com/developer/reference/lists/list-members/#post_/lists/-list_id-/members
if (operation === 'create') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
const status = this.getNodeParameter('status', i) as Status;
const options = this.getNodeParameter('options', i) as IDataObject;
const jsonActive = this.getNodeParameter('jsonParameters', i) as IDataObject;
const body: ICreateMemberBody = {
listId,
email_address: email,
status,
};
if (options.emailType) {
body.email_type = options.emailType as string;
}
if (options.language) {
body.language = options.language as string;
}
if (options.vip) {
body.vip = options.vip as boolean;
}
if (options.ipSignup) {
body.ip_signup = options.ipSignup as string;
}
if (options.ipOptIn) {
body.ip_opt = options.ipOptIn as string;
}
if (options.timestampOpt) {
body.timestamp_opt = moment(options.timestampOpt as string).format('YYYY-MM-DD HH:MM:SS') as string;
}
if (options.timestampSignup) {
body.timestamp_signup = moment(options.timestampSignup as string).format('YYYY-MM-DD HH:MM:SS') as string;
}
if (options.tags) {
// @ts-ignore
body.tags = options.tags.split(',') as string[];
}
if (!jsonActive) {
const locationValues = (this.getNodeParameter('locationFieldsUi', i) as IDataObject).locationFieldsValues as IDataObject;
if (locationValues) {
const location: ILocation = {};
for (const key of Object.keys(locationValues)) {
if (key === 'latitude') {
location.latitude = parseFloat(locationValues[key] as string) as number;
} else if (key === 'longitude') {
location.longitude = parseFloat(locationValues[key] as string) as number;
}
}
body.location = location;
}
const mergeFieldsValues = (this.getNodeParameter('mergeFieldsUi', i) as IDataObject).mergeFieldsValues as IDataObject[];
if (mergeFieldsValues) {
const mergeFields = {};
for (let i = 0; i < mergeFieldsValues.length; i++) {
// @ts-ignore
mergeFields[mergeFieldsValues[i].name] = mergeFieldsValues[i].value;
}
body.merge_fields = mergeFields;
}
const groupsValues = (this.getNodeParameter('groupsUi', i) as IDataObject).groupsValues as IDataObject[];
if (groupsValues) {
const groups = {};
for (let i = 0; i < groupsValues.length; i++) {
// @ts-ignore
groups[groupsValues[i].categoryFieldId] = groupsValues[i].value;
}
body.interests = groups;
}
} else {
const locationJson = validateJSON(this.getNodeParameter('locationJson', i) as string);
const mergeFieldsJson = validateJSON(this.getNodeParameter('mergeFieldsJson', i) as string);
const groupJson = validateJSON(this.getNodeParameter('groupJson', i) as string);
if (locationJson) {
body.location = locationJson;
}
if (mergeFieldsJson) {
body.merge_fields = mergeFieldsJson;
}
if (groupJson) {
body.interests = groupJson;
}
}
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members`, 'POST', body);
}
//https://mailchimp.com/developer/reference/lists/list-members/
if (operation === 'delete') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/actions/delete-permanent`, 'POST');
responseData = { success: true };
}
//https://mailchimp.com/developer/reference/lists/list-members/#get_/lists/-list_id-/members/-subscriber_hash-
if (operation === 'get') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
const options = this.getNodeParameter('options', i) as IDataObject;
if (options.fields) {
qs.fields = options.fields as string;
}
if (options.excludeFields) {
qs.exclude_fields = options.excludeFields as string;
}
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}`, 'GET', {}, qs);
}
//https://mailchimp.com/developer/reference/lists/list-members/#get_/lists/-list_id-/members
if (operation === 'getAll') {
const listId = this.getNodeParameter('list', i) as string;
const returnAll = this.getNodeParameter('returnAll', i) as boolean;
const options = this.getNodeParameter('options', i) as IDataObject;
if (options.beforeLastChanged) {
qs.before_last_changed = options.beforeLastChanged as string;
}
if (options.beforeTimestampOpt) {
qs.before_timestamp_opt = options.beforeTimestampOpt as string;
}
// TODO
//figure why for some reason when either fields or exclude_fields is set the endpoint returns nothing
// interestingly it works perfect when retriving just one member
// if (options.fields) {
// qs.fields = options.fields as string;
// }
// if (options.excludeFields) {
// qs.exclude_fields = options.excludeFields as string;
// }
if (options.emailType) {
qs.email_type = options.emailType as string;
}
if (options.status) {
qs.status = options.status as string;
}
if (options.sinceLastChanged) {
qs.since_last_changed = options.sinceLastChanged as string;
}
if (returnAll === true) {
responseData = await mailchimpApiRequestAllItems.call(this, `/lists/${listId}/members`, 'GET', 'members', {}, qs);
} else {
qs.count = this.getNodeParameter('limit', i) as number;
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members`, 'GET', {}, qs);
responseData = responseData.members;
}
}
//https://mailchimp.com/developer/reference/lists/list-members/#put_/lists/-list_id-/members/-subscriber_hash-
if (operation === 'update') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
const updateFields = this.getNodeParameter('updateFields', i) as IDataObject;
const jsonActive = this.getNodeParameter('jsonParameters', i) as IDataObject;
const body: ICreateMemberBody = {
listId,
email_address: email,
};
if (updateFields.skipMergeValidation) {
qs.skip_merge_validation = updateFields.skipMergeValidation as boolean;
}
if (updateFields.status) {
body.status = updateFields.status as Status;
}
if (updateFields.emailType) {
body.email_type = updateFields.emailType as string;
}
if (updateFields.language) {
body.language = updateFields.language as string;
}
if (updateFields.vip) {
body.vip = updateFields.vip as boolean;
}
if (updateFields.ipSignup) {
body.ip_signup = updateFields.ipSignup as string;
}
if (updateFields.ipOptIn) {
body.ip_opt = updateFields.ipOptIn as string;
}
if (updateFields.timestampOpt) {
body.timestamp_opt = moment(updateFields.timestampOpt as string).format('YYYY-MM-DD HH:MM:SS') as string;
}
if (updateFields.timestampSignup) {
body.timestamp_signup = moment(updateFields.timestampSignup as string).format('YYYY-MM-DD HH:MM:SS') as string;
}
if (!jsonActive) {
if (updateFields.locationFieldsUi) {
const locationValues = (updateFields.locationFieldsUi as IDataObject).locationFieldsValues as IDataObject;
if (locationValues) {
const location: ILocation = {};
for (const key of Object.keys(locationValues)) {
if (key === 'latitude') {
location.latitude = parseFloat(locationValues[key] as string) as number;
} else if (key === 'longitude') {
location.longitude = parseFloat(locationValues[key] as string) as number;
}
}
body.location = location;
}
}
if (updateFields.mergeFieldsUi) {
const mergeFieldsValues = (updateFields.mergeFieldsUi as IDataObject).mergeFieldsValues as IDataObject[];
if (mergeFieldsValues) {
const mergeFields = {};
for (let i = 0; i < mergeFieldsValues.length; i++) {
// @ts-ignore
mergeFields[mergeFieldsValues[i].name] = mergeFieldsValues[i].value;
}
body.merge_fields = mergeFields;
}
}
if (updateFields.groupsUi) {
const groupsValues = (updateFields.groupsUi as IDataObject).groupsValues as IDataObject[];
if (groupsValues) {
const groups = {};
for (let i = 0; i < groupsValues.length; i++) {
// @ts-ignore
groups[groupsValues[i].categoryFieldId] = groupsValues[i].value;
}
body.interests = groups;
}
}
} else {
const locationJson = validateJSON(this.getNodeParameter('locationJson', i) as string);
const mergeFieldsJson = validateJSON(this.getNodeParameter('mergeFieldsJson', i) as string);
const groupJson = validateJSON(this.getNodeParameter('groupJson', i) as string);
if (locationJson) {
body.location = locationJson;
}
if (mergeFieldsJson) {
body.merge_fields = mergeFieldsJson;
}
if (groupJson) {
body.interests = groupJson;
}
}
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}`, 'PUT', body);
}
}
if (resource === 'memberTag') {
//https://mailchimp.com/developer/reference/lists/list-members/list-member-tags/#post_/lists/-list_id-/members/-subscriber_hash-/tags
if (operation === 'create') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
const tags = this.getNodeParameter('tags', i) as string[];
const options = this.getNodeParameter('options', i) as IDataObject;
const body: IDataObject = {
tags: [],
};
if (options.isSyncing) {
body.is_syncing = options.isSyncing as boolean;
}
for (const tag of tags) {
//@ts-ignore
body.tags.push({
name: tag,
status: 'active',
});
}
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/tags`, 'POST', body);
responseData = { success: true };
}
//https://mailchimp.com/developer/reference/lists/list-members/list-member-tags/#post_/lists/-list_id-/members/-subscriber_hash-/tags
if (operation === 'delete') {
const listId = this.getNodeParameter('list', i) as string;
const email = this.getNodeParameter('email', i) as string;
const tags = this.getNodeParameter('tags', i) as string[];
const options = this.getNodeParameter('options', i) as IDataObject;
const body: IDataObject = {
tags: [],
};
if (options.isSyncing) {
body.is_syncing = options.isSyncing as boolean;
}
for (const tag of tags) {
//@ts-ignore
body.tags.push({
name: tag,
status: 'inactive',
});
}
responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/tags`, 'POST', body);
responseData = { success: true };
}
}
if (resource === 'campaign') {
//https://mailchimp.com/developer/api/marketing/campaigns/list-campaigns/
if (operation === 'getAll') {
const returnAll = this.getNodeParameter('returnAll', i) as boolean;
const options = this.getNodeParameter('options', i) as IDataObject;
if (options.status) {
qs.status = options.status as string;
}
if (options.beforeCreateTime) {
qs.before_create_time = options.beforeCreateTime as string;
}
if (options.beforeSendTime) {
qs.before_send_time = options.beforeSendTime as string;
}
if (options.excludeFields) {
qs.exclude_fields = (options.exclude_fields as string[]).join(',');
}
if (options.fields) {
qs.fields = (options.fields as string[]).join(',');
if ((options.fields as string[]).includes('*')) {
qs.fields = campaignFieldsMetadata.join(',');
}
} else {
qs.fields = [
'campaigns.id',
'campaigns.status',
'campaigns.tracking',
'campaigns.settings.from_name',
'campaigns.settings.title',
'campaigns.settings.reply_to',
].join(',');
}
if (options.listId) {
qs.list_id = options.listId as string;
}
if (options.sinceCreateTime) {
qs.since_create_time = options.sinceCreateTime as string;
}
if (options.sinceSendTime) {
qs.since_send_time = options.sinceSendTime as string;
}
if (options.sortDirection) {
qs.sort_dir = options.sortDirection as string;
}
if (options.sortField) {
qs.sort_field = options.sortField as string;
}
if (returnAll === true) {
responseData = await mailchimpApiRequestAllItems.call(this, `/campaigns`, 'GET', 'campaigns', {}, qs);
} else {
qs.count = this.getNodeParameter('limit', i) as number;
responseData = await mailchimpApiRequest.call(this, `/campaigns`, 'GET', {}, qs);
responseData = responseData.campaigns;
}
}
//https://mailchimp.com/developer/api/marketing/campaigns/send-campaign/
if (operation === 'send') {
const campaignId = this.getNodeParameter('campaignId', i) as string;
responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/send`, 'POST', {});
responseData = { success: true };
}
//https://mailchimp.com/developer/api/marketing/campaigns/get-campaign-info/
if (operation === 'get') {
const campaignId = this.getNodeParameter('campaignId', i) as string;
responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}`, 'GET', {});
}
//https://mailchimp.com/developer/api/marketing/campaigns/delete-campaign/
if (operation === 'delete') {
const campaignId = this.getNodeParameter('campaignId', i) as string;
responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}`, 'DELETE', {});
responseData = { success: true };
}
//https://mailchimp.com/developer/api/marketing/campaigns/replicate-campaign/
if (operation === 'replicate') {
const campaignId = this.getNodeParameter('campaignId', i) as string;
responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/replicate`, 'POST', {});
}
//https://mailchimp.com/developer/api/marketing/campaigns/resend-campaign/
if (operation === 'resend') {
const campaignId = this.getNodeParameter('campaignId', i) as string;
responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/create-resend`, 'POST', {});
}
}
if (Array.isArray(responseData)) {
returnData.push.apply(returnData, responseData as IDataObject[]);
} else {
returnData.push(responseData as IDataObject);
}
} catch (error) {
if (this.continueOnFail()) {
returnData.push({ error: error.message });
continue;
}
throw error;
}
}
return [this.helpers.returnJsonArray(returnData)];
}
}
Reference in a new issue View git blame Copy permalink