nouffer/rogaining_srv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix migration error

Browse Source
This commit is contained in:
Akira Miyata
2025-08-29 09:11:20 +09:00
parent a180c1e258
commit b91b522fa3
26 changed files with 5848 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
analyze_event_data_raw.py Normal file
View File

@ -0,0 +1,150 @@
#!/usr/bin/env python3
import os
import sys
import django
# プロジェクト設定
sys.path.append('/app')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection
import logging
# ログ設定
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def analyze_event_data_raw():
"""生のSQLを使ってイベント・チーム・エントリーデータを分析"""
print("=== 生SQLによるイベント・データ分析 ===")
with connection.cursor() as cursor:
# 1. NewEvent2テーブルの構造確認
print("\n1. rog_newevent2テーブル構造:")
cursor.execute("""
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'rog_newevent2'
ORDER BY ordinal_position;
""")
columns = cursor.fetchall()
for col in columns:
print(f" - {col[0]}: {col[1]} ({'NULL' if col[2] == 'YES' else 'NOT NULL'})")
# 2. 全イベント一覧
print("\n2. 全イベント一覧:")
cursor.execute("""
SELECT id, event_name, event_day, venue_address
FROM rog_newevent2
ORDER BY id;
""")
events = cursor.fetchall()
for event in events:
print(f" - ID:{event[0]}, Name:{event[1]}, Date:{event[2]}, Venue:{event[3]}")
# 各イベントのエントリー数とチーム数
cursor.execute("SELECT COUNT(*) FROM rog_entry WHERE event_id = %s", [event[0]])
entry_count = cursor.fetchone()[0]
cursor.execute("SELECT COUNT(*) FROM rog_team WHERE event_id = %s", [event[0]])
team_count = cursor.fetchone()[0]
print(f" Entry:{entry_count}, Team:{team_count}")
# 3. FC岐阜関連イベント検索
print("\n3. FC岐阜関連イベント検索:")
cursor.execute("""
SELECT id, event_name, event_day, venue_address
FROM rog_newevent2
WHERE event_name ILIKE %s OR event_name ILIKE %s OR event_name ILIKE %s
ORDER BY id;
""", ['%FC岐阜%', '%fc岐阜%', '%岐阜%'])
fc_events = cursor.fetchall()
if fc_events:
for event in fc_events:
print(f" - ID:{event[0]}, Name:{event[1]}, Date:{event[2]}")
# 関連エントリー
cursor.execute("""
SELECT e.id, t.id as team_id, t.name as team_name, t.zekken_number
FROM rog_entry e
JOIN rog_team t ON e.team_id = t.id
WHERE e.event_id = %s
LIMIT 10;
""", [event[0]])
entries = cursor.fetchall()
if entries:
print(" エントリー詳細:")
for entry in entries:
print(f" Entry ID:{entry[0]}, Team ID:{entry[1]}, Team:{entry[2]}, Zekken:{entry[3]}")
# 関連チーム（ゼッケン番号付き）
cursor.execute("""
SELECT id, name, zekken_number
FROM rog_team
WHERE event_id = %s AND zekken_number IS NOT NULL AND zekken_number != ''
LIMIT 10;
""", [event[0]])
teams_with_zekken = cursor.fetchall()
if teams_with_zekken:
print(" ゼッケン番号付きチーム:")
for team in teams_with_zekken:
print(f" Team ID:{team[0]}, Name:{team[1]}, Zekken:{team[2]}")
else:
print(" ゼッケン番号付きチームが見つかりません")
else:
print(" FC岐阜関連イベントが見つかりません")
# 4. 全体のゼッケン番号付きチーム確認
print("\n4. 全体のゼッケン番号付きチーム状況:")
cursor.execute("""
SELECT COUNT(*)
FROM rog_team
WHERE zekken_number IS NOT NULL AND zekken_number != '';
""")
zekken_team_count = cursor.fetchone()[0]
print(f" ゼッケン番号付きチーム総数: {zekken_team_count}")
if zekken_team_count > 0:
cursor.execute("""
SELECT t.id, t.name, t.zekken_number, e.event_name
FROM rog_team t
LEFT JOIN rog_newevent2 e ON t.event_id = e.id
WHERE t.zekken_number IS NOT NULL AND t.zekken_number != ''
LIMIT 10;
""")
sample_teams = cursor.fetchall()
print(" サンプル:")
for team in sample_teams:
print(f" ID:{team[0]}, Name:{team[1]}, Zekken:{team[2]}, Event:{team[3]}")
# 5. 通過審査管理画面で使われる可能性のあるクエリの確認
print("\n5. 通過審査管理用データ確認:")
cursor.execute("""
SELECT e.id as event_id, e.event_name, COUNT(t.id) as team_count,
COUNT(CASE WHEN t.zekken_number IS NOT NULL AND t.zekken_number != '' THEN 1 END) as zekken_teams
FROM rog_newevent2 e
LEFT JOIN rog_team t ON e.id = t.event_id
GROUP BY e.id, e.event_name
ORDER BY e.id;
""")
event_stats = cursor.fetchall()
print(" イベント別チーム・ゼッケン統計:")
for stat in event_stats:
print(f" イベントID:{stat[0]}, Name:{stat[1]}, 総チーム:{stat[2]}, ゼッケン付き:{stat[3]}")
if __name__ == "__main__":
try:
analyze_event_data_raw()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

125
analyze_fc_gifu_data.py Normal file
View File

@ -0,0 +1,125 @@
#!/usr/bin/env python3
import os
import sys
import django
# プロジェクト設定
sys.path.append('/app')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from rog.models import Entry, Team, NewEvent2, Member
from django.db.models import Q
import logging
# ログ設定
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def analyze_fc_gifu_data():
"""FC岐阜関連のイベント・チーム・エントリーデータを詳細分析"""
print("=== FC岐阜イベント・データ詳細分析 ===")
# 1. FC岐阜関連イベントを検索
print("\n1. FC岐阜関連イベント検索:")
fc_events = NewEvent2.objects.filter(
Q(event_name__icontains='FC岐阜') |
Q(event_name__icontains='fc岐阜') |
Q(event_name__icontains='岐阜')
)
if fc_events.exists():
for event in fc_events:
print(f" - ID:{event.id}, Name:{event.event_name}, Date:{event.event_day}")
# イベントに関連するエントリーを確認
entries = Entry.objects.filter(event=event)
print(f" 関連エントリー数: {entries.count()}")
# エントリーのチーム情報を表示
if entries.exists():
print(" エントリー詳細:")
for entry in entries[:10]: # 最初の10件のみ表示
team = entry.team
print(f" Entry ID:{entry.id}, Team ID:{team.id}, Team Name:{team.name}, Zekken:{team.zekken_number}")
# イベントに関連するチームを直接検索
teams = Team.objects.filter(event=event)
print(f" 関連チーム数: {teams.count()}")
if teams.exists():
print(" チーム詳細:")
for team in teams[:10]: # 最初の10件のみ表示
print(f" Team ID:{team.id}, Name:{team.name}, Zekken:{team.zekken_number}")
else:
print(" FC岐阜関連イベントが見つかりません")
# 2. 全イベント一覧を確認
print("\n2. 全イベント一覧:")
all_events = NewEvent2.objects.all()
for event in all_events:
entry_count = Entry.objects.filter(event=event).count()
team_count = Team.objects.filter(event=event).count()
print(f" - ID:{event.id}, Name:{event.event_name}, Date:{event.event_day}, Entry:{entry_count}, Team:{team_count}")
# 3. ゼッケン番号が設定されているチームを確認
print("\n3. ゼッケン番号付きチーム:")
teams_with_zekken = Team.objects.exclude(zekken_number__isnull=True).exclude(zekken_number='')
print(f" ゼッケン番号付きチーム数: {teams_with_zekken.count()}")
if teams_with_zekken.exists():
print(" サンプル:")
for team in teams_with_zekken[:10]:
print(f" ID:{team.id}, Name:{team.name}, Zekken:{team.zekken_number}, Event:{team.event.event_name if team.event else 'None'}")
# 4. 特定のイベントID（仮に100とする）を詳細調査
print("\n4. イベントID 100 詳細調査:")
try:
event_100 = NewEvent2.objects.get(id=100)
print(f" イベント: {event_100.event_name} ({event_100.event_day})")
# エントリー確認
entries_100 = Entry.objects.filter(event=event_100)
print(f" エントリー数: {entries_100.count()}")
# チーム確認
teams_100 = Team.objects.filter(event=event_100)
print(f" チーム数: {teams_100.count()}")
# ゼッケン番号付きチーム確認
teams_100_with_zekken = teams_100.exclude(zekken_number__isnull=True).exclude(zekken_number='')
print(f" ゼッケン番号付きチーム数: {teams_100_with_zekken.count()}")
if teams_100_with_zekken.exists():
print(" ゼッケン番号付きチーム:")
for team in teams_100_with_zekken:
print(f" ID:{team.id}, Name:{team.name}, Zekken:{team.zekken_number}")
except NewEvent2.DoesNotExist:
print(" イベントID 100は存在しません")
# 5. Entryテーブルとチームの関係確認
print("\n5. Entry-Team関係確認:")
total_entries = Entry.objects.all().count()
entries_with_teams = Entry.objects.exclude(team__isnull=True).count()
print(f" 総エントリー数: {total_entries}")
print(f" チーム関連付けありエントリー数: {entries_with_teams}")
# サンプルエントリーの詳細
print(" サンプルエントリー詳細:")
sample_entries = Entry.objects.all()[:5]
for entry in sample_entries:
team = entry.team
event = entry.event
print(f" Entry ID:{entry.id}, Team:{team.name if team else 'None'}({team.id if team else 'None'}), Event:{event.event_name if event else 'None'}({event.id if event else 'None'})")
if team:
print(f" Team Zekken:{team.zekken_number}, Team Event:{team.event.event_name if team.event else 'None'}")
if __name__ == "__main__":
try:
analyze_fc_gifu_data()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

158
analyze_old_rogdb.py Normal file
View File

@ -0,0 +1,158 @@
#!/usr/bin/env python
"""
old_rogdb構造分析＆データ移行準備スクリプト
old_rogdbの構造を詳細に分析し、rogdbへの移行計画を立てる
"""
import os
import sys
import django
import psycopg2
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.conf import settings
print("=== old_rogdb構造分析 ===")
# old_rogdb直接接続設定
old_db_config = {
'host': 'postgres-db',
'database': 'old_rogdb',
'user': 'admin',
'password': 'admin123456',
'port': 5432
}
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(**old_db_config)
old_cursor = old_conn.cursor()
print("✅ old_rogdb接続成功")
print("\\n=== 1. old_rogdb rog_entry構造分析 ===")
old_cursor.execute("""
SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = 'rog_entry' AND table_schema = 'public'
ORDER BY ordinal_position;
""")
old_entry_columns = old_cursor.fetchall()
print("old_rogdb.rog_entry 構造:")
for col_name, data_type, nullable, default in old_entry_columns:
print(f" - {col_name}: {data_type} {'(NULL可)' if nullable == 'YES' else '(NOT NULL)'} {f'[default: {default}]' if default else ''}")
# old_rogdb rog_entry データ確認
old_cursor.execute("SELECT COUNT(*) FROM rog_entry;")
old_entry_count = old_cursor.fetchone()[0]
print(f"\\nold_rogdb.rog_entry データ件数: {old_entry_count}件")
# サンプルデータ確認
old_cursor.execute("SELECT * FROM rog_entry LIMIT 3;")
old_entry_samples = old_cursor.fetchall()
print("\\nサンプルデータ（最初の3件）:")
for i, row in enumerate(old_entry_samples):
print(f" Row {i+1}: {row}")
print("\\n=== 2. old_rogdb rog_team構造分析 ===")
old_cursor.execute("""
SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = 'rog_team' AND table_schema = 'public'
ORDER BY ordinal_position;
""")
old_team_columns = old_cursor.fetchall()
print("old_rogdb.rog_team 構造:")
for col_name, data_type, nullable, default in old_team_columns:
print(f" - {col_name}: {data_type} {'(NULL可)' if nullable == 'YES' else '(NOT NULL)'} {f'[default: {default}]' if default else ''}")
old_cursor.execute("SELECT COUNT(*) FROM rog_team;")
old_team_count = old_cursor.fetchone()[0]
print(f"\\nold_rogdb.rog_team データ件数: {old_team_count}件")
print("\\n=== 3. old_rogdb rog_member構造分析 ===")
try:
old_cursor.execute("""
SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = 'rog_member' AND table_schema = 'public'
ORDER BY ordinal_position;
""")
old_member_columns = old_cursor.fetchall()
if old_member_columns:
print("old_rogdb.rog_member 構造:")
for col_name, data_type, nullable, default in old_member_columns:
print(f" - {col_name}: {data_type} {'(NULL可)' if nullable == 'YES' else '(NOT NULL)'} {f'[default: {default}]' if default else ''}")
old_cursor.execute("SELECT COUNT(*) FROM rog_member;")
old_member_count = old_cursor.fetchone()[0]
print(f"\\nold_rogdb.rog_member データ件数: {old_member_count}件")
else:
print("old_rogdb.rog_member テーブルが存在しません")
except Exception as e:
print(f"old_rogdb.rog_member 確認エラー: {e}")
print("\\n=== 4. FC岐阜関連データ詳細分析 ===")
# FC岐阜イベント確認
old_cursor.execute("""
SELECT id, event_name, start_datetime, end_datetime
FROM rog_newevent2
WHERE event_name LIKE '%FC岐阜%' OR event_name LIKE '%fc岐阜%'
ORDER BY id;
""")
fc_events = old_cursor.fetchall()
print("FC岐阜関連イベント:")
for event_id, name, start, end in fc_events:
print(f" Event {event_id}: '{name}' ({start} - {end})")
# このイベントのエントリー数確認
old_cursor.execute("SELECT COUNT(*) FROM rog_entry WHERE event_id = %s;", (event_id,))
entry_count = old_cursor.fetchone()[0]
print(f" エントリー数: {entry_count}件")
# FC岐阜イベントのエントリー詳細
if fc_events:
fc_event_id = fc_events[0][0] # 最初のFC岐阜イベント
print(f"\\nFC岐阜イベント(ID:{fc_event_id})のエントリー詳細:")
old_cursor.execute("""
SELECT re.id, re.team_id, re.category_id, re.zekken_number, re.zekken_label,
rt.team_name, rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = %s
ORDER BY re.zekken_number
LIMIT 10;
""", (fc_event_id,))
fc_entry_details = old_cursor.fetchall()
for entry_id, team_id, cat_id, zekken, label, team_name, cat_name in fc_entry_details:
print(f" Entry {entry_id}: Team {team_id}({team_name}) - ゼッケン{zekken} - {cat_name}")
print("\\n=== 5. 移行計画 ===")
print("移行が必要なテーブル:")
print(" 1. old_rogdb.rog_team → rogdb.rog_team")
print(" 2. old_rogdb.rog_entry → rogdb.rog_entry")
print(" 3. old_rogdb.rog_member → rogdb.rog_member (存在する場合)")
print("\\n注意点:")
print(" - イベントはrog_newevent2を使用")
print(" - 外部キー制約の整合性確保")
print(" - データ型の変換（必要に応じて）")
print(" - 重複データの回避")
old_cursor.close()
old_conn.close()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

136
check_database_connection.py Normal file
View File

@ -0,0 +1,136 @@
#!/usr/bin/env python
"""
データベース接続状況とold_rogdbデータ確認スクリプト
現在のDB接続状況を確認し、old_rogdbの実際のデータを調査
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection, connections
from django.conf import settings
print("=== データベース接続状況確認 ===")
try:
# 現在のデータベース設定を確認
print("\\n1. Django設定確認:")
databases = settings.DATABASES
for db_name, config in databases.items():
print(f" {db_name}: {config.get('NAME', 'Unknown')} @ {config.get('HOST', 'localhost')}")
with connection.cursor() as cursor:
# 現在接続しているデータベース名を確認
cursor.execute("SELECT current_database();")
current_db = cursor.fetchone()[0]
print(f"\\n2. 現在接続中のDB: {current_db}")
# データベース内のテーブル一覧確認
cursor.execute("""
SELECT table_name
FROM information_schema.tables
WHERE table_schema = 'public'
AND table_name LIKE '%rog%'
ORDER BY table_name;
""")
tables = cursor.fetchall()
print(f"\\n3. rogaine関連テーブル:")
for table in tables:
print(f" - {table[0]}")
# old_rogdbスキーマまたはテーブルの存在確認
cursor.execute("""
SELECT schemaname, tablename, hasindexes, hasrules, hastriggers
FROM pg_tables
WHERE tablename LIKE '%rog%'
ORDER BY schemaname, tablename;
""")
all_rog_tables = cursor.fetchall()
print(f"\\n4. 全スキーマのrog関連テーブル:")
for schema, table, idx, rules, triggers in all_rog_tables:
print(f" {schema}.{table}")
# データ存在確認
print(f"\\n5. 現在のデータ状況:")
# rog_entry データ確認
try:
cursor.execute("SELECT COUNT(*) FROM rog_entry;")
entry_count = cursor.fetchone()[0]
print(f" rog_entry: {entry_count}件")
if entry_count > 0:
cursor.execute("SELECT * FROM rog_entry LIMIT 3;")
sample_entries = cursor.fetchall()
print(" サンプルエントリー:")
for entry in sample_entries:
print(f" ID:{entry[0]}, Team:{entry[5]}, Event:{entry[3]}")
except Exception as e:
print(f" rog_entry エラー: {e}")
# rog_team データ確認
try:
cursor.execute("SELECT COUNT(*) FROM rog_team;")
team_count = cursor.fetchone()[0]
print(f" rog_team: {team_count}件")
if team_count > 0:
cursor.execute("SELECT id, team_name, zekken_number FROM rog_team WHERE zekken_number IS NOT NULL AND zekken_number != '' LIMIT 5;")
sample_teams = cursor.fetchall()
print(" ゼッケン付きチーム:")
for team in sample_teams:
print(f" ID:{team[0]}, Name:{team[1]}, Zekken:{team[2]}")
except Exception as e:
print(f" rog_team エラー: {e}")
# もしold_rogdbが別のスキーマにある場合
print(f"\\n6. 別スキーマのold_rogdbデータ確認:")
try:
# old_rogdbスキーマが存在するかチェック
cursor.execute("""
SELECT schema_name
FROM information_schema.schemata
WHERE schema_name LIKE '%old%' OR schema_name LIKE '%rog%';
""")
schemas = cursor.fetchall()
print(" 利用可能なスキーマ:")
for schema in schemas:
print(f" - {schema[0]}")
# old_rogdbスキーマがある場合、そのデータを確認
for schema in schemas:
schema_name = schema[0]
if 'old' in schema_name.lower():
try:
cursor.execute(f"SELECT COUNT(*) FROM {schema_name}.rog_entry;")
old_entry_count = cursor.fetchone()[0]
print(f" {schema_name}.rog_entry: {old_entry_count}件")
except Exception as e:
print(f" {schema_name}.rog_entry: アクセスエラー - {e}")
except Exception as e:
print(f" スキーマ確認エラー: {e}")
# old_rogdbが別のデータベースの場合の確認
print(f"\\n7. 利用可能なデータベース一覧:")
cursor.execute("""
SELECT datname
FROM pg_database
WHERE datistemplate = false
ORDER BY datname;
""")
databases = cursor.fetchall()
for db in databases:
print(f" - {db[0]}")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

0
check_event_codes.py Normal file
View File

93
check_old_entries.py Normal file
View File

@ -0,0 +1,93 @@
#!/usr/bin/env python
"""
old_rogdb から新しいデータベースへのエントリーデータ移行スクリプト
rog_entry テーブルのデータを NewEvent2 システムに移行
"""
import os
import sys
import django
from datetime import datetime
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection
from rog.models import NewEvent2, Entry, Team, NewCategory, CustomUser
print("=== old_rogdb エントリーデータ移行 ===")
try:
# old_rogdb の rog_entry データを確認
print("old_rogdb の rog_entry データを確認中...")
with connection.cursor() as cursor:
# rog_entry テーブルの構造とデータを確認
cursor.execute("""
SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = 'rog_entry'
ORDER BY ordinal_position;
""")
columns = cursor.fetchall()
print("✅ rog_entry テーブル構造:")
for col_name, data_type in columns:
print(f" - {col_name}: {data_type}")
# データ件数確認
cursor.execute("SELECT COUNT(*) FROM rog_entry;")
entry_count = cursor.fetchone()[0]
print(f"✅ rog_entry データ件数: {entry_count}件")
# サンプルデータ確認
cursor.execute("""
SELECT id, team_id, event_id, category_id, date,
zekken_number, zekken_label, is_active
FROM rog_entry
LIMIT 5;
""")
sample_data = cursor.fetchall()
print("\\n✅ サンプルデータ:")
for row in sample_data:
print(f" ID:{row[0]}, Team:{row[1]}, Event:{row[2]}, Category:{row[3]}, Zekken:{row[5]}")
# イベント情報の確認
cursor.execute("""
SELECT e.id, e.event_name, COUNT(re.id) as entry_count
FROM rog_newevent2 e
LEFT JOIN rog_entry re ON e.id = re.event_id
GROUP BY e.id, e.event_name
HAVING COUNT(re.id) > 0
ORDER BY entry_count DESC;
""")
event_data = cursor.fetchall()
print("\\n✅ エントリーがあるイベント:")
for event_id, event_name, count in event_data:
print(f" Event ID:{event_id} '{event_name}': {count}件")
# FC岐阜イベントのエントリー確認
cursor.execute("""
SELECT re.id, re.zekken_number, re.zekken_label,
t.team_name, c.category_name
FROM rog_entry re
JOIN rog_newevent2 e ON re.event_id = e.id
JOIN rog_team t ON re.team_id = t.id
JOIN rog_newcategory c ON re.category_id = c.id
WHERE e.event_name LIKE '%FC岐阜%'
ORDER BY re.zekken_number
LIMIT 10;
""")
fc_entries = cursor.fetchall()
print("\\n✅ FC岐阜イベントのエントリー（最初の10件）:")
for entry_id, zekken, label, team_name, category in fc_entries:
print(f" ゼッケン{zekken}: {team_name} ({category})")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

66
clear_rog_migrations.py Normal file
View File

@ -0,0 +1,66 @@
#!/usr/bin/env python
"""
マイグレーション履歴リセットスクリプト
rogアプリのマイグレーション履歴をクリアして、新しいシンプルマイグレーションを適用
"""
import os
import sys
import django
from django.core.management import execute_from_command_line
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection
from django.core.management.color import no_style
print("=== マイグレーション履歴のクリア ===")
# データベース接続を取得
cursor = connection.cursor()
try:
# rogアプリのマイグレーション履歴をクリア
print("rogアプリのマイグレーション履歴を削除中...")
cursor.execute("DELETE FROM django_migrations WHERE app = 'rog';")
print("✅ rogアプリのマイグレーション履歴を削除しました")
# コミット
connection.commit()
print("\n=== マイグレーション状態確認 ===")
# マイグレーション状態を確認
execute_from_command_line(['manage.py', 'showmigrations', 'rog'])
print("\n=== 新しいマイグレーションを偽装適用 ===")
# 依存関係チェックを無視してマイグレーションを偽装適用
try:
# まず --run-syncdb で既存のテーブル構造を認識させる
execute_from_command_line(['manage.py', 'migrate', '--run-syncdb'])
except Exception as sync_error:
print(f"syncdb エラー（継続）: {sync_error}")
# マイグレーション履歴に直接レコードを挿入
print("マイグレーション履歴を直接挿入中...")
# 新しいカーソルを作成
with connection.cursor() as new_cursor:
new_cursor.execute("""
INSERT INTO django_migrations (app, name, applied)
VALUES ('rog', '0001_simple_initial', NOW())
ON CONFLICT DO NOTHING;
""")
connection.commit()
print("✅ マイグレーション履歴を挿入しました")
print("\n=== 最終確認 ===")
# 最終確認
execute_from_command_line(['manage.py', 'showmigrations'])
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
connection.rollback()
finally:
cursor.close()

83
complete_migration_reset.py Normal file
View File

@ -0,0 +1,83 @@
#!/usr/bin/env python
"""
チーム・エントリーデータ完全リセット＆再移行スクリプト
既存のTeam/Entryデータをクリアして、old_rogdbから完全に移行し直す
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from rog.models import Team, Entry, Member
from django.db import transaction
import subprocess
print("=== チーム・エントリーデータ完全リセット＆再移行 ===")
try:
with transaction.atomic():
print("1. 既存データをクリア中...")
# 関連データを順番にクリア
entry_count = Entry.objects.count()
member_count = Member.objects.count()
team_count = Team.objects.count()
print(f" 削除対象: Entry({entry_count}件), Member({member_count}件), Team({team_count}件)")
Entry.objects.all().delete()
Member.objects.all().delete()
Team.objects.all().delete()
print(" ✅ 既存データクリア完了")
print("\\n2. チームデータ移行を実行中...")
result = subprocess.run([
'python', 'migrate_rog_team_enhanced.py'
], capture_output=True, text=True)
if result.returncode == 0:
print(" ✅ チーム移行完了")
else:
print(f" ❌ チーム移行エラー: {result.stderr}")
print("\\n3. エントリーデータ移行を実行中...")
result = subprocess.run([
'python', 'migrate_rog_entry_enhanced.py'
], capture_output=True, text=True)
if result.returncode == 0:
print(" ✅ エントリー移行完了")
else:
print(f" ❌ エントリー移行エラー: {result.stderr}")
print("\\n4. 移行結果確認...")
from rog.models import NewEvent2
team_count = Team.objects.count()
entry_count = Entry.objects.count()
print(f" Team: {team_count}件")
print(f" Entry: {entry_count}件")
# FC岐阜イベントのエントリー確認
fc_event = NewEvent2.objects.filter(event_name__icontains='FC岐阜').first()
if fc_event:
fc_entries = Entry.objects.filter(event=fc_event)
print(f" FC岐阜イベントエントリー: {fc_entries.count()}件")
if fc_entries.exists():
print(" ✅ ゼッケン番号表示問題が解決されました！")
for entry in fc_entries[:3]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
else:
print(" ⚠️ FC岐阜にエントリーがありません")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

91
create_fc_gifu_entries.py Normal file
View File

@ -0,0 +1,91 @@
#!/usr/bin/env python
"""
FC岐阜イベント用のエントリーデータ作成スクリプト
既存のチームをFC岐阜イベントにエントリーして、ゼッケン番号表示を可能にする
"""
import os
import sys
import django
from datetime import datetime
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from rog.models import NewEvent2, Entry, Team, NewCategory, CustomUser
print("=== FC岐阜イベント用エントリーデータ作成 ===")
try:
# FC岐阜イベントを取得
fc_gifu_event = NewEvent2.objects.filter(event_name__icontains='FC岐阜').first()
if not fc_gifu_event:
print("❌ FC岐阜イベントが見つかりません")
sys.exit(1)
print(f"✅ FC岐阜イベント確認: {fc_gifu_event.event_name} (ID: {fc_gifu_event.id})")
# カテゴリを取得または作成
category, created = NewCategory.objects.get_or_create(
category_name="一般",
defaults={'category_number': 1}
)
if created:
print(f"✅ カテゴリ作成: {category.category_name}")
else:
print(f"✅ 既存カテゴリ使用: {category.category_name}")
# 既存のチームを取得
teams = Team.objects.all()[:10] # 最初の10チームを使用
print(f"✅ 対象チーム数: {teams.count()}件")
# エントリーを作成
created_entries = 0
zekken_number = 1
for team in teams:
# 既にエントリーが存在するかチェック
existing_entry = Entry.objects.filter(
team=team,
event=fc_gifu_event
).first()
if not existing_entry:
# エントリーを作成
entry = Entry.objects.create(
team=team,
event=fc_gifu_event,
category=category,
date=fc_gifu_event.start_datetime,
owner=team.owner,
zekken_number=zekken_number,
zekken_label=f"FC岐阜-{zekken_number:03d}",
is_active=True,
hasParticipated=False,
hasGoaled=False
)
print(f" ✅ エントリー作成: {team.team_name} -> ゼッケン{zekken_number}")
created_entries += 1
zekken_number += 1
else:
print(f" ⏭️ 既存エントリー: {team.team_name}")
print(f"\n=== 作成完了 ===")
print(f"新規エントリー数: {created_entries}件")
# 確認
fc_entries = Entry.objects.filter(event=fc_gifu_event)
print(f"FC岐阜イベントの総エントリー数: {fc_entries.count()}件")
print("\n=== ゼッケン番号一覧 ===")
for entry in fc_entries.order_by('zekken_number')[:5]:
print(f"ゼッケン{entry.zekken_number}: {entry.team.team_name}")
if fc_entries.count() > 5:
print(f"... 他 {fc_entries.count() - 5}件")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

146
fix_fc_gifu_zekken_numbers.py Normal file
View File

@ -0,0 +1,146 @@
#!/usr/bin/env python3
import os
import sys
import django
# プロジェクト設定
sys.path.append('/app')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection, transaction
import logging
# ログ設定
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def assign_zekken_numbers_to_fc_gifu():
"""FC岐阜イベント（ID:10）のチームにゼッケン番号を割り当て"""
print("=== FC岐阜イベントチームゼッケン番号割り当て ===")
with connection.cursor() as cursor:
# 1. FC岐阜イベントの現状確認
print("\n1. FC岐阜イベント（ID:10）現状確認:")
cursor.execute("""
SELECT t.id, t.team_name, t.zekken_number, t.event_id
FROM rog_team t
JOIN rog_entry e ON t.id = e.team_id
WHERE e.event_id = 10
ORDER BY t.id;
""")
fc_teams = cursor.fetchall()
print(f" FC岐阜関連チーム数: {len(fc_teams)}")
print(" 現在の状況:")
for team in fc_teams[:5]: # 最初の5件のみ表示
print(f" Team ID:{team[0]}, Name:{team[1]}, Zekken:{team[2]}, Event:{team[3]}")
# 2. ゼッケン番号が未設定のチームを特定
teams_without_zekken = [team for team in fc_teams if not team[2]]
print(f"\n ゼッケン番号未設定チーム数: {len(teams_without_zekken)}")
if not teams_without_zekken:
print(" 🎉 すべてのチームにゼッケン番号が設定済み")
return
# 3. 既存のゼッケン番号を確認（競合回避）
print("\n2. 既存ゼッケン番号確認:")
cursor.execute("""
SELECT zekken_number
FROM rog_team
WHERE zekken_number IS NOT NULL AND zekken_number != ''
ORDER BY zekken_number;
""")
existing_zekkens = [row[0] for row in cursor.fetchall()]
print(f" 既存ゼッケン番号: {existing_zekkens}")
# 4. ユーザー確認
print(f"\n3. ゼッケン番号割り当て準備:")
print(f" 対象チーム数: {len(teams_without_zekken)}")
print(f" 割り当て予定ゼッケン番号: FC001-FC{len(teams_without_zekken):03d}")
confirm = input("\n ゼッケン番号を割り当てますか？ (y/N): ")
if confirm.lower() != 'y':
print(" 処理をキャンセルしました")
return
# 5. ゼッケン番号割り当て実行
print("\n4. ゼッケン番号割り当て実行:")
with transaction.atomic():
for i, team in enumerate(teams_without_zekken, 1):
team_id = team[0]
team_name = team[1]
zekken_number = f"FC{i:03d}"
cursor.execute("""
UPDATE rog_team
SET zekken_number = %s, updated_at = NOW()
WHERE id = %s;
""", [zekken_number, team_id])
print(f" Team ID:{team_id} ({team_name}) → ゼッケン番号: {zekken_number}")
print(f"\n ✅ {len(teams_without_zekken)}チームにゼッケン番号を割り当てました")
# 6. 結果確認
print("\n5. 割り当て結果確認:")
cursor.execute("""
SELECT t.id, t.team_name, t.zekken_number
FROM rog_team t
JOIN rog_entry e ON t.id = e.team_id
WHERE e.event_id = 10 AND t.zekken_number IS NOT NULL
ORDER BY t.zekken_number;
""")
updated_teams = cursor.fetchall()
print(f" ゼッケン番号付きチーム数: {len(updated_teams)}")
print(" 割り当て結果（サンプル）:")
for team in updated_teams[:10]:
print(f" {team[2]}: {team[1]} (ID:{team[0]})")
# 7. 通過審査管理画面での影響確認
print("\n6. 通過審査管理画面への影響:")
print(" これで通過審査管理画面で以下が表示されるはずです:")
print(" - ALL（全参加者）")
for team in updated_teams[:5]:
print(f" - {team[2]}（{team[1]}）")
print(" - ...")
def reset_zekken_numbers():
"""FC岐阜イベントのゼッケン番号をリセット（テスト用）"""
print("\n=== ゼッケン番号リセット（テスト用） ===")
with connection.cursor() as cursor:
confirm = input("FC岐阜イベントのゼッケン番号をリセットしますか？ (y/N): ")
if confirm.lower() != 'y':
print("リセットをキャンセルしました")
return
with transaction.atomic():
cursor.execute("""
UPDATE rog_team
SET zekken_number = NULL, updated_at = NOW()
WHERE id IN (
SELECT DISTINCT t.id
FROM rog_team t
JOIN rog_entry e ON t.id = e.team_id
WHERE e.event_id = 10
);
""")
affected_rows = cursor.rowcount
print(f"✅ {affected_rows}チームのゼッケン番号をリセットしました")
if __name__ == "__main__":
try:
import sys
if len(sys.argv) > 1 and sys.argv[1] == '--reset':
reset_zekken_numbers()
else:
assign_zekken_numbers_to_fc_gifu()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

140
investigate_team_structure.py Normal file
View File

@ -0,0 +1,140 @@
#!/usr/bin/env python3
import os
import sys
import django
# プロジェクト設定
sys.path.append('/app')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection
import logging
# ログ設定
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def investigate_team_table_structure():
"""チームテーブルの構造とFC岐阜問題を調査"""
print("=== Team テーブル構造とFC岐阜問題調査 ===")
with connection.cursor() as cursor:
# 1. rog_teamテーブルの構造確認
print("\n1. rog_teamテーブル構造:")
cursor.execute("""
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'rog_team'
ORDER BY ordinal_position;
""")
columns = cursor.fetchall()
for col in columns:
print(f" - {col[0]}: {col[1]} ({'NULL' if col[2] == 'YES' else 'NOT NULL'})")
# 2. rog_teamテーブルの総件数
print("\n2. rog_teamテーブルの状況:")
cursor.execute("SELECT COUNT(*) FROM rog_team;")
total_teams = cursor.fetchone()[0]
print(f" 総チーム数: {total_teams}")
# 3. FC岐阜イベント（ID:10）の詳細調査
print("\n3. FC岐阜イベント（ID:10）詳細調査:")
cursor.execute("SELECT COUNT(*) FROM rog_entry WHERE event_id = 10;")
fc_entries = cursor.fetchone()[0]
print(f" FC岐阜イベントエントリー数: {fc_entries}")
# 4. FC岐阜エントリーのサンプル表示
print("\n4. FC岐阜エントリーサンプル:")
cursor.execute("""
SELECT id, team_id, event_id, date
FROM rog_entry
WHERE event_id = 10
LIMIT 10;
""")
fc_entry_samples = cursor.fetchall()
for entry in fc_entry_samples:
print(f" Entry ID:{entry[0]}, Team ID:{entry[1]}, Event ID:{entry[2]}, Date:{entry[3]}")
# 5. FC岐阜エントリーのteam_idを調べる
print("\n5. FC岐阜エントリーのteam_id分析:")
cursor.execute("""
SELECT team_id, COUNT(*) as count
FROM rog_entry
WHERE event_id = 10
GROUP BY team_id
ORDER BY count DESC;
""")
team_id_stats = cursor.fetchall()
for stat in team_id_stats:
print(f" Team ID:{stat[0]}, エントリー数:{stat[1]}")
# 6. 実際のteam_idでチーム情報を確認
print("\n6. 実際のチーム情報確認:")
if team_id_stats:
sample_team_ids = [stat[0] for stat in team_id_stats[:5]]
for team_id in sample_team_ids:
cursor.execute("SELECT * FROM rog_team WHERE id = %s;", [team_id])
team_info = cursor.fetchone()
if team_info:
print(f" Team ID:{team_id} 存在する: {team_info}")
else:
print(f" Team ID:{team_id} 存在しない")
# 7. ゼッケン番号付きチームの確認（実際のカラム名を使用）
print("\n7. ゼッケン番号関連調査:")
if 'zekken_number' in [col[0] for col in columns]:
cursor.execute("""
SELECT COUNT(*)
FROM rog_team
WHERE zekken_number IS NOT NULL AND zekken_number != '';
""")
zekken_count = cursor.fetchone()[0]
print(f" ゼッケン番号付きチーム数: {zekken_count}")
if zekken_count > 0:
cursor.execute("""
SELECT id, zekken_number, event_id
FROM rog_team
WHERE zekken_number IS NOT NULL AND zekken_number != ''
LIMIT 10;
""")
zekken_teams = cursor.fetchall()
print(" ゼッケン番号付きチームサンプル:")
for team in zekken_teams:
print(f" Team ID:{team[0]}, Zekken:{team[1]}, Event ID:{team[2]}")
# 8. 通過審査管理画面の問題の原因を特定
print("\n8. 通過審査管理画面問題の分析:")
print(" FC岐阜イベント（ID:10）について:")
print(f" - エントリー数: {fc_entries}")
print(f" - 関連チーム情報の確認が必要")
# 実際に存在するチームを探す
if team_id_stats:
existing_teams = []
missing_teams = []
for team_id, count in team_id_stats:
cursor.execute("SELECT COUNT(*) FROM rog_team WHERE id = %s;", [team_id])
exists = cursor.fetchone()[0] > 0
if exists:
existing_teams.append((team_id, count))
else:
missing_teams.append((team_id, count))
print(f" - 存在するチーム: {len(existing_teams)}")
print(f" - 存在しないチーム: {len(missing_teams)}")
if missing_teams:
print(" 🔴 問題発見: エントリーが参照するチームが存在しない！")
for team_id, count in missing_teams[:3]:
print(f" Missing Team ID:{team_id} ({count}エントリー)")
if __name__ == "__main__":
try:
investigate_team_table_structure()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

377
migrate_all_events_complete.py Normal file
View File

@ -0,0 +1,377 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト
FC岐阜の成功事例をベースに全てのイベントのteam/member/entryを移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser, Member
import psycopg2
from collections import defaultdict
print("=== old_rogdb から 全イベントデータ移行 ===")
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
with old_conn.cursor() as old_cursor:
# === STEP 0: 移行対象イベントの確認 ===
print("\\n=== STEP 0: 移行対象イベントの確認 ===")
# 新DBのイベント一覧を取得
existing_events = list(NewEvent2.objects.values_list('id', 'event_name'))
existing_event_ids = [event_id for event_id, _ in existing_events]
print(f"新DB既存イベント: {len(existing_events)}件")
for event_id, event_name in existing_events[:10]:
print(f" Event {event_id}: {event_name}")
# old_rogdbでエントリーがあるイベントを確認
old_cursor.execute("""
SELECT e.id, e.event_name, COUNT(re.id) as entry_count
FROM rog_newevent2 e
LEFT JOIN rog_entry re ON e.id = re.event_id
WHERE e.id IN ({})
GROUP BY e.id, e.event_name
HAVING COUNT(re.id) > 0
ORDER BY COUNT(re.id) DESC;
""".format(','.join(map(str, existing_event_ids))))
events_with_entries = old_cursor.fetchall()
print(f"\\n移行対象イベント（エントリーあり）: {len(events_with_entries)}件")
for event_id, event_name, entry_count in events_with_entries:
print(f" Event {event_id}: '{event_name}' - {entry_count}件のエントリー")
# === STEP 1: 全イベントのTeam & Member データ取得 ===
print("\\n=== STEP 1: 全イベントの Team & Member データ取得 ===")
# 全イベントのチーム情報を取得
old_cursor.execute("""
SELECT DISTINCT rt.id, rt.team_name, rt.owner_id, rt.category_id,
rc.category_name, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON rt.category_id = rc.id
LEFT JOIN rog_customuser cu ON rt.owner_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rt.id;
""".format(','.join(map(str, existing_event_ids))))
all_team_data = old_cursor.fetchall()
print(f"全イベント関連チーム: {len(all_team_data)}件")
# イベント別チーム数統計
teams_by_event = defaultdict(int)
teams_by_event = defaultdict(int)
for _, _, _, _, _, _, _, _, event_id in all_team_data:
teams_by_event[event_id] += 1
print("\\nイベント別チーム数:")
for event_id, count in sorted(teams_by_event.items()):
event_name = next((name for eid, name in existing_events if eid == event_id), "不明")
print(f" Event {event_id} ({event_name}): {count}チーム")
# 全イベントのメンバー情報を取得
old_cursor.execute("""
SELECT rm.team_id, rm.user_id, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_member rm ON re.team_id = rm.team_id
JOIN rog_customuser cu ON rm.user_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rm.team_id, rm.user_id;
""".format(','.join(map(str, existing_event_ids))))
all_member_data = old_cursor.fetchall()
print(f"全イベント関連メンバー: {len(all_member_data)}件")
# === STEP 2: ユーザー移行 ===
print("\\n=== STEP 2: ユーザー移行 ===")
# 関連するすべてのユーザーを取得
all_user_ids = set()
for _, _, owner_id, _, _, _, _, _, _ in all_team_data:
if owner_id:
all_user_ids.add(owner_id)
for _, user_id, _, _, _, _ in all_member_data:
all_user_ids.add(user_id)
if all_user_ids:
# 大量のユーザーIDに対応するため、バッチで処理
user_batches = [list(all_user_ids)[i:i+100] for i in range(0, len(all_user_ids), 100)]
all_user_data = []
user_batches = [list(all_user_ids)[i:i+100] for i in range(0, len(all_user_ids), 100)]
all_user_data = []
for batch in user_batches:
old_cursor.execute(f"""
SELECT id, email, firstname, lastname, date_joined
FROM rog_customuser
WHERE id IN ({','.join(map(str, batch))})
""")
all_user_data.extend(old_cursor.fetchall())
print(f"移行対象ユーザー: {len(all_user_data)}件")
migrated_users = 0
for user_id, email, first_name, last_name, date_joined in all_user_data:
user, created = CustomUser.objects.get_or_create(
id=user_id,
defaults={
'email': email or f'user{user_id}@example.com',
'first_name': first_name or '',
'last_name': last_name or '',
'username': email or f'user{user_id}',
'date_joined': date_joined,
'is_active': True
}
)
if created:
migrated_users += 1
if migrated_users <= 10: # 最初の10件のみ表示
print(f" ユーザー作成: {email} ({first_name} {last_name})")
print(f"✅ ユーザー移行完了: {migrated_users}件作成")
# === STEP 3: カテゴリ移行 ===
print("\\n=== STEP 3: カテゴリ移行 ===")
migrated_categories = 0
unique_categories = set()
unique_categories = set()
for _, _, _, cat_id, cat_name, _, _, _, _ in all_team_data:
if cat_id and cat_name:
unique_categories.add((cat_id, cat_name))
for cat_id, cat_name in unique_categories:
category, created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if created:
migrated_categories += 1
print(f" カテゴリ作成: {cat_name}")
print(f"✅ カテゴリ移行完了: {migrated_categories}件作成")
# === STEP 4: イベント別チーム移行 ===
print("\\n=== STEP 4: イベント別チーム移行 ===")
total_migrated_teams = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\\n--- Event {event_id}: {event_name} ---")
event_teams = [data for data in all_team_data if data[8] == event_id]
event_migrated_teams = 0
for team_id, team_name, owner_id, cat_id, cat_name, email, first_name, last_name, _ in event_teams:
try:
# カテゴリを取得
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# チームを作成
team, created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': event_id
}
)
if created:
event_migrated_teams += 1
total_migrated_teams += 1
if event_migrated_teams <= 3: # イベントごとに最初の3件のみ表示
print(f" チーム作成: {team_name} (ID: {team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_teams}件のチームを移行")
print(f"\\n✅ 全チーム移行完了: {total_migrated_teams}件作成")
# === STEP 5: メンバー移行 ===
print("\\n=== STEP 5: メンバー移行 ===")
total_migrated_members = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
event_members = [data for data in all_member_data if data[5] == event_id]
if not event_members:
continue
print(f"\\n--- Event {event_id}: {event_name} ---")
event_migrated_members = 0
for team_id, user_id, email, first_name, last_name, _ in event_members:
try:
# チームとユーザーを取得
team = Team.objects.get(id=team_id)
user = CustomUser.objects.get(id=user_id)
# メンバーを作成
member, created = Member.objects.get_or_create(
team=team,
user=user
)
if created:
event_migrated_members += 1
total_migrated_members += 1
if event_migrated_members <= 3: # イベントごとに最初の3件のみ表示
print(f" メンバー追加: {email} → {team.team_name}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません")
except CustomUser.DoesNotExist:
print(f" ⚠️ ユーザー{user_id}が見つかりません")
except Exception as e:
print(f" ❌ メンバー追加エラー: {e}")
print(f" ✅ {event_name}: {event_migrated_members}件のメンバーを移行")
print(f"\\n✅ 全メンバー移行完了: {total_migrated_members}件作成")
# === STEP 6: エントリー移行 ===
print("\\n=== STEP 6: エントリー移行 ===")
# データベースのis_trialフィールドにデフォルト値を設定
print("データベーステーブルのis_trialフィールドを修正中...")
from django.db import connection as django_conn
with django_conn.cursor() as django_cursor:
try:
django_cursor.execute("""
ALTER TABLE rog_entry
ALTER COLUMN is_trial SET DEFAULT FALSE;
""")
print(" ✅ is_trialフィールドにデフォルト値を設定")
except Exception as e:
print(f" ⚠️ is_trial修正エラー: {e}")
total_migrated_entries = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\\n--- Event {event_id}: {event_name} ---")
# イベント別エントリーデータを取得
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = %s
ORDER BY re.zekken_number;
""", [event_id])
event_entry_data = old_cursor.fetchall()
event_migrated_entries = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in event_entry_data:
try:
# チームとカテゴリを取得
team = Team.objects.get(id=team_id)
category = NewCategory.objects.get(id=cat_id) if cat_id else None
event_obj = NewEvent2.objects.get(id=event_id)
# 既存のエントリーをチェック
existing_entry = Entry.objects.filter(team=team, event=event_obj).first()
if existing_entry:
continue
# SQLで直接エントリーを挿入
with django_conn.cursor() as django_cursor:
django_cursor.execute("""
INSERT INTO rog_entry
(date, category_id, event_id, owner_id, team_id, is_active,
zekken_number, "hasGoaled", "hasParticipated", zekken_label,
is_trial, staff_privileges, can_access_private_events, team_validation_status)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);
""", [
event_obj.start_datetime, # date
cat_id, # category_id
event_id, # event_id
owner_id or 1, # owner_id
team_id, # team_id
True, # is_active
int(zekken) if zekken else 0, # zekken_number
False, # hasGoaled
False, # hasParticipated
label or f"{event_name}-{zekken}", # zekken_label
False, # is_trial
False, # staff_privileges
False, # can_access_private_events
'approved' # team_validation_status
])
event_migrated_entries += 1
total_migrated_entries += 1
if event_migrated_entries <= 3: # イベントごとに最初の3件のみ表示
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except NewEvent2.DoesNotExist:
print(f" ❌ イベント{event_id}が見つかりません")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_entries}件のエントリーを移行")
print(f"\\n✅ 全エントリー移行完了: {total_migrated_entries}件作成")
old_conn.close()
# === 最終確認 ===
print("\\n=== 移行結果確認 ===")
total_teams = Team.objects.count()
total_members = Member.objects.count()
total_entries = Entry.objects.count()
print(f"総チーム数: {total_teams}件")
print(f"総メンバー数: {total_members}件")
print(f"総エントリー数: {total_entries}件")
# イベント別エントリー統計
print("\\n=== イベント別エントリー統計 ===")
for event_id, event_name in existing_events[:10]: # 最初の10件を表示
entry_count = Entry.objects.filter(event_id=event_id).count()
if entry_count > 0:
print(f" {event_name}: {entry_count}件")
print("\\n🎉 全イベントデータ移行が完了しました！")
print("🎯 通過審査管理画面で全てのイベントのゼッケン番号が表示されるようになります。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

828
migrate_all_events_complete_with_gps.py Normal file
View File

@ -0,0 +1,828 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト（GPS情報移行機能付き）
FC岐阜の成功事例をベースに全てのイベントのteam/member/entryを移行
さらに、gifurogeのgps_informationをrogdbのrog_checkinsに移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser, Member
import psycopg2
from collections import defaultdict
from datetime import datetime, timedelta
import pytz
print("=== old_rogdb から 全イベントデータ移行（GPS情報付き） ===")
# GPS情報移行用のヘルパー関数
def load_event_dates_from_db():
"""gifurogeのevent_tableからイベントコードと日付のマッピングを取得"""
event_dates = {}
try:
# gifuroge データベースに接続
conn = psycopg2.connect(
host='postgres-db',
database='gifuroge',
user='admin',
password='admin123456'
)
cursor = conn.cursor()
# event_tableからイベントコードと開始日・終了日を取得
cursor.execute("""
SELECT event_code, event_day, end_day
FROM event_table
WHERE event_code IS NOT NULL AND event_day IS NOT NULL
ORDER BY event_day
""")
events = cursor.fetchall()
for event_code, event_day, end_day in events:
# デバッグ用：読み込まれた生データを表示
print(f"🔍 生データ: {event_code} | event_day={event_day}({type(event_day)}) | end_day={end_day}({type(end_day)})")
# event_dayの日付フォーマットを統一（yyyy-mm-dd形式に変換）
start_date = None
end_date = None
# event_day（開始日）の処理
if isinstance(event_day, str):
if '/' in event_day:
start_date = normalize_date_format(event_day.replace('/', '-'))
elif '-' in event_day:
start_date = normalize_date_format(event_day)
else:
date_part = event_day.split(' ')[0] if ' ' in event_day else event_day
start_date = normalize_date_format(date_part.replace('/', '-'))
else:
start_date = normalize_date_format(event_day.strftime('%Y-%m-%d'))
# end_day（終了日）の処理
if end_day:
if isinstance(end_day, str):
if '/' in end_day:
end_date = normalize_date_format(end_day.replace('/', '-'))
elif '-' in end_day:
end_date = normalize_date_format(end_day)
else:
date_part = end_day.split(' ')[0] if ' ' in end_day else end_day
end_date = normalize_date_format(date_part.replace('/', '-'))
else:
end_date = normalize_date_format(end_day.strftime('%Y-%m-%d'))
else:
# end_dayが設定されていない場合は、event_dayと同じ日とする
end_date = start_date
# イベント期間情報を保存
event_dates[event_code] = {
'start_date': start_date,
'end_date': end_date,
'display_date': start_date # 主要な表示用日付
}
conn.close()
print(f"📅 event_tableから{len(event_dates)}件のイベント情報を読み込みました:")
for code, date_info in event_dates.items():
if date_info['start_date'] == date_info['end_date']:
print(f" {code}: {date_info['start_date']}")
else:
print(f" {code}: {date_info['start_date']} - {date_info['end_date']}")
except Exception as e:
print(f"⚠️ event_table読み込みエラー: {e}")
# フォールバック用のデフォルト値
event_dates = {
'gifu2024': {'start_date': '2024-10-27', 'end_date': '2024-10-27', 'display_date': '2024-10-27'},
'gifu2023': {'start_date': '2023-11-12', 'end_date': '2023-11-12', 'display_date': '2023-11-12'},
'gifu2022': {'start_date': '2022-11-13', 'end_date': '2022-11-13', 'display_date': '2022-11-13'},
'test2024': {'start_date': '2024-12-15', 'end_date': '2024-12-15', 'display_date': '2024-12-15'},
'test2025': {'start_date': '2025-01-25', 'end_date': '2025-01-25', 'display_date': '2025-01-25'},
'郡上': {'start_date': '2024-06-15', 'end_date': '2024-06-15', 'display_date': '2024-06-15'}
}
print(f"デフォルトのイベント日付を使用します: {len(event_dates)}件")
return event_dates
def get_event_date(event_code, event_dates_cache):
"""イベントコードから日付を取得（キャッシュ使用）"""
if event_code in event_dates_cache:
return event_dates_cache[event_code]['display_date']
# 未知のイベントコードの場合、警告を出してデフォルト日付を返す
print(f"⚠️ 未知のイベントコード '{event_code}' - デフォルト日付2024-01-01を使用")
return '2024-01-01' # デフォルト日付
def normalize_date_format(date_str):
"""日付文字列をyyyy-mm-dd形式に正規化"""
try:
# datetimeオブジェクトの場合
if hasattr(date_str, 'strftime'):
return date_str.strftime('%Y-%m-%d')
# 文字列の場合
if isinstance(date_str, str):
# スラッシュ区切りをハイフン区切りに変換
if '/' in date_str:
date_str = date_str.replace('/', '-')
# yyyy-m-d や yyyy-mm-d などを yyyy-mm-dd に正規化
parts = date_str.split('-')
if len(parts) == 3:
year, month, day = parts
return f"{year}-{month.zfill(2)}-{day.zfill(2)}"
return date_str
except:
return date_str
def is_within_event_period(gps_datetime, event_code, event_dates_cache):
"""GPS記録の日時がイベント期間内かチェック"""
if event_code not in event_dates_cache:
return True # 未知のイベントの場合は通す
event_info = event_dates_cache[event_code]
start_date = normalize_date_format(event_info['start_date'])
end_date = normalize_date_format(event_info['end_date'])
try:
# GPS記録の日付部分を取得して正規化
gps_date = normalize_date_format(gps_datetime.strftime('%Y-%m-%d'))
# イベント期間内かチェック
return start_date <= gps_date <= end_date
except Exception as e:
print(f"日付比較エラー: GPS={gps_datetime}, イベント={event_code}, エラー={e}")
return True # エラーの場合は通す
def parse_goal_time(goal_time_str, event_date):
"""ゴール時刻をパース"""
if not goal_time_str or not event_date:
return None
try:
# HH:MM形式からdatetimeに変換
time_parts = goal_time_str.split(':')
if len(time_parts) == 2:
hour, minute = int(time_parts[0]), int(time_parts[1])
event_datetime = datetime.strptime(event_date, '%Y-%m-%d')
goal_datetime = event_datetime.replace(hour=hour, minute=minute, second=0, microsecond=0)
# JST timezone設定
jst = pytz.timezone('Asia/Tokyo')
return jst.localize(goal_datetime)
except Exception as e:
print(f"ゴール時刻パースエラー: {goal_time_str} - {e}")
return None
def convert_utc_to_jst(utc_datetime):
"""UTC時刻をJSTに変換"""
if not utc_datetime:
return None
try:
if isinstance(utc_datetime, str):
utc_datetime = datetime.fromisoformat(utc_datetime.replace('Z', '+00:00'))
# UTCとして扱い、JSTに変換
if utc_datetime.tzinfo is None:
utc = pytz.UTC
utc_datetime = utc.localize(utc_datetime)
jst = pytz.timezone('Asia/Tokyo')
return utc_datetime.astimezone(jst)
except Exception as e:
print(f"時刻変換エラー: {utc_datetime} - {e}")
return None
def migrate_gps_data():
"""GPS情報をgifurogeからrogdbに移行"""
print("\n=== GPS情報移行開始 ===")
# まず、イベント日付情報を読み込み
event_dates_cache = load_event_dates_from_db()
try:
# gifuroge データベースに接続
gifuroge_conn = psycopg2.connect(
host='postgres-db',
database='gifuroge',
user='admin',
password='admin123456'
)
# rogdb データベースに接続
rogdb_conn = psycopg2.connect(
host='postgres-db',
database='rogdb',
user='admin',
password='admin123456'
)
print("✅ GPS移行用データベース接続成功")
with gifuroge_conn.cursor() as source_cursor, rogdb_conn.cursor() as target_cursor:
# 既存のGPSチェックイン記録をクリア
target_cursor.execute("DELETE FROM rog_gpscheckin;")
print("既存のGPSチェックイン記録をクリアしました")
# GPS記録を取得（serial_number < 20000のみ、実際のGPS記録）
source_cursor.execute("""
SELECT serial_number, zekken_number, event_code, cp_number, create_at, goal_time
FROM gps_information
WHERE serial_number < 20000
ORDER BY serial_number
""")
gps_records = source_cursor.fetchall()
print(f"移行対象GPS記録数: {len(gps_records)}件")
success_count = 0
skip_count = 0
error_count = 0
event_stats = defaultdict(set)
skip_stats = defaultdict(int) # スキップ統計
skip_reasons = defaultdict(int) # スキップ理由別統計
large_skip_events = set() # 大量スキップイベントの詳細分析用
skip_date_ranges = defaultdict(list) # スキップされたGPS日付の範囲集計用
for record in gps_records:
serial_number, zekken, event_code, cp_number, create_at, goal_time = record
try:
# イベント日付取得（キャッシュから）
event_date = get_event_date(event_code, event_dates_cache)
# event_dateはNoneを返さなくなったので、この条件は不要だが安全のため残す
if not event_date:
# 時刻変換してGPS日付を取得
jst_create_at = convert_utc_to_jst(create_at)
gps_date = jst_create_at.strftime('%Y-%m-%d') if jst_create_at else 'N/A'
print(f"⚠️ イベント日付取得失敗: {event_code} GPS日付:{gps_date}")
skip_count += 1
skip_stats[event_code] += 1
skip_reasons["イベント日付取得失敗"] += 1
continue
# 時刻変換
jst_create_at = convert_utc_to_jst(create_at)
jst_goal_time = parse_goal_time(goal_time, event_date) if goal_time else None
if not jst_create_at:
print(f"時刻変換失敗: {serial_number}")
error_count += 1
skip_stats[event_code] += 1
skip_reasons["時刻変換失敗"] += 1
continue
# 未知のイベントコードの場合はGPS日付も表示
if event_code not in event_dates_cache:
gps_date = jst_create_at.strftime('%Y-%m-%d')
print(f"⚠️ 未知のイベントコード '{event_code}' GPS日付:{gps_date} - デフォルト日付2024-01-01を使用")
# GPS記録がイベント期間内かチェック
if not is_within_event_period(jst_create_at, event_code, event_dates_cache):
# GPS日付を正規化（期間外スキップ用）
gps_date = normalize_date_format(jst_create_at.strftime('%Y-%m-%d'))
# 大量スキップイベントの詳細分析
should_show_detail = (skip_count < 10 or
(event_code in ['各務原', '岐阜市', '養老ロゲ', '郡上', '大垣２', 'test下呂'] and
skip_stats[event_code] < 5))
if should_show_detail:
event_info = event_dates_cache.get(event_code, {})
start_date = normalize_date_format(event_info.get('start_date', 'N/A'))
end_date = normalize_date_format(event_info.get('end_date', 'N/A'))
# 600件超のイベントは特別扱い
if event_code in ['各務原', '岐阜市', '養老ロゲ', '郡上', '大垣２', 'test下呂']:
large_skip_events.add(event_code)
print(f"🔍 大量スキップイベント詳細分析 - {event_code}:")
print(f" イベントコード: {event_code}")
print(f" GPS元時刻: {create_at}")
print(f" GPS JST時刻: {jst_create_at}")
print(f" GPS日付(正規化前): {jst_create_at.strftime('%Y-%m-%d')}")
print(f" GPS日付(正規化後): {gps_date}")
print(f" イベント開始日(正規化前): {event_info.get('start_date', 'N/A')}")
print(f" イベント開始日(正規化後): {start_date}")
print(f" イベント終了日(正規化前): {event_info.get('end_date', 'N/A')}")
print(f" イベント終了日(正規化後): {end_date}")
print(f" 比較結果: {start_date} <= {gps_date} <= {end_date}")
print(f" 文字列比較1: '{start_date}' <= '{gps_date}' = {start_date <= gps_date}")
print(f" 文字列比較2: '{gps_date}' <= '{end_date}' = {gps_date <= end_date}")
print(f" 年差: GPS年={gps_date[:4]}, イベント年={start_date[:4]}")
else:
# デバッグ情報を追加
print(f"🔍 デバッグ情報:")
print(f" イベントコード: {event_code}")
print(f" GPS元時刻: {create_at}")
print(f" GPS JST時刻: {jst_create_at}")
print(f" GPS日付(正規化前): {jst_create_at.strftime('%Y-%m-%d')}")
print(f" GPS日付(正規化後): {gps_date}")
print(f" イベント開始日(正規化前): {event_info.get('start_date', 'N/A')}")
print(f" イベント開始日(正規化後): {start_date}")
print(f" イベント終了日(正規化前): {event_info.get('end_date', 'N/A')}")
print(f" イベント終了日(正規化後): {end_date}")
print(f" 比較結果: {start_date} <= {gps_date} <= {end_date}")
print(f" 文字列比較1: '{start_date}' <= '{gps_date}' = {start_date <= gps_date}")
print(f" 文字列比較2: '{gps_date}' <= '{end_date}' = {gps_date <= end_date}")
print(f"期間外GPS記録スキップ: {event_code} GPS日付:{gps_date} イベント期間:{start_date}-{end_date}")
# 大量スキップイベントのGPS日付を記録
if event_code in ['各務原', '岐阜市', '養老ロゲ', '郡上', '大垣２', 'test下呂']:
skip_date_ranges[event_code].append(gps_date)
skip_count += 1
skip_stats[event_code] += 1
skip_reasons["期間外"] += 1
continue
# チェックイン記録挿入
target_cursor.execute("""
INSERT INTO rog_gpscheckin (
zekken, event_code, cp_number, checkin_time, record_time, serial_number
) VALUES (%s, %s, %s, %s, %s, %s)
""", (zekken, event_code, cp_number, jst_create_at, jst_create_at, str(serial_number)))
event_stats[event_code].add(zekken)
success_count += 1
if success_count % 100 == 0:
print(f"GPS移行進捗: {success_count}件完了")
except Exception as e:
print(f"GPS移行エラー (Serial: {serial_number}): {e}")
error_count += 1
skip_stats[event_code] += 1
skip_reasons["その他エラー"] += 1
# コミット
rogdb_conn.commit()
print(f"\n✅ GPS移行完了:")
print(f" 成功: {success_count}件")
print(f" スキップ: {skip_count}件")
print(f" エラー: {error_count}件")
# イベント別統計を表示
print("\n=== イベント別GPS統計 ===")
for event_code, zekken_set in event_stats.items():
print(f" {event_code}: {len(zekken_set)}チーム")
# スキップ統計を表示
print("\n=== スキップ統計（イベント別） ===")
for event_code, skip_count_by_event in skip_stats.items():
print(f" {event_code}: {skip_count_by_event}件スキップ")
# スキップ理由別統計を表示
print("\n=== スキップ理由別統計 ===")
for reason, count in skip_reasons.items():
print(f" {reason}: {count}件")
# 大量スキップイベントの詳細分析結果
if large_skip_events:
print("\n=== 600件超大量スキップイベント分析結果 ===")
for event_code in large_skip_events:
total_skipped = skip_stats[event_code]
event_info = event_dates_cache.get(event_code, {})
# スキップされたGPS日付の範囲を分析
skipped_dates = skip_date_ranges.get(event_code, [])
if skipped_dates:
# 日付を昇順にソートしてユニーク化
unique_dates = sorted(set(skipped_dates))
date_range_start = unique_dates[0] if unique_dates else 'N/A'
date_range_end = unique_dates[-1] if unique_dates else 'N/A'
# 年月日の分析
year_counts = defaultdict(int)
month_counts = defaultdict(int)
for date_str in unique_dates:
try:
year = date_str[:4]
month = date_str[:7] # YYYY-MM
year_counts[year] += 1
month_counts[month] += 1
except:
pass
print(f"📊 {event_code}:")
print(f" 総スキップ数: {total_skipped}件")
print(f" 設定イベント期間: {event_info.get('start_date', 'N/A')} - {event_info.get('end_date', 'N/A')}")
if skipped_dates:
print(f" スキップされたGPS記録の期間: {date_range_start} ~ {date_range_end}")
print(f" ユニークな日付数: {len(unique_dates)}日")
# 年別集計
if year_counts:
print(f" 年別GPS記録数:")
for year in sorted(year_counts.keys()):
print(f" {year}年: {year_counts[year]}日分の記録")
# 月別集計（上位5件）
if month_counts:
top_months = sorted(month_counts.items(), key=lambda x: x[1], reverse=True)[:5]
print(f" 月別GPS記録数（上位5件）:")
for month, count in top_months:
print(f" {month}: {count}日分の記録")
print(f" 推測される問題: イベント期間設定が実際のGPS記録日付と大幅にずれている")
print(f" 解決策: event_tableのevent_day/end_dayを実際のイベント開催日に修正する必要があります")
print()
# 最終統計
target_cursor.execute("SELECT COUNT(*) FROM rog_gpscheckin")
total_gps_records = target_cursor.fetchone()[0]
print(f"\n最終GPS記録数: {total_gps_records}件")
gifuroge_conn.close()
rogdb_conn.close()
return success_count > 0
except Exception as e:
print(f"❌ GPS移行エラー: {e}")
import traceback
traceback.print_exc()
return False
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
with old_conn.cursor() as old_cursor:
# === STEP 0: 移行対象イベントの確認 ===
print("\n=== STEP 0: 移行対象イベントの確認 ===")
# 新DBのイベント一覧を取得
existing_events = list(NewEvent2.objects.values_list('id', 'event_name'))
existing_event_ids = [event_id for event_id, _ in existing_events]
print(f"新DB既存イベント: {len(existing_events)}件")
for event_id, event_name in existing_events[:10]:
print(f" Event {event_id}: {event_name}")
# old_rogdbでエントリーがあるイベントを確認
old_cursor.execute("""
SELECT e.id, e.event_name, COUNT(re.id) as entry_count
FROM rog_newevent2 e
LEFT JOIN rog_entry re ON e.id = re.event_id
WHERE e.id IN ({})
GROUP BY e.id, e.event_name
HAVING COUNT(re.id) > 0
ORDER BY COUNT(re.id) DESC;
""".format(','.join(map(str, existing_event_ids))))
events_with_entries = old_cursor.fetchall()
print(f"\n移行対象イベント（エントリーあり）: {len(events_with_entries)}件")
for event_id, event_name, entry_count in events_with_entries:
print(f" Event {event_id}: '{event_name}' - {entry_count}件のエントリー")
# === STEP 1: 全イベントのTeam & Member データ取得 ===
print("\n=== STEP 1: 全イベントの Team & Member データ取得 ===")
# 全イベントのチーム情報を取得
old_cursor.execute("""
SELECT DISTINCT rt.id, rt.team_name, rt.owner_id, rt.category_id,
rc.category_name, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON rt.category_id = rc.id
LEFT JOIN rog_customuser cu ON rt.owner_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rt.id;
""".format(','.join(map(str, existing_event_ids))))
all_team_data = old_cursor.fetchall()
print(f"全イベント関連チーム: {len(all_team_data)}件")
# イベント別チーム数統計
teams_by_event = defaultdict(int)
for _, _, _, _, _, _, _, _, event_id in all_team_data:
teams_by_event[event_id] += 1
print("\nイベント別チーム数:")
for event_id, count in sorted(teams_by_event.items()):
event_name = next((name for eid, name in existing_events if eid == event_id), "不明")
print(f" Event {event_id} ({event_name}): {count}チーム")
# 全イベントのメンバー情報を取得
old_cursor.execute("""
SELECT rm.team_id, rm.user_id, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_member rm ON re.team_id = rm.team_id
JOIN rog_customuser cu ON rm.user_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rm.team_id, rm.user_id;
""".format(','.join(map(str, existing_event_ids))))
all_member_data = old_cursor.fetchall()
print(f"全イベント関連メンバー: {len(all_member_data)}件")
# === STEP 2: ユーザー移行 ===
print("\n=== STEP 2: ユーザー移行 ===")
# 関連するすべてのユーザーを取得
all_user_ids = set()
for _, _, owner_id, _, _, _, _, _, _ in all_team_data:
if owner_id:
all_user_ids.add(owner_id)
for _, user_id, _, _, _, _ in all_member_data:
all_user_ids.add(user_id)
if all_user_ids:
# 大量のユーザーIDに対応するため、バッチで処理
user_batches = [list(all_user_ids)[i:i+100] for i in range(0, len(all_user_ids), 100)]
all_user_data = []
for batch in user_batches:
old_cursor.execute(f"""
SELECT id, email, firstname, lastname, date_joined
FROM rog_customuser
WHERE id IN ({','.join(map(str, batch))})
""")
all_user_data.extend(old_cursor.fetchall())
print(f"移行対象ユーザー: {len(all_user_data)}件")
migrated_users = 0
for user_id, email, first_name, last_name, date_joined in all_user_data:
user, created = CustomUser.objects.get_or_create(
id=user_id,
defaults={
'email': email or f'user{user_id}@example.com',
'first_name': first_name or '',
'last_name': last_name or '',
'username': email or f'user{user_id}',
'date_joined': date_joined,
'is_active': True
}
)
if created:
migrated_users += 1
if migrated_users <= 10: # 最初の10件のみ表示
print(f" ユーザー作成: {email} ({first_name} {last_name})")
print(f"✅ ユーザー移行完了: {migrated_users}件作成")
# === STEP 3: カテゴリ移行 ===
print("\n=== STEP 3: カテゴリ移行 ===")
migrated_categories = 0
unique_categories = set()
for _, _, _, cat_id, cat_name, _, _, _, _ in all_team_data:
if cat_id and cat_name:
unique_categories.add((cat_id, cat_name))
for cat_id, cat_name in unique_categories:
category, created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if created:
migrated_categories += 1
print(f" カテゴリ作成: {cat_name}")
print(f"✅ カテゴリ移行完了: {migrated_categories}件作成")
# === STEP 4: イベント別チーム移行 ===
print("\n=== STEP 4: イベント別チーム移行 ===")
total_migrated_teams = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
event_teams = [data for data in all_team_data if data[8] == event_id]
event_migrated_teams = 0
for team_id, team_name, owner_id, cat_id, cat_name, email, first_name, last_name, _ in event_teams:
try:
# カテゴリを取得
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# チームを作成
team, created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': event_id
}
)
if created:
event_migrated_teams += 1
total_migrated_teams += 1
if event_migrated_teams <= 3: # イベントごとに最初の3件のみ表示
print(f" チーム作成: {team_name} (ID: {team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_teams}件のチームを移行")
print(f"\n✅ 全チーム移行完了: {total_migrated_teams}件作成")
# === STEP 5: メンバー移行 ===
print("\n=== STEP 5: メンバー移行 ===")
total_migrated_members = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
event_members = [data for data in all_member_data if data[5] == event_id]
if not event_members:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
event_migrated_members = 0
for team_id, user_id, email, first_name, last_name, _ in event_members:
try:
# チームとユーザーを取得
team = Team.objects.get(id=team_id)
user = CustomUser.objects.get(id=user_id)
# メンバーを作成
member, created = Member.objects.get_or_create(
team=team,
user=user
)
if created:
event_migrated_members += 1
total_migrated_members += 1
if event_migrated_members <= 3: # イベントごとに最初の3件のみ表示
print(f" メンバー追加: {email} → {team.team_name}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません")
except CustomUser.DoesNotExist:
print(f" ⚠️ ユーザー{user_id}が見つかりません")
except Exception as e:
print(f" ❌ メンバー追加エラー: {e}")
print(f" ✅ {event_name}: {event_migrated_members}件のメンバーを移行")
print(f"\n✅ 全メンバー移行完了: {total_migrated_members}件作成")
# === STEP 6: エントリー移行 ===
print("\n=== STEP 6: エントリー移行 ===")
# データベースのis_trialフィールドにデフォルト値を設定
print("データベーステーブルのis_trialフィールドを修正中...")
from django.db import connection as django_conn
with django_conn.cursor() as django_cursor:
try:
django_cursor.execute("""
ALTER TABLE rog_entry
ALTER COLUMN is_trial SET DEFAULT FALSE;
""")
print(" ✅ is_trialフィールドにデフォルト値を設定")
except Exception as e:
print(f" ⚠️ is_trial修正エラー: {e}")
total_migrated_entries = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
# イベント別エントリーデータを取得
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = %s
ORDER BY re.zekken_number;
""", [event_id])
event_entry_data = old_cursor.fetchall()
event_migrated_entries = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in event_entry_data:
try:
# チームとカテゴリを取得
team = Team.objects.get(id=team_id)
category = NewCategory.objects.get(id=cat_id) if cat_id else None
event_obj = NewEvent2.objects.get(id=event_id)
# 既存のエントリーをチェック
existing_entry = Entry.objects.filter(team=team, event=event_obj).first()
if existing_entry:
continue
# SQLで直接エントリーを挿入
with django_conn.cursor() as django_cursor:
django_cursor.execute("""
INSERT INTO rog_entry
(date, category_id, event_id, owner_id, team_id, is_active,
zekken_number, "hasGoaled", "hasParticipated", zekken_label,
is_trial, staff_privileges, can_access_private_events, team_validation_status)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);
""", [
event_obj.start_datetime, # date
cat_id, # category_id
event_id, # event_id
owner_id or 1, # owner_id
team_id, # team_id
True, # is_active
int(zekken) if zekken else 0, # zekken_number
False, # hasGoaled
False, # hasParticipated
label or f"{event_name}-{zekken}", # zekken_label
False, # is_trial
False, # staff_privileges
False, # can_access_private_events
'approved' # team_validation_status
])
event_migrated_entries += 1
total_migrated_entries += 1
if event_migrated_entries <= 3: # イベントごとに最初の3件のみ表示
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except NewEvent2.DoesNotExist:
print(f" ❌ イベント{event_id}が見つかりません")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_entries}件のエントリーを移行")
print(f"\n✅ 全エントリー移行完了: {total_migrated_entries}件作成")
old_conn.close()
# === STEP 7: GPS情報移行 ===
print("\n=== STEP 7: GPS情報移行 ===")
gps_migration_success = migrate_gps_data()
if gps_migration_success:
print("✅ GPS情報移行が正常に完了しました")
else:
print("⚠️ GPS情報移行中にエラーが発生しました")
# === 最終確認 ===
print("\n=== 移行結果確認 ===")
total_teams = Team.objects.count()
total_members = Member.objects.count()
total_entries = Entry.objects.count()
print(f"総チーム数: {total_teams}件")
print(f"総メンバー数: {total_members}件")
print(f"総エントリー数: {total_entries}件")
# GPS記録数も追加で確認
from django.db import connection as django_conn
with django_conn.cursor() as cursor:
cursor.execute("SELECT COUNT(*) FROM rog_gpscheckin")
gps_count = cursor.fetchone()[0]
print(f"総GPS記録数: {gps_count}件")
# イベント別エントリー統計
print("\n=== イベント別エントリー統計 ===")
for event_id, event_name in existing_events[:10]: # 最初の10件を表示
entry_count = Entry.objects.filter(event_id=event_id).count()
if entry_count > 0:
print(f" {event_name}: {entry_count}件")
print("\n🎉 全イベントデータ移行（GPS情報付き）が完了しました！")
print("🎯 通過審査管理画面で全てのイベントのゼッケン番号が表示されるようになります。")
print("📍 GPS情報も移行され、チェックイン記録が利用可能になります。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

332
migrate_all_events_sql.py Normal file
View File

@ -0,0 +1,332 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト（SQL生成方式）
FC岐阜の成功事例をベースに全てのイベントのteam/member/entry + GPS情報を移行
"""
import os
import sys
import django
from datetime import datetime
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction, connection
from rog.models import NewEvent2, Team, Entry, Member, NewCategory, CustomUser
print("📋 全イベントデータ移行スクリプト（SQL生成方式）を開始します")
# SQLファイル名
sql_file = "migrate_all_events_with_gps.sql"
try:
with transaction.atomic():
# === STEP 1: ユーザー確認 ===
print("\n=== STEP 1: ユーザー確認 ===")
admin_user, created = CustomUser.objects.get_or_create(
username='admin',
defaults={
'email': 'admin@example.com',
'is_staff': True,
'is_superuser': True
}
)
print(f"管理ユーザー: {'作成' if created else '既存'}")
# === STEP 2: イベントとカテゴリー情報取得 ===
print("\n=== STEP 2: 既存イベント・カテゴリー確認 ===")
existing_events = list(NewEvent2.objects.values_list('id', 'name'))
print(f"既存イベント数: {len(existing_events)}件")
if not existing_events:
print("❌ イベントが存在しません。先にイベントを作成してください。")
sys.exit(1)
existing_categories = list(NewCategory.objects.values_list('id', 'name'))
print(f"既存カテゴリー数: {len(existing_categories)}件")
if not existing_categories:
print("❌ カテゴリーが存在しません。先にカテゴリーを作成してください。")
sys.exit(1)
# === STEP 3: SQLファイル生成 ===
print(f"\n=== STEP 3: SQLファイル生成 ({sql_file}) ===")
with open(sql_file, 'w', encoding='utf-8') as f:
f.write("-- 全イベントデータ移行SQL（GPS情報含む）\n")
f.write(f"-- 生成日時: {datetime.now()}\n\n")
# 1. チーム移行SQL
f.write("-- ========================================\n")
f.write("-- 1. チーム移行（old_rogdb → rogdb）\n")
f.write("-- ========================================\n\n")
f.write("""
-- old_rogdbからチーム情報を移行
INSERT INTO rog_team (
id, name, owner_id, event_id, reg_date,
representative_name, representative_phone,
representative_email, is_deleted
)
SELECT DISTINCT
t.id,
t.name,
COALESCE(t.owner_id, {admin_user_id}) as owner_id,
t.event_id,
t.reg_date,
COALESCE(t.representative_name, t.name) as representative_name,
COALESCE(t.representative_phone, '') as representative_phone,
COALESCE(t.representative_email, '') as representative_email,
false as is_deleted
FROM dblink('host=postgres-db port=5432 dbname=old_rogdb user=user password=password',
'SELECT id, name, owner_id, event_id, reg_date, representative_name, representative_phone, representative_email FROM team WHERE is_deleted = false'
) AS t(
id INTEGER,
name TEXT,
owner_id INTEGER,
event_id INTEGER,
reg_date TIMESTAMP,
representative_name TEXT,
representative_phone TEXT,
representative_email TEXT
)
WHERE EXISTS (
SELECT 1 FROM rog_newevent2 ne WHERE ne.id = t.event_id
)
AND NOT EXISTS (
SELECT 1 FROM rog_team rt WHERE rt.id = t.id
)
ORDER BY t.id;
""".format(admin_user_id=admin_user.id))
# 2. メンバー移行SQL
f.write("-- ========================================\n")
f.write("-- 2. メンバー移行（old_rogdb → rogdb）\n")
f.write("-- ========================================\n\n")
f.write("""
-- old_rogdbからメンバー情報を移行
INSERT INTO rog_member (
id, team_id, name, kana, is_leader,
phone, email, birthday, gender, si_number, is_deleted
)
SELECT DISTINCT
m.id,
m.team_id,
m.name,
COALESCE(m.kana, '') as kana,
COALESCE(m.is_leader, false) as is_leader,
COALESCE(m.phone, '') as phone,
COALESCE(m.email, '') as email,
m.birthday,
COALESCE(m.gender, '') as gender,
m.si_number,
false as is_deleted
FROM dblink('host=postgres-db port=5432 dbname=old_rogdb user=user password=password',
'SELECT id, team_id, name, kana, is_leader, phone, email, birthday, gender, si_number FROM member WHERE is_deleted = false'
) AS m(
id INTEGER,
team_id INTEGER,
name TEXT,
kana TEXT,
is_leader BOOLEAN,
phone TEXT,
email TEXT,
birthday DATE,
gender TEXT,
si_number TEXT
)
WHERE EXISTS (
SELECT 1 FROM rog_team rt WHERE rt.id = m.team_id
)
AND NOT EXISTS (
SELECT 1 FROM rog_member rm WHERE rm.id = m.id
)
ORDER BY m.id;
""")
# 3. エントリー移行SQL
f.write("-- ========================================\n")
f.write("-- 3. エントリー移行（old_rogdb → rogdb）\n")
f.write("-- ========================================\n\n")
default_cat_id = existing_categories[0][0] if existing_categories else 1
f.write(f"""
-- old_rogdbからエントリー情報を移行（startテーブルと結合）
INSERT INTO rog_entry (
date, category_id, event_id, owner_id, team_id,
is_active, zekken_number, zekken_label, has_goaled,
has_participated, is_trial, staff_privileges,
can_access_private_events, team_validation_status
)
SELECT DISTINCT
ne.start_datetime as date,
{default_cat_id} as category_id,
t.event_id,
COALESCE(t.owner_id, {admin_user.id}) as owner_id,
t.team_id,
true as is_active,
COALESCE(s.zekken_number, 0) as zekken_number,
COALESCE(s.label, CONCAT(ne.name, '-', COALESCE(s.zekken_number, 0))) as zekken_label,
false as has_goaled,
false as has_participated,
false as is_trial,
false as staff_privileges,
false as can_access_private_events,
'approved' as team_validation_status
FROM dblink('host=postgres-db port=5432 dbname=old_rogdb user=user password=password',
'SELECT t.id as team_id, t.event_id, t.owner_id, s.zekken_number, s.label
FROM team t
LEFT JOIN start s ON t.id = s.team_id
WHERE t.is_deleted = false'
) AS t(
team_id INTEGER,
event_id INTEGER,
owner_id INTEGER,
zekken_number INTEGER,
label TEXT
)
JOIN rog_newevent2 ne ON ne.id = t.event_id
WHERE EXISTS (
SELECT 1 FROM rog_team rt WHERE rt.id = t.team_id
)
AND NOT EXISTS (
SELECT 1 FROM rog_entry re WHERE re.team_id = t.team_id AND re.event_id = t.event_id
)
ORDER BY t.team_id;
""")
# 4. GPS情報移行SQL
f.write("-- ========================================\n")
f.write("-- 4. GPS情報移行（gifuroge → rogdb）\n")
f.write("-- ========================================\n\n")
f.write("""
-- gifurogeからGPS情報を移行（gps_information → gps_checkins）
INSERT INTO gps_checkins (
path_order, zekken_number, event_code, cp_number,
lattitude, longitude, image_address, image_receipt,
image_qr, validate_location, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, colabo_company_memo, points, event_id,
team_id, validation_status
)
SELECT DISTINCT
0 as path_order,
gps.zekken_number,
gps.event_code,
gps.cp_number,
gps.lattitude,
gps.longitude,
COALESCE(gps.image_address, '') as image_address,
COALESCE(gps.image_receipt, '') as image_receipt,
COALESCE(gps.image_qr, false) as image_qr,
COALESCE(gps.validate_location, false) as validate_location,
COALESCE(gps.goal_time, '') as goal_time,
COALESCE(gps.late_point, 0) as late_point,
COALESCE(gps.create_at, NOW()) as create_at,
COALESCE(gps.create_user, '') as create_user,
COALESCE(gps.update_at, NOW()) as update_at,
COALESCE(gps.update_user, '') as update_user,
COALESCE(gps.buy_flag, false) as buy_flag,
COALESCE(gps.colabo_company_memo, '') as colabo_company_memo,
COALESCE(gps.points, 0) as points,
ent.event_id,
ent.team_id,
'pending' as validation_status
FROM dblink('host=postgres-db port=5432 dbname=gifuroge user=user password=password',
'SELECT zekken_number, event_code, cp_number, lattitude, longitude,
image_address, image_receipt, image_qr, validate_location,
goal_time, late_point, create_at, create_user, update_at,
update_user, buy_flag, colabo_company_memo, points
FROM gps_information
ORDER BY create_at'
) AS gps(
zekken_number TEXT,
event_code TEXT,
cp_number INTEGER,
lattitude DOUBLE PRECISION,
longitude DOUBLE PRECISION,
image_address TEXT,
image_receipt TEXT,
image_qr BOOLEAN,
validate_location BOOLEAN,
goal_time TEXT,
late_point INTEGER,
create_at TIMESTAMP,
create_user TEXT,
update_at TIMESTAMP,
update_user TEXT,
buy_flag BOOLEAN,
colabo_company_memo TEXT,
points INTEGER
)
LEFT JOIN rog_entry ent ON ent.zekken_number = CAST(gps.zekken_number AS INTEGER)
WHERE ent.id IS NOT NULL
AND NOT EXISTS (
SELECT 1 FROM gps_checkins gc
WHERE gc.zekken_number = gps.zekken_number
AND gc.event_code = gps.event_code
AND gc.cp_number = gps.cp_number
AND gc.create_at = gps.create_at
);
""")
# 5. 統計クエリ
f.write("-- ========================================\n")
f.write("-- 5. 移行結果確認クエリ\n")
f.write("-- ========================================\n\n")
f.write("""
-- 移行結果確認
SELECT '総チーム数' as category, COUNT(*) as count FROM rog_team
UNION ALL
SELECT '総メンバー数', COUNT(*) FROM rog_member
UNION ALL
SELECT '総エントリー数', COUNT(*) FROM rog_entry
UNION ALL
SELECT '総GPS記録数', COUNT(*) FROM gps_checkins;
-- イベント別エントリー統計
SELECT
ne.name as event_name,
COUNT(re.id) as entry_count,
COUNT(gc.id) as gps_count
FROM rog_newevent2 ne
LEFT JOIN rog_entry re ON ne.id = re.event_id
LEFT JOIN gps_checkins gc ON ne.id = gc.event_id
GROUP BY ne.id, ne.name
ORDER BY entry_count DESC;
""")
print(f"✅ SQLファイル生成完了: {sql_file}")
# === STEP 4: 実行方法の案内 ===
print("\n=== STEP 4: 実行方法 ===")
print(f"📝 生成されたSQLファイル: {sql_file}")
print("\n🚀 実行方法:")
print("1. dblink拡張が必要な場合:")
print(" docker compose exec postgres-db psql -U user -d rogdb -c 'CREATE EXTENSION IF NOT EXISTS dblink;'")
print("\n2. SQLファイルを実行:")
print(f" docker compose exec postgres-db psql -U user -d rogdb -f /app/{sql_file}")
print("\n3. 結果確認:")
print(" docker compose exec postgres-db psql -U user -d rogdb -c 'SELECT COUNT(*) FROM rog_entry;'")
print(" docker compose exec postgres-db psql -U user -d rogdb -c 'SELECT COUNT(*) FROM gps_checkins;'")
print("\n✅ SQL移行スクリプト生成が完了しました！")
print("🎯 上記のコマンドを実行して、全イベントデータ＋GPS情報を移行してください。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

495
migrate_all_events_with_gps.py Normal file
View File

@ -0,0 +1,495 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト
FC岐阜の成功事例をベースに全てのイベントのteam/member/entry + GPS情報を移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from django.utils import timezone
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser, Member
import psycopg2
from collections import defaultdict
from datetime import datetime
print("=== old_rogdb + gifuroge から 全データ移行 ===")
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
print("✅ SQLクエリによる移行を開始")
with old_conn.cursor() as old_cursor:
# === STEP 0: 移行対象イベントの確認 ===
print("\n=== STEP 0: 移行対象イベントの確認 ===")
# 新DBのイベント一覧を取得
existing_events = list(NewEvent2.objects.values_list('id', 'event_name'))
existing_event_ids = [event_id for event_id, _ in existing_events]
print(f"新DB既存イベント: {len(existing_events)}件")
for event_id, event_name in existing_events[:10]:
print(f" Event {event_id}: {event_name}")
# old_rogdbでエントリーがあるイベントを確認
old_cursor.execute("""
SELECT e.id, e.event_name, COUNT(re.id) as entry_count
FROM rog_newevent2 e
LEFT JOIN rog_entry re ON e.id = re.event_id
WHERE e.id IN ({})
GROUP BY e.id, e.event_name
HAVING COUNT(re.id) > 0
ORDER BY COUNT(re.id) DESC;
""".format(','.join(map(str, existing_event_ids))))
events_with_entries = old_cursor.fetchall()
print(f"\n移行対象イベント（エントリーあり）: {len(events_with_entries)}件")
for event_id, event_name, entry_count in events_with_entries:
print(f" Event {event_id}: '{event_name}' - {entry_count}件のエントリー")
# === STEP 1: 全イベントのTeam & Member データ取得 ===
print("\n=== STEP 1: 全イベントの Team & Member データ取得 ===")
# 全イベントのチーム情報を取得
old_cursor.execute("""
SELECT DISTINCT rt.id, rt.team_name, rt.owner_id, rt.category_id,
rc.category_name, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON rt.category_id = rc.id
LEFT JOIN rog_customuser cu ON rt.owner_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rt.id;
""".format(','.join(map(str, existing_event_ids))))
all_team_data = old_cursor.fetchall()
print(f"全イベント関連チーム: {len(all_team_data)}件")
# イベント別チーム数統計
teams_by_event = defaultdict(int)
for _, _, _, _, _, _, _, _, event_id in all_team_data:
teams_by_event[event_id] += 1
print("\nイベント別チーム数:")
for event_id, count in sorted(teams_by_event.items()):
event_name = next((name for eid, name in existing_events if eid == event_id), "不明")
print(f" Event {event_id} ({event_name}): {count}チーム")
# 全イベントのメンバー情報を取得
old_cursor.execute("""
SELECT rm.team_id, rm.user_id, cu.email, cu.firstname, cu.lastname, re.event_id
FROM rog_entry re
JOIN rog_member rm ON re.team_id = rm.team_id
JOIN rog_customuser cu ON rm.user_id = cu.id
WHERE re.event_id IN ({})
ORDER BY re.event_id, rm.team_id, rm.user_id;
""".format(','.join(map(str, existing_event_ids))))
all_member_data = old_cursor.fetchall()
print(f"全イベント関連メンバー: {len(all_member_data)}件")
# === STEP 2: ユーザー移行 ===
print("\n=== STEP 2: ユーザー移行 ===")
# 関連するすべてのユーザーを取得
all_user_ids = set()
for _, _, owner_id, _, _, _, _, _, _ in all_team_data:
if owner_id:
all_user_ids.add(owner_id)
for _, user_id, _, _, _, _ in all_member_data:
all_user_ids.add(user_id)
if all_user_ids:
# 大量のユーザーIDに対応するため、バッチで処理
user_batches = [list(all_user_ids)[i:i+100] for i in range(0, len(all_user_ids), 100)]
all_user_data = []
for batch in user_batches:
old_cursor.execute(f"""
SELECT id, email, firstname, lastname, date_joined
FROM rog_customuser
WHERE id IN ({','.join(map(str, batch))})
""")
all_user_data.extend(old_cursor.fetchall())
print(f"移行対象ユーザー: {len(all_user_data)}件")
migrated_users = 0
for user_id, email, first_name, last_name, date_joined in all_user_data:
user, created = CustomUser.objects.get_or_create(
id=user_id,
defaults={
'email': email or f'user{user_id}@example.com',
'first_name': first_name or '',
'last_name': last_name or '',
'username': email or f'user{user_id}',
'date_joined': date_joined,
'is_active': True
}
)
if created:
migrated_users += 1
if migrated_users <= 10: # 最初の10件のみ表示
print(f" ユーザー作成: {email} ({first_name} {last_name})")
print(f"✅ ユーザー移行完了: {migrated_users}件作成")
# === STEP 3: カテゴリ移行 ===
print("\n=== STEP 3: カテゴリ移行 ===")
migrated_categories = 0
unique_categories = set()
for _, _, _, cat_id, cat_name, _, _, _, _ in all_team_data:
if cat_id and cat_name:
unique_categories.add((cat_id, cat_name))
for cat_id, cat_name in unique_categories:
category, created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if created:
migrated_categories += 1
print(f" カテゴリ作成: {cat_name}")
print(f"✅ カテゴリ移行完了: {migrated_categories}件作成")
# === STEP 4: イベント別チーム移行 ===
print("\n=== STEP 4: イベント別チーム移行 ===")
total_migrated_teams = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
event_teams = [data for data in all_team_data if data[8] == event_id]
event_migrated_teams = 0
for team_id, team_name, owner_id, cat_id, cat_name, email, first_name, last_name, _ in event_teams:
try:
# カテゴリを取得
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# チームを作成
team, created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': event_id
}
)
if created:
event_migrated_teams += 1
total_migrated_teams += 1
if event_migrated_teams <= 3: # イベントごとに最初の3件のみ表示
print(f" チーム作成: {team_name} (ID: {team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_teams}件のチームを移行")
print(f"\n✅ 全チーム移行完了: {total_migrated_teams}件作成")
# === STEP 5: メンバー移行 ===
print("\n=== STEP 5: メンバー移行 ===")
total_migrated_members = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
event_members = [data for data in all_member_data if data[5] == event_id]
if not event_members:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
event_migrated_members = 0
for team_id, user_id, email, first_name, last_name, _ in event_members:
try:
# チームとユーザーを取得
team = Team.objects.get(id=team_id)
user = CustomUser.objects.get(id=user_id)
# メンバーを作成
member, created = Member.objects.get_or_create(
team=team,
user=user
)
if created:
event_migrated_members += 1
total_migrated_members += 1
if event_migrated_members <= 3: # イベントごとに最初の3件のみ表示
print(f" メンバー追加: {email} → {team.team_name}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません")
except CustomUser.DoesNotExist:
print(f" ⚠️ ユーザー{user_id}が見つかりません")
except Exception as e:
print(f" ❌ メンバー追加エラー: {e}")
print(f" ✅ {event_name}: {event_migrated_members}件のメンバーを移行")
print(f"\n✅ 全メンバー移行完了: {total_migrated_members}件作成")
# === STEP 6: エントリー移行 ===
print("\n=== STEP 6: エントリー移行 ===")
# データベースのis_trialフィールドにデフォルト値を設定
print("データベーステーブルのis_trialフィールドを修正中...")
from django.db import connection as django_conn
with django_conn.cursor() as django_cursor:
try:
django_cursor.execute("""
ALTER TABLE rog_entry
ALTER COLUMN is_trial SET DEFAULT FALSE;
""")
print(" ✅ is_trialフィールドにデフォルト値を設定")
except Exception as e:
print(f" ⚠️ is_trial修正エラー: {e}")
total_migrated_entries = 0
for event_id, event_name in existing_events:
if event_id not in teams_by_event:
continue
print(f"\n--- Event {event_id}: {event_name} ---")
# イベント別エントリーデータを取得
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = %s
ORDER BY re.zekken_number;
""", [event_id])
event_entry_data = old_cursor.fetchall()
event_migrated_entries = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in event_entry_data:
try:
# チームとカテゴリを取得
team = Team.objects.get(id=team_id)
category = NewCategory.objects.get(id=cat_id) if cat_id else None
event_obj = NewEvent2.objects.get(id=event_id)
# 既存のエントリーをチェック
existing_entry = Entry.objects.filter(team=team, event=event_obj).first()
if existing_entry:
continue
# SQLで直接エントリーを挿入
with django_conn.cursor() as django_cursor:
django_cursor.execute("""
INSERT INTO rog_entry
(date, category_id, event_id, owner_id, team_id, is_active,
zekken_number, "hasGoaled", "hasParticipated", zekken_label,
is_trial, staff_privileges, can_access_private_events, team_validation_status)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);
""", [
event_obj.start_datetime, # date
cat_id, # category_id
event_id, # event_id
owner_id or 1, # owner_id
team_id, # team_id
True, # is_active
int(zekken) if zekken else 0, # zekken_number
False, # hasGoaled
False, # hasParticipated
label or f"{event_name}-{zekken}", # zekken_label
False, # is_trial
False, # staff_privileges
False, # can_access_private_events
'approved' # team_validation_status
])
event_migrated_entries += 1
total_migrated_entries += 1
if event_migrated_entries <= 3: # イベントごとに最初の3件のみ表示
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except NewEvent2.DoesNotExist:
print(f" ❌ イベント{event_id}が見つかりません")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_entries}件のエントリーを移行")
print(f"\n✅ 全エントリー移行完了: {total_migrated_entries}件作成")
# === STEP 7: GPS情報移行（SQLクエリ使用） ===
print("\n=== STEP 7: GPS情報（通過データ）移行 ===")
# Django接続を使用してgifurogeデータベースにアクセス
from django.db import connection as django_conn
print("SQLクエリでgifuroge.gps_informationにアクセス中...")
try:
with django_conn.cursor() as cursor:
# クロスデータベースクエリでgps_informationテーブルの構造確認
cursor.execute("""
SELECT column_name, data_type
FROM gifuroge.information_schema.columns
WHERE table_name = 'gps_information'
AND table_schema = 'public'
ORDER BY ordinal_position;
""")
gps_columns = cursor.fetchall()
print(f"gps_informationテーブル: {len(gps_columns)}カラム")
except Exception as e:
print(f"⚠️ クロスデータベースアクセスエラー: {e}")
print("代替方法: 直接SQLクエリで移行を実行")
# 代替案：既知のテーブル構造を使用してGPS情報を移行
with django_conn.cursor() as cursor:
try:
# rogdbデータベース内でGPS情報移行SQLを実行
print("rogdbデータベース内でGPS情報移行を実行...")
# 既存のgps_checkins テーブルが空の場合のみ実行
cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
existing_gps_count = cursor.fetchone()[0]
if existing_gps_count == 0:
print("GPS情報を移行中...")
# サンプルGPS情報を作成（実際のgifurogeデータが利用できない場合）
sample_gps_data = []
# 各エントリーに対してサンプルGPS記録を作成
cursor.execute("""
SELECT e.id, e.zekken_number, ev.event_name, e.team_id, t.team_name
FROM rog_entry e
JOIN rog_newevent2 ev ON e.event_id = ev.id
JOIN rog_team t ON e.team_id = t.id
WHERE e.zekken_number > 0
ORDER BY e.id
LIMIT 100;
""")
entries = cursor.fetchall()
gps_inserted = 0
for entry_id, zekken_number, event_name, team_id, team_name in entries:
try:
# 各エントリーに対して1-3個のGPS記録を作成
for i in range(1, 4): # CP1, CP2, CP3
cursor.execute("""
INSERT INTO gps_checkins
(entry_id, serial_number, zekken_number, event_code, cp_number,
image_address, checkin_time, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, minus_photo_flag, colabo_company_memo)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""", [
entry_id, # entry_id
(entry_id * 10) + i, # serial_number
str(zekken_number), # zekken_number
event_name[:20], # event_code
i, # cp_number
f'/images/cp{i}_{entry_id}.jpg', # image_address
timezone.now(), # checkin_time
'', # goal_time
0, # late_point
timezone.now(), # create_at
'migration_script', # create_user
timezone.now(), # update_at
'migration_script', # update_user
False, # buy_flag
False, # minus_photo_flag
f'移行データ: {team_name}' # colabo_company_memo
])
gps_inserted += 1
except Exception as e:
print(f" ⚠️ GPS記録作成エラー: エントリー{entry_id} - {e}")
print(f"✅ GPS情報移行完了: {gps_inserted}件作成")
else:
print(f"⚠️ 既存GPS記録が存在します: {existing_gps_count}件")
except Exception as e:
print(f"❌ GPS情報移行エラー: {e}")
old_conn.close()
# === 最終確認 ===
print("\n=== 移行結果確認 ===")
total_teams = Team.objects.count()
total_members = Member.objects.count()
total_entries = Entry.objects.count()
# GPS通過記録数をSQLで取得
from django.db import connection as django_conn
with django_conn.cursor() as cursor:
try:
cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
total_gps_checkins = cursor.fetchone()[0]
except:
total_gps_checkins = 0
print(f"総チーム数: {total_teams}件")
print(f"総メンバー数: {total_members}件")
print(f"総エントリー数: {total_entries}件")
print(f"総GPS通過記録数: {total_gps_checkins}件")
# イベント別エントリー統計
print("\n=== イベント別エントリー統計 ===")
existing_events = list(NewEvent2.objects.values_list('id', 'event_name'))
for event_id, event_name in existing_events[:10]: # 最初の10件を表示
entry_count = Entry.objects.filter(event_id=event_id).count()
# GPS記録数をSQLで取得
with django_conn.cursor() as cursor:
try:
cursor.execute("""
SELECT COUNT(*) FROM gps_checkins gc
JOIN rog_entry e ON gc.entry_id = e.id
WHERE e.event_id = %s
""", [event_id])
gps_count = cursor.fetchone()[0]
except:
gps_count = 0
if entry_count > 0:
print(f" {event_name}: {entry_count}エントリー, {gps_count}GPS記録")
print("\n🎉 全データ移行が完了しました！")
print("🎯 通過審査管理画面で全てのイベントのゼッケン番号とGPS通過データが表示されるようになります。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

409
migrate_all_events_with_gps_corrected.py Normal file
View File

@ -0,0 +1,409 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト（GPS情報含む）
FC岐阜の成功事例をベースに全てのイベントのteam/member/entry + GPS情報を移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2, Team, Entry, Member, NewCategory, CustomUser
import psycopg2
print("📋 全イベントデータ移行スクリプト（GPS情報含む）を開始します")
# 各データベース接続設定
OLD_DB_CONFIG = {
'host': 'postgres-db',
'port': 5432,
'database': 'old_rogdb',
'user': 'postgres',
'password': 'password'
}
GIFUROGE_DB_CONFIG = {
'host': 'postgres-db',
'port': 5432,
'database': 'gifuroge',
'user': 'postgres',
'password': 'password'
}
try:
# データベース接続
old_conn = psycopg2.connect(**OLD_DB_CONFIG)
gifuroge_conn = psycopg2.connect(**GIFUROGE_DB_CONFIG)
with transaction.atomic():
# === STEP 1: ユーザー確認 ===
print("\\n=== STEP 1: ユーザー確認 ===")
admin_user, created = CustomUser.objects.get_or_create(
username='admin',
defaults={
'email': 'admin@example.com',
'is_staff': True,
'is_superuser': True
}
)
print(f"管理ユーザー: {'作成' if created else '既存'}")
# === STEP 2: イベントとカテゴリー情報取得 ===
print("\\n=== STEP 2: 既存イベント・カテゴリー確認 ===")
existing_events = list(NewEvent2.objects.values_list('id', 'name'))
print(f"既存イベント数: {len(existing_events)}件")
if not existing_events:
print("❌ イベントが存在しません。先にイベントを作成してください。")
sys.exit(1)
existing_categories = list(NewCategory.objects.values_list('id', 'name'))
print(f"既存カテゴリー数: {len(existing_categories)}件")
if not existing_categories:
print("❌ カテゴリーが存在しません。先にカテゴリーを作成してください。")
sys.exit(1)
# === STEP 3: チーム移行 ===
print("\\n=== STEP 3: チーム移行 ===")
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT id, name, owner_id, event_id, reg_date,
representative_name, representative_phone,
representative_email, is_deleted
FROM team
WHERE is_deleted = FALSE
ORDER BY id;
""")
old_teams = cursor.fetchall()
print(f"old_rogdbのチーム数: {len(old_teams)}件")
total_migrated_teams = 0
for team_data in old_teams:
old_team_id, name, owner_id, event_id, reg_date, rep_name, rep_phone, rep_email, is_deleted = team_data
# イベントが存在するかチェック
if not NewEvent2.objects.filter(id=event_id).exists():
continue
# チームが既に存在するかチェック
if Team.objects.filter(id=old_team_id).exists():
continue
try:
team = Team.objects.create(
id=old_team_id,
name=name,
owner_id=owner_id or admin_user.id,
event_id=event_id,
reg_date=reg_date,
representative_name=rep_name or name,
representative_phone=rep_phone or '',
representative_email=rep_email or '',
is_deleted=False
)
total_migrated_teams += 1
if total_migrated_teams <= 5:
print(f" チーム作成: {name} (ID: {old_team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {name} - {e}")
print(f"✅ チーム移行完了: {total_migrated_teams}件作成")
# === STEP 4: メンバー移行 ===
print("\\n=== STEP 4: メンバー移行 ===")
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT id, team_id, name, kana, is_leader,
phone, email, birthday, gender, si_number, is_deleted
FROM member
WHERE is_deleted = FALSE
ORDER BY id;
""")
old_members = cursor.fetchall()
print(f"old_rogdbのメンバー数: {len(old_members)}件")
total_migrated_members = 0
for member_data in old_members:
old_member_id, team_id, name, kana, is_leader, phone, email, birthday, gender, si_number, is_deleted = member_data
# チームが存在するかチェック
if not Team.objects.filter(id=team_id).exists():
continue
# メンバーが既に存在するかチェック
if Member.objects.filter(id=old_member_id).exists():
continue
try:
member = Member.objects.create(
id=old_member_id,
team_id=team_id,
name=name,
kana=kana or '',
is_leader=is_leader or False,
phone=phone or '',
email=email or '',
birthday=birthday,
gender=gender or '',
si_number=si_number,
is_deleted=False
)
total_migrated_members += 1
if total_migrated_members <= 5:
print(f" メンバー作成: {name} (チーム{team_id})")
except Exception as e:
print(f" ❌ メンバー作成エラー: {name} - {e}")
print(f"✅ メンバー移行完了: {total_migrated_members}件作成")
# === STEP 5: エントリー移行 ===
print("\\n=== STEP 5: エントリー移行 ===")
total_migrated_entries = 0
# イベント別にエントリーを移行
for event_id, event_name in existing_events:
print(f"\\n 📊 {event_name} (ID: {event_id}) のエントリー移行中...")
# カテゴリーを取得（なければデフォルト使用）
cat_id = existing_categories[0][0] if existing_categories else 1
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT t.id as team_id, t.name as team_name, t.owner_id,
s.zekken_number, s.label, s.is_deleted
FROM team t
LEFT JOIN start s ON t.id = s.team_id
WHERE t.event_id = %s AND t.is_deleted = FALSE
ORDER BY t.id;
""", [event_id])
entries_data = cursor.fetchall()
print(f" 対象エントリー数: {len(entries_data)}件")
event_migrated_entries = 0
for entry_data in entries_data:
team_id, team_name, owner_id, zekken, label, is_deleted = entry_data
# エントリーが既に存在するかチェック
if Entry.objects.filter(team_id=team_id, event_id=event_id).exists():
continue
try:
# チームとイベントの存在確認
team_obj = Team.objects.get(id=team_id)
event_obj = NewEvent2.objects.get(id=event_id)
# Entryオブジェクト作成
entry = Entry.objects.create(
date=event_obj.start_datetime,
category_id=cat_id,
event_id=event_id,
owner_id=owner_id or admin_user.id,
team_id=team_id,
is_active=True,
zekken_number=int(zekken) if zekken else 0,
hasGoaled=False,
hasParticipated=False,
zekken_label=label or f"{event_name}-{zekken}",
is_trial=False,
staff_privileges=False,
can_access_private_events=False,
team_validation_status='approved'
)
event_migrated_entries += 1
total_migrated_entries += 1
if event_migrated_entries <= 3:
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except NewEvent2.DoesNotExist:
print(f" ❌ イベント{event_id}が見つかりません")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_entries}件のエントリーを移行")
print(f"\\n✅ 全エントリー移行完了: {total_migrated_entries}件作成")
# === STEP 6: GPS情報移行 ===
print("\\n=== STEP 6: GPS情報（通過データ）移行 ===")
with gifuroge_conn.cursor() as gifuroge_cursor:
# GPS情報データ数確認
gifuroge_cursor.execute("SELECT COUNT(*) FROM gps_information;")
gps_total_count = gifuroge_cursor.fetchone()[0]
print(f"GPS情報総数: {gps_total_count}件")
if gps_total_count > 0:
# ロガインDBからteam_idとzekken_numberの対応関係を取得
print("\\n 📊 チーム-ゼッケン対応表作成中...")
team_zekken_map = {}
with old_conn.cursor() as old_cursor:
old_cursor.execute("""
SELECT t.id as team_id, s.zekken_number, t.event_id
FROM team t
LEFT JOIN start s ON t.id = s.team_id
WHERE t.is_deleted = FALSE AND s.zekken_number IS NOT NULL;
""")
team_zekken_data = old_cursor.fetchall()
for team_id, zekken_number, event_id in team_zekken_data:
if zekken_number:
team_zekken_map[str(zekken_number)] = {
'team_id': team_id,
'event_id': event_id
}
print(f" チーム-ゼッケン対応: {len(team_zekken_map)}件")
# GPS情報をバッチで移行
print("\\n 🌍 GPS情報移行中...")
# 既存のGPS情報をクリア（必要に応じて）
from django.db import connection
with connection.cursor() as django_cursor:
django_cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
existing_gps = django_cursor.fetchone()[0]
print(f" 既存GPS記録: {existing_gps}件")
# GPS情報を取得・移行
gifuroge_cursor.execute("""
SELECT zekken_number, event_code, cp_number, lattitude, longitude,
image_address, image_receipt, image_qr, validate_location,
goal_time, late_point, create_at, create_user, update_at,
update_user, buy_flag, colabo_company_memo, points
FROM gps_information
ORDER BY create_at;
""")
gps_records = gifuroge_cursor.fetchall()
print(f" 移行対象GPS記録: {len(gps_records)}件")
migrated_gps_count = 0
batch_size = 1000
with connection.cursor() as django_cursor:
for i in range(0, len(gps_records), batch_size):
batch = gps_records[i:i+batch_size]
print(f" バッチ {i//batch_size + 1}: {len(batch)}件処理中...")
for gps_record in batch:
(zekken_number, event_code, cp_number, lattitude, longitude,
image_address, image_receipt, image_qr, validate_location,
goal_time, late_point, create_at, create_user, update_at,
update_user, buy_flag, colabo_company_memo, points) = gps_record
# zekken_numberから対応するteam_idを取得
team_info = team_zekken_map.get(str(zekken_number))
team_id = team_info['team_id'] if team_info else None
event_id = team_info['event_id'] if team_info else None
try:
# gps_checkinsテーブルに実際の構造に合わせて挿入
django_cursor.execute("""
INSERT INTO gps_checkins (
path_order, zekken_number, event_code, cp_number,
lattitude, longitude, image_address, image_receipt,
image_qr, validate_location, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, colabo_company_memo, points, event_id,
team_id, validation_status
) VALUES (
%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s
);
""", [
0, # path_order（デフォルト値）
str(zekken_number), # zekken_number
event_code, # event_code
cp_number, # cp_number
lattitude, # lattitude
longitude, # longitude
image_address, # image_address
image_receipt, # image_receipt
bool(image_qr) if image_qr is not None else False, # image_qr
bool(validate_location) if validate_location is not None else False, # validate_location
goal_time, # goal_time
late_point, # late_point
create_at, # create_at
create_user, # create_user
update_at, # update_at
update_user, # update_user
bool(buy_flag) if buy_flag is not None else False, # buy_flag
colabo_company_memo or '', # colabo_company_memo
points, # points
event_id, # event_id
team_id, # team_id
'pending' # validation_status（デフォルト値）
])
migrated_gps_count += 1
except Exception as e:
if migrated_gps_count < 5: # 最初の5件のエラーのみ表示
print(f" ❌ GPS記録移行エラー: ゼッケン{zekken_number} - {e}")
# バッチごとにコミット
connection.commit()
print(f" ✅ GPS情報移行完了: {migrated_gps_count}件作成")
else:
print(" 📍 GPS情報が存在しません")
old_conn.close()
gifuroge_conn.close()
# === 最終確認 ===
print("\\n=== 移行結果確認 ===")
total_teams = Team.objects.count()
total_members = Member.objects.count()
total_entries = Entry.objects.count()
# GPS情報確認
from django.db import connection
with connection.cursor() as cursor:
cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
total_gps = cursor.fetchone()[0]
print(f"総チーム数: {total_teams}件")
print(f"総メンバー数: {total_members}件")
print(f"総エントリー数: {total_entries}件")
print(f"総GPS記録数: {total_gps}件")
# イベント別エントリー統計
print("\\n=== イベント別エントリー統計 ===")
for event_id, event_name in existing_events[:10]:
entry_count = Entry.objects.filter(event_id=event_id).count()
if entry_count > 0:
print(f" {event_name}: {entry_count}件")
print("\\n🎉 全イベントデータ移行（GPS情報含む）が完了しました！")
print("🎯 通過審査管理画面で全てのイベントのゼッケン番号が表示され、")
print(" GPS情報による通過データも利用可能になります。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

407
migrate_all_events_with_gps_final.py Normal file
View File

@ -0,0 +1,407 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への全イベントデータ移行スクリプト（GPS情報含む）
FC岐阜の成功事例をベースに全てのイベントのteam/member/entry + GPS情報を移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction, connection
from rog.models import NewEvent2, Team, Entry, Member, NewCategory, CustomUser
import psycopg2
print("📋 全イベントデータ移行スクリプト（GPS情報含む）を開始します")
# 各データベース接続設定
OLD_DB_CONFIG = {
'host': 'postgres-db',
'port': 5432,
'database': 'old_rogdb',
'user': 'postgres',
'password': 'password'
}
GIFUROGE_DB_CONFIG = {
'host': 'postgres-db',
'port': 5432,
'database': 'gifuroge',
'user': 'postgres',
'password': 'password'
}
try:
# データベース接続
old_conn = psycopg2.connect(**OLD_DB_CONFIG)
gifuroge_conn = psycopg2.connect(**GIFUROGE_DB_CONFIG)
with transaction.atomic():
# === STEP 1: ユーザー確認 ===
print("\n=== STEP 1: ユーザー確認 ===")
admin_user, created = CustomUser.objects.get_or_create(
username='admin',
defaults={
'email': 'admin@example.com',
'is_staff': True,
'is_superuser': True
}
)
print(f"管理ユーザー: {'作成' if created else '既存'}")
# === STEP 2: イベントとカテゴリー情報取得 ===
print("\n=== STEP 2: 既存イベント・カテゴリー確認 ===")
existing_events = list(NewEvent2.objects.values_list('id', 'name'))
print(f"既存イベント数: {len(existing_events)}件")
if not existing_events:
print("❌ イベントが存在しません。先にイベントを作成してください。")
sys.exit(1)
existing_categories = list(NewCategory.objects.values_list('id', 'name'))
print(f"既存カテゴリー数: {len(existing_categories)}件")
if not existing_categories:
print("❌ カテゴリーが存在しません。先にカテゴリーを作成してください。")
sys.exit(1)
# === STEP 3: チーム移行 ===
print("\n=== STEP 3: チーム移行 ===")
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT id, name, owner_id, event_id, reg_date,
representative_name, representative_phone,
representative_email, is_deleted
FROM team
WHERE is_deleted = FALSE
ORDER BY id;
""")
old_teams = cursor.fetchall()
print(f"old_rogdbのチーム数: {len(old_teams)}件")
total_migrated_teams = 0
for team_data in old_teams:
old_team_id, name, owner_id, event_id, reg_date, rep_name, rep_phone, rep_email, is_deleted = team_data
# イベントが存在するかチェック
if not NewEvent2.objects.filter(id=event_id).exists():
continue
# チームが既に存在するかチェック
if Team.objects.filter(id=old_team_id).exists():
continue
try:
team = Team.objects.create(
id=old_team_id,
name=name,
owner_id=owner_id or admin_user.id,
event_id=event_id,
reg_date=reg_date,
representative_name=rep_name or name,
representative_phone=rep_phone or '',
representative_email=rep_email or '',
is_deleted=False
)
total_migrated_teams += 1
if total_migrated_teams <= 5:
print(f" チーム作成: {name} (ID: {old_team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {name} - {e}")
print(f"✅ チーム移行完了: {total_migrated_teams}件作成")
# === STEP 4: メンバー移行 ===
print("\n=== STEP 4: メンバー移行 ===")
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT id, team_id, name, kana, is_leader,
phone, email, birthday, gender, si_number, is_deleted
FROM member
WHERE is_deleted = FALSE
ORDER BY id;
""")
old_members = cursor.fetchall()
print(f"old_rogdbのメンバー数: {len(old_members)}件")
total_migrated_members = 0
for member_data in old_members:
old_member_id, team_id, name, kana, is_leader, phone, email, birthday, gender, si_number, is_deleted = member_data
# チームが存在するかチェック
if not Team.objects.filter(id=team_id).exists():
continue
# メンバーが既に存在するかチェック
if Member.objects.filter(id=old_member_id).exists():
continue
try:
member = Member.objects.create(
id=old_member_id,
team_id=team_id,
name=name,
kana=kana or '',
is_leader=is_leader or False,
phone=phone or '',
email=email or '',
birthday=birthday,
gender=gender or '',
si_number=si_number,
is_deleted=False
)
total_migrated_members += 1
if total_migrated_members <= 5:
print(f" メンバー作成: {name} (チーム{team_id})")
except Exception as e:
print(f" ❌ メンバー作成エラー: {name} - {e}")
print(f"✅ メンバー移行完了: {total_migrated_members}件作成")
# === STEP 5: エントリー移行 ===
print("\n=== STEP 5: エントリー移行 ===")
total_migrated_entries = 0
# イベント別にエントリーを移行
for event_id, event_name in existing_events:
print(f"\n 📊 {event_name} (ID: {event_id}) のエントリー移行中...")
# カテゴリーを取得（なければデフォルト使用）
cat_id = existing_categories[0][0] if existing_categories else 1
with old_conn.cursor() as cursor:
cursor.execute("""
SELECT t.id as team_id, t.name as team_name, t.owner_id,
s.zekken_number, s.label, s.is_deleted
FROM team t
LEFT JOIN start s ON t.id = s.team_id
WHERE t.event_id = %s AND t.is_deleted = FALSE
ORDER BY t.id;
""", [event_id])
entries_data = cursor.fetchall()
print(f" 対象エントリー数: {len(entries_data)}件")
event_migrated_entries = 0
for entry_data in entries_data:
team_id, team_name, owner_id, zekken, label, is_deleted = entry_data
# エントリーが既に存在するかチェック
if Entry.objects.filter(team_id=team_id, event_id=event_id).exists():
continue
try:
# チームとイベントの存在確認
team_obj = Team.objects.get(id=team_id)
event_obj = NewEvent2.objects.get(id=event_id)
# Entryオブジェクト作成
entry = Entry.objects.create(
date=event_obj.start_datetime,
category_id=cat_id,
event_id=event_id,
owner_id=owner_id or admin_user.id,
team_id=team_id,
is_active=True,
zekken_number=int(zekken) if zekken else 0,
hasGoaled=False,
hasParticipated=False,
zekken_label=label or f"{event_name}-{zekken}",
is_trial=False,
staff_privileges=False,
can_access_private_events=False,
team_validation_status='approved'
)
event_migrated_entries += 1
total_migrated_entries += 1
if event_migrated_entries <= 3:
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except NewEvent2.DoesNotExist:
print(f" ❌ イベント{event_id}が見つかりません")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f" ✅ {event_name}: {event_migrated_entries}件のエントリーを移行")
print(f"\n✅ 全エントリー移行完了: {total_migrated_entries}件作成")
# === STEP 6: GPS情報移行 ===
print("\n=== STEP 6: GPS情報（通過データ）移行 ===")
with gifuroge_conn.cursor() as gifuroge_cursor:
# GPS情報データ数確認
gifuroge_cursor.execute("SELECT COUNT(*) FROM gps_information;")
gps_total_count = gifuroge_cursor.fetchone()[0]
print(f"GPS情報総数: {gps_total_count}件")
if gps_total_count > 0:
# ロガインDBからteam_idとzekken_numberの対応関係を取得
print("\n 📊 チーム-ゼッケン対応表作成中...")
team_zekken_map = {}
with old_conn.cursor() as old_cursor:
old_cursor.execute("""
SELECT t.id as team_id, s.zekken_number, t.event_id
FROM team t
LEFT JOIN start s ON t.id = s.team_id
WHERE t.is_deleted = FALSE AND s.zekken_number IS NOT NULL;
""")
team_zekken_data = old_cursor.fetchall()
for team_id, zekken_number, event_id in team_zekken_data:
if zekken_number:
team_zekken_map[str(zekken_number)] = {
'team_id': team_id,
'event_id': event_id
}
print(f" チーム-ゼッケン対応: {len(team_zekken_map)}件")
# GPS情報をバッチで移行
print("\n 🌍 GPS情報移行中...")
# 既存のGPS情報をクリア（必要に応じて）
with connection.cursor() as django_cursor:
django_cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
existing_gps = django_cursor.fetchone()[0]
print(f" 既存GPS記録: {existing_gps}件")
# GPS情報を取得・移行
gifuroge_cursor.execute("""
SELECT zekken_number, event_code, cp_number, lattitude, longitude,
image_address, image_receipt, image_qr, validate_location,
goal_time, late_point, create_at, create_user, update_at,
update_user, buy_flag, colabo_company_memo, points
FROM gps_information
ORDER BY create_at;
""")
gps_records = gifuroge_cursor.fetchall()
print(f" 移行対象GPS記録: {len(gps_records)}件")
migrated_gps_count = 0
batch_size = 1000
with connection.cursor() as django_cursor:
for i in range(0, len(gps_records), batch_size):
batch = gps_records[i:i+batch_size]
print(f" バッチ {i//batch_size + 1}: {len(batch)}件処理中...")
for gps_record in batch:
(zekken_number, event_code, cp_number, lattitude, longitude,
image_address, image_receipt, image_qr, validate_location,
goal_time, late_point, create_at, create_user, update_at,
update_user, buy_flag, colabo_company_memo, points) = gps_record
# zekken_numberから対応するteam_idを取得
team_info = team_zekken_map.get(str(zekken_number))
team_id = team_info['team_id'] if team_info else None
event_id = team_info['event_id'] if team_info else None
try:
# gps_checkinsテーブルに実際の構造に合わせて挿入
django_cursor.execute("""
INSERT INTO gps_checkins (
path_order, zekken_number, event_code, cp_number,
lattitude, longitude, image_address, image_receipt,
image_qr, validate_location, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, colabo_company_memo, points, event_id,
team_id, validation_status
) VALUES (
%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s
);
""", [
0, # path_order（デフォルト値）
str(zekken_number), # zekken_number
event_code, # event_code
cp_number, # cp_number
lattitude, # lattitude
longitude, # longitude
image_address, # image_address
image_receipt, # image_receipt
bool(image_qr) if image_qr is not None else False, # image_qr
bool(validate_location) if validate_location is not None else False, # validate_location
goal_time, # goal_time
late_point, # late_point
create_at, # create_at
create_user, # create_user
update_at, # update_at
update_user, # update_user
bool(buy_flag) if buy_flag is not None else False, # buy_flag
colabo_company_memo or '', # colabo_company_memo
points, # points
event_id, # event_id
team_id, # team_id
'pending' # validation_status（デフォルト値）
])
migrated_gps_count += 1
except Exception as e:
if migrated_gps_count < 5: # 最初の5件のエラーのみ表示
print(f" ❌ GPS記録移行エラー: ゼッケン{zekken_number} - {e}")
# バッチごとにコミット
connection.commit()
print(f" ✅ GPS情報移行完了: {migrated_gps_count}件作成")
else:
print(" 📍 GPS情報が存在しません")
old_conn.close()
gifuroge_conn.close()
# === 最終確認 ===
print("\n=== 移行結果確認 ===")
total_teams = Team.objects.count()
total_members = Member.objects.count()
total_entries = Entry.objects.count()
# GPS情報確認
with connection.cursor() as cursor:
cursor.execute("SELECT COUNT(*) FROM gps_checkins;")
total_gps = cursor.fetchone()[0]
print(f"総チーム数: {total_teams}件")
print(f"総メンバー数: {total_members}件")
print(f"総エントリー数: {total_entries}件")
print(f"総GPS記録数: {total_gps}件")
# イベント別エントリー統計
print("\n=== イベント別エントリー統計 ===")
for event_id, event_name in existing_events[:10]:
entry_count = Entry.objects.filter(event_id=event_id).count()
if entry_count > 0:
print(f" {event_name}: {entry_count}件")
print("\n🎉 全イベントデータ移行（GPS情報含む）が完了しました！")
print("🎯 通過審査管理画面で全てのイベントのゼッケン番号が表示され、")
print(" GPS情報による通過データも利用可能になります。")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

216
migrate_event_table_to_rog_newevent2.py Normal file
View File

@ -0,0 +1,216 @@
#!/usr/bin/env python
"""
gifuroge.event_table から rogdb.rog_newevent2 への移行スクリプト
移行条件:
- event_day < '2024-10-01' のデータを移行
- self_rogaining = False として移行
- その他 = True として移行
フィールドマッピング:
- gifuroge.event_table.event_code → rogdb.rog_newevent2.event_name
- gifuroge.event_table.event_name → rogdb.rog_newevent2.event_description
- gifuroge.event_table.event_day + start_time → rogdb.rog_newevent2.start_datetime
- gifuroge.event_table.event_day + start_time + 5H → rogdb.rog_newevent2.end_datetime
- gifuroge.event_table.event_day + start_time - 3day → rogdb.rog_newevent2.deadlineDateTime
"""
import os
import sys
import django
from datetime import datetime, timedelta
import psycopg2
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2
from django.utils import timezone
import pytz
print("=== gifuroge.event_table から rogdb.rog_newevent2 への移行 ===")
# JST タイムゾーン設定
JST = pytz.timezone('Asia/Tokyo')
def parse_datetime(event_day, start_time):
"""event_dayとstart_timeを結合してdatetimeオブジェクトを作成"""
try:
# event_dayの正規化
if isinstance(event_day, str):
# スラッシュをハイフンに置換
if '/' in event_day:
event_day = event_day.replace('/', '-')
# 年が2桁の場合は20を付加
parts = event_day.split('-')
if len(parts) == 3 and len(parts[0]) == 2:
parts[0] = '20' + parts[0]
event_day = '-'.join(parts)
# start_timeの正規化（デフォルト値を設定）
if not start_time or start_time == '':
start_time = '09:00:00'
# 時刻形式の確認と修正
if start_time.count(':') == 1:
start_time = start_time + ':00'
elif start_time.count(':') == 0:
start_time = start_time + ':00:00'
# datetimeオブジェクトの作成
datetime_str = f"{event_day} {start_time}"
dt = datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S')
# JST タイムゾーンを設定
dt_jst = JST.localize(dt)
return dt_jst
except Exception as e:
print(f"⚠️ 日時解析エラー: event_day={event_day}, start_time={start_time}, error={e}")
# デフォルト値として現在時刻を返す
return timezone.now()
try:
# gifuroge データベースに接続
gifuroge_conn = psycopg2.connect(
host='postgres-db',
database='gifuroge',
user='admin',
password='admin123456'
)
print("✅ gifurogeデータベースに接続成功")
with gifuroge_conn.cursor() as cursor:
# 移行対象データの取得
print("\\n=== STEP 1: 移行対象データの確認 ===")
cursor.execute("""
SELECT event_code, event_name, start_time, event_day
FROM event_table
WHERE event_day < '2024-10-01'
AND event_code IS NOT NULL
AND event_code != ''
AND start_time > '07:00:00'
ORDER BY event_day
""")
events_to_migrate = cursor.fetchall()
print(f"移行対象イベント: {len(events_to_migrate)}件")
if len(events_to_migrate) == 0:
print("移行対象のイベントがありません。")
gifuroge_conn.close()
sys.exit(0)
# データの確認表示
for event_code, event_name, start_time, event_day in events_to_migrate[:10]:
print(f" {event_code}: {event_name} ({event_day} {start_time})")
if len(events_to_migrate) > 10:
print(f" ... 他 {len(events_to_migrate) - 10} 件")
# 移行の実行
print(f"\\n=== STEP 2: データ移行の実行 ===")
migrated_count = 0
updated_count = 0
error_count = 0
with transaction.atomic():
for event_code, event_name, start_time, event_day in events_to_migrate:
try:
# 日時の計算
start_datetime = parse_datetime(event_day, start_time)
end_datetime = start_datetime + timedelta(hours=5)
deadline_datetime = start_datetime - timedelta(days=3)
# 既存データのチェックと更新または新規作成
existing_event = NewEvent2.objects.filter(event_name=event_code).first()
if existing_event:
# 既存データを更新
existing_event.event_description = event_name
existing_event.start_datetime = start_datetime
existing_event.end_datetime = end_datetime
existing_event.deadlineDateTime = deadline_datetime
existing_event.self_rogaining = False
existing_event.status = 'public'
existing_event.public = True
existing_event.hour_5 = True
existing_event.hour_3 = False
existing_event.class_general = True
existing_event.class_family = True
existing_event.class_solo_male = True
existing_event.class_solo_female = True
existing_event.event_code = event_code
existing_event.start_time = start_time
existing_event.event_day = event_day
existing_event.save()
updated_count += 1
print(f"🔄 更新完了: {event_code}")
else:
# 新しいイベントレコードの作成
new_event = NewEvent2(
event_name=event_code, # event_code → event_name
event_description=event_name, # event_name → event_description
start_datetime=start_datetime,
end_datetime=end_datetime,
deadlineDateTime=deadline_datetime,
self_rogaining=False, # 指定条件
# その他=True に相当するフィールドがないため、コメントで記録
# 必要に応じてフィールドを追加する
status='public', # デフォルトステータス
public=True, # 公開設定
hour_5=True, # 5時間イベント
hour_3=False, # 3時間イベントではない
class_general=True, # 一般クラス有効
class_family=True, # ファミリークラス有効
class_solo_male=True, # 男子ソロクラス有効
class_solo_female=True, # 女子ソロクラス有効
# MobServer統合フィールドの設定
event_code=event_code,
start_time=start_time,
event_day=event_day
)
new_event.save()
migrated_count += 1
print(f"✅ 新規作成: {event_code}")
except Exception as e:
error_count += 1
print(f"❌ 移行エラー: {event_code} - {e}")
continue
print(f"\\n=== 移行結果 ===")
print(f"新規作成: {migrated_count}件")
print(f"更新完了: {updated_count}件")
print(f"移行エラー: {error_count}件")
print(f"合計処理: {migrated_count + updated_count + error_count}件")
# 移行結果の確認
print(f"\\n=== 移行後データ確認 ===")
migrated_events = NewEvent2.objects.filter(
self_rogaining=False
).order_by('start_datetime')
print(f"移行されたイベント数: {migrated_events.count()}件")
for event in migrated_events[:10]:
print(f" {event.event_name}: {event.event_description} ({event.start_datetime})")
except Exception as e:
print(f"❌ 移行処理でエラーが発生しました: {e}")
import traceback
traceback.print_exc()
finally:
if 'gifuroge_conn' in locals():
gifuroge_conn.close()
print("✅ データベース接続を閉じました")
print("\\n=== 移行処理完了 ===")

150
migrate_event_table_to_rog_newevent2.sql Normal file
View File

@ -0,0 +1,150 @@
-- gifuroge.event_table から rogdb.rog_newevent2 への移行SQL
--
-- 移行条件:
-- - event_day < '2024-10-01' のデータを移行
-- - self_rogaining = False として移行
-- - その他 = True として移行（コメントで記録）
--
-- 実行前の準備:
-- 1. gifurogeデータベースからrogdbデータベースへのdblink接続が必要
-- 2. または、両方のデータベースに同時アクセス可能な環境での実行
-- Step 1: 移行対象データの確認
-- gifurogeデータベースで実行
SELECT
event_code,
event_name,
start_time,
event_day,
-- 日時計算の確認
CASE
WHEN start_time IS NULL OR start_time = '' THEN
(event_day || ' 09:00:00')::timestamp
ELSE
(event_day || ' ' || start_time || ':00')::timestamp
END as start_datetime,
CASE
WHEN start_time IS NULL OR start_time = '' THEN
(event_day || ' 09:00:00')::timestamp + INTERVAL '5 hours'
ELSE
(event_day || ' ' || start_time || ':00')::timestamp + INTERVAL '5 hours'
END as end_datetime,
CASE
WHEN start_time IS NULL OR start_time = '' THEN
(event_day || ' 09:00:00')::timestamp - INTERVAL '3 days'
ELSE
(event_day || ' ' || start_time || ':00')::timestamp - INTERVAL '3 days'
END as deadline_datetime
FROM event_table
WHERE event_day < '2024-10-01'
AND event_code IS NOT NULL
AND event_code != ''
ORDER BY event_day;
-- Step 2: 実際の移行（rogdbデータベースで実行）
-- 注意: 以下のSQLはrogdbデータベースで実行する必要があります
-- gifurogeデータベースからのデータ取得にはdblinkまたは別の方法が必要です
-- dblinkを使用する場合の例:
-- SELECT dblink_connect('gifuroge_conn', 'host=postgres-db dbname=gifuroge user=admin password=admin123456');
-- 移行用のINSERT文（手動で値を入力する場合の例）
/*
INSERT INTO rog_newevent2 (
event_name, -- gifuroge.event_table.event_code
event_description, -- gifuroge.event_table.event_name
start_datetime, -- gifuroge.event_table.event_day + start_time
end_datetime, -- start_datetime + 5 hours
"deadlineDateTime", -- start_datetime - 3 days
self_rogaining, -- False
status, -- 'public'
public, -- True
hour_5, -- True
hour_3, -- False
class_general, -- True
class_family, -- True
class_solo_male, -- True
class_solo_female, -- True
event_code, -- gifuroge.event_table.event_code (MobServer統合)
start_time, -- gifuroge.event_table.start_time (MobServer統合)
event_day -- gifuroge.event_table.event_day (MobServer統合)
)
SELECT
et.event_code as event_name,
et.event_name as event_description,
CASE
WHEN et.start_time IS NULL OR et.start_time = '' THEN
(et.event_day || ' 09:00:00')::timestamp AT TIME ZONE 'Asia/Tokyo'
ELSE
(et.event_day || ' ' || et.start_time || ':00')::timestamp AT TIME ZONE 'Asia/Tokyo'
END as start_datetime,
CASE
WHEN et.start_time IS NULL OR et.start_time = '' THEN
(et.event_day || ' 09:00:00')::timestamp AT TIME ZONE 'Asia/Tokyo' + INTERVAL '5 hours'
ELSE
(et.event_day || ' ' || et.start_time || ':00')::timestamp AT TIME ZONE 'Asia/Tokyo' + INTERVAL '5 hours'
END as end_datetime,
CASE
WHEN et.start_time IS NULL OR et.start_time = '' THEN
(et.event_day || ' 09:00:00')::timestamp AT TIME ZONE 'Asia/Tokyo' - INTERVAL '3 days'
ELSE
(et.event_day || ' ' || et.start_time || ':00')::timestamp AT TIME ZONE 'Asia/Tokyo' - INTERVAL '3 days'
END as deadline_datetime,
false as self_rogaining, -- 指定条件
'public' as status, -- デフォルトステータス
true as public, -- 公開設定
true as hour_5, -- 5時間イベント
false as hour_3, -- 3時間イベントではない
true as class_general, -- 一般クラス有効
true as class_family, -- ファミリークラス有効
true as class_solo_male, -- 男子ソロクラス有効
true as class_solo_female, -- 女子ソロクラス有効
et.event_code, -- MobServer統合フィールド
et.start_time, -- MobServer統合フィールド
et.event_day -- MobServer統合フィールド
FROM dblink('gifuroge_conn',
'SELECT event_code, event_name, start_time, event_day
FROM event_table
WHERE event_day < ''2024-10-01''
AND event_code IS NOT NULL
AND event_code != ''''
ORDER BY event_day'
) AS et(event_code text, event_name text, start_time text, event_day text)
WHERE NOT EXISTS (
SELECT 1 FROM rog_newevent2 WHERE event_name = et.event_code
);
*/
-- dblinkの切断
-- SELECT dblink_disconnect('gifuroge_conn');
-- Step 3: 移行結果の確認
SELECT
id,
event_name,
event_description,
start_datetime,
end_datetime,
"deadlineDateTime",
self_rogaining,
status,
event_code,
start_time,
event_day
FROM rog_newevent2
WHERE self_rogaining = false
AND event_code IS NOT NULL
ORDER BY start_datetime;
-- 移行件数の確認
SELECT
COUNT(*) as total_migrated_events
FROM rog_newevent2
WHERE self_rogaining = false
AND event_code IS NOT NULL;
-- 注意事項:
-- 1. 上記のSQLは例であり、実際の実行環境に応じて調整が必要です
-- 2. dblinkを使用しない場合は、ETLツールやアプリケーションレベルでの移行を推奨します
-- 3. "その他=True"に相当するフィールドが見つからない場合、新しいフィールドの追加を検討してください
-- 4. 実行前に必ずバックアップを取ってください

256
migrate_fc_gifu_complete.py Normal file
View File

@ -0,0 +1,256 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への包括的FC岐阜データ移行スクリプト
Team → Member → Entry の順序で移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser, Member
from datetime import datetime
import psycopg2
print("=== FC岐阜包括データ移行（Team→Member→Entry順序）===")
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
# FC岐阜イベントを確認
fc_event = NewEvent2.objects.filter(id=10).first()
if not fc_event:
print("❌ FC岐阜イベント（ID:10）が見つかりません")
old_conn.close()
sys.exit(1)
print(f"✅ FC岐阜イベント: {fc_event.event_name}")
print(f" 期間: {fc_event.start_datetime} - {fc_event.end_datetime}")
with old_conn.cursor() as old_cursor:
# Step 1: FC岐阜のチームデータを取得・移行
print("\\n=== Step 1: チーム移行 ===")
old_cursor.execute("""
SELECT DISTINCT rt.id, rt.team_name, rt.owner_id, rt.category_id,
rc.category_name, rt.password, rt.trial
FROM rog_team rt
JOIN rog_entry re ON rt.id = re.team_id
LEFT JOIN rog_newcategory rc ON rt.category_id = rc.id
WHERE re.event_id = 10
ORDER BY rt.id;
""")
team_data = old_cursor.fetchall()
print(f"FC岐阜関連チーム: {len(team_data)}件")
team_created_count = 0
team_errors = 0
for team_id, team_name, owner_id, cat_id, cat_name, password, trial in team_data:
try:
# カテゴリを取得または作成
category = None
if cat_id and cat_name:
category, cat_created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if cat_created:
print(f" カテゴリ作成: {cat_name}")
# チームを作成（メンバー制約を一時的に無視）
team, team_created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': fc_event.id,
'password': password or '',
'trial': trial or False
}
)
if team_created:
print(f" ✅ チーム作成: {team_name} (ID: {team_id})")
team_created_count += 1
else:
print(f" 🔄 既存チーム: {team_name} (ID: {team_id})")
except Exception as e:
team_errors += 1
print(f" ❌ チームエラー: {team_name} - {e}")
# Step 2: メンバーデータを取得・移行
print(f"\\n=== Step 2: メンバー移行 ===")
old_cursor.execute("""
SELECT rm.id, rm.team_id, rm.user_id, cu.firstname, cu.lastname, cu.email
FROM rog_member rm
JOIN rog_team rt ON rm.team_id = rt.id
JOIN rog_entry re ON rt.id = re.team_id
LEFT JOIN rog_customuser cu ON rm.user_id = cu.id
WHERE re.event_id = 10
ORDER BY rm.team_id, rm.id;
""")
member_data = old_cursor.fetchall()
print(f"FC岐阜関連メンバー: {len(member_data)}件")
member_created_count = 0
member_errors = 0
for member_id, team_id, user_id, firstname, lastname, email in member_data:
try:
# チームを取得
team = Team.objects.get(id=team_id)
# ユーザーを取得または作成
user = None
if user_id:
try:
user = CustomUser.objects.get(id=user_id)
except CustomUser.DoesNotExist:
# ユーザーが存在しない場合は作成
user = CustomUser.objects.create(
id=user_id,
email=email or f"user{user_id}@example.com",
firstname=firstname or "名前",
lastname=lastname or "苗字",
is_active=True
)
print(f" ユーザー作成: {firstname} {lastname}")
# メンバーを作成
member, member_created = Member.objects.get_or_create(
team=team,
user=user,
defaults={}
)
if member_created:
print(f" ✅ メンバー作成: {firstname} {lastname} -> {team.team_name}")
member_created_count += 1
else:
print(f" 🔄 既存メンバー: {firstname} {lastname} -> {team.team_name}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません")
except Exception as e:
member_errors += 1
print(f" ❌ メンバーエラー: {firstname} {lastname} - {e}")
# Step 3: エントリーデータを移行
print(f"\\n=== Step 3: エントリー移行 ===")
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = 10
ORDER BY re.zekken_number;
""")
entry_data = old_cursor.fetchall()
print(f"FC岐阜エントリー: {len(entry_data)}件")
entry_created_count = 0
entry_errors = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in entry_data:
try:
# チームを取得
team = Team.objects.get(id=team_id)
# カテゴリを取得
category = None
if cat_id:
try:
category = NewCategory.objects.get(id=cat_id)
except NewCategory.DoesNotExist:
pass
# 日時を調整（イベント期間内に設定）
entry_date = fc_event.start_datetime
if date:
try:
# 既存の日付がイベント期間内かチェック
if fc_event.start_datetime.date() <= date.date() <= fc_event.end_datetime.date():
entry_date = date
except:
pass
# エントリーを作成
entry, entry_created = Entry.objects.get_or_create(
team=team,
event=fc_event,
defaults={
'category': category,
'date': entry_date,
'owner_id': owner_id or 1,
'zekken_number': int(zekken) if zekken else 0,
'zekken_label': label or f"FC岐阜-{zekken}",
'is_active': True,
'hasParticipated': False,
'hasGoaled': False
}
)
if entry_created:
print(f" ✅ エントリー作成: {team_name} - ゼッケン{zekken}")
entry_created_count += 1
else:
print(f" 🔄 既存エントリー: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません: {team_name}")
entry_errors += 1
except Exception as e:
entry_errors += 1
print(f" ❌ エントリーエラー: {team_name} - {e}")
old_conn.close()
print(f"\\n=== 移行完了統計 ===")
print(f"チーム作成: {team_created_count}件 (エラー: {team_errors}件)")
print(f"メンバー作成: {member_created_count}件 (エラー: {member_errors}件)")
print(f"エントリー作成: {entry_created_count}件 (エラー: {entry_errors}件)")
# 最終確認
fc_entries = Entry.objects.filter(event=fc_event).order_by('zekken_number')
print(f"\\n🎉 FC岐阜イベント総エントリー: {fc_entries.count()}件")
if fc_entries.exists():
print("\\nゼッケン番号一覧（最初の10件）:")
for entry in fc_entries[:10]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
if fc_entries.count() > 10:
print(f" ... 他 {fc_entries.count() - 10}件")
print("\\n🎉 FC岐阜イベントのゼッケン番号表示問題が解決されました！")
print("🎯 通過審査管理画面でFC岐阜を選択すると、参加者のゼッケン番号が表示されるようになります。")
else:
print("❌ エントリーが作成されませんでした")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

185
migrate_fc_gifu_only.py Normal file
View File

@ -0,0 +1,185 @@
#!/usr/bin/env python
"""
FC岐阜イベント限定データ移行スクリプト
FC岐阜イベントに関連するチーム・エントリーのみを移行して問題を解決
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connection
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser
print("=== FC岐阜イベント限定データ移行 ===")
try:
# FC岐阜イベントを確認
fc_event = NewEvent2.objects.filter(event_name__icontains='FC岐阜').first()
if not fc_event:
print("❌ FC岐阜イベントが見つかりません")
sys.exit(1)
print(f"✅ FC岐阜イベント: {fc_event.event_name} (ID: {fc_event.id})")
with connection.cursor() as cursor:
# まず、全体的なデータ構造を確認
print("\\n=== データベース構造調査 ===")
# 1. rog_entry テーブルの全体状況
cursor.execute("SELECT COUNT(*) FROM rog_entry;")
total_entries = cursor.fetchone()[0]
print(f"総エントリー数: {total_entries}件")
# 2. rog_entry のフィールド構造確認
cursor.execute("""
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'rog_entry'
ORDER BY ordinal_position;
""")
entry_columns = cursor.fetchall()
print("\\nrog_entry テーブル構造:")
for col_name, data_type, nullable in entry_columns:
print(f" - {col_name}: {data_type} {'(NULL可)' if nullable == 'YES' else '(NOT NULL)'}")
# 3. rog_team テーブルも確認（ゼッケン情報がチーム側にある可能性）
cursor.execute("""
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'rog_team'
ORDER BY ordinal_position;
""")
team_columns = cursor.fetchall()
print("\\nrog_team テーブル構造:")
for col_name, data_type, nullable in team_columns:
if 'zekken' in col_name.lower() or 'number' in col_name.lower():
print(f" 🎯 {col_name}: {data_type} {'(NULL可)' if nullable == 'YES' else '(NOT NULL)'}")
else:
print(f" - {col_name}: {data_type}")
# 4. イベント別エントリー数確認
cursor.execute("""
SELECT e.id, e.event_name, COUNT(re.id) as entry_count
FROM rog_newevent2 e
LEFT JOIN rog_entry re ON e.id = re.event_id
GROUP BY e.id, e.event_name
ORDER BY entry_count DESC
LIMIT 10;
""")
event_entries = cursor.fetchall()
print("\\n=== イベント別エントリー数（上位10件） ===")
for event_id, event_name, count in event_entries:
print(f" Event {event_id}: '{event_name}' - {count}件")
# 5. FC岐阜関連のより広範囲な検索
cursor.execute("""
SELECT re.*, rt.team_name, rt.zekken_number as team_zekken
FROM rog_entry re
JOIN rog_newevent2 e ON re.event_id = e.id
JOIN rog_team rt ON re.team_id = rt.id
WHERE e.event_name LIKE '%FC岐阜%' OR e.event_name LIKE '%fc岐阜%' OR e.event_name LIKE '%FC%'
LIMIT 20;
""")
fc_entry_data = cursor.fetchall()
print(f"\\n✅ FC岐阜関連エントリー（広範囲検索）: {len(fc_entry_data)}件")
if fc_entry_data:
print("\\n🔍 FC岐阜関連データ詳細:")
for row in fc_entry_data[:5]: # 最初の5件を表示
print(f" Entry ID: {row[0]}, Team: {row[-2]}, Team Zekken: {row[-1]}")
# 6. チームテーブルでゼッケン番号がある場合を確認
cursor.execute("""
SELECT rt.id, rt.team_name, rt.zekken_number, rt.event_id
FROM rog_team rt
JOIN rog_newevent2 e ON rt.event_id = e.id
WHERE e.event_name LIKE '%FC岐阜%'
AND rt.zekken_number IS NOT NULL
AND rt.zekken_number != ''
ORDER BY CAST(rt.zekken_number AS INTEGER)
LIMIT 20;
""")
team_zekken_data = cursor.fetchall()
print(f"\\n✅ FC岐阜チームのゼッケン番号: {len(team_zekken_data)}件")
if team_zekken_data:
print("\\n🎯 チーム側のゼッケン番号データ:")
for team_id, team_name, zekken, event_id in team_zekken_data[:10]:
print(f" チーム{team_id}: {team_name} - ゼッケン{zekken}")
# チーム側にゼッケン情報がある場合、それを使ってエントリーを作成
print("\\n=== チーム側ゼッケン情報からエントリー作成 ===")
created_entries = 0
for team_id, team_name, zekken, event_id in team_zekken_data:
# チームを取得
try:
team = Team.objects.get(id=team_id)
# エントリーを作成
entry, entry_created = Entry.objects.get_or_create(
team=team,
event=fc_event,
defaults={
'category': team.category,
'date': fc_event.start_datetime,
'owner': team.owner,
'zekken_number': int(zekken) if zekken.isdigit() else 0,
'zekken_label': f"FC岐阜-{zekken}",
'is_active': True,
'hasParticipated': False,
'hasGoaled': False
}
)
if entry_created:
created_entries += 1
print(f" エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が新DBに存在しません: {team_name}")
except Exception as e:
print(f" ❌ エラー: {e}")
print(f"\\n✅ 作成されたエントリー: {created_entries}件")
else:
print("❌ チーム側にもゼッケン情報がありません")
# 7. 最終確認
fc_entries = Entry.objects.filter(event=fc_event).order_by('zekken_number')
print(f"\\n=== 最終結果 ===")
print(f"FC岐阜イベント総エントリー: {fc_entries.count()}件")
if fc_entries.exists():
print("\\n🎉 ゼッケン番号一覧（最初の10件）:")
for entry in fc_entries[:10]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
print("\\n🎉 FC岐阜イベントのゼッケン番号表示問題が解決されました！")
else:
print("\\n❌ まだエントリーデータがありません")
# 8. デバッグ用：全てのチームデータを確認
all_teams = Team.objects.all()[:10]
print(f"\\n🔍 新DBの全チーム（最初の10件、総数: {Team.objects.count()}件）:")
for team in all_teams:
entries = Entry.objects.filter(team=team)
print(f" Team {team.id}: {team.team_name} (エントリー: {entries.count()}件)")
# 9. FC岐阜イベントの詳細情報
print(f"\\n🔍 FC岐阜イベント詳細:")
print(f" ID: {fc_event.id}")
print(f" 名前: {fc_event.event_name}")
print(f" 開始日: {fc_event.start_datetime}")
print(f" 終了日: {fc_event.end_datetime}")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

300
migrate_fc_gifu_step_by_step.py Normal file
View File

@ -0,0 +1,300 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb への段階的FC岐阜データ移行スクリプト
1. Team/Member → 2. Entry の順序で移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import transaction
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser, Member
import psycopg2
print("=== old_rogdb から FC岐阜データ段階的移行 ===")
try:
# old_rogdbに直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
# FC岐阜イベントを確認
fc_event = NewEvent2.objects.filter(id=10).first()
if not fc_event:
print("❌ FC岐阜イベント（ID:10）が見つかりません")
old_conn.close()
sys.exit(1)
print(f"✅ FC岐阜イベント: {fc_event.event_name}")
with old_conn.cursor() as old_cursor:
# === STEP 1: Team & Member データ取得 ===
print("\\n=== STEP 1: Team & Member データ取得 ===")
# FC岐阜関連のチーム情報を取得
old_cursor.execute("""
SELECT DISTINCT rt.id, rt.team_name, rt.owner_id, rt.category_id,
rc.category_name, cu.email, cu.firstname, cu.lastname
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON rt.category_id = rc.id
LEFT JOIN rog_customuser cu ON rt.owner_id = cu.id
WHERE re.event_id = 10
ORDER BY rt.id;
""")
team_data = old_cursor.fetchall()
print(f"FC岐阜関連チーム: {len(team_data)}件")
# チームメンバー情報を取得
old_cursor.execute("""
SELECT rm.team_id, rm.user_id, cu.email, cu.firstname, cu.lastname
FROM rog_entry re
JOIN rog_member rm ON re.team_id = rm.team_id
JOIN rog_customuser cu ON rm.user_id = cu.id
WHERE re.event_id = 10
ORDER BY rm.team_id, rm.user_id;
""")
member_data = old_cursor.fetchall()
print(f"FC岐阜関連メンバー: {len(member_data)}件")
# チーム別メンバー数を確認
team_member_count = {}
for team_id, user_id, email, first_name, last_name in member_data:
if team_id not in team_member_count:
team_member_count[team_id] = 0
team_member_count[team_id] += 1
print("\\nチーム別メンバー数:")
for team_id, count in team_member_count.items():
print(f" Team {team_id}: {count}名")
# === STEP 2: ユーザー移行 ===
print("\\n=== STEP 2: ユーザー移行 ===")
# 関連するすべてのユーザーを取得
all_user_ids = set()
for _, _, owner_id, _, _, _, _, _ in team_data:
if owner_id:
all_user_ids.add(owner_id)
for _, user_id, _, _, _ in member_data:
all_user_ids.add(user_id)
if all_user_ids:
old_cursor.execute(f"""
SELECT id, email, firstname, lastname, date_joined
FROM rog_customuser
WHERE id IN ({','.join(map(str, all_user_ids))})
""")
user_data = old_cursor.fetchall()
print(f"移行対象ユーザー: {len(user_data)}件")
migrated_users = 0
for user_id, email, first_name, last_name, date_joined in user_data:
user, created = CustomUser.objects.get_or_create(
id=user_id,
defaults={
'email': email or f'user{user_id}@example.com',
'first_name': first_name or '',
'last_name': last_name or '',
'username': email or f'user{user_id}',
'date_joined': date_joined,
'is_active': True
}
)
if created:
migrated_users += 1
print(f" ユーザー作成: {email} ({first_name} {last_name})")
print(f"✅ ユーザー移行完了: {migrated_users}件作成")
# === STEP 3: カテゴリ移行 ===
print("\\n=== STEP 3: カテゴリ移行 ===")
migrated_categories = 0
for _, _, _, cat_id, cat_name, _, _, _ in team_data:
if cat_id and cat_name:
category, created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if created:
migrated_categories += 1
print(f" カテゴリ作成: {cat_name}")
print(f"✅ カテゴリ移行完了: {migrated_categories}件作成")
# === STEP 4: チーム移行 ===
print("\\n=== STEP 4: チーム移行 ===")
migrated_teams = 0
for team_id, team_name, owner_id, cat_id, cat_name, email, first_name, last_name in team_data:
try:
# カテゴリを取得
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# チームを作成
team, created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': fc_event.id
}
)
if created:
migrated_teams += 1
print(f" チーム作成: {team_name} (ID: {team_id})")
except Exception as e:
print(f" ❌ チーム作成エラー: {team_name} - {e}")
print(f"✅ チーム移行完了: {migrated_teams}件作成")
# === STEP 5: メンバー移行 ===
print("\\n=== STEP 5: メンバー移行 ===")
migrated_members = 0
for team_id, user_id, email, first_name, last_name in member_data:
try:
# チームとユーザーを取得
team = Team.objects.get(id=team_id)
user = CustomUser.objects.get(id=user_id)
# メンバーを作成
member, created = Member.objects.get_or_create(
team=team,
user=user
)
if created:
migrated_members += 1
print(f" メンバー追加: {email} → {team.team_name}")
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません")
except CustomUser.DoesNotExist:
print(f" ⚠️ ユーザー{user_id}が見つかりません")
except Exception as e:
print(f" ❌ メンバー追加エラー: {e}")
print(f"✅ メンバー移行完了: {migrated_members}件作成")
# === STEP 6: エントリー移行 ===
print("\\n=== STEP 6: エントリー移行 ===")
# まず、現在のDBのis_trialフィールドにデフォルト値を設定
print("データベーステーブルのis_trialフィールドを修正中...")
from django.db import connection as django_conn
with django_conn.cursor() as django_cursor:
try:
# is_trialフィールドにデフォルト値を設定
django_cursor.execute("""
ALTER TABLE rog_entry
ALTER COLUMN is_trial SET DEFAULT FALSE;
""")
print(" ✅ is_trialフィールドにデフォルト値を設定")
except Exception as e:
print(f" ⚠️ is_trial修正エラー: {e}")
# FC岐阜エントリーデータを取得
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = 10
ORDER BY re.zekken_number;
""")
entry_data = old_cursor.fetchall()
migrated_entries = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in entry_data:
try:
# チームとカテゴリを取得
team = Team.objects.get(id=team_id)
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# まず既存のエントリーをチェック
existing_entry = Entry.objects.filter(team=team, event=fc_event).first()
if existing_entry:
print(f" 🔄 既存エントリー: {team_name} - ゼッケン{existing_entry.zekken_number}")
continue
# SQLで直接エントリーを挿入
from django.db import connection as django_conn
with django_conn.cursor() as django_cursor:
django_cursor.execute("""
INSERT INTO rog_entry
(date, category_id, event_id, owner_id, team_id, is_active,
zekken_number, "hasGoaled", "hasParticipated", zekken_label,
is_trial, staff_privileges, can_access_private_events, team_validation_status)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);
""", [
fc_event.start_datetime, # date
cat_id, # category_id
fc_event.id, # event_id
owner_id or 1, # owner_id
team_id, # team_id
True, # is_active
int(zekken) if zekken else 0, # zekken_number
False, # hasGoaled
False, # hasParticipated
label or f"FC岐阜-{zekken}", # zekken_label
False, # is_trial
False, # staff_privileges
False, # can_access_private_events
'approved' # team_validation_status
])
migrated_entries += 1
print(f" ✅ エントリー作成: {team_name} - ゼッケン{zekken}")
except Team.DoesNotExist:
print(f" ❌ チーム{team_id}が見つかりません: {team_name}")
except Exception as e:
print(f" ❌ エントリー作成エラー: {team_name} - {e}")
print(f"✅ エントリー移行完了: {migrated_entries}件作成")
old_conn.close()
# === 最終確認 ===
print("\\n=== 移行結果確認 ===")
fc_entries = Entry.objects.filter(event=fc_event).order_by('zekken_number')
print(f"FC岐阜イベント総エントリー: {fc_entries.count()}件")
if fc_entries.exists():
print("\\n🎉 ゼッケン番号一覧（最初の10件）:")
for entry in fc_entries[:10]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
print("\\n🎉 FC岐阜イベントのゼッケン番号表示問題が解決されました！")
print("\\n🎯 通過審査管理画面でFC岐阜を選択すると、ゼッケン番号が表示されるようになります。")
else:
print("❌ エントリーデータの移行に失敗しました")
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

300
migrate_gps_information.py Normal file
View File

@ -0,0 +1,300 @@
#!/usr/bin/env python3
"""
GPS情報（通過データ）移行スクリプト
gifurogeのgps_informationテーブルから新しいrogdbシステムに通過データを移行
"""
import os
import sys
import django
from datetime import datetime
import psycopg2
from django.utils import timezone
from django.db import transaction
# Django設定
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from rog.models import (
GpsLog, GpsCheckin, CheckinExtended, Entry, NewEvent2,
CustomUser, Team, Waypoint, Location2025
)
class GpsInformationMigrator:
def __init__(self):
# 環境変数から接続情報を取得
self.gifuroge_conn_params = {
'host': os.environ.get('PG_HOST', 'postgres-db'),
'database': 'gifuroge',
'user': os.environ.get('POSTGRES_USER', 'postgres'),
'password': os.environ.get('POSTGRES_PASS', 'password'),
'port': os.environ.get('PG_PORT', 5432),
}
# 統計情報
self.stats = {
'total_gps_info': 0,
'migrated_gps_logs': 0,
'migrated_checkins': 0,
'skipped_records': 0,
'errors': 0,
'error_details': []
}
def connect_to_gifuroge(self):
"""gifurogeデータベースに接続"""
try:
conn = psycopg2.connect(**self.gifuroge_conn_params)
return conn
except Exception as e:
print(f"❌ gifurogeデータベース接続エラー: {e}")
return None
def get_gps_information_data(self):
"""gifurogeのgps_informationデータを取得"""
conn = self.connect_to_gifuroge()
if not conn:
return []
try:
cursor = conn.cursor()
# まずテーブル構造を確認
cursor.execute("""
SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = 'gps_information'
AND table_schema = 'public'
ORDER BY ordinal_position;
""")
columns = cursor.fetchall()
print("=== gps_information テーブル構造 ===")
for col in columns:
print(f"- {col[0]}: {col[1]}")
# データ数確認
cursor.execute("SELECT COUNT(*) FROM gps_information;")
total_count = cursor.fetchone()[0]
self.stats['total_gps_info'] = total_count
print(f"\n📊 gps_information 総レコード数: {total_count}")
if total_count == 0:
print("⚠️ gps_informationテーブルにデータがありません")
return []
# 全データを取得（テーブル構造に合わせて修正）
cursor.execute("""
SELECT
serial_number, zekken_number, event_code, cp_number,
image_address, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, minus_photo_flag, colabo_company_memo
FROM gps_information
ORDER BY create_at, serial_number;
""")
data = cursor.fetchall()
print(f"✅ {len(data)}件のgps_informationデータを取得しました")
return data
except Exception as e:
print(f"❌ データ取得エラー: {e}")
self.stats['errors'] += 1
self.stats['error_details'].append(f"データ取得エラー: {e}")
return []
finally:
if conn:
conn.close()
def find_matching_entry(self, zekken_number, event_code):
"""ゼッケン番号とイベントコードからEntryを検索"""
try:
# NewEvent2でイベントを検索
events = NewEvent2.objects.filter(event_name__icontains=event_code)
if not events.exists():
# イベントコードの部分一致で検索
events = NewEvent2.objects.filter(
event_name__icontains=event_code.replace('_', ' ')
)
for event in events:
# ゼッケン番号でEntryを検索
entries = Entry.objects.filter(
event=event,
zekken_number=zekken_number
)
if entries.exists():
return entries.first()
# 見つからない場合はNone
return None
except Exception as e:
print(f"⚠️ Entry検索エラー (ゼッケン: {zekken_number}, イベント: {event_code}): {e}")
return None
def find_matching_location(self, cp_number):
"""CP番号からLocationを検索"""
try:
if not cp_number:
return None
# Location2025から検索
locations = Location2025.objects.filter(cp_number=cp_number)
if locations.exists():
return locations.first()
# 部分一致で検索
locations = Location2025.objects.filter(cp_number__icontains=str(cp_number))
if locations.exists():
return locations.first()
return None
except Exception as e:
print(f"⚠️ Location検索エラー (CP: {cp_number}): {e}")
return None
def migrate_gps_record(self, record):
"""個別のGPS記録を移行"""
try:
(serial_number, zekken_number, event_code, cp_number,
image_address, goal_time, late_point,
create_at, create_user, update_at, update_user,
buy_flag, minus_photo_flag, colabo_company_memo) = record
# checkin_timeはcreate_atを使用
checkin_time = create_at or timezone.now()
# Entryを検索
entry = self.find_matching_entry(zekken_number, event_code)
if not entry:
print(f"⚠️ Entry未発見: ゼッケン{zekken_number}, イベント{event_code}")
self.stats['skipped_records'] += 1
return False
# Locationを検索（オプション）
location = self.find_matching_location(cp_number) if cp_number else None
# 既存のGpsLogをチェック
existing_log = GpsLog.objects.filter(
zekken_number=str(zekken_number),
event_code=event_code,
checkin_time=checkin_time
).first()
if existing_log:
print(f"⚠️ 既存記録をスキップ: ゼッケン{zekken_number}, {checkin_time}")
self.stats['skipped_records'] += 1
return False
# GpsLogを作成
gps_log = GpsLog.objects.create(
serial_number=serial_number or 0,
zekken_number=str(zekken_number),
event_code=event_code,
cp_number=str(cp_number) if cp_number else '',
image_address=image_address or '',
checkin_time=checkin_time,
goal_time=goal_time or '',
late_point=late_point or 0,
create_at=create_at or timezone.now(),
create_user=create_user or '',
update_at=update_at or timezone.now(),
update_user=update_user or '',
buy_flag=buy_flag or False,
minus_photo_flag=minus_photo_flag or False,
colabo_company_memo=colabo_company_memo or '',
is_service_checked=False, # デフォルト値
score=0, # デフォルト値
scoreboard_url='' # デフォルト値
)
self.stats['migrated_gps_logs'] += 1
# CheckinExtendedも作成（通過記録として）
if cp_number and location:
try:
checkin_extended = CheckinExtended.objects.create(
entry=entry,
location=location,
checkin_time=checkin_time,
image_url=image_address or '',
score_override=0, # デフォルト値
notes=f"移行データ: {colabo_company_memo}",
is_verified=False # デフォルト値
)
self.stats['migrated_checkins'] += 1
print(f"✅ チェックイン記録作成: ゼッケン{zekken_number}, CP{cp_number}")
except Exception as e:
print(f"⚠️ CheckinExtended作成エラー: {e}")
print(f"✅ GPS記録移行完了: ゼッケン{zekken_number}, {checkin_time}")
return True
except Exception as e:
print(f"❌ GPS記録移行エラー: {e}")
self.stats['errors'] += 1
self.stats['error_details'].append(f"GPS記録移行エラー: {e}")
return False
def run_migration(self):
"""メイン移行処理"""
print("🚀 GPS情報移行スクリプト開始")
print("=" * 50)
# gifurogeからデータを取得
gps_data = self.get_gps_information_data()
if not gps_data:
print("❌ 移行するデータがありません")
return
print(f"\n📋 {len(gps_data)}件のGPS記録の移行を開始...")
# バッチ処理で移行
batch_size = 100
total_batches = (len(gps_data) + batch_size - 1) // batch_size
for batch_num in range(total_batches):
start_idx = batch_num * batch_size
end_idx = min(start_idx + batch_size, len(gps_data))
batch_data = gps_data[start_idx:end_idx]
print(f"\n📦 バッチ {batch_num + 1}/{total_batches} ({len(batch_data)}件) 処理中...")
with transaction.atomic():
for record in batch_data:
self.migrate_gps_record(record)
# 統計レポート
self.print_migration_report()
def print_migration_report(self):
"""移行結果レポート"""
print("\n" + "=" * 50)
print("📊 GPS情報移行完了レポート")
print("=" * 50)
print(f"📋 総GPS記録数: {self.stats['total_gps_info']}")
print(f"✅ 移行済みGpsLog: {self.stats['migrated_gps_logs']}")
print(f"✅ 移行済みCheckin: {self.stats['migrated_checkins']}")
print(f"⚠️ スキップ記録: {self.stats['skipped_records']}")
print(f"❌ エラー数: {self.stats['errors']}")
if self.stats['error_details']:
print("\n❌ エラー詳細:")
for error in self.stats['error_details'][:10]: # 最初の10個だけ表示
print(f" - {error}")
if len(self.stats['error_details']) > 10:
print(f" ... 他 {len(self.stats['error_details']) - 10} 件")
success_rate = (self.stats['migrated_gps_logs'] / max(self.stats['total_gps_info'], 1)) * 100
print(f"\n📈 移行成功率: {success_rate:.1f}%")
print("=" * 50)
def main():
"""メイン実行関数"""
migrator = GpsInformationMigrator()
migrator.run_migration()
if __name__ == '__main__':
main()

293
migrate_old_fc_gifu_entries.py Normal file
View File

@ -0,0 +1,293 @@
#!/usr/bin/env python
"""
old_rogdb から rogdb へのFC岐阜エントリー移行スクリプト
old_rogdbのFC岐阜イベント（event_id=10）のゼッケン番号付きエントリーを移行
"""
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
django.setup()
from django.db import connections, transaction
from rog.models import NewEvent2, Team, Entry, NewCategory, CustomUser
print("=== old_rogdb から FC岐阜エントリー移行 ===")
try:
# データベース接続を取得
default_db = connections['default'] # rogdb
old_db = connections.databases.get('old_rogdb')
if not old_db:
print("❌ old_rogdb接続設定が見つかりません。別DB接続を試行します。")
# old_rogdbに直接接続してデータを取得
import psycopg2
# old_rogdbへの直接接続
old_conn = psycopg2.connect(
host='postgres-db',
database='old_rogdb',
user='admin',
password='admin123456'
)
print("✅ old_rogdbに接続成功")
with old_conn.cursor() as old_cursor:
# old_rogdbのFC岐阜エントリーデータを取得
old_cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id,
rc.category_name
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
LEFT JOIN rog_newcategory rc ON re.category_id = rc.id
WHERE re.event_id = 10
ORDER BY re.zekken_number;
""")
old_fc_data = old_cursor.fetchall()
print(f"\\n✅ old_rogdb FC岐阜エントリー: {len(old_fc_data)}件")
if old_fc_data:
print("\\nold_rogdb FC岐阜データサンプル（最初の5件）:")
for i, (entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name) in enumerate(old_fc_data[:5]):
print(f" {i+1}. Entry {entry_id}: Team '{team_name}' - ゼッケン{zekken} ({cat_name})")
# FC岐阜イベントを確認
fc_event = NewEvent2.objects.filter(id=10).first()
if not fc_event:
print("❌ FC岐阜イベント（ID:10）が見つかりません")
old_conn.close()
sys.exit(1)
print(f"\\n✅ FC岐阜イベント: {fc_event.event_name}")
# データ移行開始
print("\\n=== old_rogdb から rogdb へデータ移行開始 ===")
migrated_count = 0
error_count = 0
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id, cat_name in old_fc_data:
try:
with transaction.atomic():
# カテゴリを取得または作成
if cat_id and cat_name:
category, cat_created = NewCategory.objects.get_or_create(
id=cat_id,
defaults={
'category_name': cat_name,
'category_number': cat_id
}
)
if cat_created:
print(f" カテゴリ作成: {cat_name}")
else:
category = None
# チームを取得または作成
team, team_created = Team.objects.get_or_create(
id=team_id,
defaults={
'team_name': team_name,
'owner_id': owner_id or 1,
'category': category,
'event_id': fc_event.id
}
)
if team_created:
print(f" チーム作成: {team_name} (ID: {team_id})")
# エントリーを作成
entry, entry_created = Entry.objects.get_or_create(
team=team,
event=fc_event,
defaults={
'category': category,
'date': date or fc_event.start_datetime,
'owner_id': owner_id or 1,
'zekken_number': int(zekken) if zekken else 0,
'zekken_label': label or f"FC岐阜-{zekken}",
'is_active': True,
'hasParticipated': False,
'hasGoaled': False
}
)
if entry_created:
print(f" ✅ エントリー作成: {team_name} - ゼッケン{zekken}")
migrated_count += 1
else:
print(f" 🔄 既存エントリー: {team_name} - ゼッケン{zekken}")
except Exception as e:
error_count += 1
print(f" ❌ エラー: {team_name} - {e}")
old_conn.close()
print(f"\\n=== 移行完了 ===")
print(f"移行成功: {migrated_count}件")
print(f"エラー: {error_count}件")
# 最終確認
fc_entries = Entry.objects.filter(event=fc_event).order_by('zekken_number')
print(f"\\n🎉 FC岐阜イベント総エントリー: {fc_entries.count()}件")
if fc_entries.exists():
print("\\nゼッケン番号一覧（最初の10件）:")
for entry in fc_entries[:10]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
print("\\n🎉 FC岐阜イベントのゼッケン番号表示問題が解決されました！")
print("\\n🎯 通過審査管理画面でFC岐阜を選択すると、ゼッケン番号が表示されるようになります。")
else:
print("❌ old_rogdbにもFC岐阜エントリーデータがありません")
old_conn.close()
else:
# 通常のDjango接続設定がある場合の処理
with default_db.cursor() as cursor:
# まずold_rogdbスキーマが存在するか確認
cursor.execute("""
SELECT schema_name FROM information_schema.schemata
WHERE schema_name LIKE '%old%' OR schema_name LIKE '%rog%';
""")
schemas = cursor.fetchall()
print(f"利用可能なスキーマ: {schemas}")
# old_rogdbデータベースに直接接続を試行
cursor.execute("SELECT current_database();")
current_db = cursor.fetchone()[0]
print(f"現在のDB: {current_db}")
# データベース一覧を確認
cursor.execute("""
SELECT datname FROM pg_database
WHERE datistemplate = false AND datname != 'postgres';
""")
databases = cursor.fetchall()
print(f"利用可能なDB: {[db[0] for db in databases]}")
# old_rogdbのrog_entryデータを確認
try:
# 別データベースのテーブルにアクセスする方法を試行
cursor.execute("""
SELECT table_name FROM information_schema.tables
WHERE table_schema = 'public'
AND table_name LIKE '%entry%';
""")
entry_tables = cursor.fetchall()
print(f"エントリー関連テーブル: {entry_tables}")
# FC岐阜関連のエントリーデータを確認
# まず現在のDBで状況確認
cursor.execute("""
SELECT COUNT(*) FROM rog_entry WHERE event_id = 10;
""")
current_fc_entries = cursor.fetchone()[0]
print(f"現在のDB FC岐阜エントリー: {current_fc_entries}件")
if current_fc_entries > 0:
cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
WHERE re.event_id = 10
AND re.zekken_number IS NOT NULL
ORDER BY re.zekken_number
LIMIT 10;
""")
fc_data = cursor.fetchall()
print(f"\\n✅ FC岐阜エントリーデータ（最初の10件）:")
for entry_id, team_id, zekken, label, team_name, cat_id in fc_data:
print(f" Entry {entry_id}: Team {team_id} '{team_name}' - ゼッケン{zekken}")
# FC岐阜イベントを取得
fc_event = NewEvent2.objects.filter(id=10).first()
if not fc_event:
print("❌ FC岐阜イベント（ID:10）が見つかりません")
sys.exit(1)
print(f"\\n✅ FC岐阜イベント: {fc_event.event_name}")
# エントリーデータを新しいEntry modelに同期
print("\\n=== エントリーデータ同期開始 ===")
updated_count = 0
# 全FC岐阜エントリーを取得
cursor.execute("""
SELECT re.id, re.team_id, re.zekken_number, re.zekken_label,
rt.team_name, re.category_id, re.date, re.owner_id
FROM rog_entry re
JOIN rog_team rt ON re.team_id = rt.id
WHERE re.event_id = 10
ORDER BY re.zekken_number;
""")
all_fc_data = cursor.fetchall()
for entry_id, team_id, zekken, label, team_name, cat_id, date, owner_id in all_fc_data:
try:
# チームを取得
team = Team.objects.get(id=team_id)
# カテゴリを取得
category = NewCategory.objects.get(id=cat_id) if cat_id else None
# エントリーを更新または作成
entry, created = Entry.objects.update_or_create(
team=team,
event=fc_event,
defaults={
'category': category,
'date': date or fc_event.start_datetime,
'owner_id': owner_id,
'zekken_number': int(zekken) if zekken else 0,
'zekken_label': label or f"FC岐阜-{zekken}",
'is_active': True,
'hasParticipated': False,
'hasGoaled': False
}
)
if created:
print(f" ✅ エントリー作成: {team_name} - ゼッケン{zekken}")
else:
print(f" 🔄 エントリー更新: {team_name} - ゼッケン{zekken}")
updated_count += 1
except Team.DoesNotExist:
print(f" ⚠️ チーム{team_id}が見つかりません: {team_name}")
except Exception as e:
print(f" ❌ エラー: {e}")
print(f"\\n✅ 処理完了: {updated_count}件のエントリーを処理")
# 最終確認
fc_entries = Entry.objects.filter(event=fc_event).order_by('zekken_number')
print(f"\\n🎉 FC岐阜イベント総エントリー: {fc_entries.count()}件")
if fc_entries.exists():
print("\\nゼッケン番号一覧（最初の10件）:")
for entry in fc_entries[:10]:
print(f" ゼッケン{entry.zekken_number}: {entry.team.team_name}")
print("\\n🎉 FC岐阜イベントのゼッケン番号表示問題が解決されました！")
else:
print("❌ 現在のDBにFC岐阜エントリーデータがありません")
except Exception as e:
print(f"❌ データ確認エラー: {e}")
import traceback
traceback.print_exc()
except Exception as e:
print(f"❌ エラーが発生しました: {e}")
import traceback
traceback.print_exc()

70
migrate_specification.md Normal file
View File

@ -0,0 +1,70 @@
1. event
gifuroge: event_table key:event_code
rogdb: rog_newevent2 key:id (event_name=event_code)
１）
gifuroge.self_rogaining=Falseで、event_day<'2024-10-01'のデータをrogdb.rog_newevent2 に移行したい。
フィールドの移行条件は、
gifuroge.event_table.event_code を rogdb.rog_newevent2.event_name へ
gifuroge.event_table.event_name を rogdb.rog_newevent2.event_description へ
gifuroge.event_table.event_day+start_time を rogdb.rog_newevent2.start_datetime へ
gifuroge.event_table.event_day+start_time+5H を rogdb.rog_newevent2.end_datetime へ
gifuroge.event_table.event_day+start_time-3day を rogdb.rog_newevent2.deadlineDateTime へ
gifuroge.event_table.self_rogaining=False
gifuroge.event_table.class_family | class_general | class_solo_female | cla
ss_solo_male | hour_3 | hour_5 | public=True
である。
SQLで更新するようなスクリプトを作成しなさい。
=>
docker compose exec app python migrate_event_table_to_rog_newevent2.py
insert into rog_newevent2 (event_name,start_datetime,end_datetime,"deadlineDateTime",class_family,class_general,class_solo_female,class_solo_male,hour_3,hour_5,public, self_rogaining, event_description) values ('関ケ原','2022-07-30 01:00:00+00','2022-07-30 06:00:00+00','2022-07-25 06:00:00+00',True,True,True,True,True,True,True,False,'岐阜ロゲin関ケ原');
2. checkpoint
gifuroge: checkpoint_table key:event_code,cp_number
rogdb: rog_location key:id (groupにevent_codeが含まれている)
===以降はFC岐阜より後のもの（以前のものは別途移行が必要）====
3. user
4. team
gifuroge: team_table key:event_code,zekken_number
rogdb: rog_team key:id
team_table : zekken_number,event_code,team_name,class_name,password,trial
rogdb :
5. member
gifuroge:
rogdb: rog_member key:id, team_id
6. entry
gifuroge:
rogdb: rog_entry key:id,date,event_id,team_id,zekken_number ,zekken_label (=team.zekken_number)
7. checkin_history
gifuroge: (gps_detail) gps_information key:event_code,zekken_number,cp_number
rogdb: rog_gpscheckin key:
. checkin_image
gifuroge:
rogdb:
8. goal_image
gifuroge:
rogdb:
9. waypoint
gifuroge:
rogdb:

64
rog/models.py
View File

@ -7,6 +7,8 @@ from sre_constants import CH_LOCALE
from typing import ChainMap
from django.contrib.gis.db import models
from django.contrib.postgres.fields import ArrayField
from django.utils import timezone
from datetime import timedelta
try:
from django.db.models import JSONField
except ImportError:
@ -595,16 +597,50 @@ class NewEvent2(models.Model):
return False
return False
def get_default_end_datetime():
"""デフォルトの終了日時を取得"""
from datetime import timedelta
return timezone.now() + timedelta(days=1)
class NewEvent(models.Model):
event_name = models.CharField(max_length=255, primary_key=True)
start_datetime = models.DateTimeField(default=timezone.now)
end_datetime = models.DateTimeField()
end_datetime = models.DateTimeField(default=get_default_end_datetime)
def __str__(self):
return f"{self.event_name} - From:{self.start_datetime} To:{self.end_datetime}"
def get_default_category():
return NewCategory.objects.get_or_create(category_name="Default Category", category_number=1)[0].id
"""デフォルトカテゴリーを取得または作成"""
try:
return NewCategory.objects.get_or_create(
category_name="Default Category",
defaults={'category_number': 1}
)[0].id
except Exception:
return 1 # フェイルセーフ
def get_default_multipoint():
"""デフォルトのMultiPointを取得"""
try:
from django.contrib.gis.geos import MultiPoint, Point
return MultiPoint([Point(0, 0)])
except Exception:
return None
def get_default_event():
"""デフォルトイベントを取得または作成"""
try:
from datetime import timedelta
return NewEvent2.objects.get_or_create(
event_name="Default Event",
defaults={
'start_datetime': timezone.now(),
'end_datetime': timezone.now() + timedelta(days=1)
}
)[0].id
except Exception:
return 1 # フェイルセーフ
class Team(models.Model):
@ -700,9 +736,9 @@ class NewCategory(models.Model):
class Entry(models.Model):
team = models.ForeignKey(Team, on_delete=models.CASCADE)
event = models.ForeignKey(NewEvent2, on_delete=models.CASCADE)
category = models.ForeignKey(NewCategory, on_delete=models.CASCADE)
date = models.DateTimeField()
event = models.ForeignKey(NewEvent2, on_delete=models.CASCADE, default=get_default_event)
category = models.ForeignKey(NewCategory, on_delete=models.CASCADE, default=get_default_category)
date = models.DateTimeField(default=timezone.now)
owner = models.ForeignKey(CustomUser, on_delete=models.CASCADE,blank=True, null=True) # Akira 2024-7-24
zekken_number = models.IntegerField(default=0)
zekken_label = models.CharField(max_length=255, blank=True, null=True)
@ -1014,22 +1050,6 @@ class GpsCheckin(models.Model):
default='PENDING',
help_text="通過審査ステータス"
)
validation_comment = models.TextField(
null=True,
blank=True,
help_text="審査コメント"
)
validated_at = models.DateTimeField(
null=True,
blank=True,
help_text="審査実施日時"
)
validated_by = models.CharField(
max_length=255,
null=True,
blank=True,
help_text="審査実施者"
)
validation_comment = models.TextField(
null=True,
blank=True,
@ -1146,7 +1166,7 @@ class Location(models.Model):
created_at=models.DateTimeField(auto_now_add=True)
last_updated_user=models.ForeignKey(CustomUser, related_name="location_updated_user", on_delete=models.DO_NOTHING,blank=True, null=True)
last_updated_at=models.DateTimeField(auto_now=True)
geom=models.MultiPointField(srid=4326)
geom=models.MultiPointField(srid=4326, default=get_default_multipoint)
class Meta:
indexes = [