ra/odinsea-elixir
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2c3d0ab580a128342d1c2fbf167da709171899fd
odinsea-elixir/lib/odinsea/database/context.ex
Rooba 2c3d0ab580 fix login issue*
2026-02-25 12:26:26 -07:00

1981 lines
48 KiB
Elixir
Raw Blame History

defmodule Odinsea.Database.Context do
@moduledoc """
Database context module for Odinsea.
Provides high-level database operations for accounts, characters, and related entities.
Ported from Java UnifiedDB.java and MapleClient.java login functionality.
"""
require Logger
import Ecto.Query
alias Odinsea.Repo
alias Odinsea.Database.Schema.{
Account,
Character,
CharacterSlot,
InventoryItem,
Buddy,
Guild,
Skill,
QuestStatus,
QuestStatusMob,
QuestInfo,
Gift,
NxCode,
IpBan,
MacBan
}
alias Odinsea.Game.InventoryType
alias Odinsea.Net.Cipher.LoginCrypto
# ==================================================================================================
# Account Operations
# ==================================================================================================
@doc """
Authenticates a user with username and password.
Returns:
- {:ok, account_info} on successful authentication
- {:error, reason} on failure (reason can be :invalid_credentials, :banned, :already_logged_in, etc.)
Ported from MapleClient.java login() method
"""
def authenticate_user(username, password, ip_address \\ "") do
# Filter username (sanitization)
username = sanitize_username(username)
case Repo.get_by(Account, name: username) do
nil ->
Logger.warning("Login attempt for non-existent account: #{username}")
{:error, :account_not_found}
account ->
check_account_login(account, password, ip_address)
end
end
@doc """
Gets an account by name.
Returns nil if not found.
"""
def get_account_by_name(name) do
Repo.get_by(Account, name: name)
end
@doc """
Gets an account by ID.
Returns nil if not found.
"""
def get_account(account_id) do
Repo.get(Account, account_id)
end
@doc """
Updates all accounts to logged out state.
Used during server startup/shutdown.
"""
def set_all_accounts_logged_off do
Repo.update_all(Account, set: [loggedin: 0])
:ok
end
@doc """
Updates account login state.
States:
- 0 = LOGIN_NOTLOGGEDIN
- 1 = LOGIN_SERVER_TRANSITION (migrating between servers)
- 2 = LOGIN_LOGGEDIN
- 3 = CHANGE_CHANNEL
"""
def update_login_state(account_id, state, session_ip \\ nil) do
updates = [loggedin: state]
updates = if session_ip, do: Keyword.put(updates, :session_ip, session_ip), else: updates
Repo.update_all(
from(a in Account, where: a.id == ^account_id),
set: updates
)
:ok
end
@doc """
Updates account logged in status.
"""
def update_logged_in_status(account_id, status) do
Repo.update_all(
from(a in Account, where: a.id == ^account_id),
set: [loggedin: status]
)
:ok
end
@doc """
Gets the current login state for an account.
"""
def get_login_state(account_id) do
case Repo.get(Account, account_id) do
nil -> 0
account -> account.loggedin
end
end
@doc """
Updates account last login time.
"""
def update_last_login(account_id) do
now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
Repo.update_all(
from(a in Account, where: a.id == ^account_id),
set: [lastlogin: now]
)
:ok
end
@doc """
Bans an account.
Options:
- :banned - ban status (1 = banned, 2 = auto-banned)
- :banreason - reason for ban
- :tempban - temporary ban expiry datetime
- :greason - GM reason code
"""
def ban_account(account_id, attrs \\ %{}) do
case Repo.get(Account, account_id) do
nil ->
{:error, :not_found}
account ->
account
|> Account.ban_changeset(attrs)
|> Repo.update()
end
end
@doc """
Bans an account with explicit reason and duration (in days).
For permanent ban, set duration to nil or 0.
"""
def ban_account(account_id, reason, duration) do
attrs = %{
banned: 1,
banreason: reason
}
attrs =
if duration && duration > 0 do
tempban =
NaiveDateTime.utc_now()
|> NaiveDateTime.add(duration * 86400, :second)
|> NaiveDateTime.truncate(:second)
Map.put(attrs, :tempban, tempban)
else
attrs
end
ban_account(account_id, attrs)
end
@doc """
Checks if an IP address is banned.
Returns true if the IP is in the ipbans table.
"""
def ip_banned?(ip_address) do
IpBan
|> where([i], i.ip == ^ip_address)
|> Repo.exists?()
end
@doc """
Checks if a MAC address is banned.
Returns true if the MAC is in the macbans table.
"""
def mac_banned?(mac_address) do
MacBan
|> where([m], m.mac == ^mac_address)
|> Repo.exists?()
end
@doc """
Alias for log_ip_address/2.
Also known as ban_ip_address in some contexts.
"""
def ban_ip_address(ip_address, _reason \\ "", _is_mac \\ false, _times \\ 1) do
# For enforcement, we insert into ipbans table
# The original Java code logs and potentially bans
%IpBan{}
|> IpBan.changeset(%{ip: ip_address})
|> Repo.insert()
|> case do
{:ok, _} -> :ok
{:error, _} -> :error
end
end
@doc """
Updates the second password (SPW) for an account.
Input: account_id, hashed_password
"""
def update_second_password(account_id, hashed_password) do
Repo.update_all(
from(a in Account, where: a.id == ^account_id),
set: [second_password: hashed_password]
)
:ok
end
@doc """
Records an IP log entry for audit purposes.
"""
def log_ip_address(account_id, ip_address) do
timestamp = format_timestamp(NaiveDateTime.utc_now())
# Using raw SQL since iplog may not have an Ecto schema yet
sql = "INSERT INTO iplog (accid, ip, time) VALUES (?, ?, ?)"
case Ecto.Adapters.SQL.query(Repo, sql, [account_id, ip_address, timestamp]) do
{:ok, _} ->
:ok
{:error, err} ->
Logger.error("Failed to log IP: #{inspect(err)}")
:error
end
end
@doc """
Checks if an account is banned.
Returns {:ok, account} if not banned, {:error, :banned} if banned.
"""
def check_ban_status(account_id) do
case Repo.get(Account, account_id) do
nil ->
{:error, :not_found}
account ->
if account.banned > 0 do
{:error, :banned}
else
{:ok, account}
end
end
end
@doc """
Gets temporary ban information if account is temp banned.
"""
def get_temp_ban_info(account_id) do
case Repo.get(Account, account_id) do
nil ->
nil
account ->
if account.tempban &&
NaiveDateTime.compare(account.tempban, NaiveDateTime.utc_now()) == :gt do
%{reason: account.banreason, expires: account.tempban}
else
nil
end
end
end
@doc """
Updates account NX cash (ACash) and Maple Points.
"""
def update_account_cash(account_id, acash, mpoints, points \\ nil, vpoints \\ nil) do
updates = [acash: acash, mpoints: mpoints]
updates = if points, do: Keyword.put(updates, :points, points), else: updates
updates = if vpoints, do: Keyword.put(updates, :vpoints, vpoints), else: updates
Repo.update_all(
from(a in Account, where: a.id == ^account_id),
set: updates
)
:ok
end
# ==================================================================================================
# Cash Shop Operations
# ==================================================================================================
@doc """
Gets coupon information by code.
Input: coupon_code string
Output: {:ok, coupon} or {:error, reason}
"""
def get_coupon_info(coupon_code) do
case Repo.get(NxCode, coupon_code) do
nil -> {:error, :not_found}
coupon -> {:ok, coupon}
end
end
@doc """
Marks a coupon as used by an account.
Input: coupon_id (code string), account_id
Output: {:ok, _} or {:error, _}
"""
def mark_coupon_used(coupon_id, account_id) do
case Repo.get(NxCode, coupon_id) do
nil ->
{:error, :not_found}
coupon ->
# Mark as invalid (0) and set user to account name
# We need to look up the account name first
account = Repo.get(Account, account_id)
user_name = if account, do: account.name, else: ""
coupon
|> NxCode.changeset(%{valid: 0, user: user_name})
|> Repo.update()
end
end
@doc """
Increments character slots for an account in a world.
Input: account_id, amount (default 1)
Output: {:ok, new_slot_count} or {:error, _}
"""
def increment_character_slots(account_id, amount \\ 1, world_id \\ 0) do
case CharacterSlot
|> where([c], c.accid == ^account_id and c.worldid == ^world_id)
|> Repo.one() do
nil ->
# Create new slot record with default + amount
%CharacterSlot{}
|> CharacterSlot.changeset(%{
accid: account_id,
worldid: world_id,
charslots: 6 + amount
})
|> Repo.insert()
|> case do
{:ok, slot} -> {:ok, slot.charslots}
error -> error
end
slot ->
# Update existing
new_count = slot.charslots + amount
slot
|> CharacterSlot.changeset(%{charslots: new_count})
|> Repo.update()
|> case do
{:ok, _} -> {:ok, new_count}
error -> error
end
end
end
@doc """
Loads gifts for an account.
Input: account_id (used as recipient ID)
Output: {:ok, gifts} or {:error, _}
"""
def load_gifts(account_id) do
gifts =
Gift
|> where([g], g.recipient == ^account_id)
|> Repo.all()
{:ok, gifts}
end
@doc """
Creates a new gift (cash shop gift from one character to another).
## Parameters
- attrs: Map with keys:
- :recipient (required) - Account ID of the recipient
- :from (required) - Name of the sender
- :message (optional) - Gift message
- :sn (optional) - Cash shop serial number
- :uniqueid (optional) - Unique item ID
Output: {:ok, gift} or {:error, changeset}
"""
def create_gift(attrs) do
%Gift{}
|> Gift.changeset(attrs)
|> Repo.insert()
end
@doc """
Creates a new gift with explicit parameters.
Alternative to create_gift/1 for direct parameter passing.
## Parameters
- recipient_id: Account ID of the recipient
- from_name: Name of the sender
- message: Gift message
- sn: Cash shop serial number
- uniqueid: Unique item ID
"""
def create_gift(recipient_id, from_name, message \\ "", sn \\ 0, uniqueid \\ 0) do
attrs = %{
recipient: recipient_id,
from: from_name,
message: message,
sn: sn,
uniqueid: uniqueid
}
create_gift(attrs)
end
# ==================================================================================================
# Character Operations
# ==================================================================================================
@doc """
Loads character entries for an account in a specific world.
Returns a list of character summaries (id, name, gm level).
Ported from UnifiedDB.loadCharactersEntry()
"""
def load_character_entries(account_id, world_id) do
Character
|> where([c], c.accountid == ^account_id and c.world == ^world_id)
|> select([c], %{id: c.id, name: c.name, gm: c.gm})
|> Repo.all()
end
@doc """
Gets the count of characters for an account in a world.
"""
def character_count(account_id, world_id) do
Character
|> where([c], c.accountid == ^account_id and c.world == ^world_id)
|> Repo.aggregate(:count, :id)
end
@doc """
Gets all character IDs for an account in a world.
"""
def load_character_ids(account_id, world_id) do
Character
|> where([c], c.accountid == ^account_id and c.world == ^world_id)
|> select([c], c.id)
|> Repo.all()
end
@doc """
Gets all character names for an account in a world.
"""
def load_character_names(account_id, world_id) do
Character
|> where([c], c.accountid == ^account_id and c.world == ^world_id)
|> select([c], c.name)
|> Repo.all()
end
@doc """
Gets all characters for an account in a world.
Returns full Character structs.
"""
def get_characters_by_account(account_id, world_id) do
Character
|> where([c], c.accountid == ^account_id and c.world == ^world_id)
|> Repo.all()
end
@doc """
Loads full character data by ID.
Returns the Character struct or nil if not found.
TODO: Expand to load related data (inventory, skills, quests, etc.)
"""
def load_character(character_id) do
Repo.get(Character, character_id)
end
@doc """
Gets a character by ID.
Alias for load_character/1 with {:ok, character} or {:error, reason} return.
"""
def get_character(character_id) do
case Repo.get(Character, character_id) do
nil -> {:error, :not_found}
character -> {:ok, character}
end
end
@doc """
Updates character data.
Input: character_id, attrs map
Uses a generic update changeset that allows updating any character field.
"""
def update_character(character_id, attrs) do
case Repo.get(Character, character_id) do
nil ->
{:error, :not_found}
character ->
# Use a generic changeset that casts all valid character fields
changeset =
Ecto.Changeset.cast(character, attrs, [
:name,
:level,
:exp,
:str,
:dex,
:luk,
:int,
:hp,
:mp,
:maxhp,
:maxmp,
:ap,
:meso,
:fame,
:job,
:skincolor,
:gender,
:hair,
:face,
:map,
:spawnpoint,
:gm,
:party,
:buddy_capacity,
:guildid,
:guildrank,
:alliance_rank,
:guild_contribution,
:pets,
:sp,
:subcategory,
:rank,
:rank_move,
:job_rank,
:job_rank_move,
:marriage_id,
:familyid,
:seniorid,
:junior1,
:junior2,
:currentrep,
:totalrep,
:gachexp,
:fatigue,
:charm,
:craft,
:charisma,
:will,
:sense,
:insight,
:total_wins,
:total_losses,
:pvp_exp,
:pvp_points
])
Repo.update(changeset)
end
end
@doc """
Checks if a character name is already in use.
"""
def character_name_exists?(name) do
Character
|> where([c], c.name == ^name)
|> Repo.exists?()
end
@doc """
Gets character ID by name and world.
"""
def get_character_id(name, world_id) do
Character
|> where([c], c.name == ^name and c.world == ^world_id)
|> select([c], c.id)
|> Repo.one()
end
@doc """
Gets a character by name.
"""
def get_character_by_name(name) do
Repo.get_by(Character, name: name)
end
@doc """
Creates a new character.
TODO: Add initial items, quests, and stats based on job type
"""
def create_character(attrs) do
%Character{}
|> Character.creation_changeset(attrs)
|> Repo.insert()
end
@doc """
Deletes a character (soft delete - renames and moves to deleted world).
Returns {:ok, character} on success, {:error, reason} on failure.
Ported from UnifiedDB.deleteCharacter()
"""
def delete_character(character_id) do
# TODO: Check guild rank (can't delete if guild leader)
# TODO: Remove from family
# TODO: Handle sidekick
# WORLD_DELETED
deleted_world = -1
# Soft delete: rename with # prefix and move to deleted world
# Need to get the character name first to construct the new name
case Repo.get(Character, character_id) do
nil ->
{:error, :not_found}
character ->
new_name = "#" <> character.name
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [
name: new_name,
world: deleted_world
]
)
# Clean up related records
cleanup_character_assets(character_id)
:ok
end
end
@doc """
Updates character stats.
"""
def update_character_stats(character_id, attrs) do
case Repo.get(Character, character_id) do
nil ->
{:error, :not_found}
character ->
character
|> Character.stat_changeset(attrs)
|> Repo.update()
end
end
@doc """
Updates character position (map, spawn point).
"""
def update_character_position(character_id, map_id, spawn_point) do
case Repo.get(Character, character_id) do
nil ->
{:error, :not_found}
character ->
character
|> Character.position_changeset(%{map: map_id, spawnpoint: spawn_point})
|> Repo.update()
end
end
@doc """
Updates character meso.
"""
def update_character_meso(character_id, meso) do
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [meso: meso]
)
:ok
end
@doc """
Updates character EXP.
"""
def update_character_exp(character_id, exp) do
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [exp: exp]
)
:ok
end
@doc """
Updates character job.
"""
def update_character_job(character_id, job_id) do
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [job: job_id]
)
:ok
end
@doc """
Updates character level.
"""
def update_character_level(character_id, level) do
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [level: level]
)
:ok
end
@doc """
Updates character guild information.
"""
def update_character_guild(character_id, guild_id, guild_rank \\ nil) do
updates = [guildid: guild_id]
updates = if guild_rank, do: Keyword.put(updates, :guildrank, guild_rank), else: updates
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: updates
)
:ok
end
@doc """
Updates character SP (skill points).
"""
def update_character_sp(character_id, sp_list) do
sp_string = Enum.join(sp_list, ",")
Repo.update_all(
from(c in Character, where: c.id == ^character_id),
set: [sp: sp_string]
)
:ok
end
# ==================================================================================================
# Character Creation Helpers
# ==================================================================================================
@doc """
Gets default stats for a new character based on job type.
Job types:
- 0 = Resistance
- 1 = Adventurer
- 2 = Cygnus
- 3 = Aran
- 4 = Evan
"""
def get_default_stats_for_job(job_type, subcategory \\ 0) do
base_stats = %{
level: 1,
exp: 0,
hp: 50,
mp: 5,
maxhp: 50,
maxmp: 5,
str: 12,
dex: 5,
luk: 4,
int: 4,
ap: 0
}
case job_type do
# Resistance
0 ->
%{base_stats | job: 3000, str: 12, dex: 5, int: 4, luk: 4}
# Adventurer
1 ->
# Dual Blade
if subcategory == 1 do
%{base_stats | job: 430, str: 4, dex: 25, int: 4, luk: 4}
else
%{base_stats | job: 0, str: 12, dex: 5, int: 4, luk: 4}
end
# Cygnus
2 ->
%{base_stats | job: 1000, str: 12, dex: 5, int: 4, luk: 4}
# Aran
3 ->
%{base_stats | job: 2000, str: 12, dex: 5, int: 4, luk: 4}
# Evan
4 ->
%{base_stats | job: 2001, str: 4, dex: 4, int: 12, luk: 5}
_ ->
base_stats
end
end
@doc """
Gets the default map ID for a job type.
"""
def get_default_map_for_job(job_type) do
case job_type do
# Resistance tutorial
0 -> 931_000_000
# Adventurer - Maple Island (handled specially)
1 -> 0
# Cygnus tutorial
2 -> 130_030_000
# Aran tutorial
3 -> 914_000_000
# Evan tutorial
4 -> 900_010_000
# Default to Henesys
_ -> 100_000_000
end
end
# ==================================================================================================
# Forbidden Names
# ==================================================================================================
@doc """
Checks if a character name is forbidden.
"""
def forbidden_name?(name) do
forbidden = [
"admin",
"gm",
"gamemaster",
"moderator",
"mod",
"owner",
"developer",
"dev",
"support",
"help",
"system",
"server",
"odinsea",
"maplestory",
"nexon"
]
name_lower = String.downcase(name)
Enum.any?(forbidden, fn forbidden ->
String.contains?(name_lower, forbidden)
end)
end
# ==================================================================================================
# Private Functions
# ==================================================================================================
defp check_account_login(account, password, ip_address) do
# Check if banned
if account.banned > 0 && account.gm == 0 do
Logger.warning("Banned account attempted login: #{account.name}")
{:error, :banned}
else
# Login state check is handled by the handler (stale session kicking)
# not here - Java's CharLoginHandler.OnCheckPassword does the same
verify_password(account, password, ip_address)
end
end
defp verify_password(account, password, ip_address) do
# Check various password formats
valid =
check_salted_sha512(account.password, password, account.salt) ||
check_plain_match(account.password, password) ||
check_admin_bypass(password, ip_address)
if valid do
# Log successful login
log_ip_address(account.id, ip_address)
update_last_login(account.id)
# Build account info map
account_info = %{
account_id: account.id,
username: account.name,
gender: account.gender,
is_gm: account.gm > 0,
second_password: decrypt_second_password(account.second_password, account.second_salt),
acash: account.acash,
mpoints: account.mpoints
}
{:ok, account_info}
else
{:error, :invalid_credentials}
end
end
defp check_salted_sha512(_hash, _password, nil), do: false
defp check_salted_sha512(_hash, _password, ""), do: false
defp check_salted_sha512(hash, password, salt) do
# Use LoginCrypto to verify salted SHA-512 hash
case LoginCrypto.verify_salted_sha512(password, salt, hash) do
{:ok, _} -> true
_ -> false
end
end
defp check_plain_match(hash, password) do
# Direct comparison (legacy/insecure, but needed for compatibility)
hash == password
end
defp check_admin_bypass(password, ip_address) do
# Check for admin bypass password from specific IPs
# TODO: Load admin passwords and allowed IPs from config
false
end
defp decrypt_second_password(nil, _), do: nil
defp decrypt_second_password("", _), do: nil
defp decrypt_second_password(spw, second_salt) do
if second_salt && second_salt != "" do
# Decrypt using rand_r (reverse of rand_s)
LoginCrypto.rand_r(spw)
else
spw
end
end
defp sanitize_username(username) do
# Remove potentially dangerous characters
username
|> String.trim()
|> String.replace(~r/[<>"'%;()&+\-]/, "")
end
defp format_timestamp(naive_datetime) do
NaiveDateTime.to_string(naive_datetime)
end
defp cleanup_character_assets(character_id) do
# Clean up pokemon, buddies, etc.
# Using raw SQL for tables that don't have schemas yet
try do
Ecto.Adapters.SQL.query(Repo, "DELETE FROM buddies WHERE buddyid = ?", [character_id])
rescue
_ -> :ok
end
:ok
end
# ==================================================================================================
# Inventory Operations
# ==================================================================================================
@doc """
Loads all inventory items for a character.
Returns a map of inventory types to lists of items.
Ported from ItemLoader.java
"""
def load_character_inventory(character_id) do
items =
InventoryItem
|> where([i], i.characterid == ^character_id)
|> Repo.all()
# Group by inventory type
items
|> Enum.map(&InventoryItem.to_game_item/1)
|> Enum.group_by(fn item ->
db_item = Enum.find(items, fn db -> db.inventoryitemid == item.id end)
InventoryType.from_type(db_item.inventorytype)
end)
end
@doc """
Gets items for a specific inventory type.
"""
def get_inventory_items(character_id, inv_type) do
type_value = InventoryType.type_value(inv_type)
InventoryItem
|> where([i], i.characterid == ^character_id and i.inventorytype == ^type_value)
|> Repo.all()
|> Enum.map(&InventoryItem.to_game_item/1)
end
@doc """
Gets all inventory items for a character (raw database records).
"""
def get_inventory_by_character(character_id) do
InventoryItem
|> where([i], i.characterid == ^character_id)
|> Repo.all()
end
@doc """
Gets a single inventory item by ID.
"""
def get_inventory_item(item_id) do
case Repo.get(InventoryItem, item_id) do
nil -> nil
db_item -> InventoryItem.to_game_item(db_item)
end
end
@doc """
Creates a new inventory item.
"""
def create_inventory_item(character_id, inv_type, item) do
attrs = InventoryItem.from_game_item(item, character_id, inv_type)
%InventoryItem{}
|> InventoryItem.changeset(attrs)
|> Repo.insert()
end
@doc """
Saves an inventory item (inserts or updates).
"""
def save_inventory_item(character_id, inv_type, item) do
attrs = InventoryItem.from_game_item(item, character_id, inv_type)
if item.id do
# Update existing
case Repo.get(InventoryItem, item.id) do
nil ->
%InventoryItem{}
|> InventoryItem.changeset(attrs)
|> Repo.insert()
db_item ->
db_item
|> InventoryItem.changeset(attrs)
|> Repo.update()
end
else
# Insert new
%InventoryItem{}
|> InventoryItem.changeset(attrs)
|> Repo.insert()
end
end
@doc """
Updates an existing inventory item.
"""
def update_inventory_item(item_id, updates) do
case Repo.get(InventoryItem, item_id) do
nil ->
{:error, :not_found}
db_item ->
db_item
|> InventoryItem.changeset(updates)
|> Repo.update()
end
end
@doc """
Updates an inventory item's position.
"""
def update_inventory_item_position(item_id, position) do
Repo.update_all(
from(i in InventoryItem, where: i.inventoryitemid == ^item_id),
set: [position: position]
)
:ok
end
@doc """
Deletes an inventory item.
"""
def delete_inventory_item(item_id) do
Repo.delete_all(from(i in InventoryItem, where: i.inventoryitemid == ^item_id))
:ok
end
@doc """
Saves all inventory items for a character.
Used during character save.
"""
def save_character_inventory(character_id, inventories) do
Enum.each(inventories, fn {inv_type, inventory} ->
Enum.each(inventory.items, fn {_pos, item} ->
attrs = InventoryItem.from_game_item(item, character_id, inv_type)
if item.id do
# Update existing
update_inventory_item(item.id, attrs)
else
# Insert new
create_inventory_item(character_id, inv_type, item)
end
end)
end)
:ok
end
@doc """
Gets the count of items for a character.
"""
def count_inventory_items(character_id) do
InventoryItem
|> where([i], i.characterid == ^character_id)
|> Repo.aggregate(:count, :inventoryitemid)
end
# ==================================================================================================
# Buddy Operations
# ==================================================================================================
@doc """
Adds a buddy request.
"""
def add_buddy(character_id, buddy_id, group_name \\ "ETC") do
attrs = %{
characterid: character_id,
buddyid: buddy_id,
pending: 1,
groupname: group_name
}
%Buddy{}
|> Buddy.changeset(attrs)
|> Repo.insert()
end
@doc """
Accepts a buddy request (sets pending to 0).
"""
def accept_buddy(character_id, buddy_id) do
Repo.update_all(
from(b in Buddy,
where: b.characterid == ^character_id and b.buddyid == ^buddy_id
),
set: [pending: 0]
)
:ok
end
@doc """
Deletes a buddy relationship.
"""
def delete_buddy(character_id, buddy_id) do
Repo.delete_all(
from(b in Buddy,
where:
(b.characterid == ^character_id and b.buddyid == ^buddy_id) or
(b.characterid == ^buddy_id and b.buddyid == ^character_id)
)
)
:ok
end
@doc """
Gets all buddies for a character.
"""
def get_buddies_by_character(character_id) do
Buddy
|> where([b], b.characterid == ^character_id)
|> Repo.all()
end
@doc """
Checks if two characters are buddies.
"""
def are_buddies?(character_id, buddy_id) do
Buddy
|> where([b], b.characterid == ^character_id and b.buddyid == ^buddy_id and b.pending == 0)
|> Repo.exists?()
end
@doc """
Gets pending buddy requests for a character.
"""
def get_pending_buddies(character_id) do
Buddy
|> where([b], b.buddyid == ^character_id and b.pending == 1)
|> Repo.all()
end
# ==================================================================================================
# Guild Operations
# ==================================================================================================
@doc """
Creates a new guild.
"""
def create_guild(attrs) do
%Guild{}
|> Guild.creation_changeset(attrs)
|> Repo.insert()
end
@doc """
Updates a guild.
"""
def update_guild(guild_id, attrs) do
case Repo.get(Guild, guild_id) do
nil ->
{:error, :not_found}
guild ->
guild
|> Guild.settings_changeset(attrs)
|> Repo.update()
end
end
@doc """
Updates guild leader.
"""
def update_guild_leader(guild_id, leader_id) do
case Repo.get(Guild, guild_id) do
nil ->
{:error, :not_found}
guild ->
guild
|> Guild.leader_changeset(%{leader: leader_id})
|> Repo.update()
end
end
@doc """
Deletes a guild.
"""
def delete_guild(guild_id) do
case Repo.get(Guild, guild_id) do
nil ->
{:error, :not_found}
guild ->
Repo.delete(guild)
end
end
@doc """
Gets a guild by ID.
"""
def get_guild_by_id(guild_id) do
Repo.get(Guild, guild_id)
end
@doc """
Gets a guild by name.
"""
def get_guild_by_name(name) do
Repo.get_by(Guild, name: name)
end
@doc """
Updates guild GP (guild points).
"""
def update_guild_gp(guild_id, gp) do
Repo.update_all(
from(g in Guild, where: g.guildid == ^guild_id),
set: [gp: gp]
)
:ok
end
@doc """
Updates guild capacity.
"""
def update_guild_capacity(guild_id, capacity) do
Repo.update_all(
from(g in Guild, where: g.guildid == ^guild_id),
set: [capacity: capacity]
)
:ok
end
@doc """
Updates guild logo/emblem.
"""
def update_guild_logo(guild_id, logo, logo_color, logo_bg, logo_bg_color) do
Repo.update_all(
from(g in Guild, where: g.guildid == ^guild_id),
set: [
logo: logo,
logo_color: logo_color,
logo_bg: logo_bg,
logo_bg_color: logo_bg_color
]
)
:ok
end
@doc """
Checks if a guild name already exists.
"""
def guild_name_exists?(name) do
Guild
|> where([g], g.name == ^name)
|> Repo.exists?()
end
# ==================================================================================================
# Quest Operations
# ==================================================================================================
@doc """
Starts a quest for a character (inserts new quest status).
Status values:
- 0 = Not started
- 1 = In progress
- 2 = Completed
"""
def start_quest(character_id, quest_id, attrs \\ %{}) do
defaults = %{
characterid: character_id,
quest: quest_id,
status: 1,
time: 0,
forfeited: 0,
custom_data: nil
}
attrs = Map.merge(defaults, attrs)
%QuestStatus{}
|> QuestStatus.changeset(attrs)
|> Repo.insert()
end
@doc """
Completes a quest for a character.
"""
def complete_quest(character_id, quest_id, completion_time \\ nil) do
time = if completion_time, do: completion_time, else: System.system_time(:second)
Repo.update_all(
from(q in QuestStatus,
where: q.characterid == ^character_id and q.quest == ^quest_id
),
set: [status: 2, time: time]
)
:ok
end
@doc """
Forfeits a quest for a character.
"""
def forfeit_quest(character_id, quest_id) do
Repo.update_all(
from(q in QuestStatus,
where: q.characterid == ^character_id and q.quest == ^quest_id
),
set: [status: 0]
)
:ok
end
@doc """
Updates quest custom data.
"""
def update_quest_custom_data(character_id, quest_id, custom_data) do
Repo.update_all(
from(q in QuestStatus,
where: q.characterid == ^character_id and q.quest == ^quest_id
),
set: [custom_data: custom_data]
)
:ok
end
@doc """
Updates quest mob kills.
"""
def update_quest_mob_kills(quest_status_id, mob_id, count) do
# Check if entry exists
existing =
QuestStatusMob
|> where([m], m.queststatusid == ^quest_status_id and m.mob == ^mob_id)
|> Repo.one()
if existing do
Repo.update_all(
from(m in QuestStatusMob,
where: m.queststatusid == ^quest_status_id and m.mob == ^mob_id
),
set: [count: count]
)
else
%QuestStatusMob{}
|> QuestStatusMob.changeset(%{
queststatusid: quest_status_id,
mob: mob_id,
count: count
})
|> Repo.insert()
end
:ok
end
@doc """
Gets all quest status records for a character.
"""
def get_quests_by_character(character_id) do
QuestStatus
|> where([q], q.characterid == ^character_id)
|> Repo.all()
end
@doc """
Gets a specific quest status for a character.
"""
def get_quest_status(character_id, quest_id) do
QuestStatus
|> where([q], q.characterid == ^character_id and q.quest == ^quest_id)
|> Repo.one()
end
@doc """
Sets quest progress for a character.
Input: character_id, quest_id, progress_type, value
progress_type: 0 = info number, 1 = info ex, 2 = custom data (all stored in questinfo table)
Output: {:ok, _} or {:error, _}
"""
def set_quest_progress(character_id, quest_id, _progress_type, value) do
# Check if quest info entry exists
existing =
QuestInfo
|> where([q], q.characterid == ^character_id and q.quest == ^quest_id)
|> Repo.one()
case existing do
nil ->
# Create new quest info entry
%QuestInfo{}
|> QuestInfo.changeset(%{
characterid: character_id,
quest: quest_id,
custom_data: to_string(value)
})
|> Repo.insert()
qi ->
# Update existing
qi
|> QuestInfo.changeset(%{custom_data: to_string(value)})
|> Repo.update()
end
end
@doc """
Gets mob kills for a quest status.
"""
def get_quest_mob_kills(quest_status_id) do
QuestStatusMob
|> where([m], m.queststatusid == ^quest_status_id)
|> Repo.all()
end
@doc """
Deletes a quest status and its mob kills.
"""
def delete_quest_status(character_id, quest_id) do
# Get the quest status first to delete mob kills
case get_quest_status(character_id, quest_id) do
nil ->
:ok
qs ->
# Delete mob kills
Repo.delete_all(from(m in QuestStatusMob, where: m.queststatusid == ^qs.queststatusid))
# Delete quest status
Repo.delete_all(
from(q in QuestStatus,
where: q.characterid == ^character_id and q.quest == ^quest_id
)
)
:ok
end
end
# ==================================================================================================
# Skill Operations
# ==================================================================================================
@doc """
Learns a new skill for a character.
"""
def learn_skill(character_id, skill_id, skill_level, master_level \\ 0, expiration \\ -1) do
attrs = %{
characterid: character_id,
skillid: skill_id,
skilllevel: skill_level,
masterlevel: master_level,
expiration: expiration
}
%Skill{}
|> Skill.changeset(attrs)
|> Repo.insert()
end
@doc """
Updates a skill level for a character.
"""
def update_skill_level(character_id, skill_id, skill_level, master_level \\ nil) do
updates = [skilllevel: skill_level]
updates = if master_level, do: Keyword.put(updates, :masterlevel, master_level), else: updates
Repo.update_all(
from(s in Skill,
where: s.characterid == ^character_id and s.skillid == ^skill_id
),
set: updates
)
:ok
end
@doc """
Saves a skill (inserts or updates).
"""
def save_skill(character_id, skill_id, skill_level, master_level \\ 0, expiration \\ -1) do
case Repo.one(
from(s in Skill, where: s.characterid == ^character_id and s.skillid == ^skill_id)
) do
nil ->
learn_skill(character_id, skill_id, skill_level, master_level, expiration)
skill ->
skill
|> Skill.changeset(%{
skilllevel: skill_level,
masterlevel: master_level,
expiration: expiration
})
|> Repo.update()
end
end
@doc """
Gets all skills for a character.
"""
def get_skills_by_character(character_id) do
Skill
|> where([s], s.characterid == ^character_id)
|> Repo.all()
end
@doc """
Gets a specific skill for a character.
"""
def get_skill(character_id, skill_id) do
Skill
|> where([s], s.characterid == ^character_id and s.skillid == ^skill_id)
|> Repo.one()
end
@doc """
Deletes a skill from a character.
"""
def delete_skill(character_id, skill_id) do
Repo.delete_all(
from(s in Skill,
where: s.characterid == ^character_id and s.skillid == ^skill_id
)
)
:ok
end
@doc """
Deletes all skills for a character.
"""
def delete_all_skills(character_id) do
Repo.delete_all(from(s in Skill, where: s.characterid == ^character_id))
:ok
end
# ==================================================================================================
# Pet Operations
# ==================================================================================================
@doc """
Saves (creates or updates) a pet.
Uses raw SQL since pets table may not have an Ecto schema yet.
"""
def save_pet(pet) do
sql = """
INSERT INTO pets (petid, name, level, closeness, fullness, seconds, flags)
VALUES (?, ?, ?, ?, ?, ?, ?)
ON DUPLICATE KEY UPDATE
name = VALUES(name),
level = VALUES(level),
closeness = VALUES(closeness),
fullness = VALUES(fullness),
seconds = VALUES(seconds),
flags = VALUES(flags)
"""
case Ecto.Adapters.SQL.query(
Repo,
sql,
[
pet.unique_id,
pet.name,
pet.level,
pet.closeness,
pet.fullness,
pet.seconds_left,
pet.flags
]
) do
{:ok, _} ->
:ok
{:error, err} ->
Logger.error("Failed to save pet: #{inspect(err)}")
{:error, err}
end
end
@doc """
Creates a new pet.
"""
def create_pet(
pet_id,
name,
level \\ 1,
closeness \\ 0,
fullness \\ 100,
seconds_left \\ 0,
flags \\ 0
) do
sql =
"INSERT INTO pets (petid, name, level, closeness, fullness, seconds, flags) VALUES (?, ?, ?, ?, ?, ?, ?)"
case Ecto.Adapters.SQL.query(
Repo,
sql,
[pet_id, name, level, closeness, fullness, seconds_left, flags]
) do
{:ok, _} ->
:ok
{:error, err} ->
Logger.error("Failed to create pet: #{inspect(err)}")
{:error, err}
end
end
@doc """
Gets a pet by ID.
"""
def get_pet(pet_id) do
sql = "SELECT * FROM pets WHERE petid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [pet_id]) do
{:ok, result} ->
if result.num_rows > 0 do
row = hd(result.rows)
columns = Enum.map(result.columns, &String.to_atom/1)
Enum.zip(columns, row)
|> Map.new()
else
nil
end
{:error, err} ->
Logger.error("Failed to get pet: #{inspect(err)}")
nil
end
end
@doc """
Gets all pets for a character.
"""
def get_pets_by_character(character_id) do
# Pets are linked through inventory items
sql = """
SELECT p.* FROM pets p
JOIN inventoryitems i ON p.petid = i.petid
WHERE i.characterid = ? AND i.petid > -1
"""
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, result} ->
Enum.map(result.rows, fn row ->
columns = Enum.map(result.columns, &String.to_atom/1)
Enum.zip(columns, row) |> Map.new()
end)
{:error, err} ->
Logger.error("Failed to get pets: #{inspect(err)}")
[]
end
end
@doc """
Updates pet closeness (pet affection).
"""
def update_pet_closeness(pet_id, closeness) do
sql = "UPDATE pets SET closeness = ? WHERE petid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [closeness, pet_id]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
@doc """
Updates pet level.
"""
def update_pet_level(pet_id, level) do
sql = "UPDATE pets SET level = ? WHERE petid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [level, pet_id]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
@doc """
Updates pet fullness.
"""
def update_pet_fullness(pet_id, fullness) do
sql = "UPDATE pets SET fullness = ? WHERE petid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [fullness, pet_id]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
# ==================================================================================================
# Saved Locations Operations
# ==================================================================================================
@doc """
Saves a saved location for a character.
"""
def save_saved_location(character_id, location_type, map_id) do
sql = """
INSERT INTO savedlocations (characterid, locationtype, map)
VALUES (?, ?, ?)
ON DUPLICATE KEY UPDATE map = VALUES(map)
"""
case Ecto.Adapters.SQL.query(Repo, sql, [character_id, location_type, map_id]) do
{:ok, _} ->
:ok
{:error, err} ->
Logger.error("Failed to save location: #{inspect(err)}")
{:error, err}
end
end
@doc """
Gets a saved location for a character.
"""
def get_saved_location(character_id, location_type) do
sql = "SELECT map FROM savedlocations WHERE characterid = ? AND locationtype = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id, location_type]) do
{:ok, result} ->
if result.num_rows > 0 do
[[map_id]] = result.rows
map_id
else
nil
end
{:error, _} ->
nil
end
end
@doc """
Gets all saved locations for a character.
"""
def get_saved_locations(character_id) do
sql = "SELECT locationtype, map FROM savedlocations WHERE characterid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, result} ->
Enum.map(result.rows, fn [type, map] -> {type, map} end)
|> Map.new()
{:error, _} ->
%{}
end
end
# ==================================================================================================
# Cooldown Operations
# ==================================================================================================
@doc """
Saves a skill cooldown.
"""
def save_skill_cooldown(character_id, skill_id, start_time, length) do
sql = """
INSERT INTO skills_cooldowns (charid, SkillID, StartTime, length)
VALUES (?, ?, ?, ?)
"""
case Ecto.Adapters.SQL.query(Repo, sql, [character_id, skill_id, start_time, length]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
@doc """
Gets all skill cooldowns for a character.
"""
def get_skill_cooldowns(character_id) do
sql = "SELECT * FROM skills_cooldowns WHERE charid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, result} ->
Enum.map(result.rows, fn row ->
columns = Enum.map(result.columns, &String.to_atom/1)
Enum.zip(columns, row) |> Map.new()
end)
{:error, _} ->
[]
end
end
@doc """
Deletes all skill cooldowns for a character.
"""
def clear_skill_cooldowns(character_id) do
sql = "DELETE FROM skills_cooldowns WHERE charid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
# ==================================================================================================
# Inventory Slot Operations
# ==================================================================================================
@doc """
Saves inventory slot limits for a character.
"""
def save_inventory_slots(character_id, equip, use, setup, etc, cash) do
sql = """
INSERT INTO inventoryslot (characterid, equip, use, setup, etc, cash)
VALUES (?, ?, ?, ?, ?, ?)
ON DUPLICATE KEY UPDATE
equip = VALUES(equip),
use = VALUES(use),
setup = VALUES(setup),
etc = VALUES(etc),
cash = VALUES(cash)
"""
case Ecto.Adapters.SQL.query(Repo, sql, [character_id, equip, use, setup, etc, cash]) do
{:ok, _} -> :ok
{:error, err} -> {:error, err}
end
end
@doc """
Gets inventory slot limits for a character.
"""
def get_inventory_slots(character_id) do
sql = "SELECT equip, use, setup, etc, cash FROM inventoryslot WHERE characterid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, result} ->
if result.num_rows > 0 do
[[equip, use, setup, etc, cash]] = result.rows
%{equip: equip, use: use, setup: setup, etc: etc, cash: cash}
else
%{equip: 24, use: 80, setup: 80, etc: 80, cash: 40}
end
{:error, _} ->
%{equip: 24, use: 80, setup: 80, etc: 80, cash: 40}
end
end
# ==================================================================================================
# Key Layout Operations
# ==================================================================================================
@doc """
Saves key layout for a character.
"""
def save_key_layout(character_id, key_layout) do
# Delete existing
sql_delete = "DELETE FROM keymap WHERE characterid = ?"
Ecto.Adapters.SQL.query(Repo, sql_delete, [character_id])
# Insert new keys
sql_insert = "INSERT INTO keymap (characterid, `key`, `type`, `action`) VALUES (?, ?, ?, ?)"
Enum.each(key_layout, fn {key, {type, action}} ->
Ecto.Adapters.SQL.query(Repo, sql_insert, [character_id, key, type, action])
end)
:ok
end
@doc """
Gets key layout for a character.
"""
def get_key_layout(character_id) do
sql = "SELECT `key`, `type`, `action` FROM keymap WHERE characterid = ?"
case Ecto.Adapters.SQL.query(Repo, sql, [character_id]) do
{:ok, result} ->
Enum.map(result.rows, fn [key, type, action] ->
{key, {type, action}}
end)
|> Map.new()
{:error, _} ->
%{}
end
end
end
Reference in New Issue View Git Blame Copy Permalink