Random GI Joe
@raymondcamden
code:
data:privatelast updated:1 year ago
today
Build integrations remarkably fast!
You're viewing a public workflow template.
Sign up to customize, add steps, modify code and more.
Join 1,000,000+ developers using the Pipedream platform
steps.
trigger
Cron Scheduler
Deploy to configure a custom schedule
This workflow runs on Pipedream's servers and is triggered on a custom schedule.
steps.
getjoe
auth
to use OAuth tokens and API keys in code via theauths object
code
Write any Node.jscodeand use anynpm package. You can alsoexport datafor use in later steps via return or this.key = 'value', pass input data to your code viaparams, and maintain state across executions with$checkpoint.
async (event, steps) => {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
}
105
	//const fetch = require('node-fetch@2');
	import fetch from 'node-fetch';
	
	const randomURL = 'https://gijoe.fandom.com/wiki/Special:RandomInCategory/A_Real_American_Hero_characters';
	const apiURL = 'https://gijoe.fandom.com/api.php';

	async function getRandomCharacter() {
		return await fetch(randomURL + '?format=json', {redirect:'manual'})
		.then(res => {
			let header = res.headers.raw();
			return header.location[0].split('/').pop();
		});
	}

	async function getPageData(page) {
		let resp =  await fetch(apiURL + `?action=parse&page=${page}&format=json&prop=wikitext`);
		let data = await resp.json();
		console.log('data', data);
		return { 
			title: data.parse.title, 
			wikitext: data.parse.wikitext['*']
		};
		
	}

	/* 
	Looks for the infobox code and parses it into fields, also prepares image.
	Tries to deal with the different forms of infobox
	*/
	function getInfoBox(str) {
		let matches = str.match(/{{.*?[_ ]character[_ ]infobox[.\s\S]*?}}/);
		if(!matches) {
			//hopefully the only alternative
			matches = str.match(/{{Character_infobox[.\s\S]*?}}/);
		}
		
		if(!matches) return;
		if(matches[0]) {
			let box = matches[0];
			box = box.replace(/{{.*?[_ ]character[_ ]infobox[\s\S]/,'');
			box = box.replace(/{{Character_infobox[\s\S]/,'');
			box = box.replace(/}}/,'');
			let parts = box.split('\n');
			let result = {};
			parts.forEach(p => {
				if(p.indexOf("|") === 0) {
					let [key,value] = p.split('=');
					key = key.replace('|','');
					if(key && value) result[key.trim()] = value;
				}
			});
			/*
			look for image as a key, and it may be: [[File:Marvel-Mainframe.jpg|270px]]'
			*/
			if(result.image) {
				let [file] = result.image.split('|');
				if(file.indexOf('File:') > 0 || file.indexOf('Image:') > 0) {
					file = file.replace('[[File:','');
					file = file.replace('[[Image:','');
					file = file.replace(']]','');
					result.image = file;
				}
			}

			/*
			possibly fix speciality:
			"Sailor; [[Wikipedia:United States Navy SEALs|S.E.A.L.]]; Gunner's mate; Machinist
			In this case, we'll just take the first part
			*/
			console.log(result);
			if(!result.specialty) result.specialty = 'Unknown';
			if(result.specialty.indexOf(';') > 0) {
				result.specialty = result.specialty.split(';')[0];
			}

			return result;
		}
	}

	async function getImageURL(f) {
		let url = `https://gijoe.fandom.com/api.php?action=query&titles=Image:${f}&prop=imageinfo&iiprop=url&format=json`;
		let result = await fetch(url);
		let data = await result.json();
		if(data && data.query && data.query.pages) {
			//result is an object with one random key
			let keys = Object.keys(data.query.pages);
			let image = data.query.pages[keys[0]];
			if(image && image.imageinfo) return image.imageinfo[0].url;
			return '';
		}
	}

	let char = await getRandomCharacter();
	let page = await getPageData(char);
	console.log(page.wikitext);
	this.box = getInfoBox(page.wikitext);
	//console.log(this.box);
	if(!this.box) $end("No box?");
	if(!this.box.image) $end("No image");
	this.pic = await getImageURL(this.box.image);
	if(this.pic === '') $end("No image");
	this.url = `https://gijoe.fandom.com/wiki/${char}`;
steps.
maketext
auth
to use OAuth tokens and API keys in code via theauths object
code
Write any Node.jscodeand use anynpm package. You can alsoexport datafor use in later steps via return or this.key = 'value', pass input data to your code viaparams, and maintain state across executions with$checkpoint.
async (event, steps) => {
1
2
3
4
5
6
}
7
this.text = `
Name: ${steps.getjoe.box.name}
Speciality: ${steps.getjoe.box.specialty}
Link: ${steps.getjoe.url}
`;
steps.
upload_media_to_twitter
Uploads media to Twitter using the Upload API
auth
(auths.twitter)
params
URL

URL of media to upload to Twitter

 
string ·params.url
Media Type
 
string ·params.media_type
code
async (params, auths) => {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
}
90
const axios = require("axios")
const chunk = require("lodash.chunk")

// Data we need to make the Twitter API request
const oauthSignerUri = auths.twitter.oauth_signer_uri
const token = {
  key: auths.twitter.oauth_access_token,
  secret: auths.twitter.oauth_refresh_token,
}
const signConfig = {
  token,
  oauthSignerUri
}

// Download image, base64 encode it, then upload the media to Twitter
const imageResponse = await axios({
  url: params.url,
  method: "GET",
  responseType: "arraybuffer"
})

const file = Buffer.from(imageResponse.data, 'binary')
const total_bytes = file.length
const base64EncodedFile = file.toString('base64')
const { media_type } = params

// First, tell Twitter the type of file you're uploading, how big it is, etc.
// https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-upload-init
const mediaUploadInitRequest = {
  method: 'POST',
  data: '',
  url: "https://upload.twitter.com/1.1/media/upload.json",
  params: {
    command: "INIT",
    total_bytes,
    media_type,
  }
}

// Twitter returns a media_id_string that we use to upload the file,
// and to reference it in future steps
this.uploadMediaInitResponse = (await require("@pipedreamhq/platform").axios(this, mediaUploadInitRequest, signConfig))
this.mediaIdString = this.uploadMediaInitResponse.media_id_string 

// Split the file into chunks, APPEND each chunk
const splitStringRe = new RegExp('.{1,' + 10000 + '}', 'g');
const chunks = base64EncodedFile.match(splitStringRe);

// Collect all of our requests into an array
const requests = []

for (const [segment_index, media_data] of chunks.entries()) {
  // APPEND file content in chunks
  // See https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-upload-append
  const mediaUploadAppendRequest = {
    method: 'POST',
    data: '',
    url: "https://upload.twitter.com/1.1/media/upload.json",
    params: {
      command: "APPEND",
      media_id: this.mediaIdString,
      segment_index,
      media_data,
    }
  }
  requests.push(require("@pipedreamhq/platform").axios(this, mediaUploadAppendRequest, signConfig))
}

// Send N requests at a time
const requestChunks = chunk(requests, 10)

for (const [i, chunk] of requestChunks.entries()) {
  console.log(`Processing chunk ${i}`)
  await Promise.all(chunk)
}

// Finally, tell Twitter we're done uploading
// https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-upload-finalize
const mediaUploadFinalizeRequest = {
    method: 'POST',
    data: '',
    url: "https://upload.twitter.com/1.1/media/upload.json",
    params: {
      command: "FINALIZE",
      media_id: this.mediaIdString,
    }
  }
  await require("@pipedreamhq/platform").axios(this, mediaUploadFinalizeRequest, signConfig)
steps.
post_tweet
Post a tweet.
auth
(auths.twitter)
params
Status
 
string ·params.status
Optional
code
async (params, auths) => {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
}
19
const axios = require('axios')
const oauthSignerUri = auths.twitter.oauth_signer_uri
const {status, in_reply_to_status_id, auto_populate_reply_metadata, exclude_reply_user_ids, attachment_url, media_ids, possibly_sensitive, lat, long, place_id, display_coordinates, trim_user, enable_dmcommands, fail_dmcommands, card_uri} = params
const config = {
    url: `https://api.twitter.com/1.1/statuses/update.json`,
    method: 'POST',
    params,
}
const token = {
    key: auths.twitter.oauth_access_token,
    secret: auths.twitter.oauth_refresh_token,
}
const signConfig = {
  token,
  oauthSignerUri
}
return await require("@pipedreamhq/platform").axios(this, config, signConfig)