1201 lines
43 KiB
PHP
1201 lines
43 KiB
PHP
<?php
|
|
class Tracker extends CI_Controller
|
|
{
|
|
|
|
var $stockbit_token;
|
|
var $stockbit_base_url;
|
|
|
|
public function index()
|
|
{
|
|
echo "Resultentry API";
|
|
}
|
|
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
parent::__construct();
|
|
$this->load->model('ScreenerModel');
|
|
$this->load->helper('url');
|
|
|
|
// Stockbit API configuration
|
|
$this->stockbit_base_url = 'https://exodus.stockbit.com';
|
|
// Token should be refreshed periodically or stored in config
|
|
$this->stockbit_token = 'Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjU3MDc0NjI3LTg4MWItNDQzZC04OTcyLTdmMmMzOTNlMzYyOSIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7InVzZSI6ImZhanJpaG0iLCJlbWEiOiJtdXJ0aWZhanJpQGdtYWlsLmNvbSIsImZ1bCI6IkZhanJpIE11cnRpIiwic2VzIjoiYjZGMUFkMjhxeVVGSEhueiIsImR2YyI6IjlhNTZhYTA4ZjdmYTc2NDRiOWY0MTRhMzVhYzk2Y2EyIiwidWlkIjo0NDI2NzMsImNvdSI6IklEIn0sImV4cCI6MTc2Mjk1NzkwNSwiaWF0IjoxNzYyODcxNTA1LCJpc3MiOiJTVE9DS0JJVCIsImp0aSI6IjY0YmIxMDk5LTAzNmYtNGMyYS05YTgwLWQ4M2M4MGFjYzkyNCIsIm5iZiI6MTc2Mjg3MTUwNSwidmVyIjoidjEifQ.vYOcwQhuH5RFMpxRXz1Fb7RgvAsia0mMJ16iUUr2DFKOotMyjLlhpG7y839CtdES_6LwpwR9F-qjvvjQ7ilnPOXHob5o2GJRmdnYFlql72PP_-rQTAEexqKz3ghjHAOHHWdISseXGVZT8lWSjoo_71DPa4mL00Gtvj_FZB_ntetGz2YvrDv80Ew0SevbELUmLzSp4bNoCRZcj7VQfShqmm1w3gyVKUiVLHh1ZqNI-DdpYIDqUFBkt1AXBIQ7g8kornoW8-UgDCj805oRInhe8nWANIUDPo1XFPgmG3rkfq7q5PxPfK4gSoMSxEvfoAc6QoKNoHa_Bf5P3rZ88TOPpQ'; // Replace with actual token management
|
|
|
|
}
|
|
|
|
function sys_ok($data)
|
|
{
|
|
echo json_encode(array(
|
|
'status' => 'OK',
|
|
'data' => $data
|
|
));
|
|
exit;
|
|
}
|
|
|
|
function sys_error($message)
|
|
{
|
|
echo json_encode(array(
|
|
'status' => 'ERROR',
|
|
'message' => $message
|
|
));
|
|
exit;
|
|
}
|
|
/**
|
|
* Run screener and save results
|
|
*
|
|
* POST /screener/screenertracker/run_screener
|
|
* Body: {
|
|
* "template_id": 1,
|
|
* "ihsg_price": 7200.00,
|
|
* "market_sentiment": "BULLISH",
|
|
* "notes": "Optional notes"
|
|
* }
|
|
*/
|
|
public function run_screener()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
// Validate required params
|
|
if (!isset($prm['template_id']) || intval($prm['template_id']) <= 0) {
|
|
$this->sys_error("Template ID is required");
|
|
exit;
|
|
}
|
|
|
|
$template_id = intval($prm['template_id']);
|
|
$ihsg_price = isset($prm['ihsg_price']) ? floatval($prm['ihsg_price']) : null;
|
|
$market_sentiment = isset($prm['market_sentiment']) ? $prm['market_sentiment'] : 'NEUTRAL';
|
|
$notes = isset($prm['notes']) ? $prm['notes'] : '';
|
|
|
|
// Get template configuration
|
|
$template = $this->ScreenerModel->get_template($template_id);
|
|
if (!$template) {
|
|
$this->sys_error("Template not found");
|
|
exit;
|
|
}
|
|
|
|
// Call Stockbit API
|
|
$screener_data = $this->call_stockbit_screener($template);
|
|
|
|
|
|
if (!$screener_data || !isset($screener_data['data'])) {
|
|
$this->sys_error("Failed to fetch screener results from Stockbit");
|
|
exit;
|
|
}
|
|
|
|
// Save screener run
|
|
$run_data = array(
|
|
'screener_templates_template_id' => $template_id,
|
|
'run_date' => date('Y-m-d'),
|
|
'run_datetime' => date('Y-m-d H:i:s'),
|
|
'total_results' => count($screener_data['data']['calcs']),
|
|
'ihsg_price' => $ihsg_price,
|
|
'market_sentiment' => $market_sentiment,
|
|
'notes' => $notes,
|
|
'api_response_json' => json_encode($screener_data)
|
|
);
|
|
|
|
$run_id = $this->ScreenerModel->save_screener_run($run_data);
|
|
|
|
if (!$run_id) {
|
|
$this->sys_error("Failed to save screener run");
|
|
exit;
|
|
}
|
|
|
|
// Save individual results
|
|
$results_saved = 0;
|
|
foreach ($screener_data['data']['calcs'] as $stock) {
|
|
$company = $stock['company'];
|
|
$results = $stock['results'];
|
|
|
|
// Extract price (usually first result or look for "Price" item)
|
|
$entry_price = 0;
|
|
foreach ($results as $result) {
|
|
if (strpos($result['item'], 'Price') !== false &&
|
|
!strpos($result['item'], 'Returns') &&
|
|
!strpos($result['item'], 'MA')) {
|
|
$entry_price = floatval($result['raw']);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Prepare metrics
|
|
$metrics_data = array();
|
|
for ($i = 0; $i < min(10, count($results)); $i++) {
|
|
$metrics_data['metric_' . ($i + 1) . '_value'] = floatval($results[$i]['raw']);
|
|
$metrics_data['metric_' . ($i + 1) . '_name'] = $results[$i]['item'];
|
|
}
|
|
|
|
$result_data = array(
|
|
'screener_runs_run_id' => $run_id,
|
|
'symbol' => $company['symbol'],
|
|
'company_name' => $company['name'],
|
|
'company_id' => $company['id'],
|
|
'entry_price' => $entry_price,
|
|
'entry_date' => date('Y-m-d'),
|
|
'entry_datetime' => date('Y-m-d H:i:s'),
|
|
'metrics_json' => json_encode($results),
|
|
'is_scored' => 'N',
|
|
'is_tracked' => 'N'
|
|
);
|
|
|
|
$result_data = array_merge($result_data, $metrics_data);
|
|
|
|
if ($this->ScreenerModel->save_screener_result($result_data)) {
|
|
$results_saved++;
|
|
}
|
|
}
|
|
|
|
$response = array(
|
|
'run_id' => $run_id,
|
|
'template_name' => $template['template_name'],
|
|
'total_results' => count($screener_data['data']['calcs']),
|
|
'results_saved' => $results_saved,
|
|
'run_date' => date('Y-m-d H:i:s'),
|
|
'next_step' => 'Call score_results to score these stocks'
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Score screener results based on strategy
|
|
*
|
|
* POST /screener/screenertracker/score_results
|
|
* Body: {
|
|
* "run_id": 1,
|
|
* "auto_track_high_scores": true, // Auto track high scores
|
|
* "min_score_to_track": 10 // Optional: Override template's min_score
|
|
* }
|
|
*
|
|
* Note: If min_score_to_track not provided, uses template's min_score (default: 8.0)
|
|
*/
|
|
public function score_results()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
if (!isset($prm['run_id']) || intval($prm['run_id']) <= 0) {
|
|
$this->sys_error("Run ID is required");
|
|
exit;
|
|
}
|
|
|
|
$run_id = intval($prm['run_id']);
|
|
$auto_track = isset($prm['auto_track_high_scores']) ? $prm['auto_track_high_scores'] : true;
|
|
|
|
// Get run details
|
|
$run = $this->ScreenerModel->get_screener_run($run_id);
|
|
if (!$run) {
|
|
$this->sys_error("Screener run not found");
|
|
exit;
|
|
}
|
|
|
|
// Get template to know scoring strategy
|
|
$template = $this->ScreenerModel->get_template($run['screener_templates_template_id']);
|
|
|
|
// Use template's min_score as default threshold
|
|
$min_score_to_track = isset($prm['min_score_to_track'])
|
|
? floatval($prm['min_score_to_track'])
|
|
: floatval($template['min_score'] ?? 8.0);
|
|
|
|
// Get all unscored results for this run
|
|
$results = $this->ScreenerModel->get_unscored_results($run_id);
|
|
|
|
if (empty($results)) {
|
|
$this->sys_error("No unscored results found for this run");
|
|
exit;
|
|
}
|
|
|
|
$scored_count = 0;
|
|
$high_scores = array();
|
|
|
|
foreach ($results as $result) {
|
|
// Score based on template configuration
|
|
$score_data = $this->calculate_score($result, $template);
|
|
|
|
// Add result_id and run_id
|
|
$score_data['screener_results_result_id'] = $result['result_id'];
|
|
$score_data['screener_runs_run_id'] = $run_id;
|
|
$score_data['symbol'] = $result['symbol'];
|
|
|
|
// Save score
|
|
if ($this->ScreenerModel->save_score($score_data)) {
|
|
$scored_count++;
|
|
|
|
// Mark result as scored
|
|
$this->ScreenerModel->mark_as_scored($result['result_id']);
|
|
|
|
// Auto-track high scores
|
|
if ($auto_track && $score_data['total_score'] >= $min_score_to_track) {
|
|
$this->start_tracking($result['result_id']);
|
|
$high_scores[] = array(
|
|
'symbol' => $result['symbol'],
|
|
'score' => $score_data['total_score'],
|
|
'decision' => $score_data['decision']
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
$response = array(
|
|
'run_id' => $run_id,
|
|
'total_scored' => $scored_count,
|
|
'high_scores_tracked' => count($high_scores),
|
|
'high_scores' => $high_scores,
|
|
'next_step' => 'Monitor tracked positions via get_active_positions'
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update prices for all tracked positions
|
|
*
|
|
* POST /screener/screenertracker/update_prices
|
|
* Body: {
|
|
* "date": "2025-01-15", // Optional, defaults to today
|
|
* "check_targets": true // Check if targets hit
|
|
* }
|
|
*/
|
|
public function update_prices()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
$tracking_date = isset($prm['date']) ? $prm['date'] : date('Y-m-d');
|
|
$check_targets = isset($prm['check_targets']) ? $prm['check_targets'] : true;
|
|
|
|
// Get all active tracked positions
|
|
$active_positions = $this->ScreenerModel->get_active_positions();
|
|
|
|
if (empty($active_positions)) {
|
|
$this->sys_ok(array('message' => 'No active positions to update'));
|
|
exit;
|
|
}
|
|
|
|
$updated_count = 0;
|
|
$alerts = array();
|
|
|
|
foreach ($active_positions as $position) {
|
|
// Fetch current price from Stockbit
|
|
$price_data = $this->get_stock_price($position['symbol']);
|
|
|
|
if (!$price_data) {
|
|
continue;
|
|
}
|
|
|
|
// Calculate returns
|
|
$entry_price = floatval($position['entry_price']);
|
|
$current_price = floatval($price_data['lastprice']);
|
|
$return_amount = $current_price - $entry_price;
|
|
$return_percentage = ($return_amount / $entry_price) * 100;
|
|
|
|
// Days since entry
|
|
$entry_date = new DateTime($position['entry_date']);
|
|
$today = new DateTime($tracking_date);
|
|
$days_since_entry = $today->diff($entry_date)->days;
|
|
$weeks_since_entry = floor($days_since_entry / 7);
|
|
|
|
// Save price tracking
|
|
$tracking_data = array(
|
|
'screener_results_result_id' => $position['screener_results_result_id'],
|
|
'symbol' => $position['symbol'],
|
|
'tracking_date' => $tracking_date,
|
|
'tracking_datetime' => date('Y-m-d H:i:s'),
|
|
'current_price' => $current_price,
|
|
'open_price' => $price_data['open'],
|
|
'high_price' => $price_data['high'],
|
|
'low_price' => $price_data['low'],
|
|
'volume' => $price_data['volume'],
|
|
'value' => $price_data['value'],
|
|
'frequency' => $price_data['frequency'],
|
|
'foreign_buy' => $price_data['fbuy'],
|
|
'foreign_sell' => $price_data['fsell'],
|
|
'foreign_net' => $price_data['fnet'],
|
|
'entry_price' => $entry_price,
|
|
'return_amount' => $return_amount,
|
|
'return_percentage' => $return_percentage,
|
|
'days_since_entry' => $days_since_entry,
|
|
'weeks_since_entry' => $weeks_since_entry
|
|
);
|
|
|
|
if ($this->ScreenerModel->save_price_tracking($tracking_data)) {
|
|
$updated_count++;
|
|
|
|
// Update performance
|
|
$this->update_performance($position['screener_results_result_id'], $return_percentage, $days_since_entry);
|
|
|
|
// Check targets if enabled
|
|
if ($check_targets) {
|
|
$target_alerts = $this->check_targets($position, $return_percentage, $tracking_date);
|
|
if (!empty($target_alerts)) {
|
|
$alerts = array_merge($alerts, $target_alerts);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$response = array(
|
|
'tracking_date' => $tracking_date,
|
|
'positions_tracked' => count($active_positions),
|
|
'prices_updated' => $updated_count,
|
|
'alerts_generated' => count($alerts),
|
|
'alerts' => $alerts
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get active positions
|
|
*
|
|
* GET /screener/screenertracker/get_active_positions
|
|
* Query params:
|
|
* - template_id (optional): Filter by template
|
|
* - min_score (optional): Filter by minimum score
|
|
* - sort_by: return_percentage, days_held, score (default: return_percentage)
|
|
* - order: asc, desc (default: desc)
|
|
*/
|
|
public function get_active_positions()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
$filters = array(
|
|
'template_id' => isset($prm['template_id']) ? intval($prm['template_id']) : null,
|
|
'min_score' => isset($prm['min_score']) ? floatval($prm['min_score']) : null,
|
|
'sort_by' => isset($prm['sort_by']) ? $prm['sort_by'] : 'return_percentage',
|
|
'order' => isset($prm['order']) ? $prm['order'] : 'desc'
|
|
);
|
|
|
|
$positions = $this->ScreenerModel->get_active_positions_with_details($filters);
|
|
|
|
$response = array(
|
|
'total_positions' => count($positions),
|
|
'positions' => $positions,
|
|
'summary' => $this->calculate_portfolio_summary($positions)
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get performance statistics
|
|
*
|
|
* GET /screener/screenertracker/get_statistics
|
|
* Query params:
|
|
* - template_id (required or 'all')
|
|
* - period: ALL_TIME, LAST_3M, LAST_6M, LAST_1Y
|
|
* - refresh: true to recalculate
|
|
*/
|
|
public function get_statistics()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
$template_id = isset($prm['template_id']) ? $prm['template_id'] : 'all';
|
|
$period = isset($prm['period']) ? $prm['period'] : 'ALL_TIME';
|
|
$refresh = isset($prm['refresh']) && $prm['refresh'] === true;
|
|
|
|
if ($refresh && $template_id !== 'all') {
|
|
// Recalculate statistics
|
|
$this->ScreenerModel->calculate_statistics(intval($template_id));
|
|
}
|
|
|
|
if ($template_id === 'all') {
|
|
$statistics = $this->ScreenerModel->get_all_statistics($period);
|
|
} else {
|
|
$statistics = $this->ScreenerModel->get_statistics(intval($template_id), $period);
|
|
}
|
|
|
|
$this->sys_ok(array('statistics' => $statistics));
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all available templates
|
|
*
|
|
* GET /screener/screenertracker/get_templates
|
|
* Response: List of all active screener templates with configuration
|
|
*/
|
|
public function get_templates()
|
|
{
|
|
try {
|
|
|
|
|
|
$templates = $this->ScreenerModel->get_all_templates();
|
|
|
|
// Parse JSON configs for each template
|
|
foreach ($templates as &$template) {
|
|
if (!empty($template['scoring_config_json'])) {
|
|
$template['scoring_config'] = json_decode($template['scoring_config_json'], true);
|
|
}
|
|
if (!empty($template['target_config_json'])) {
|
|
$template['target_config'] = json_decode($template['target_config_json'], true);
|
|
}
|
|
if (!empty($template['filters_json'])) {
|
|
$template['filters'] = json_decode($template['filters_json'], true);
|
|
}
|
|
}
|
|
|
|
$this->sys_ok(array(
|
|
'total' => count($templates),
|
|
'templates' => $templates
|
|
));
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get single template details
|
|
*
|
|
* GET /screener/screenertracker/get_template
|
|
* Params: template_id or template_slug
|
|
*/
|
|
public function get_template()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
$template_id = isset($prm['template_id']) ? $prm['template_id'] : null;
|
|
$template_slug = isset($prm['template_slug']) ? $prm['template_slug'] : null;
|
|
|
|
$template = null;
|
|
|
|
if ($template_id) {
|
|
$template = $this->ScreenerModel->get_template(intval($template_id));
|
|
} elseif ($template_slug) {
|
|
$template = $this->ScreenerModel->get_template_by_slug($template_slug);
|
|
} else {
|
|
$this->sys_error("template_id or template_slug is required");
|
|
exit;
|
|
}
|
|
|
|
if (!$template) {
|
|
$this->sys_error("Template not found");
|
|
exit;
|
|
}
|
|
|
|
$this->sys_ok($template);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manual Track Result - Start tracking a specific result
|
|
*
|
|
* POST /screener/tracker/track_result
|
|
* Body: {
|
|
* "result_id": 1
|
|
* }
|
|
*/
|
|
public function track_result()
|
|
{
|
|
try {
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
if (!isset($prm['result_id'])) {
|
|
$this->sys_error("Result ID is required");
|
|
exit;
|
|
}
|
|
|
|
$result_id = intval($prm['result_id']);
|
|
|
|
// Get result to verify it exists and is scored
|
|
$result = $this->ScreenerModel->get_result($result_id);
|
|
if (!$result) {
|
|
$this->sys_error("Result not found");
|
|
exit;
|
|
}
|
|
|
|
// Check if already tracked
|
|
if ($result['is_tracked'] == 'Y') {
|
|
$this->sys_error("Result is already being tracked");
|
|
exit;
|
|
}
|
|
|
|
// Check if scored
|
|
if ($result['is_scored'] != 'Y') {
|
|
$this->sys_error("Result must be scored before tracking. Run score_results first.");
|
|
exit;
|
|
}
|
|
|
|
// Start tracking
|
|
$this->start_tracking($result_id);
|
|
|
|
$response = array(
|
|
'result_id' => $result_id,
|
|
'symbol' => $result['symbol'],
|
|
'entry_price' => $result['entry_price'],
|
|
'message' => 'Started tracking position',
|
|
'next_step' => 'Monitor via get_active_positions or update_prices'
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close position manually
|
|
*
|
|
* POST /screener/screenertracker/close_position
|
|
* Body: {
|
|
* "result_id": 1,
|
|
* "exit_price": 2500,
|
|
* "exit_reason": "TARGET_2",
|
|
* "notes": "Manual exit"
|
|
* }
|
|
*/
|
|
public function close_position()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
if (!isset($prm['result_id'])) {
|
|
$this->sys_error("Result ID is required");
|
|
exit;
|
|
}
|
|
|
|
$result_id = intval($prm['result_id']);
|
|
$exit_price = isset($prm['exit_price']) ? floatval($prm['exit_price']) : null;
|
|
$exit_reason = isset($prm['exit_reason']) ? $prm['exit_reason'] : 'MANUAL';
|
|
$notes = isset($prm['notes']) ? $prm['notes'] : '';
|
|
|
|
// Get performance record
|
|
$performance = $this->ScreenerModel->get_performance_by_result($result_id);
|
|
|
|
if (!$performance) {
|
|
$this->sys_error("Performance record not found");
|
|
exit;
|
|
}
|
|
|
|
if ($performance['is_active'] === 'N') {
|
|
$this->sys_error("Position already closed");
|
|
exit;
|
|
}
|
|
|
|
// If no exit price provided, get current price
|
|
if (!$exit_price) {
|
|
$price_data = $this->get_stock_price($performance['symbol']);
|
|
if($price_data['status'] != 'OK') {
|
|
$this->sys_error("Failed to get stock price");
|
|
exit;
|
|
}
|
|
$exit_price = $price_data['data']['lastprice'];
|
|
}
|
|
|
|
// Calculate final returns
|
|
$entry_price = floatval($performance['entry_price']);
|
|
$return_amount = $exit_price - $entry_price;
|
|
$return_percentage = ($return_amount / $entry_price) * 100;
|
|
|
|
$entry_date = new DateTime($performance['entry_date']);
|
|
$exit_date = new DateTime(date('Y-m-d'));
|
|
$days_held = $exit_date->diff($entry_date)->days;
|
|
|
|
// Update performance
|
|
$close_data = array(
|
|
'exit_date' => date('Y-m-d'),
|
|
'exit_price' => $exit_price,
|
|
'exit_reason' => $exit_reason,
|
|
'days_held' => $days_held,
|
|
'weeks_held' => floor($days_held / 7),
|
|
'return_amount' => $return_amount,
|
|
'return_percentage' => $return_percentage,
|
|
'is_active' => 'N',
|
|
'notes' => $notes,
|
|
'closed_at' => date('Y-m-d H:i:s')
|
|
);
|
|
|
|
if ($this->ScreenerModel->close_performance($performance['performance_id'], $close_data)) {
|
|
// Recalculate statistics
|
|
$this->ScreenerModel->calculate_statistics($performance['screener_templates_template_id']);
|
|
|
|
$response = array(
|
|
'message' => 'Position closed successfully',
|
|
'symbol' => $performance['symbol'],
|
|
'entry_price' => $entry_price,
|
|
'exit_price' => $exit_price,
|
|
'return_percentage' => round($return_percentage, 2),
|
|
'days_held' => $days_held,
|
|
'outcome' => $close_data['outcome']
|
|
);
|
|
|
|
$this->sys_ok($response);
|
|
} else {
|
|
$this->sys_error("Failed to close position");
|
|
}
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get detailed performance for a symbol
|
|
*
|
|
* GET /screener/screenertracker/get_symbol_performance
|
|
* Query params:
|
|
* - symbol (required)
|
|
* - include_price_history: true/false
|
|
*/
|
|
public function get_symbol_performance()
|
|
{
|
|
try {
|
|
|
|
|
|
// Read JSON body manually for POST requests
|
|
$json = file_get_contents('php://input');
|
|
$prm = json_decode($json, true);
|
|
|
|
// Fallback to regular POST if JSON is empty
|
|
if (empty($prm)) {
|
|
$prm = $this->input->post();
|
|
}
|
|
|
|
// Also check GET params as fallback
|
|
if (empty($prm)) {
|
|
$prm = $this->input->get();
|
|
}
|
|
|
|
if (!isset($prm['symbol'])) {
|
|
$this->sys_error("Symbol is required");
|
|
exit;
|
|
}
|
|
|
|
$symbol = strtoupper($prm['symbol']);
|
|
$include_history = isset($prm['include_price_history']) && $prm['include_price_history'];
|
|
|
|
// Get all performance records for this symbol
|
|
$performances = $this->ScreenerModel->get_symbol_performances($symbol);
|
|
|
|
if (empty($performances)) {
|
|
$this->sys_error("No performance records found for symbol: " . $symbol);
|
|
exit;
|
|
}
|
|
|
|
$response = array(
|
|
'symbol' => $symbol,
|
|
'total_trades' => count($performances),
|
|
'performances' => $performances
|
|
);
|
|
|
|
if ($include_history) {
|
|
// Get price history for latest active position
|
|
$active = array_filter($performances, function($p) {
|
|
return $p['is_active'] === 'Y';
|
|
});
|
|
|
|
if (!empty($active)) {
|
|
$latest = reset($active);
|
|
$price_history = $this->ScreenerModel->get_price_history($latest['screener_results_result_id']);
|
|
$response['price_history'] = $price_history;
|
|
}
|
|
}
|
|
|
|
$this->sys_ok($response);
|
|
|
|
} catch (Exception $exc) {
|
|
$this->sys_error($exc->getMessage());
|
|
}
|
|
}
|
|
|
|
// ============================================
|
|
// PRIVATE HELPER METHODS
|
|
// ============================================
|
|
|
|
/**
|
|
* Call Stockbit screener API
|
|
*/
|
|
private function call_stockbit_screener($template)
|
|
{
|
|
$url = $this->stockbit_base_url . '/screener/templates';
|
|
|
|
$post_data = array(
|
|
'name' => $template['template_name'],
|
|
'description' => $template['description'],
|
|
'save' => '0',
|
|
'ordertype' => 'asc',
|
|
'ordercol' => 2,
|
|
'page' => 1,
|
|
'universe' => '{"scope":"IHSG","scopeID":"","name":""}',
|
|
'filters' => $template['filters_json'],
|
|
'sequence' => $template['sequence'],
|
|
'screenerid' => '0',
|
|
'type' => 'TEMPLATE_TYPE_CUSTOM'
|
|
);
|
|
|
|
$ch = curl_init($url);
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($ch, CURLOPT_POST, true);
|
|
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($post_data));
|
|
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
|
|
'Content-Type: application/json',
|
|
'Authorization: ' . $this->stockbit_token,
|
|
'Accept: application/json'
|
|
));
|
|
|
|
$response = curl_exec($ch);
|
|
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
|
|
curl_close($ch);
|
|
|
|
if ($http_code !== 200) {
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
return json_decode($response, true);
|
|
}
|
|
|
|
/**
|
|
* Get stock price from Stockbit
|
|
*/
|
|
private function get_stock_price($symbol)
|
|
{
|
|
$url = $this->stockbit_base_url . '/company-price-feed/v2/orderbook/companies/' . $symbol;
|
|
|
|
$ch = curl_init($url);
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
|
|
'Authorization: ' . $this->stockbit_token,
|
|
'Accept: application/json'
|
|
));
|
|
|
|
$response = curl_exec($ch);
|
|
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
|
|
curl_close($ch);
|
|
|
|
if ($http_code !== 200) {
|
|
return false;
|
|
}
|
|
|
|
return json_decode($response, true);
|
|
}
|
|
|
|
/**
|
|
* Calculate score based on strategy type
|
|
*/
|
|
private function calculate_score($result, $template)
|
|
{
|
|
$metrics = json_decode($result['metrics_json'], true);
|
|
|
|
// Convert metrics array to associative array for easier lookup
|
|
$metrics_map = array();
|
|
foreach ($metrics as $metric) {
|
|
// Create keys from metric item names
|
|
$key = $this->normalize_metric_key($metric['item']);
|
|
$metrics_map[$key] = floatval($metric['raw']);
|
|
|
|
// Also store with generic keys for common metrics
|
|
if (strpos($metric['item'], 'Foreign') !== false) {
|
|
if (strpos($metric['item'], 'Streak') !== false) {
|
|
$metrics_map['foreign_streak'] = floatval($metric['raw']);
|
|
} elseif (strpos($metric['item'], '1M') !== false || strpos($metric['item'], '1 Month') !== false) {
|
|
$metrics_map['foreign_flow_1m'] = floatval($metric['raw']);
|
|
}
|
|
}
|
|
|
|
if (strpos($metric['item'], 'Bandar') !== false) {
|
|
if (strpos($metric['item'], 'Accum') !== false) {
|
|
$metrics_map['bandar_accum_dist'] = floatval($metric['raw']);
|
|
}
|
|
}
|
|
|
|
if (strpos($metric['item'], 'Price Return') !== false) {
|
|
if (strpos($metric['item'], '1 Day') !== false) {
|
|
$metrics_map['1d_return'] = floatval($metric['raw']);
|
|
} elseif (strpos($metric['item'], '1 Week') !== false) {
|
|
$metrics_map['1w_return'] = floatval($metric['raw']);
|
|
} elseif (strpos($metric['item'], '1 Month') !== false) {
|
|
$metrics_map['1m_return'] = floatval($metric['raw']);
|
|
}
|
|
}
|
|
|
|
if (strpos($metric['item'], 'Volume Change') !== false) {
|
|
$metrics_map['1d_vol_change'] = floatval($metric['raw']);
|
|
}
|
|
}
|
|
|
|
// Use flexible scoring from model
|
|
$score_result = $this->ScreenerModel->calculate_score_from_template($template, $metrics_map);
|
|
|
|
// Format for database storage
|
|
$score_data = array(
|
|
'category_1_score' => 0,
|
|
'category_1_name' => 'Category 1',
|
|
'category_1_max' => 4,
|
|
'category_2_score' => 0,
|
|
'category_2_name' => 'Category 2',
|
|
'category_2_max' => 4,
|
|
'category_3_score' => 0,
|
|
'category_3_name' => 'Category 3',
|
|
'category_3_max' => 2,
|
|
'category_4_score' => 0,
|
|
'category_4_name' => 'Category 4',
|
|
'category_4_max' => 2,
|
|
'total_score' => $score_result['total_score'],
|
|
'max_possible_score' => $score_result['max_possible_score'],
|
|
'decision' => $score_result['decision'],
|
|
'confidence' => $score_result['confidence'],
|
|
'suggested_position_size' => $score_result['suggested_position_size'],
|
|
'scoring_notes' => isset($score_result['scoring_notes']) ? json_encode($score_result['scoring_notes']) : null
|
|
);
|
|
|
|
// Fill in category scores
|
|
if (!empty($score_result['category_scores'])) {
|
|
foreach ($score_result['category_scores'] as $cat_key => $cat_data) {
|
|
$score_data[$cat_key . '_score'] = $cat_data['score'];
|
|
$score_data[$cat_key . '_name'] = $cat_data['name'];
|
|
$score_data[$cat_key . '_max'] = $cat_data['max'];
|
|
}
|
|
}
|
|
|
|
return $score_data;
|
|
}
|
|
|
|
/**
|
|
* Normalize metric key for easy matching
|
|
*/
|
|
private function normalize_metric_key($item_name)
|
|
{
|
|
// Convert to lowercase and remove special characters
|
|
$key = strtolower($item_name);
|
|
$key = str_replace(array(' ', '/', '-'), '_', $key);
|
|
$key = preg_replace('/[^a-z0-9_]/', '', $key);
|
|
return $key;
|
|
}
|
|
|
|
// OLD SCORING METHODS REMOVED - Now using flexible scoring from ScreenerModel
|
|
// All scoring logic is now in ScreenerModel->calculate_score_from_template()
|
|
// which reads from scoring_config_json in database
|
|
|
|
/**
|
|
* Start tracking a result
|
|
*/
|
|
private function start_tracking($result_id)
|
|
{
|
|
$this->ScreenerModel->mark_as_tracked($result_id);
|
|
|
|
// Create initial performance record
|
|
$result = $this->ScreenerModel->get_result($result_id);
|
|
$score = $this->ScreenerModel->get_score_by_result($result_id);
|
|
|
|
$performance_data = array(
|
|
'screener_results_result_id' => $result_id,
|
|
'screener_scores_score_id' => $score['score_id'],
|
|
'symbol' => $result['symbol'],
|
|
'screener_templates_template_id' => $result['screener_templates_template_id'],
|
|
'entry_date' => $result['entry_date'],
|
|
'entry_price' => $result['entry_price'],
|
|
'entry_score' => $score['total_score'],
|
|
'entry_decision' => $score['decision'],
|
|
'is_active' => 'Y',
|
|
'win_loss' => 'OPEN'
|
|
);
|
|
|
|
$this->ScreenerModel->create_performance($performance_data);
|
|
|
|
// Create initial price tracking
|
|
$price_data = $this->get_stock_price($result['symbol']);
|
|
if ($price_data) {
|
|
$tracking_data = array(
|
|
'screener_results_result_id' => $result_id,
|
|
'symbol' => $result['symbol'],
|
|
'tracking_date' => date('Y-m-d'),
|
|
'tracking_datetime' => date('Y-m-d H:i:s'),
|
|
'current_price' => $price_data['lastprice'],
|
|
'entry_price' => $result['entry_price'],
|
|
'return_amount' => 0,
|
|
'return_percentage' => 0,
|
|
'days_since_entry' => 0,
|
|
'weeks_since_entry' => 0
|
|
);
|
|
$this->ScreenerModel->save_price_tracking($tracking_data);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update performance record
|
|
*/
|
|
private function update_performance($result_id, $return_pct, $days_held)
|
|
{
|
|
$performance = $this->ScreenerModel->get_performance_by_result($result_id);
|
|
|
|
if (!$performance) {
|
|
return;
|
|
}
|
|
|
|
// Update max gain/loss
|
|
$update_data = array(
|
|
'return_percentage' => $return_pct,
|
|
'days_held' => $days_held,
|
|
'weeks_held' => floor($days_held / 7)
|
|
);
|
|
|
|
if ($return_pct > floatval($performance['max_gain_percentage'])) {
|
|
$update_data['max_gain_percentage'] = $return_pct;
|
|
$update_data['max_gain_date'] = date('Y-m-d');
|
|
}
|
|
|
|
if ($return_pct < floatval($performance['max_loss_percentage'])) {
|
|
$update_data['max_loss_percentage'] = $return_pct;
|
|
$update_data['max_loss_date'] = date('Y-m-d');
|
|
}
|
|
|
|
$this->ScreenerModel->update_performance($performance['performance_id'], $update_data);
|
|
}
|
|
|
|
/**
|
|
* Check if targets hit and generate alerts
|
|
*/
|
|
private function check_targets($position, $return_pct, $date)
|
|
{
|
|
$alerts = array();
|
|
$performance = $this->ScreenerModel->get_performance_by_result($position['screener_results_result_id']);
|
|
|
|
// Target 1: +15-20%
|
|
if ($return_pct >= 15 && $performance['target_1_hit'] === 'N') {
|
|
$this->ScreenerModel->mark_target_hit($performance['performance_id'], 1, $date);
|
|
$alerts[] = array(
|
|
'symbol' => $position['symbol'],
|
|
'type' => 'TARGET_1',
|
|
'return' => round($return_pct, 2),
|
|
'message' => 'Target 1 (+15%) hit! Consider taking 30% profit'
|
|
);
|
|
}
|
|
|
|
// Target 2: +30-40%
|
|
if ($return_pct >= 30 && $performance['target_2_hit'] === 'N') {
|
|
$this->ScreenerModel->mark_target_hit($performance['performance_id'], 2, $date);
|
|
$alerts[] = array(
|
|
'symbol' => $position['symbol'],
|
|
'type' => 'TARGET_2',
|
|
'return' => round($return_pct, 2),
|
|
'message' => 'Target 2 (+30%) hit! Consider taking 50% profit'
|
|
);
|
|
}
|
|
|
|
// Target 3: +50%+
|
|
if ($return_pct >= 50 && $performance['target_3_hit'] === 'N') {
|
|
$this->ScreenerModel->mark_target_hit($performance['performance_id'], 3, $date);
|
|
$alerts[] = array(
|
|
'symbol' => $position['symbol'],
|
|
'type' => 'TARGET_3',
|
|
'return' => round($return_pct, 2),
|
|
'message' => 'Target 3 (+50%) hit! Consider exiting remaining position'
|
|
);
|
|
}
|
|
|
|
// Stop loss: -8% to -10%
|
|
if ($return_pct <= -8) {
|
|
$alerts[] = array(
|
|
'symbol' => $position['symbol'],
|
|
'type' => 'STOP_LOSS',
|
|
'return' => round($return_pct, 2),
|
|
'message' => 'Stop loss triggered! Consider exiting position',
|
|
'level' => 'CRITICAL'
|
|
);
|
|
}
|
|
|
|
// Time stop: 8 weeks
|
|
if ($position['weeks_held'] >= 8 && $return_pct < 10) {
|
|
$alerts[] = array(
|
|
'symbol' => $position['symbol'],
|
|
'type' => 'TIME_STOP',
|
|
'return' => round($return_pct, 2),
|
|
'weeks' => $position['weeks_held'],
|
|
'message' => '8 weeks held with <10% return. Consider exiting',
|
|
'level' => 'WARNING'
|
|
);
|
|
}
|
|
|
|
// Save alerts to database
|
|
foreach ($alerts as $alert) {
|
|
$this->ScreenerModel->save_alert($position['screener_results_result_id'], $alert);
|
|
}
|
|
|
|
return $alerts;
|
|
}
|
|
|
|
/**
|
|
* Calculate portfolio summary
|
|
*/
|
|
|
|
private function calculate_portfolio_summary($positions)
|
|
{
|
|
if (empty($positions)) {
|
|
return array();
|
|
}
|
|
|
|
$total_positions = count($positions);
|
|
$total_return = 0;
|
|
$total_invested = 0;
|
|
$winners = 0;
|
|
$losers = 0;
|
|
|
|
foreach ($positions as $pos) {
|
|
$return_pct = floatval($pos['return_percentage']);
|
|
$total_return += $return_pct;
|
|
|
|
if ($return_pct > 0) {
|
|
$winners++;
|
|
} elseif ($return_pct < 0) {
|
|
$losers++;
|
|
}
|
|
}
|
|
|
|
$avg_return = $total_return / $total_positions;
|
|
|
|
return array(
|
|
'total_positions' => $total_positions,
|
|
'winners' => $winners,
|
|
'losers' => $losers,
|
|
'breakeven' => $total_positions - $winners - $losers,
|
|
'avg_return_percentage' => round($avg_return, 2),
|
|
'best_performer' => $positions[0] ?? null,
|
|
'worst_performer' => $positions[count($positions) - 1] ?? null
|
|
);
|
|
}
|
|
|
|
|
|
|
|
}
|