Campaign API

const segmentId = '<segment-id>'; // segment_id is optional
// Create a dynamic user segment based on the filter provided.
// e.g., following segment will include all users created after 2020-01-01
const segment = client.segment('user', segmentId, {
  name: 'New App Users Segment (optional)',
  filter: {
    created_at: {
      $gte: '2020-01-01T00:00:00Z',
    }
  }
})
await segment.create();

const campaign_id = '<campaign-id>'; // campaign_id is optional
const campaign = client.campaign(campaign_id, {
  // Users targeted by following segment will receive the message
  segment_ids: [segmentId],
  // Alternatively, instead of segment_ids, you can also provide user_ids to send the message to specific users
  // user_ids: ['<user-id-1>', '<user-id-2>'],
  sender_id: '<user-id-of-sender>', // mandatory
  name: 'Campaign name', // optional
  description: 'Campaign Description', // optional
  message_template: {
    text: 'Hello {{receiver.name}}!', // mandatory, message text template
    attachments: [], // Optional, message attachments
    poll_id: 'poll-id', // Optional, send a poll with message
    custom: { promotional: true }, // Optional, custom fields will be added to message object received by the receiver.
  },
  create_channels: true, // Optional, create channel between sender and receiver if not already present
  // channel_template is required if create_channels is true
  channel_template: {
     // mandatory, channel type
    type: 'messaging',
    // Optional, template for channel id for channel creation
    // if not provided, channel id will be generated on server side
    id: '{{receiver.id}}-{{sender.id}}',
    // Optional, custom fields will be added to channel object
    custom: { promotional: true },
    // Optional, if provided (and multi tenancy is enabled), you can limit accessibility to the channel only to a team
    team: 'kansas-city-chiefs',
    // Optional, if provided following members will be added to each of the newly created channel
    // if not provided, only sender and receiver will be added to the channel
    // You can use this to add e.g., moderator or admin to each newly created channel
    members: ['user-id-1', 'user-id-2']
  }
})

await campaign.create();

// Start sending messages to targeted users
await campaign.start();

// Alternatively you can also schedule the campaign to start at a later time and stop at a specific time
await campaign.start({
  scheduledFor: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString()
  stopAt: new Date(Date.now() + 72 * 60 * 60 * 1000).toISOString()
});

await campaign.create(); // create a campaign based on data passed above
await campaign.get(); // check the status of the campaign
await campaign.update({
  segment_ids: ["a869fc0f-2e7e-4fe0-8651-775c892c1718"],
  sender_id: "Updated-user-id-of-sender", // mandatory
  name: "Updated name (optional)",
  message_template: {
    text: "Updated Hello {{receiver.name}}!",
  },
}); // updates the campaign data

// You can start a campaign immediately, which will start sending messages to the users in the segment(s) immediately.
await campaign.start();

// Or you can schedule a campaign to start at a later time.
await campaign.start({
  // start campaign in 48 hours
  scheduledFor: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString(), // optional, campaign will start running after this time
  // automatically stop the campaign after 72 hours
  stopAt: new Date(Date.now() + 72 * 60 * 60 * 1000).toISOString(), // optional, campaign will stop running after this time
});

await campaign.stop(); // stops the campaign
await campaign.delete(); // delete the campaign

const filter = {
  segments: { $in: ["<segment-id>"] },
};
const sort = [{ field: "created_at", direction: -1 }];
const options = {
  limit: 30,
  next: "<encoded_next>",
};
const result = client.queryCampaigns(filter, sort, options); // query campaigns
// result.campaigns is an array of campaigns
// result.next is a cursor for the next page of campaigns

// Query campaigns with which are scheduled or in progress
const filter = { status: { $in: ["scheduled", "in_progress"] } };
const sort = [{ field: "created_at", direction: -1 }];
const options = { limit: 10 };

// query first page
const { campaigns, next } = await client.queryCampaigns(filter, sort, options);

// query next page
const res = await client.queryCampaigns(filter, sort, { ...options, next });

const filterStatus = { status: { $in: ["scheduled", "in_progress"] } };
const filterID = { id: { $in: ["campaign_id_1", "campaign_id_2"] } };
const filterBySegments = {
  segments: { $in: ["segment_id_1", "segment_id_2"] },
};
const filterByName = { name: { $in: ["campaign_name_1", "campaign_name_2"] } };
const filterBySender = { sender_id: { $in: ["sender_1", "sender_2"] } };
const filterByCreated = { created_at: { $gte: "2021-01-01T00:00:00Z" } };
const filterByUpdated = { updated_at: { $gte: "2021-01-01T00:00:00Z" } };

const type = <'user'|'channel'>; // mandatory
const id = "<segment_id>"; // optional
const data = {
	filter: {
		team:'commonteam'
	},
	name: 'segment_name',
	description: 'segment_description'
} // optional

const segment = client.segment(type, id, data)

const segmentType = "user"; // mandatory
const segmentId = "<segment_id>"; // optional
const data = {
	filter: {
		//...
	}
} // optional
let userSegment = client.segment(segmentType, segmentId, data);

await userSegment.create()
await userSegment.get()
await userSegment.addTargets(userIds); // a max of 10,000 users can be added in 1 API call
await userSegment.removeTargets(userIds); // no error if doesn't exits
await userSegment.targetExists(userId); // checks if target exists in the segment
await userSegment.queryTargets(
	{ "target_id": {"$gte": <user_id>} },
	[{ field: "target_id", direction: -1 }],
	{
	 limit: 10000,
	 next: '<encoded_next>', // or prev
	}
); // queries targets in the segment
	await userSegment.delete(); // deletes segment

const data = {
  name: "everyone",
  all_users: true,
};
let userSegment = client.segment("user", data);
await userSegment.create();

// note: channel template is not required for channel segment
let segmentType = "channel";
let segmentId = "segmentId";
let data = {
  name: "segment_name",
  description: "segment_description",
  filter: {
    team: "commonteam",
  },
};
let channelSegment = client.segment(segmentType, segmentId, data);
await channelSegment.create();
await channelSegment.get();
await channelSegment.addTargets(channelCids);
await channelSegment.removeTargets(channelCids);
await channelSegment.targetExists(channelCid);
await channelSegment.delete();

const data = {
  name: "All my existing chats",
  all_sender_channels: true,
};
let channelSegment = client.segment("channel", data);
await channelSegment.create();

const segment = client.segment(segmentType, segmentId);
const response = await segment.get();

const data = {
	name: 'People in the USA'
	filter: {
		country: 'USA'
	}
};
const segment = client.segment('user', data);
await segment.create();

const campaign = client.campaign({
  segment_ids: [segment.id],
  sender_id: "user-id-of-sender", // mandatory
  name: "Campaign name (optional)",
  description: "Optional description",
  message_template: {
    text: "Hi {{ receiver.name }} I'm {{ sender.name }}!",
  },
});
await campaign.create();
await campaign.start();

// Alternatively you can schedule the campaign to start at a later time.
// Also you can stop the campaign at a specific time. E.g.,
await campaign.start({
  scheduledFor: "2021-12-31T23:59:59Z",
  stopAt: "2022-01-01T23:59:59Z",
});

const res = await campaign.get();
console.log(res.campaign.status); // "draft" | "scheduled" | "stopped" | "completed" | "in_progress"

// await campaign.get()
{
 "id": "...",
 "stats": {
  "started_at": "2021-02-01 00:00:00",
  "completed_at": "2024-23-02 00:00:00",
  "messages_sent": 1000,
  "channels_created": 10,
  "stats_progress": 0.97
 }
}

const filter = {
  name: "<name>",
};
const sort = [{ field: "created_at", direction: -1 }];
const options = {
  limit: 30,
  next: "<encoded_next>",
};
let response = await client.querySegments(filter, sort, options);