Market Data API

import requests

def get_franchises():
    url = "https://provericeni.com/api/v0/franchises"
    headers = {"x-api-key": "YOUR_API_KEY_HERE"}
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        franchises = response.json()
        print(f"Available franchises: {franchises}")
        return franchises
    else:
        print(f"Error: {response.status_code} - {response.json()}")
        return None

franchises = get_franchises()

const axios = require('axios');

async function getFranchises() {
    try {
        const response = await axios.get('https://provericeni.com/api/v0/franchises', {
            headers: {
                'x-api-key': 'YOUR_API_KEY_HERE'
            }
        });
        
        const franchises = response.data;
        console.log(`Available franchises: ${franchises.join(', ')}`);
        return franchises;
    } catch (error) {
        console.error('Error fetching franchises:', error.response?.data || error.message);
        return null;
    }
}

getFranchises();

import requests

def search_products(search_term):
    url = "https://provericeni.com/api/v0/search-products"
    headers = {"x-api-key": "YOUR_API_KEY_HERE"}
    params = {"searchString": search_term}
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 200:
        products = response.json()
        print(f"Found {len(products)} products matching '{search_term}'")
        for product in products[:5]:  # Show first 5 results
            print(f"- {product['product']['name']} ({product['product']['price']}) at {product['market_name']}")
        return products
    else:
        print(f"Error: {response.status_code} - {response.json()}")
        return None

results = search_products("oriz")

const axios = require('axios');

async function searchProducts(searchTerm) {
    try {
        const response = await axios.get('https://provericeni.com/api/v0/search-products', {
            headers: {
                'x-api-key': 'YOUR_API_KEY_HERE'
            },
            params: {
                searchString: searchTerm
            }
        });
        
        const products = response.data;
        console.log(`Found ${products.length} products matching '${searchTerm}'`);
        
        products.slice(0, 5).forEach(product => {
            console.log(`- ${product.product.name} (${product.product.price}) at ${product.market_name}`);
        });
        
        return products;
    } catch (error) {
        console.error('Error searching products:', error.response?.data || error.message);
        return null;
    }
}

searchProducts('oriz');

import requests

def get_franchise_markets(franchise_name):
    url = "https://provericeni.com/api/v0/markets"
    headers = {"x-api-key": "YOUR_API_KEY_HERE"}
    params = {"franchise": franchise_name}
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 200:
        markets = response.json()
        print(f"{franchise_name} has {len(markets)} markets:")
        for market in markets:
            print(f"- {market['name']}: {market['address']}")
        return markets
    else:
        print(f"Error: {response.status_code} - {response.json()}")
        return None

ramstore_markets = get_franchise_markets("ramstore")

const axios = require('axios');

async function getFranchiseMarkets(franchiseName) {
    try {
        const response = await axios.get('https://provericeni.com/api/v0/markets', {
            headers: {
                'x-api-key': 'YOUR_API_KEY_HERE'
            },
            params: {
                franchise: franchiseName
            }
        });
        
        const markets = response.data;
        console.log(`${franchiseName} has ${markets.length} markets:`);
        
        markets.forEach(market => {
            console.log(`- ${market.name}: ${market.address}`);
        });
        
        return markets;
    } catch (error) {
        console.error('Error fetching markets:', error.response?.data || error.message);
        return null;
    }
}

getFranchiseMarkets('ramstore');

import requests

def get_market_products_categorized(franchise, market_name):
    url = "https://provericeni.com/api/v0/market-products"
    headers = {"x-api-key": "YOUR_API_KEY_HERE"}
    params = {
        "franchise": franchise,
        "marketName": market_name,
        "categorizedProducts": "true"
    }
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 200:
        data = response.json()
        print(f"Products from {data['market_name']}:")
        for category in data['categories']:
            print(f"\n{category['subgroup']} ({len(category['products'])} items):")
            for product in category['products'][:3]:  # Show first 3 in each category
                print(f"  - {product['name']}: {product['price']} MKD")
        return data
    else:
        print(f"Error: {response.status_code} - {response.json()}")
        return None

products = get_market_products_categorized("ramstore", "ramstore-karposh")

const axios = require('axios');

async function getMarketProductsCategorized(franchise, marketName) {
    try {
        const response = await axios.get('https://provericeni.com/api/v0/market-products', {
            headers: {
                'x-api-key': 'YOUR_API_KEY_HERE'
            },
            params: {
                franchise: franchise,
                marketName: marketName,
                categorizedProducts: 'true'
            }
        });
        
        const data = response.data;
        console.log(`Products from ${data.market_name}:`);
        
        data.categories.forEach(category => {
            console.log(`\n${category.subgroup} (${category.products.length} items):`);
            category.products.slice(0, 3).forEach(product => {
                console.log(`  - ${product.name}: ${product.price} MKD`);
            });
        });
        
        return data;
    } catch (error) {
        console.error('Error fetching market products:', error.response?.data || error.message);
        return null;
    }
}

getMarketProductsCategorized('ramstore', 'ramstore-karposh');

import requests

def compare_product_prices(search_term):
    url = "https://provericeni.com/api/v0/search-products"
    headers = {"x-api-key": "YOUR_API_KEY_HERE"}
    params = {"searchString": search_term}
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 200:
        products = response.json()
        
        # Group by product name and extract prices
        price_comparison = {}
        for item in products:
            product_name = item['product']['name']
            price_str = item['product']['price'].replace(' DEN.', '').replace('.00', '')
            try:
                price = float(price_str)
                market_info = f"{item['franchise']} - {item['market_name']}"
                
                if product_name not in price_comparison:
                    price_comparison[product_name] = []
                price_comparison[product_name].append((market_info, price))
            except ValueError:
                continue
        
        # Print only 3
        for product, prices in list(price_comparison.items())[:3]:
            if len(prices) > 1:
                prices.sort(key=lambda x: x[1])
                print(f"\n{product}:")
                for market, price in prices:
                    print(f"  {price} MKD - {market}")
        
        return price_comparison
    else:
        print(f"Error: {response.status_code} - {response.json()}")
        return None

comparison = compare_product_prices("mleko")

const axios = require('axios');

async function compareProductPrices(searchTerm) {
    try {
        const response = await axios.get('https://provericeni.com/api/v0/search-products', {
            headers: {
                'x-api-key': 'YOUR_API_KEY_HERE'
            },
            params: {
                searchString: searchTerm
            }
        });
        
        const products = response.data;
        const priceComparison = {};
        
        // Group by product name and extract prices
        products.forEach(item => {
            const productName = item.product.name;
            const priceStr = item.product.price.replace(' DEN.', '').replace('.00', '');
            const price = parseFloat(priceStr);
            
            if (!isNaN(price)) {
                const marketInfo = `${item.franchise} - ${item.market_name}`;
                
                if (!priceComparison[productName]) {
                    priceComparison[productName] = [];
                }
                priceComparison[productName].push({ market: marketInfo, price });
            }
        });
        
        Object.entries(priceComparison)
            .slice(0, 3)
            .forEach(([product, prices]) => {
                if (prices.length > 1) {
                    prices.sort((a, b) => a.price - b.price);
                    console.log(`\n${product}:`);
                    prices.forEach(({ market, price }) => {
                        console.log(`  ${price} MKD - ${market}`);
                    });
                }
            });
        
        return priceComparison;
    } catch (error) {
        console.error('Error comparing prices:', error.response?.data || error.message);
        return null;
    }
}

compareProductPrices('mleko');