567 lines
18 KiB
Bash
Executable File
567 lines
18 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
[ -f functions.sh ] && source functions.sh
|
|
|
|
# Dependencies required by this module
|
|
dependencies=("curl" "jq" "date")
|
|
|
|
if ! check_dependencies "${dependencies[@]}"; then
|
|
msg "$2" "$1: This module requires: ${dependencies[*]}"
|
|
exit 1
|
|
fi
|
|
|
|
set -f
|
|
|
|
name="$1"
|
|
channelName="$2"
|
|
shift 2
|
|
|
|
# Database file for user locations and cached geocoding
|
|
weatherDb="data/weather.db"
|
|
weatherDbLock="${weatherDb}.lock"
|
|
nominatimRateLimitFile="data/nominatim_last_request"
|
|
mkdir -p "$(dirname "$weatherDb")"
|
|
touch "$weatherDb"
|
|
|
|
# Weather code mapping (Open-Meteo codes to descriptions)
|
|
declare -A weatherCodes=(
|
|
[0]="Clear sky"
|
|
[1]="Mainly clear"
|
|
[2]="Partly cloudy"
|
|
[3]="Overcast"
|
|
[45]="Fog"
|
|
[48]="Rime fog"
|
|
[51]="Light drizzle"
|
|
[53]="Moderate drizzle"
|
|
[55]="Dense drizzle"
|
|
[56]="Light freezing drizzle"
|
|
[57]="Dense freezing drizzle"
|
|
[61]="Slight rain"
|
|
[63]="Moderate rain"
|
|
[65]="Heavy rain"
|
|
[66]="Light freezing rain"
|
|
[67]="Heavy freezing rain"
|
|
[71]="Slight snow fall"
|
|
[73]="Moderate snow fall"
|
|
[75]="Heavy snow fall"
|
|
[77]="Snow flurries"
|
|
[80]="Slight rain showers"
|
|
[81]="Moderate rain showers"
|
|
[82]="Heavy rain showers"
|
|
[85]="Slight snow showers"
|
|
[86]="Heavy snow showers"
|
|
[95]="Thunderstorm"
|
|
[96]="Thunderstorm with slight hail"
|
|
[99]="Thunderstorm with heavy hail"
|
|
)
|
|
|
|
# Function to get cached geocode result
|
|
get_cached_location() {
|
|
local query="$1"
|
|
local queryLower="${query,,}"
|
|
grep -i "^CACHE|${queryLower}|" "$weatherDb" 2>/dev/null | head -n1
|
|
}
|
|
|
|
# Function to get user's saved location
|
|
get_user_location() {
|
|
local user="$1"
|
|
grep "^USER|${user}|" "$weatherDb" 2>/dev/null | head -n1
|
|
}
|
|
|
|
# Function to save user location
|
|
save_user_location() {
|
|
local user="$1"
|
|
local location="$2"
|
|
local lat="$3"
|
|
local lon="$4"
|
|
local formatted="$5"
|
|
|
|
# Use flock to prevent race conditions
|
|
(
|
|
flock -x 200
|
|
|
|
# Remove old entry if exists
|
|
if [[ -f "$weatherDb" ]]; then
|
|
grep -v "^USER|${user}|" "$weatherDb" > "${weatherDb}.tmp"
|
|
mv "${weatherDb}.tmp" "$weatherDb"
|
|
fi
|
|
|
|
# Add new entry
|
|
echo "USER|${user}|${location}|${lat}|${lon}|${formatted}" >> "$weatherDb"
|
|
|
|
) 200>"$weatherDbLock"
|
|
}
|
|
|
|
# Function to delete user location
|
|
delete_user_location() {
|
|
local user="$1"
|
|
|
|
# Use flock to prevent race conditions
|
|
(
|
|
flock -x 200
|
|
|
|
if [[ -f "$weatherDb" ]]; then
|
|
grep -v "^USER|${user}|" "$weatherDb" > "${weatherDb}.tmp"
|
|
mv "${weatherDb}.tmp" "$weatherDb"
|
|
fi
|
|
|
|
) 200>"$weatherDbLock"
|
|
}
|
|
|
|
# Function to maintain cache size
|
|
maintain_cache() {
|
|
# Use flock to prevent race conditions
|
|
(
|
|
flock -x 200
|
|
|
|
if [[ ! -f "$weatherDb" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
local lineCount
|
|
lineCount=$(wc -l < "$weatherDb")
|
|
|
|
# If file has 2000 or more lines, keep only the most recent 1500
|
|
if [[ $lineCount -ge 2000 ]]; then
|
|
# Separate USER and CACHE entries
|
|
grep "^USER|" "$weatherDb" > "${weatherDb}.tmp.user" 2>/dev/null || true
|
|
grep "^CACHE|" "$weatherDb" | tail -n 1000 > "${weatherDb}.tmp.cache" 2>/dev/null || true
|
|
|
|
# Combine them back (keep all user entries, trim cache entries)
|
|
cat "${weatherDb}.tmp.user" "${weatherDb}.tmp.cache" > "${weatherDb}.tmp" 2>/dev/null
|
|
mv "${weatherDb}.tmp" "$weatherDb"
|
|
|
|
# Clean up temp files
|
|
rm -f "${weatherDb}.tmp.user" "${weatherDb}.tmp.cache"
|
|
fi
|
|
|
|
) 200>"$weatherDbLock"
|
|
}
|
|
|
|
# Function to cache geocode result
|
|
cache_location() {
|
|
local query="$1"
|
|
local location="$2"
|
|
local lat="$3"
|
|
local lon="$4"
|
|
local formatted="$5"
|
|
local queryLower="${query,,}"
|
|
|
|
# Check if already cached
|
|
local cached
|
|
cached=$(get_cached_location "$query")
|
|
if [[ -z "$cached" ]]; then
|
|
# Use flock to prevent race conditions
|
|
(
|
|
flock -x 200
|
|
echo "CACHE|${queryLower}|${location}|${lat}|${lon}|${formatted}" >> "$weatherDb"
|
|
) 200>"$weatherDbLock"
|
|
|
|
# Maintain cache size after adding new entry
|
|
maintain_cache
|
|
fi
|
|
}
|
|
|
|
# Function to enforce Nominatim rate limit (1 request per second)
|
|
rate_limit_nominatim() {
|
|
local rateLimitLock="${nominatimRateLimitFile}.lock"
|
|
|
|
(
|
|
flock -x 200
|
|
|
|
# Check if rate limit file exists and read last request time
|
|
if [[ -f "$nominatimRateLimitFile" ]]; then
|
|
local lastRequest
|
|
lastRequest=$(cat "$nominatimRateLimitFile" 2>/dev/null || echo "0")
|
|
local currentTime
|
|
currentTime=$(date +%s)
|
|
local timeSinceLastRequest=$((currentTime - lastRequest))
|
|
|
|
# If less than 1 second has passed, sleep for the remaining time
|
|
if [[ $timeSinceLastRequest -lt 1 ]]; then
|
|
local sleepTime=$((1 - timeSinceLastRequest))
|
|
sleep "$sleepTime"
|
|
fi
|
|
fi
|
|
|
|
# Update last request time
|
|
date +%s > "$nominatimRateLimitFile"
|
|
|
|
) 200>"$rateLimitLock"
|
|
}
|
|
|
|
# Function to format location (City, State or City, Country)
|
|
format_location() {
|
|
local address="$1"
|
|
|
|
# Use jq to parse the address components
|
|
local locality
|
|
local state
|
|
local country
|
|
local countryCode
|
|
|
|
# Try various location types in order of specificity
|
|
locality=$(echo "$address" | jq -r '.city // .town // .village // .hamlet // .municipality // .suburb // empty' 2>/dev/null)
|
|
state=$(echo "$address" | jq -r '.state // empty' 2>/dev/null)
|
|
country=$(echo "$address" | jq -r '.country // empty' 2>/dev/null)
|
|
countryCode=$(echo "$address" | jq -r '.country_code // empty' 2>/dev/null)
|
|
|
|
# For US addresses, always show state if available
|
|
if [[ "$countryCode" == "us" && -n "$locality" && -n "$state" ]]; then
|
|
echo "${locality}, ${state}"
|
|
elif [[ "$countryCode" == "us" && -n "$state" ]]; then
|
|
# No locality, just show state
|
|
echo "${state}, United States"
|
|
elif [[ -n "$locality" && -n "$country" ]]; then
|
|
# International: show locality and country
|
|
echo "${locality}, ${country}"
|
|
elif [[ -n "$country" ]]; then
|
|
# Just country
|
|
echo "$country"
|
|
else
|
|
# Fallback to display_name if parsing fails
|
|
echo "$address" | jq -r '.display_name // "Unknown location"' 2>/dev/null
|
|
fi
|
|
}
|
|
|
|
# Function to geocode a location
|
|
geocode_location() {
|
|
local query="$1"
|
|
|
|
# Check cache first
|
|
local cached
|
|
local location
|
|
local lat
|
|
local lon
|
|
local formatted
|
|
cached=$(get_cached_location "$query")
|
|
if [[ -n "$cached" ]]; then
|
|
# Format: CACHE|query|location|lat|lon|formatted
|
|
location=$(echo "$cached" | cut -d'|' -f3)
|
|
lat=$(echo "$cached" | cut -d'|' -f4)
|
|
lon=$(echo "$cached" | cut -d'|' -f5)
|
|
formatted=$(echo "$cached" | cut -d'|' -f6)
|
|
|
|
# If no formatted location in cache (old format), use location
|
|
if [[ -z "$formatted" ]]; then
|
|
formatted="$location"
|
|
fi
|
|
|
|
echo "${location}|${lat}|${lon}|${formatted}"
|
|
return 0
|
|
fi
|
|
|
|
# Query Nominatim API
|
|
local url="https://nominatim.openstreetmap.org/search"
|
|
local userAgent="stormbot-weather/1.0"
|
|
local response
|
|
|
|
# Check if query contains common US indicators (case-insensitive)
|
|
local countryCode=""
|
|
local queryLower="${query,,}"
|
|
local isUsZipCode=false
|
|
|
|
# Common US state names and abbreviations
|
|
local usStates="alabama|alaska|arizona|arkansas|california|colorado|connecticut|delaware|florida|georgia|hawaii|idaho|illinois|indiana|iowa|kansas|kentucky|louisiana|maine|maryland|massachusetts|michigan|minnesota|mississippi|missouri|montana|nebraska|nevada|new hampshire|new jersey|new mexico|new york|north carolina|north dakota|ohio|oklahoma|oregon|pennsylvania|rhode island|south carolina|south dakota|tennessee|texas|utah|vermont|virginia|washington|west virginia|wisconsin|wyoming"
|
|
|
|
# Check if this is a US ZIP code query
|
|
if [[ "$query" =~ ^[0-9]{5}([[:space:]]|$) ]]; then
|
|
isUsZipCode=true
|
|
fi
|
|
|
|
if [[ "$queryLower" =~ (usa|united states) ]] || \
|
|
[[ "$query" =~ [[:space:]][A-Z]{2}$ ]] || \
|
|
[[ "$queryLower" =~ [[:space:]](${usStates})$ ]] || \
|
|
[[ "$isUsZipCode" == true ]]; then
|
|
# Query mentions USA, ends with state abbreviation, ends with state name, or is a zip code
|
|
countryCode="&countrycodes=us"
|
|
fi
|
|
|
|
# Build the query URL
|
|
local apiUrl
|
|
if [[ "$isUsZipCode" == true ]]; then
|
|
# For ZIP codes, use postalcode parameter for better accuracy
|
|
local zipCode="${query%% *}" # Extract just the ZIP code (remove any trailing text)
|
|
apiUrl="${url}?postalcode=${zipCode}&country=us&format=json&limit=1&addressdetails=1"
|
|
else
|
|
# URL encode the query (replace spaces with +)
|
|
local encodedQuery="${query// /+}"
|
|
apiUrl="${url}?q=${encodedQuery}&format=json&limit=1&addressdetails=1${countryCode}"
|
|
fi
|
|
|
|
# Enforce rate limit before making API request
|
|
rate_limit_nominatim
|
|
|
|
response=$(curl -s --connect-timeout 5 --max-time 10 \
|
|
-H "User-Agent: ${userAgent}" \
|
|
"${apiUrl}")
|
|
|
|
if [[ -z "$response" || "$response" == "[]" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
# Parse response
|
|
local fullAddress
|
|
local addressDetails
|
|
local formattedLocation
|
|
lat=$(echo "$response" | jq -r '.[0].lat // empty' 2>/dev/null)
|
|
lon=$(echo "$response" | jq -r '.[0].lon // empty' 2>/dev/null)
|
|
fullAddress=$(echo "$response" | jq -r '.[0].display_name // empty' 2>/dev/null)
|
|
addressDetails=$(echo "$response" | jq -r '.[0].address // empty' 2>/dev/null)
|
|
|
|
if [[ -z "$lat" || -z "$lon" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
# Format the location nicely
|
|
formattedLocation=$(format_location "$addressDetails")
|
|
|
|
# Cache the result
|
|
cache_location "$query" "$fullAddress" "$lat" "$lon" "$formattedLocation"
|
|
|
|
echo "${fullAddress}|${lat}|${lon}|${formattedLocation}"
|
|
return 0
|
|
}
|
|
|
|
# Function to get weather data
|
|
get_weather() {
|
|
local lat="$1"
|
|
local lon="$2"
|
|
|
|
local url="https://api.open-meteo.com/v1/forecast"
|
|
local params="latitude=${lat}&longitude=${lon}"
|
|
params+="¤t=temperature_2m,apparent_temperature,relative_humidity_2m,weather_code,wind_speed_10m"
|
|
params+="&daily=weather_code,temperature_2m_max,temperature_2m_min"
|
|
params+="&timezone=auto&forecast_days=3&temperature_unit=fahrenheit&wind_speed_unit=mph"
|
|
|
|
local response
|
|
response=$(curl -s --connect-timeout 5 --max-time 10 "${url}?${params}")
|
|
|
|
if [[ -z "$response" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
echo "$response"
|
|
return 0
|
|
}
|
|
|
|
# Function to format weather output
|
|
format_weather() {
|
|
local weatherData="$1"
|
|
local locationName="$2"
|
|
|
|
# Parse current weather
|
|
local temp
|
|
local feelsLike
|
|
local humidity
|
|
local windSpeed
|
|
local weatherCode
|
|
temp=$(echo "$weatherData" | jq -r '.current.temperature_2m // "N/A"')
|
|
feelsLike=$(echo "$weatherData" | jq -r '.current.apparent_temperature // "N/A"')
|
|
humidity=$(echo "$weatherData" | jq -r '.current.relative_humidity_2m // "N/A"')
|
|
windSpeed=$(echo "$weatherData" | jq -r '.current.wind_speed_10m // "N/A"')
|
|
weatherCode=$(echo "$weatherData" | jq -r '.current.weather_code // 0')
|
|
local conditions="${weatherCodes[$weatherCode]:-Unknown}"
|
|
|
|
# Build message
|
|
local message="Weather for ${locationName}: ${temp}°F"
|
|
|
|
# Add feels-like if different from actual temp (round to nearest degree for comparison)
|
|
if [[ "$feelsLike" != "N/A" && "$temp" != "N/A" ]]; then
|
|
local tempRounded
|
|
local feelsLikeRounded
|
|
tempRounded=$(printf "%.0f" "$temp" 2>/dev/null || echo "$temp")
|
|
feelsLikeRounded=$(printf "%.0f" "$feelsLike" 2>/dev/null || echo "$feelsLike")
|
|
|
|
# Only show feels-like if it differs by at least 3 degrees
|
|
local diff=$((tempRounded - feelsLikeRounded))
|
|
if [[ ${diff#-} -ge 3 ]]; then
|
|
message+=" (feels like ${feelsLike}°F)"
|
|
fi
|
|
fi
|
|
|
|
message+=", ${conditions}"
|
|
|
|
if [[ "$humidity" != "N/A" ]]; then
|
|
message+=", Humidity: ${humidity}%"
|
|
fi
|
|
|
|
if [[ "$windSpeed" != "N/A" ]]; then
|
|
message+=", Wind: ${windSpeed} mph"
|
|
fi
|
|
|
|
echo "$message"
|
|
}
|
|
|
|
# Function to format forecast output
|
|
format_forecast() {
|
|
local weatherData="$1"
|
|
|
|
# Parse forecast data
|
|
local dates
|
|
dates=$(echo "$weatherData" | jq -r '.daily.time[]' 2>/dev/null)
|
|
|
|
if [[ -z "$dates" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
local forecastParts=()
|
|
local i=0
|
|
|
|
while IFS= read -r dateStr; do
|
|
local minTemp
|
|
local maxTemp
|
|
local code
|
|
minTemp=$(echo "$weatherData" | jq -r ".daily.temperature_2m_min[$i] // \"N/A\"")
|
|
maxTemp=$(echo "$weatherData" | jq -r ".daily.temperature_2m_max[$i] // \"N/A\"")
|
|
code=$(echo "$weatherData" | jq -r ".daily.weather_code[$i] // 0")
|
|
|
|
# Format date to day of week
|
|
local dayName
|
|
if date --version &>/dev/null; then
|
|
# GNU date
|
|
dayName=$(date -d "$dateStr" '+%A' 2>/dev/null)
|
|
else
|
|
# BSD date (macOS)
|
|
dayName=$(date -j -f '%Y-%m-%d' "$dateStr" '+%A' 2>/dev/null)
|
|
fi
|
|
|
|
if [[ -z "$dayName" ]]; then
|
|
dayName="$dateStr"
|
|
fi
|
|
|
|
local forecastConditions="${weatherCodes[$code]:-Unknown}"
|
|
|
|
if [[ "$minTemp" != "N/A" && "$maxTemp" != "N/A" ]]; then
|
|
forecastParts+=("${dayName}: ${minTemp}°F to ${maxTemp}°F, ${forecastConditions}")
|
|
fi
|
|
|
|
((i++))
|
|
|
|
# Only show 3 days
|
|
if [[ $i -ge 3 ]]; then
|
|
break
|
|
fi
|
|
done <<< "$dates"
|
|
|
|
if [[ ${#forecastParts[@]} -gt 0 ]]; then
|
|
local IFS=" | "
|
|
echo "Forecast: ${forecastParts[*]}"
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# Main command logic
|
|
subcommand="${1:-}"
|
|
|
|
case "$subcommand" in
|
|
set)
|
|
# Set user's location
|
|
shift
|
|
if [[ $# -eq 0 ]]; then
|
|
msg "$channelName" "$name: Usage: weather set <location>"
|
|
exit 0
|
|
fi
|
|
|
|
location="$*"
|
|
|
|
# Validate location length
|
|
if [[ ${#location} -gt 100 ]]; then
|
|
msg "$channelName" "$name: Location is too long (max 100 characters)."
|
|
exit 0
|
|
fi
|
|
|
|
# Geocode the location
|
|
geocodeResult=$(geocode_location "$location")
|
|
if [[ $? -ne 0 || -z "$geocodeResult" ]]; then
|
|
msg "$channelName" "$name: Could not find that location. Please try a different search term."
|
|
exit 0
|
|
fi
|
|
|
|
# Parse result: fullAddress|lat|lon|formattedLocation
|
|
fullAddress=$(echo "$geocodeResult" | cut -d'|' -f1)
|
|
lat=$(echo "$geocodeResult" | cut -d'|' -f2)
|
|
lon=$(echo "$geocodeResult" | cut -d'|' -f3)
|
|
formattedLocation=$(echo "$geocodeResult" | cut -d'|' -f4)
|
|
|
|
# Save user location
|
|
save_user_location "$name" "$fullAddress" "$lat" "$lon" "$formattedLocation"
|
|
|
|
msg "$channelName" "$name: Your location has been set to: ${formattedLocation}"
|
|
exit 0
|
|
;;
|
|
|
|
del|delete)
|
|
# Delete user's location
|
|
delete_user_location "$name"
|
|
msg "$channelName" "$name: Your location has been deleted."
|
|
;;
|
|
|
|
*)
|
|
# Show weather (default action)
|
|
if [[ -n "$subcommand" ]]; then
|
|
# Weather for specified location
|
|
location="$*"
|
|
|
|
# Validate location length
|
|
if [[ ${#location} -gt 100 ]]; then
|
|
msg "$channelName" "$name: Location is too long (max 100 characters)."
|
|
exit 0
|
|
fi
|
|
|
|
# Geocode the location
|
|
geocodeResult=$(geocode_location "$location")
|
|
if [[ $? -ne 0 || -z "$geocodeResult" ]]; then
|
|
msg "$channelName" "$name: Could not find that location. Please try a different search term."
|
|
exit 0
|
|
fi
|
|
|
|
# Parse result
|
|
fullAddress=$(echo "$geocodeResult" | cut -d'|' -f1)
|
|
lat=$(echo "$geocodeResult" | cut -d'|' -f2)
|
|
lon=$(echo "$geocodeResult" | cut -d'|' -f3)
|
|
formattedLocation=$(echo "$geocodeResult" | cut -d'|' -f4)
|
|
|
|
locationDisplay="$formattedLocation"
|
|
else
|
|
# Weather for user's saved location
|
|
userLocation=$(get_user_location "$name")
|
|
if [[ -z "$userLocation" ]]; then
|
|
msg "$channelName" "$name: You have not set a location. Use 'weather set <location>' to save your location, or 'weather <location>' to check weather for a specific location."
|
|
exit 0
|
|
fi
|
|
|
|
# Parse user location: USER|name|location|lat|lon|formatted
|
|
fullAddress=$(echo "$userLocation" | cut -d'|' -f3)
|
|
lat=$(echo "$userLocation" | cut -d'|' -f4)
|
|
lon=$(echo "$userLocation" | cut -d'|' -f5)
|
|
formattedLocation=$(echo "$userLocation" | cut -d'|' -f6)
|
|
|
|
# If no formatted location stored (old format), use full address
|
|
if [[ -z "$formattedLocation" ]]; then
|
|
formattedLocation="$fullAddress"
|
|
fi
|
|
|
|
locationDisplay="$formattedLocation"
|
|
fi
|
|
|
|
# Get weather data
|
|
weatherData=$(get_weather "$lat" "$lon")
|
|
if [[ $? -ne 0 || -z "$weatherData" ]]; then
|
|
msg "$channelName" "$name: Could not retrieve weather data. Please try again later."
|
|
exit 1
|
|
fi
|
|
|
|
# Format and send current weather
|
|
weatherMessage=$(format_weather "$weatherData" "$locationDisplay")
|
|
msg "$channelName" "$name: ${weatherMessage}"
|
|
|
|
# Format and send forecast
|
|
forecastMessage=$(format_forecast "$weatherData")
|
|
if [[ $? -eq 0 && -n "$forecastMessage" ]]; then
|
|
msg "$channelName" "$name: ${forecastMessage}"
|
|
fi
|
|
;;
|
|
esac
|