neo4j_.py

company_names = {
    "ADVANC": "บริษัท แอดวานซ์ อินโฟร์ เซอร์วิส จำกัด (มหาชน)",
    "AOT": "บริษัท ท่าอากาศยานไทย จำกัด (มหาชน)",
    "AWC": "บริษัท แอสเสท เวิรด์ คอร์ป จำกัด (มหาชน)",
    "BBL": "ธนาคารกรุงเทพ จำกัด (มหาชน)",
    "BCP": "บริษัท บางจาก คอร์ปอเรชั่น จำกัด (มหาชน)",
    "BDMS": "บริษัท กรุงเทพดุสิตเวชการ จำกัด (มหาชน)",
    "BEM": "บริษัท ทางด่วนและรถไฟฟ้ากรุงเทพ จำกัด (มหาชน)",
    "BGRIM": "บริษัท บี.กริม เพาเวอร์ จำกัด (มหาชน)",
    "BH": "บริษัท โรงพยาบาลบำรุงราษฎร์ จำกัด (มหาชน)",
    "BJC": "บริษัท เบอร์ลี่ ยุคเกอร์ จำกัด (มหาชน)",
    "BTS": "บริษัท บีทีเอส กรุ๊ป โฮลดิ้งส์ จำกัด (มหาชน)",
    "CBG": "บริษัท คาราบาวกรุ๊ป จำกัด (มหาชน)",
    "CENTEL": "บริษัท โรงแรมเซ็นทรัลพลาซา จำกัด (มหาชน)",
    "CPALL": "บริษัท ซีพี ออลล์ จำกัด (มหาชน)",
    "CPF": "บริษัท เจริญโภคภัณฑ์อาหาร จำกัด (มหาชน)",
    "CPN": "บริษัท เซ็นทรัลพัฒนา จำกัด (มหาชน)",
    "CRC": "บริษัท เซ็นทรัล รีเทล คอร์ปอเรชั่น จำกัด (มหาชน)",
    "DELTA": "บริษัท เดลต้า อีเลคโทรนิคส์ (ประเทศไทย) จำกัด (มหาชน)",
    "EA": "บริษัท พลังงานบริสุทธิ์ จำกัด (มหาชน)",
    "EGCO": "บริษัท ผลิตไฟฟ้า จำกัด (มหาชน)",
    "GLOBAL": "บริษัท สยามโกลบอลเฮ้าส์ จำกัด (มหาชน)",
    "GPSC": "บริษัท โกลบอล เพาเวอร์ ซินเนอร์ยี่ จำกัด (มหาชน)",
    "GULF": "บริษัท กัลฟ์ เอ็นเนอร์จี ดีเวลลอปเมนท์ จำกัด (มหาชน)",
    "HMPRO": "บริษัท โฮม โปรดักส์ เซ็นเตอร์ จำกัด (มหาชน)",
    "INTUCH": "บริษัท อินทัช โฮลดิ้งส์ จำกัด (มหาชน)",
    "ITC": "บริษัท ไอ-เทล คอร์ปอเรชั่น จำกัด (มหาชน)",
    "IVL": "บริษัท อินโดรามา เวนเจอร์ส จำกัด (มหาชน)",
    "KBANK": "ธนาคารกสิกรไทย จำกัด (มหาชน)",
    "KTB": "ธนาคารกรุงไทย จำกัด (มหาชน)",
    "KTC": "บริษัท บัตรกรุงไทย จำกัด (มหาชน)",
    "LH": "บริษัท แลนด์ แอนด์ เฮ้าส์ จำกัด (มหาชน)",
    "MINT": "บริษัท ไมเนอร์ อินเตอร์เนชั่นแนล จำกัด (มหาชน)",
    "MTC": "บริษัท เมืองไทย แคปปิตอล จำกัด (มหาชน)",
    "OR": "บริษัท ปตท. น้ำมันและการค้าปลีก จำกัด (มหาชน)",
    "OSP": "บริษัท โอสถสภา จำกัด (มหาชน)",
    "PTT": "บริษัท ปตท. จำกัด (มหาชน)",
    "PTTEP": "บริษัท ปตท. สำรวจและผลิตปิโตรเลียม จำกัด (มหาชน)",
    "PTTGC": "บริษัท พีทีที โกลบอล เคมิคอล จำกัด (มหาชน)",
    "RATCH": "บริษัท ราช กรุ๊ป จำกัด (มหาชน)",
    "SCB": "ธนาคารไทยพาณิชย์ จำกัด (มหาชน)",
    "SCC": "บริษัท ปูนซิเมนต์ไทย จำกัด (มหาชน)",
    "SCGP": "บริษัท เอสซีจี แพคเกจจิ้ง จำกัด (มหาชน)",
    "TIDLOR": "บริษัท เงินติดล้อ จำกัด (มหาชน)",
    "TISCO": "บริษัท ทิสโก้ไฟแนนเชียลกรุ๊ป จำกัด (มหาชน)",
    "TLI": "บริษัท ไทยประกันชีวิต จำกัด (มหาชน)",
    "TOP": "บริษัท ไทยออยล์ จำกัด (มหาชน)",
    "TRUE": "บริษัท ทรู คอร์ปอเรชั่น จำกัด (มหาชน)",
    "TTB": "ธนาคารทหารไทยธนชาต จำกัด (มหาชน)",
    "TU": "บริษัท ไทยยูเนี่ยน กรุ๊ป จำกัด (มหาชน)",
    "WHA": "บริษัท ดับบลิวเอชเอ คอร์ปอเรชั่น จำกัด (มหาชน)"
}

from neo4j import GraphDatabase
import json

# Neo4j connection setup
uri = "bolt://localhost:7687"
user = "neo4j"
password = "Neo4jpassword"

driver = GraphDatabase.driver(uri, auth=(user, password))

# Load JSON data
with open('FilteredEODData.json') as eod_file:
    eod_data = json.load(eod_file)

with open('FilteredFinancialData.json') as fin_file:
    financial_data = json.load(fin_file)

def get_company_name(symbol):
    return company_names.get(symbol, symbol)

from datetime import datetime
def extract_year_and_quarter(date_str):
    date_obj = datetime.strptime(date_str, '%Y-%m-%d')
    year = date_obj.year
    quarter = (date_obj.month - 1) // 3 + 1
    return year, quarter

# Helper function to execute Cypher queries
def run_query(query, parameters=None):
    with driver.session() as session:
        session.run(query, parameters)

# Insert companies and related data
for record in eod_data:
    symbol = record['symbol']
    name = get_company_name(symbol)
    date_str = record['date']
    year, quarter = extract_year_and_quarter(date_str)

    # Create or match company
    run_query("""
    MERGE (c:Company {symbol: $symbol})
    ON CREATE SET c.name = $name
    """, {'symbol': symbol, 'name': name})

    # Create or match MarketData node with a relationship to Period
    run_query("""
    MERGE (md:MarketData {date: $date})
    MERGE (c:Company {symbol: $symbol})
    MERGE (c)-[:HAS_MARKET_DATA]->(md)
    MERGE (md)-[:IS_FOR_PERIOD]->(p)
    """, {
        'date': date_str,
        'symbol': symbol,
    })

    # Create or match Period node
    run_query("""
    MERGE (p:Period {year: $year, quarter: $quarter})
    ON CREATE SET p.date = $date
    """, {
        'date': date_str,
        'year': year,
        'quarter': quarter,
    })

    
    # Create or match market data nodes
    run_query("""
    MERGE (pr:Price {date: $date, symbol: $symbol})
    SET pr.prior = $prior, pr.open = $open, pr.high = $high, pr.low = $low, pr.close = $close, pr.average = $average
    MERGE (md:MarketData {date: $date})
    MERGE (md)-[:HAS_PRICE]->(pr)
    """, {
        'date': record['date'],
        'symbol': symbol,
        'prior': record.get('prior'),
        'open': record.get('open'),
        'high': record.get('high'),
        'low': record.get('low'),
        'close': record.get('close'),
        'average': record.get('average', None),
    })
    
    # Create or match volume nodes
    run_query("""
    MERGE (v:Volume {date: $date, symbol: $symbol})
    SET v.aomVolume = $aomVolume, v.aomValue = $aomValue, v.trVolume = $trVolume, v.trValue = $trValue,
        v.totalVolume = $totalVolume, v.totalValue = $totalValue
    MERGE (md:MarketData {date: $date})
    MERGE (md)-[:HAS_VOLUME]->(pr)
    """, {
        'date': record['date'],
        'symbol': symbol,
        'aomVolume': record.get('aomVolume'),
        'aomValue': record.get('aomValue'),
        'trVolume': record.get('trVolume'),
        'trValue': record.get('trValue'),
        'totalVolume': record.get('totalVolume'),
        'totalValue': record.get('totalValue'),
    })
    

# Map of field names to ratio types
    market_ratios = {
        'pe': 'PE',
        'pbv': 'PBV',
        'bvps': 'BVPS',
        'dividendYield': 'Dividend Yield',
        'marketCap': 'Market Cap',
        'volumeTurnover': 'Volume Turnover'
    }

    for ratio_field, ratio_type in market_ratios.items():
        value = record.get(ratio_field)
        if value is not None:
            run_query("""
            MERGE (mr:MarketRatio {date: $date, symbol: $symbol, type: $type})
            SET mr.value = $value
            MERGE (md:MarketData {date: $date})
            MERGE (md)-[:HAS_MARKET_RATIO]->(mr)
            """, {
                'date': record['date'],
                'symbol': symbol,
                'type': ratio_type,
                'value': value,
            })

# Insert financial data and relationships
for record in financial_data:
    symbol = record['symbol']
    year = record['year']
    quarter = record['quarter']
    
    # Create or match financial statement
    run_query("""
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    ON CREATE SET fs.createdAt = timestamp()
    WITH fs
    MERGE (c:Company {symbol: $symbol})
    WITH fs, c
    MERGE (p:Period {year: $year, quarter: $quarter})
    MERGE (fs)-[:IS_FOR_PERIOD]->(p)
    MERGE (c)-[:HAS_FINANCIAL_STATEMENT]->(fs)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
    })
    
    # Create or match granular financial nodes and relationships
    run_query("""
    MERGE (a:Assets {symbol: $symbol, year: $year, quarter: $quarter})
    SET a.totalAssets = $totalAssets
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_ASSETS]->(a)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'totalAssets': record.get('totalAssets'),
    })
    
    run_query("""
    MERGE (l:Liabilities {symbol: $symbol, year: $year, quarter: $quarter})
    SET l.totalLiabilities = $totalLiabilities
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_LIABILITIES]->(l)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'totalLiabilities': record.get('totalLiabilities'),
    })
    
    run_query("""
    MERGE (e:Equity {symbol: $symbol, year: $year, quarter: $quarter})
    SET e.shareholderEquity = $shareholderEquity, e.totalEquity = $totalEquity
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_EQUITY]->(e)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'shareholderEquity': record.get('shareholderEquity'),
        'totalEquity': record.get('totalEquity'),
    })
    
    run_query("""
    MERGE (r:Revenue {symbol: $symbol, year: $year, quarter: $quarter})
    SET r.totalRevenueQuarter = $totalRevenueQuarter, r.totalRevenueAccum = $totalRevenueAccum
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_REVENUE]->(r)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'totalRevenueQuarter': record.get('totalRevenueQuarter'),
        'totalRevenueAccum': record.get('totalRevenueAccum'),
    })
    
    run_query("""
    MERGE (e:Expenses {symbol: $symbol, year: $year, quarter: $quarter})
    SET e.totalExpensesQuarter = $totalExpensesQuarter, e.totalExpensesAccum = $totalExpensesAccum
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_EXPENSES]->(e)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'totalExpensesQuarter': record.get('totalExpensesQuarter'),
        'totalExpensesAccum': record.get('totalExpensesAccum'),
    })
    
    run_query("""
    MERGE (cf:CashFlow {symbol: $symbol, year: $year, quarter: $quarter})
    SET cf.operatingCashFlow = $operatingCashFlow, cf.investingCashFlow = $investingCashFlow, cf.financingCashFlow = $financingCashFlow
    MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
    MERGE (fs)-[:HAS_CASH_FLOW]->(cf)
    """, {
        'year': year,
        'quarter': quarter,
        'symbol': symbol,
        'operatingCashFlow': record.get('operatingCashFlow'),
        'investingCashFlow': record.get('investingCashFlow'),
        'financingCashFlow': record.get('financingCashFlow'),
    })
    # Financial Ratios
    financial_ratios = {
        'ROE': record.get('roe'),
        'ROA': record.get('roa'),
        'NetProfitMarginQuarter': record.get('netProfitMarginQuarter'),
        'NetProfitMarginAccum': record.get('netProfitMarginAccum'),
        'DE': record.get('de'),
        'FixedAssetTurnover': record.get('fixedAssetTurnover'),
        'TotalAssetTurnover': record.get('totalAssetTurnover')
    }

    for ratio_type, ratio_value in financial_ratios.items():
        if ratio_value is not None:
            run_query("""
            MERGE (fr:FinancialRatio {symbol: $symbol, year: $year, quarter: $quarter, type: $type})
            SET fr.value = $value
            MERGE (fs:FinancialStatement {year: $year, quarter: $quarter, symbol: $symbol})
            MERGE (fs)-[:HAS_RATIO]->(fr)
            """, {
                'year': year,
                'quarter': quarter,
                'symbol': symbol,
                'type': ratio_type,
                'value': ratio_value,
            })    

# Close the driver
driver.close()