Add MLS by HansonXyz plugin for MLS Grid API integration

Features:
- Full sync of NorthStar MLS properties via MLS Grid API v2
- Incremental sync using ModificationTimestamp
- Local media download and storage
- Rate limit compliance (2 req/sec, 7200/hr, 40000/day)
- Sync state tracking with resume capability
- WP-CLI commands: test, sync, status, stats, cache
- Admin settings page with manual sync triggers
- Public API functions: mls_get_properties, mls_get_property, etc.

Database tables:
- mls_properties: Listing data with full field mapping
- mls_media: Downloaded images
- mls_sync_state: Sync progress tracking
- mls_rate_limits: API usage tracking
- mls_sync_log: Debug logging

Documentation:
- docs/CLAUDE.md: AI development guide
- docs/API.md: MLS Grid API reference
- docs/USAGE.md: User documentation

Tested: Connection, auth, sync 10 records, media download verified

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Hanson.xyz Dev
2025-12-14 21:24:38 -06:00
parent ec5a309555
commit 6556479417
18 changed files with 5324 additions and 10 deletions
@@ -0,0 +1,323 @@
<?php
/**
* Rate limiter class for MLS Grid API compliance
*
* MLS Grid Rate Limits:
* - 2 requests per second
* - 7,200 requests per hour
* - 40,000 requests per day
* - 4GB data per hour
*/
if (!defined('ABSPATH')) {
exit;
}
class MLS_Rate_Limiter {
/**
* Rate limit constants
*/
const LIMIT_PER_SECOND = 2;
const LIMIT_PER_HOUR = 7200;
const LIMIT_PER_DAY = 40000;
const LIMIT_BYTES_PER_HOUR = 4294967296; // 4GB
/**
* Window types
*/
const WINDOW_SECOND = 'second';
const WINDOW_HOUR = 'hour';
const WINDOW_DAY = 'day';
/**
* Database instance
*/
private $db;
/**
* Last request timestamp for per-second limiting
*/
private $last_request_time = 0;
/**
* Constructor
*
* @param MLS_DB $db Database instance
*/
public function __construct(MLS_DB $db) {
$this->db = $db;
}
/**
* Check if we can make a request (and wait if needed)
*
* @param bool $wait Whether to wait if rate limited
* @return bool True if request can proceed
*/
public function check_and_wait($wait = true) {
// Check per-second limit (most restrictive)
$this->enforce_per_second_limit();
// Check hourly limit
if (!$this->check_limit(self::WINDOW_HOUR, self::LIMIT_PER_HOUR)) {
if ($wait) {
$this->wait_for_window(self::WINDOW_HOUR);
} else {
return false;
}
}
// Check daily limit
if (!$this->check_limit(self::WINDOW_DAY, self::LIMIT_PER_DAY)) {
if ($wait) {
$this->wait_for_window(self::WINDOW_DAY);
} else {
return false;
}
}
return true;
}
/**
* Enforce per-second rate limit
*/
private function enforce_per_second_limit() {
$now = microtime(true);
$min_interval = 1.0 / self::LIMIT_PER_SECOND; // 0.5 seconds
if ($this->last_request_time > 0) {
$elapsed = $now - $this->last_request_time;
if ($elapsed < $min_interval) {
$sleep_time = ($min_interval - $elapsed) * 1000000; // microseconds
usleep((int) $sleep_time);
}
}
$this->last_request_time = microtime(true);
}
/**
* Check if under the limit for a window type
*
* @param string $window_type Window type
* @param int $limit Limit for this window
* @return bool True if under limit
*/
private function check_limit($window_type, $limit) {
$count = $this->get_window_count($window_type);
return $count < $limit;
}
/**
* Get current count for a window
*
* @param string $window_type Window type
* @return int Current request count
*/
private function get_window_count($window_type) {
global $wpdb;
$window_start = $this->get_window_start($window_type);
$count = $wpdb->get_var($wpdb->prepare(
"SELECT request_count FROM {$this->db->rate_limits_table()}
WHERE window_type = %s AND window_start = %s",
$window_type,
$window_start
));
return $count ? (int) $count : 0;
}
/**
* Get window start time
*
* @param string $window_type Window type
* @return string MySQL datetime
*/
private function get_window_start($window_type) {
$now = current_time('timestamp');
switch ($window_type) {
case self::WINDOW_SECOND:
return gmdate('Y-m-d H:i:s', $now);
case self::WINDOW_HOUR:
return gmdate('Y-m-d H:00:00', $now);
case self::WINDOW_DAY:
return gmdate('Y-m-d 00:00:00', $now);
default:
return gmdate('Y-m-d H:i:s', $now);
}
}
/**
* Record a request
*
* @param int $bytes_transferred Optional bytes transferred
*/
public function record_request($bytes_transferred = 0) {
global $wpdb;
// Record for hourly window
$this->increment_window(self::WINDOW_HOUR, $bytes_transferred);
// Record for daily window
$this->increment_window(self::WINDOW_DAY, $bytes_transferred);
// Clean up old records
$this->cleanup_old_records();
}
/**
* Increment count for a window
*
* @param string $window_type Window type
* @param int $bytes_transferred Bytes transferred
*/
private function increment_window($window_type, $bytes_transferred = 0) {
global $wpdb;
$window_start = $this->get_window_start($window_type);
// Try to update existing record
$updated = $wpdb->query($wpdb->prepare(
"UPDATE {$this->db->rate_limits_table()}
SET request_count = request_count + 1,
bytes_transferred = bytes_transferred + %d
WHERE window_type = %s AND window_start = %s",
$bytes_transferred,
$window_type,
$window_start
));
// If no record existed, insert new one
if (0 === $updated) {
$wpdb->insert(
$this->db->rate_limits_table(),
array(
'window_type' => $window_type,
'window_start' => $window_start,
'request_count' => 1,
'bytes_transferred' => $bytes_transferred,
),
array('%s', '%s', '%d', '%d')
);
}
}
/**
* Wait for a rate limit window to reset
*
* @param string $window_type Window type
*/
private function wait_for_window($window_type) {
$now = current_time('timestamp');
switch ($window_type) {
case self::WINDOW_HOUR:
// Wait until next hour
$next_hour = strtotime('+1 hour', strtotime(gmdate('Y-m-d H:00:00', $now)));
$wait_seconds = $next_hour - $now;
break;
case self::WINDOW_DAY:
// Wait until next day
$next_day = strtotime('+1 day', strtotime(gmdate('Y-m-d 00:00:00', $now)));
$wait_seconds = $next_day - $now;
break;
default:
$wait_seconds = 1;
}
if ($wait_seconds > 0) {
sleep(min($wait_seconds, 60)); // Max 60 second wait per call
}
}
/**
* Clean up old rate limit records
*/
private function cleanup_old_records() {
global $wpdb;
// Delete records older than 48 hours
$cutoff = gmdate('Y-m-d H:i:s', strtotime('-48 hours'));
$wpdb->query($wpdb->prepare(
"DELETE FROM {$this->db->rate_limits_table()} WHERE window_start < %s",
$cutoff
));
}
/**
* Get current rate limit status
*
* @return array Rate limit status
*/
public function get_status() {
return array(
'hourly' => array(
'used' => $this->get_window_count(self::WINDOW_HOUR),
'limit' => self::LIMIT_PER_HOUR,
'remaining' => max(0, self::LIMIT_PER_HOUR - $this->get_window_count(self::WINDOW_HOUR)),
),
'daily' => array(
'used' => $this->get_window_count(self::WINDOW_DAY),
'limit' => self::LIMIT_PER_DAY,
'remaining' => max(0, self::LIMIT_PER_DAY - $this->get_window_count(self::WINDOW_DAY)),
),
'bytes_this_hour' => $this->get_bytes_this_hour(),
'bytes_limit' => self::LIMIT_BYTES_PER_HOUR,
);
}
/**
* Get bytes transferred this hour
*
* @return int Bytes
*/
private function get_bytes_this_hour() {
global $wpdb;
$window_start = $this->get_window_start(self::WINDOW_HOUR);
$bytes = $wpdb->get_var($wpdb->prepare(
"SELECT bytes_transferred FROM {$this->db->rate_limits_table()}
WHERE window_type = %s AND window_start = %s",
self::WINDOW_HOUR,
$window_start
));
return $bytes ? (int) $bytes : 0;
}
/**
* Check if we're approaching rate limits
*
* @param float $threshold Percentage threshold (0.0 - 1.0)
* @return bool True if approaching limits
*/
public function is_approaching_limit($threshold = 0.9) {
$status = $this->get_status();
$hourly_pct = $status['hourly']['used'] / $status['hourly']['limit'];
$daily_pct = $status['daily']['used'] / $status['daily']['limit'];
return $hourly_pct >= $threshold || $daily_pct >= $threshold;
}
/**
* Reset all rate limit counters (for testing)
*/
public function reset() {
global $wpdb;
$wpdb->query("TRUNCATE TABLE {$this->db->rate_limits_table()}");
$this->last_request_time = 0;
}
}