ayadn 0.6.0

data/lib/ayadn/api.rb

@@ -0,0 +1,302 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+class AyaDN
+	class API
+		def initialize(token)
+			@token = token
+			@endpoints = AyaDN::Endpoints.new(@token)
+		end
+		def makeAuthorizeURL
+			@endpoints.authorize_url
+		end
+
+		def getHash
+			JSON.parse(http_get(@url))
+		end
+
+		def checkLastPageID(last_page_id)
+			@url += "&since_id=#{last_page_id}" if last_page_id != nil
+		end
+
+		def getAPIConfig
+			@url = CONFIG_API_URL
+			getHash
+		end
+
+		def getGlobal(last_page_id)
+			@url = @endpoints.global
+			@url += @endpoints.light_params
+			@url += @endpoints.include_directed if $tools.config['timeline']['directed']
+			checkLastPageID(last_page_id)
+			getHash
+		end	
+		def getUnified(last_page_id)
+			@url = @endpoints.unified
+			@url += @endpoints.base_params
+			@url += @endpoints.include_directed if $tools.config['timeline']['directed']
+			checkLastPageID(last_page_id)
+			getHash
+		end
+		def getSimpleUnified
+			@url = @endpoints.unified_streamback
+			@url += @endpoints.base_params
+			@url += @endpoints.include_directed if $tools.config['timeline']['directed']
+			getHash
+		end
+		def getInteractions
+			@url = @endpoints.interactions
+			#checkLastPageID(last_page_id)
+			getHash
+		end
+		def getHashtags(tag)
+			@url = @endpoints.hashtags(tag)
+			getHash
+		end
+		def getExplore(stream, last_page_id)
+			@url = @endpoints.explore(stream)
+			@url += @endpoints.base_params
+			checkLastPageID(last_page_id)
+			getHash
+		end
+		def getUserMentions(username, last_page_id)
+			@url = @endpoints.mentions(username)
+			@url += @endpoints.light_params
+			checkLastPageID(last_page_id)
+			getHash
+		end
+		def getUserPosts(username, last_page_id)
+			@url = @endpoints.posts(username)
+			@url += @endpoints.base_params
+			checkLastPageID(last_page_id)
+			getHash
+		end
+		def getUserInfos(username)
+			@url = @endpoints.user_info(username)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def getWhoReposted(post_id)
+			@url = @endpoints.who_reposted(post_id)
+			@url += @endpoints.light_params
+			getHash
+		end
+		def getWhoStarred(post_id)
+			@url = @endpoints.who_starred(post_id)
+			@url += @endpoints.light_params
+			getHash
+		end
+		def getPostInfos(post_id)
+			@url = @endpoints.single_post(post_id)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def getSinglePost(post_id)
+			@url = @endpoints.single_post(post_id)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def getStarredPosts(username)
+			@url = @endpoints.starred_posts(username)
+			@url += @endpoints.light_params
+			getHash
+		end
+		def getPostReplies(post_id)
+			@url = @endpoints.replies(post_id)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def getPostMentions(post_id)
+			@url = @endpoints.single_post(post_id)
+			@url += @endpoints.light_params
+			theHash = getHash
+			postInfo = theHash['data']
+			#rawText = postInfo['text']
+			postMentionsArray = []
+			postInfo['entities']['mentions'].each { |item| postMentionsArray.push(item['name']) }
+			return postMentionsArray, postInfo['user']['username'], postInfo['repost_of']
+		end
+		def getUserName(username)
+			@url = @endpoints.user_info(username)
+			@url += @endpoints.light_params
+			theHash = getHash
+			theHash['data']['username']
+		end
+		def goDelete(post_id)
+			@url = @endpoints.single_post(post_id)
+			@url += @endpoints.light_params
+			isTherePost, isYours = ifExists(post_id)
+			return isTherePost, isYours
+		end
+		def starPost(post_id)
+			@url = @endpoints.star(post_id)
+			@url += @endpoints.light_params
+			httpPost(@url)
+		end
+		def unstarPost(post_id)
+			@url = @endpoints.star(post_id)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def repostPost(post_id)
+			@url = @endpoints.repost(post_id)
+			@url += @endpoints.light_params
+			httpPost(@url)
+		end
+		def unrepostPost(post_id)
+			@url = @endpoints.repost(post_id)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def ifExists(post_id)
+			theHash = getHash
+			postInfo = theHash['data']
+			return postInfo['text'], postInfo['user']['username']
+		end
+		def getOriginalPost(post_id)
+			theHash = getHash
+			theHash['data']['repost_of']['id']
+		end
+		def getUserFollowInfo(username)
+			@url = @endpoints.user_info(username)
+			@url += @endpoints.light_params
+			theHash = getHash
+			{you_follow: theHash['data']['you_follow'], follows_you: theHash['data']['follows_you']}
+		end
+		def getUserMuteInfo(username)
+			@url = @endpoints.user_info(username)
+			@url += @endpoints.light_params
+			theHash = getHash
+			theHash['data']['you_muted']
+		end
+		def getUserBlockInfo(username)
+			@url = @endpoints.user_info(username)
+			@url += @endpoints.light_params
+			theHash = getHash
+			theHash['data']['you_blocked']
+		end
+		def muteUser(username)
+			@url = @endpoints.mute(username)
+			@url += @endpoints.light_params
+			httpPost(@url)
+		end
+		def unmuteUser(username)
+			@url = @endpoints.mute(username)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def blockUser(username)
+			@url = @endpoints.block(username)
+			@url += @endpoints.light_params
+			httpPost(@url)
+		end
+		def unblockUser(username)
+			@url = @endpoints.block(username)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def followUser(username)
+			@url = @endpoints.follow(username)
+			@url += @endpoints.light_params
+			httpPost(@url)
+		end
+		def unfollowUser(username)
+			@url = @endpoints.follow(username)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def getFollowings(username, beforeID)
+			@url = @endpoints.following(username)
+			@url += @endpoints.light_params
+			@url += "&count=200"
+			@url += "&before_id=#{beforeID}" if beforeID != nil
+			getHash
+		end
+		def getFollowers(username, beforeID)
+			@url = @endpoints.followers(username)
+			@url += @endpoints.light_params
+			@url += "&count=200"
+			@url += "&before_id=#{beforeID}" if beforeID != nil
+			getHash
+		end
+		def getMuted(username, beforeID)
+			@url = @endpoints.muted(username)
+			@url += @endpoints.light_params
+			@url += "&count=200"
+			@url += "&before_id=#{beforeID}" if beforeID != nil
+			getHash
+		end
+		def getBlocked(username, beforeID)
+			@url = @endpoints.blocked(username)
+			@url += @endpoints.light_params
+			@url += "&count=200"
+			@url += "&before_id=#{beforeID}" if beforeID != nil
+			getHash
+		end
+		def getSearch(words)
+			@url = @endpoints.search(words)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def unique_message(channel_id, message_id)
+			@url = @endpoints.get_message(channel_id, message_id)
+			@url += @endpoints.base_params
+		end
+		def getUniqueMessage(channel_id, message_id)
+			@url = @endpoints.get_message(channel_id, message_id)
+			@url += @endpoints.base_params
+			getHash
+		end
+		def getMessages(channel, last_page_id)
+			@url = @endpoints.messages(channel)
+			@url += @endpoints.base_params
+			@url += "&include_machine=1"
+			checkLastPageID(last_page_id)
+			getHash
+		end
+		def get_pm_channels
+			@url = @endpoints.channels
+			@url += @endpoints.base_params
+			@url += "&channel_types=net.app.core.pm"
+			@url += "&include_recent_message=1"
+			getHash
+		end
+		def get_channels
+			@url = @endpoints.channels
+			@url += @endpoints.base_params
+			@url += "&include_recent_message=1"
+			getHash
+		end
+		def getFilesList(beforeID)
+			@url = @endpoints.files_list
+			@url += @endpoints.light_params
+			@url += "&before_id=#{beforeID}" if beforeID != nil
+			getHash
+		end
+		def getSingleFile(file_id)
+			@url = @endpoints.get_file(file_id)
+			@url += @endpoints.light_params
+			getHash
+		end
+		def getMultipleFiles(file_ids)
+			@url = @endpoints.get_multiple_files(file_ids)
+			@url += @endpoints.light_params
+			getHash
+		end
+		def deleteFile(file_id)
+			@url = @endpoints.get_file(file_id)
+			@url += @endpoints.light_params
+			$tools.checkHTTPResp(http_delete())
+		end
+		def deleteMessage(channel_id, message_id)
+			@url = @endpoints.get_message(channel_id, message_id)
+			@url += @endpoints.access_token
+			$tools.checkHTTPResp(http_delete())
+		end
+		# def deactivateChannel(channel_id)
+		# 	@url = CHANNELS_URL + "#{channel_id}?"
+		# 	@url += @endpoints.access_token
+		# 	resp = http_delete
+		# 	$tools.checkHTTPResp(resp)
+		# end
+	end
+end

data/lib/ayadn/authorize.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+class AyaDN
+	def ayadnAuthorize(action)
+		$files.makedir($tools.ayadn_configuration[:authorization_path])
+		if action == "reset"
+			$files.reset_credentials
+		end
+		auth_token = $files.auth_read
+		if auth_token == nil
+			url = @api.makeAuthorizeURL
+			case $tools.ayadn_configuration[:platform]
+			when $tools.winplatforms
+				puts $status.launchAuthorization("win")
+			when /linux/
+				puts $status.launchAuthorization("linux")
+			else
+				puts $status.launchAuthorization("osx")
+				$tools.startBrowser(url)
+			end
+			auth_token = STDIN.gets.chomp()
+			$files.auth_write(auth_token)
+			puts $status.authorized
+			sleep 3
+			puts $tools.helpScreen
+			puts "Enjoy!\n".cyan
+		end
+	end
+end

data/lib/ayadn/client-http.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/env ruby
+require 'json'
+require 'net/http'
+require 'openssl'
+
+# encoding: utf-8
+class AyaDN
+	class API
+		# WIP
+		# TESTING DIFFERENT WAYS
+		# TODO: DRY
+		def check_http_error_code(body)
+			code = JSON.parse(body)
+			case code['meta']['code']
+			when 204
+				puts "\nNo content (or incomplete).\n\n".red
+				exit
+			when 400
+				puts "\nBad request.\n\n".red
+				puts code['meta'].inspect
+				exit
+			when 401
+				puts "\nUnauthorized.\n\n".red
+				exit
+			when 403
+				puts "\nForbidden.\n\n".red
+				exit
+			when 404
+				puts "\nDoes not exist (or has been deleted).\n\n".red
+				exit
+			when 429
+				puts "\nToo many requests.\n\n".red
+				exit
+			when 507
+				puts "\nInsufficient storage.\n\n".red
+				exit
+			end
+		end
+		def http_get(target)
+			encoded_url = URI.encode("#{target}")
+			uri = URI.parse(encoded_url)
+			https = Net::HTTP.new(uri.host,uri.port)
+			https.use_ssl = true
+			https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			request = Net::HTTP::Get.new(uri.request_uri)
+			request["Authorization"] = "Bearer #{@token}"
+			request["Content-Type"] = "application/json"
+			if @progress_indicator == false
+				#print "Connecting to #{uri.host}#{uri.path} ...\n\n".cyan
+				response = https.request(request)
+				check_http_error_code(response.body)
+				return response.body
+			else
+				#print "\rConnecting to #{uri.host}#{uri.path}".cyan
+				body = ''
+				https.request(request) do |res| 
+					fileSize = res['Content-Length'].to_i
+					bytesTransferred = 0
+					res.read_body do |part|
+						bytesTransferred += part.length
+						rounded = bytesTransferred.percent_of(fileSize).round(2)
+						print "\rFetching data: ".cyan + "#{rounded}      ".brown
+						# print "\rDownloading response from App.net\t#{bytesTransferred.to_filesize}"
+						body << part
+					end
+				end
+				print "\r                           "
+				#puts ""
+				check_http_error_code(body)
+				return body
+			end
+		end
+		def http_delete
+			uri = URI("#{@url}")
+			https = Net::HTTP.new(uri.host,uri.port)
+			https.use_ssl = true
+			https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			request = Net::HTTP::Delete.new(uri.path)
+			request["Authorization"] = "Bearer #{@token}"
+			request["Content-Type"] = "application/json"
+			https.request(request)
+		end
+		def http_download(target=nil)
+			uri = URI("#{target}")
+			final_uri = ''
+			open(uri) do |h|
+			  final_uri = h.base_uri.to_s
+			end
+			new_uri = URI.parse(final_uri)
+			https = Net::HTTP.new(new_uri.host,new_uri.port)
+			https.use_ssl = true
+			https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			request = Net::HTTP::Get.new(new_uri.request_uri)
+			request["Authorization"] = "Bearer #{@token}"
+			request["Content-Type"] = "application/json"
+			https.request(request)
+		end
+		##### 
+		# experimenting
+		# def createIncompleteFileUpload(file_name) #this part works
+		# 	https, request = connectWithHTTP(FILES_URL)
+		# 	payload = {
+		# 		"kind" => "image",
+		# 		"type" => "com.ayadn.files",
+		# 		"name" => File.basename(file_name),
+		# 		"public" => true
+		# 	}.to_json
+		# 	response = https.request(request, payload)
+		# 	return response.body
+		# end
+		# def setFileContentUpload(file_id, file_path, file_token) #this one doesn't
+		# 	url = FILES_URL + "#{file_id}/content?file_token=#{file_token}"
+		# 	uri = URI("#{url}")
+		# 	# ...
+		# end
+		#####
+
+		def httpPutFile(file, data) # data must be json
+			url = "https://alpha-api.app.net/stream/0/files/#{file}"
+			uri = URI("#{url}")
+			https = Net::HTTP.new(uri.host,uri.port)
+			https.use_ssl = true
+			https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			request = Net::HTTP::Put.new(uri.path)
+			request["Authorization"] = "Bearer #{@token}"
+			request["Content-Type"] = "application/json"
+			return https.request(request, data)
+		end
+
+		def connectWithHTTP(url)
+			uri = URI("#{url}")
+			https = Net::HTTP.new(uri.host,uri.port)
+			https.use_ssl = true
+			https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			request = Net::HTTP::Post.new(uri.path)
+			request["Authorization"] = "Bearer #{@token}"
+			request["Content-Type"] = "application/json"
+			return https, request
+		end
+		def httpPost(url)
+			https, request = connectWithHTTP(url)
+			return https.request(request)
+		end
+		def httpSendMessage(target, text)
+			url = PM_URL
+			url += "?include_annotations=1"
+			https, request = connectWithHTTP(url)
+			entities_content = { 
+				"parse_markdown_links" => true, 
+				"parse_links" => true
+			}
+			ayadnAnno = clientAnnotations
+			destinations = []
+			payload = {
+				"text" => "#{text}",
+				"destinations" => destinations.push(target),
+				"entities" => entities_content,
+				"annotations" => ayadnAnno
+			}.to_json
+			response = https.request(request, payload)
+			return response.body
+		end
+		def httpSendMessageToChannel(target, text)
+			url = CHANNELS_URL
+			url += "#{target}/messages"
+			#url += "&include_annotations=1"
+
+			https, request = connectWithHTTP(url)
+			entities_content = { 
+				"parse_markdown_links" => true, 
+				"parse_links" => true
+			}
+			ayadnAnno = clientAnnotations
+			#destinations = []
+			payload = {
+				"text" => "#{text}",
+				"entities" => entities_content,
+				"annotations" => ayadnAnno
+			}.to_json
+			response = https.request(request, payload)
+			return response.body
+		end
+		def httpSend(text, replyto = nil)
+			url = POSTS_URL
+			url += "?include_annotations=1"
+			https, request = connectWithHTTP(url)
+			entities_content = { 
+					"parse_markdown_links" => true, 
+					"parse_links" => true
+				}
+			ayadnAnno = clientAnnotations
+			if replyto == nil
+				payload = {
+							"text" => "#{text}",
+							"entities" => entities_content,
+							"annotations" => ayadnAnno
+						}.to_json
+			else
+				payload = {
+							"text" => "#{text}",
+							"reply_to" => "#{replyto}",
+							"entities" => entities_content,
+							"annotations" => ayadnAnno
+						}.to_json
+			end
+			response = https.request(request, payload)
+			return response.body
+		end
+
+		def clientAnnotations
+			ayadn_annotations = [{
+				"type" => "com.ayadn.client",
+				"value" => {
+		        			"+net.app.core.user" => {
+		            			"user_id" => "@ayadn",
+		            			"format" => "basic"
+			        			}
+			        		}
+				},{
+				"type" => "com.ayadn.client",
+				"value" => { "url" => "http://ayadn-app.net" }
+				}]
+			return ayadn_annotations
+		end
+	end
+end

data/lib/ayadn/colors.rb

@@ -0,0 +1,62 @@
+class String
+    def reddish;
+        "\033[1;31m#{self}\033[0m"
+    end
+    def pink;
+        "\033[1;35m#{self}\033[0m"
+    end
+    def black;          
+        "\033[30m#{self}\033[0m" 
+    end
+    def red;            
+        "\033[31m#{self}\033[0m" 
+    end
+    def green;          
+        "\033[32m#{self}\033[0m" 
+    end
+    def brown;          
+        "\033[33m#{self}\033[0m" 
+    end
+    def blue;           
+        "\033[34m#{self}\033[0m" 
+    end
+    def magenta;        
+        "\033[35m#{self}\033[0m" 
+    end
+    def cyan;           
+        "\033[36m#{self}\033[0m" 
+    end
+    def gray;           
+        "\033[37m#{self}\033[0m" 
+    end
+    def bg_black;       
+        "\033[40m#{self}\0330m"  
+    end
+    def bg_red;         
+        "\033[41m#{self}\033[0m" 
+    end
+    def bg_green;       
+        "\033[42m#{self}\033[0m" 
+    end
+    def bg_brown;       
+        "\033[43m#{self}\033[0m" 
+    end
+    def bg_blue;        
+        "\033[44m#{self}\033[0m" 
+    end
+    def bg_magenta;     
+        "\033[45m#{self}\033[0m" 
+    end
+    def bg_cyan;        
+        "\033[46m#{self}\033[0m" 
+    end
+    def bg_gray;        
+        "\033[47m#{self}\033[0m" 
+    end
+    def bold;           
+        "\033[1m#{self}\033[22m" 
+    end
+    def reverse_color;  
+        "\033[7m#{self}\033[27m" 
+    end
+end

data/lib/ayadn/debug.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+class AyaDN
+	def debugStream
+		puts @view.new(@hash).showDebugStream
+	end
+	def ayadnDebugStream
+		@hash = @api.getUnified(nil)
+		debugStream
+	end
+	def ayadnDebugPost(postID)
+		@hash = @api.getPostInfos(postID)
+		debugStream
+	end
+	def ayadnDebugUser(username)
+		@hash = @api.getUserInfos(username)
+		debugStream
+	end
+	def ayadnDebugMessage(channel_id, message_id)
+		@hash = @api.getUniqueMessage(channel_id, message_id)
+		debugStream
+	end
+	def buildDebugStream(post_hash)
+		# ret_string = ""
+		# post_hash.each do |k, v|
+		# 	ret_string << "#{k}: #{v}\n\n"
+		# end
+		jj post_hash
+		#exit
+		#return ret_string
+	end
+	def ayadnDebugChannel(channel)
+		@hash = @api.getMessages(channel, nil)
+		jj @hash
+	end
+end