Integration Guide

require 'uri'
require 'net/http'

url = URI("https://api.middesk.com/v1/businesses")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Authorization"] = '<Your Auth Token>'
request.body = "{\n  \"name\": \"Joe's Bakery\",\n  \"addresses\": [\n\t  {\n\t\t  \"full_address\": \"123 Main Street, Tampa, FL 33626\"\n\t  }\n  ],\n  \"website\": {\n\t  \"url\": \"www.joesbakery.com\"\n  },\n\t\"orders\": [\n\t\t{\n\t\t  \"product\": \"website\",\n\t\t  \"subproducts\": [\"web_analysis\"]\n\t\t}\n\t]\n}"

response = http.request(request)
puts response.read_body

curl --request POST \
  --url https://api.middesk.com/v1/businesses \
  --header 'Authorization: <Your Auth Token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "Joe'\''s Bakery",
  "addresses": [
	  {
		  "full_address": "123 Main Street, Tampa, FL 33626"
	  }
  ],
  "website": {
	  "url": "www.joesbakery.com"
  },
	"orders": [
		{
		  "product": "website",
		  "subproducts": ["web_analysis"]
		}
	]
}'

import http.client

conn = http.client.HTTPConnection("https://api.middesk.com")

payload = "{\n  \"name\": \"Joe's Bakery\",\n  \"addresses\": [\n\t  {\n\t\t  \"full_address\": \"123 Main Street, Tampa, FL 33626\"\n\t  }\n  ],\n  \"website\": {\n\t  \"url\": \"www.joesbakery.com\"\n  },\n\t\"orders\": [\n\t\t{\n\t\t  \"product\": \"website\",\n\t\t  \"subproducts\": [\"web_analysis\"]\n\t\t}\n\t]\n}"

headers = {
    'Content-Type': "application/json",
    'Authorization': "<Your Auth Token>"
    }

conn.request("POST", "/v1/businesses", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

const options = {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: '<Your Auth Token>'
  },
  body: '{"name":"Joe\'s Bakery","addresses":[{"full_address":"123 Main Street, Tampa, FL 33626"}],"website":{"url":"www.joesbakery.com"},"orders":[{"product":"website","subproducts":["web_analysis"]}]}'
};

fetch('https://api.middesk.com/v1/businesses', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));

require 'net/http'
require 'net/https'
require 'json'

def send_request
	business_id = "<business_id>"
  uri = URI("https://api.middesk.com/v1/businesses/#{business_id}")

  # Create client
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  # Create Request
  req =  Net::HTTP::Get.new(uri)
  # Add headers
  req.add_field "Accept", "application/json"
  # Add headers
  req.add_field "Authorization", "Basic <api_key>"

  # Fetch Request
  res = http.request(req)
  
	response = JSON.parse(res.body)
	website_status_task = response['review']['tasks'].find { |task| task['key'] == 'website_status' }
	
	if website_status_task['status'] == 'success'
		puts 'Website online'
	else
    puts 'Website offline'
	end
rescue StandardError => e
  puts "HTTP Request failed (#{e.message})"
end

import requests
from requests.auth import HTTPBasicAuth

def send_request():
    business_id = "<business_id>"
    url = f"https://api.middesk.com/v1/businesses/{business_id}"

    headers = {
        "Accept": "application/json",
        "Authorization": "Basic <api_key>"
    }

    try:
        # Make the request
        response = requests.get(url, headers=headers, auth=HTTPBasicAuth('<api_key>', ''))
        
        # Parse the response JSON
        response_data = response.json()
        website_status_task = next((task for task in response_data['review']['tasks'] if task['key'] == 'website_status'), None)

        if website_status_task and website_status_task['status'] == 'success':
            print('Website online')
        else:
            print('Website offline')

    except requests.exceptions.RequestException as e:
        print(f"HTTP Request failed ({e})")

send_request()

  const businessId = "<business_id>";
  const url = `https://api.middesk.com/v1/businesses/${businessId}`;

  const headers = {
    "Accept": "application/json",
    "Authorization": "Basic <api_key>"
  };

  try {
    // Make the request using fetch
    const response = await fetch(url, { headers });
    
    // Check if the request was successful
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }

    const responseData = await response.json();
    const websiteStatusTask = responseData.review.tasks.find(task => task.key === 'website_status');

    if (websiteStatusTask && websiteStatusTask.status === 'success') {
      console.log('Website online');
    } else {
      console.log('Website offline');
    }
  } catch (error) {
    console.error(`HTTP Request failed: ${error.message}`);
  }
}

sendRequest();

require 'net/http'
require 'uri'
require 'json'
require 'base64'

def print_indicators_quality_ratings
  # Replace with your actual business ID and API key
  business_id = "51c4b91e-f324-467b-86b5-9e0155bcc251"  # Example business ID
  api_key = "YOUR_API_KEY_HERE"  # Replace with your actual API key

  uri = URI.parse("https://api.middesk.com/v1/businesses/#{business_id}/website")

  # Create the HTTP Basic Auth header
  auth = Base64.strict_encode64("#{api_key}:")
  headers = {
    "Accept" => "application/json",
    "Authorization" => "Basic #{auth}"
  }

  # Create the HTTP request
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  request = Net::HTTP::Get.new(uri.request_uri, headers)

  begin
    # Make the request
    response = http.request(request)

    # Raise an error if the response is not successful
    unless response.is_a?(Net::HTTPSuccess)
      puts "HTTP Request failed (#{response.code} #{response.message})"
      return
    end

    # Parse the JSON response
    data = JSON.parse(response.body)

    # Navigate to the indicators
    indicators = data.dig('rating', 'indicators') || []

    if indicators.empty?
      puts "No indicators found in the response."
      return
    end

    # Print each indicator's name and rating
    puts "Indicators' Quality Ratings:"
    puts "----------------------------"
    indicators.each do |indicator|
      name = indicator['name'] || 'Unknown Indicator'
      rating = indicator['rating'] || 'No Rating'
      description = indicator['description'] || ''
      puts "#{name}: #{rating} (#{description})"
    end

  rescue JSON::ParserError
    puts "Error parsing JSON response."
  rescue StandardError => e
    puts "An error occurred: #{e.message}"
  end
end

print_indicators_quality_ratings

# Sample Output:
# Indicators' Quality Ratings:
# ----------------------------
# Domain age: positive (3 to 10 years old)
# Compliance info: positive (Found)
# Spelling and grammar: positive (Good)
# Contact info: positive (Found)
# Content diversity: positive (High)
# Https: positive (Enabled)
# Broken links: negative (Some broken)
# Filler text: positive (Minimal)
# Page count: positive (High)
# Image quality: positive (Good)

import requests
from requests.auth import HTTPBasicAuth

def print_indicators_quality_ratings():
    # Replace with your actual business ID and API key
    business_id = "51c4b91e-f324-467b-86b5-9e0155bcc251"  # Example business ID
    api_key = "YOUR_API_KEY_HERE"  # Replace with your actual API key

    url = f"https://api.middesk.com/v1/businesses/{business_id}/website"

    headers = {
        "Accept": "application/json"
    }

    try:
        # Make the GET request with HTTP Basic Authentication
        response = requests.get(url, headers=headers, auth=HTTPBasicAuth(api_key, ''))

        # Raise an exception if the request was unsuccessful
        response.raise_for_status()

        # Parse the JSON response
        data = response.json()

        # Navigate to the indicators
        indicators = data.get('rating', {}).get('indicators', [])

        if not indicators:
            print("No indicators found in the response.")
            return

        # Print each indicator's name and rating
        print("Indicators' Quality Ratings:")
        print("----------------------------")
        for indicator in indicators:
            name = indicator.get('name', 'Unknown Indicator')
            rating = indicator.get('rating', 'No Rating')
            description = indicator.get('description', '')
            print(f"{name}: {rating} ({description})")

    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")  # e.g., 404 Not Found
    except requests.exceptions.RequestException as req_err:
        print(f"Request error occurred: {req_err}")  # Other request-related errors
    except ValueError:
        print("Error parsing JSON response.")
    except KeyError as key_err:
        print(f"Missing expected data in response: {key_err}")

if __name__ == "__main__":
    print_indicators_quality_ratings()

''' Sample output
Indicators' Quality Ratings:
----------------------------
Domain age: positive (3 to 10 years old)
Compliance info: positive (Found)
Spelling and grammar: positive (Good)
Contact info: positive (Found)
Content diversity: positive (High)
Https: positive (Enabled)
Broken links: negative (Some broken)
Filler text: positive (Minimal)
Page count: positive (High)
Image quality: positive (Good)
'''

const axios = require('axios');

async function printIndicatorsQualityRatings() {
  // Replace with your actual business ID and API key
  const businessId = "51c4b91e-f324-467b-86b5-9e0155bcc251"; // Example business ID
  const apiKey = "YOUR_API_KEY_HERE"; // Replace with your actual API key

  const url = `https://api.middesk.com/v1/businesses/${businessId}/website`;

  try {
    const response = await axios.get(url, {
      headers: {
        'Accept': 'application/json',
        'Authorization': `Basic ${Buffer.from(`${apiKey}:`).toString('base64')}`
      }
    });

    const data = response.data;

    // Navigate to the indicators
    const indicators = data.rating && data.rating.indicators ? data.rating.indicators : [];

    if (indicators.length === 0) {
      console.log("No indicators found in the response.");
      return;
    }

    // Print each indicator's name and rating
    console.log("Indicators' Quality Ratings:");
    console.log("----------------------------");
    indicators.forEach(indicator => {
      const name = indicator.name || 'Unknown Indicator';
      const rating = indicator.rating || 'No Rating';
      const description = indicator.description || '';
      console.log(`${name}: ${rating} (${description})`);
    });

  } catch (error) {
    if (error.response) {
      // Server responded with a status other than 2xx
      console.error(`HTTP error occurred: ${error.response.status} ${error.response.statusText}`);
    } else if (error.request) {
      // No response received
      console.error("No response received:", error.request);
    } else {
      // Other errors
      console.error("Error:", error.message);
    }
  }
}

printIndicatorsQualityRatings();

// Sample Output:
// Indicators' Quality Ratings:
// ----------------------------
// Domain age: positive (3 to 10 years old)
// Compliance info: positive (Found)
// Spelling and grammar: positive (Good)
// Contact info: positive (Found)
// Content diversity: positive (High)
// Https: positive (Enabled)
// Broken links: negative (Some broken)
// Filler text: positive (Minimal)
// Page count: positive (High)
// Image quality: positive (Good)