1083 lines
32 KiB
Zig
1083 lines
32 KiB
Zig
const std = @import("std");
|
|
const json_utils = @import("json_utils.zig");
|
|
const assert = std.debug.assert;
|
|
const json = std.json;
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
const Character = @import("./schemas/character.zig");
|
|
const EnumStringUtils = @import("./enum_string_utils.zig").EnumStringUtils;
|
|
const Position = @import("./position.zig");
|
|
const Store = @import("./store.zig");
|
|
|
|
const errors = @import("./errors.zig");
|
|
const FetchError = errors.FetchError;
|
|
|
|
// Specification: https://api.artifactsmmo.com/docs
|
|
|
|
const Server = @This();
|
|
|
|
const log = std.log.scoped(.api);
|
|
|
|
allocator: Allocator,
|
|
client: std.http.Client,
|
|
|
|
server: []u8,
|
|
server_uri: std.Uri,
|
|
token: ?[]u8 = null,
|
|
|
|
store: Store,
|
|
prefetched: bool = false,
|
|
|
|
// ------------------------- API result structs ------------------------
|
|
|
|
const BoundedSlotsArray = @import("./schemas/slot_array.zig").BoundedSlotsArray;
|
|
pub const EquipmentSlot = @import("./schemas/equipment.zig").Slot;
|
|
pub const ServerStatus = @import("./schemas/status.zig");
|
|
pub const Cooldown = @import("./schemas/cooldown.zig");
|
|
pub const FightResult = @import("./schemas/character_fight.zig");
|
|
pub const Skill = @import("./schemas/skill.zig").Skill;
|
|
pub const GatherResult = @import("./schemas/skill_data.zig");
|
|
pub const MoveResult = @import("./schemas/character_movement.zig");
|
|
pub const GoldTransactionResult = @import("./schemas/bank_gold_transaction.zig");
|
|
pub const ItemTransactionResult = @import("./schemas/bank_item_transaction.zig");
|
|
pub const CraftResult = @import("./schemas/skill_data.zig");
|
|
pub const UnequipResult = @import("./schemas/equip_request.zig");
|
|
pub const EquipResult = @import("./schemas/equip_request.zig");
|
|
const DropRate = @import("./schemas/drop_rate.zig");
|
|
pub const AcceptTaskResult = @import("./schemas/task_data.zig");
|
|
pub const CompleteTaskResult = @import("./schemas/task_reward_data.zig");
|
|
pub const MapContent = @import("./schemas/map_content.zig");
|
|
pub const MapTile = @import("./schemas/map.zig");
|
|
pub const Item = @import("./schemas/item.zig");
|
|
pub const ItemWithGE = @import("./schemas/single_item.zig");
|
|
pub const Resource = @import("./schemas/resource.zig");
|
|
pub const Monster = @import("./schemas/monster.zig");
|
|
|
|
const ItemQuantity = @import("./schemas/item_quantity.zig");
|
|
|
|
pub const ArtifactsFetchResult = struct {
|
|
arena: std.heap.ArenaAllocator,
|
|
status: std.http.Status,
|
|
body: ?json.Value = null,
|
|
|
|
fn deinit(self: ArtifactsFetchResult) void {
|
|
self.arena.deinit();
|
|
}
|
|
};
|
|
|
|
// ------------------------- General API methods ------------------------
|
|
|
|
pub fn init(allocator: Allocator) !Server {
|
|
const url = try allocator.dupe(u8, "https://api.artifactsmmo.com");
|
|
const uri = std.Uri.parse(url) catch unreachable;
|
|
|
|
return Server{
|
|
.allocator = allocator,
|
|
.client = .{ .allocator = allocator },
|
|
.server = url,
|
|
.server_uri = uri,
|
|
|
|
.store = Store.init(allocator),
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Server) void {
|
|
self.client.deinit();
|
|
self.allocator.free(self.server);
|
|
if (self.token) |str| self.allocator.free(str);
|
|
|
|
self.store.deinit();
|
|
}
|
|
|
|
const FetchOptions = struct {
|
|
method: std.http.Method,
|
|
path: []const u8,
|
|
payload: ?[]const u8 = null,
|
|
|
|
query: ?[]const u8 = null,
|
|
|
|
page: ?u64 = null,
|
|
page_size: ?u64 = null,
|
|
paginated: bool = false
|
|
};
|
|
|
|
fn appendQueryParam(query: *std.ArrayList(u8), key: []const u8, value: []const u8) !void {
|
|
if (query.items.len > 0) {
|
|
try query.appendSlice("&");
|
|
}
|
|
|
|
try query.appendSlice(key);
|
|
try query.appendSlice("=");
|
|
try query.appendSlice(value);
|
|
}
|
|
|
|
fn allocPaginationParams(allocator: Allocator, page: u64, page_size: ?u64) ![]u8 {
|
|
if (page_size) |size| {
|
|
return try std.fmt.allocPrint(allocator, "page={}&size={}", .{page, size});
|
|
} else {
|
|
return try std.fmt.allocPrint(allocator, "page={}", .{page});
|
|
}
|
|
}
|
|
|
|
// TODO: add retries when hitting a ratelimit
|
|
fn fetch(self: *Server, options: FetchOptions) FetchError!ArtifactsFetchResult {
|
|
const method = options.method;
|
|
const path = options.path;
|
|
const payload = options.payload;
|
|
|
|
var uri = self.server_uri;
|
|
uri.path = .{ .raw = path };
|
|
|
|
var arena = std.heap.ArenaAllocator.init(self.allocator);
|
|
errdefer arena.deinit();
|
|
|
|
var result_status: std.http.Status = .ok;
|
|
var result_body: ?json.Value = null;
|
|
|
|
var current_page: u64 = options.page orelse 1;
|
|
var total_pages: u64 = 1;
|
|
var fetch_results = std.ArrayList(json.Value).init(arena.allocator());
|
|
|
|
const has_query = options.query != null and options.query.?.len > 0;
|
|
|
|
while (true) : (current_page += 1) {
|
|
var pagination_params: ?[]u8 = null;
|
|
defer if (pagination_params) |str| self.allocator.free(str);
|
|
|
|
if (options.paginated) {
|
|
pagination_params = try allocPaginationParams(self.allocator, current_page, options.page_size);
|
|
}
|
|
|
|
if (has_query and pagination_params != null) {
|
|
const combined = try std.mem.join(self.allocator, "&", &.{ options.query.?, pagination_params.? });
|
|
self.allocator.free(pagination_params.?);
|
|
pagination_params = combined;
|
|
|
|
uri.query = .{ .raw = combined };
|
|
} else if (pagination_params != null) {
|
|
uri.query = .{ .raw = pagination_params.? };
|
|
} else if (has_query) {
|
|
uri.query = .{ .raw = options.query.? };
|
|
}
|
|
|
|
var response_storage = std.ArrayList(u8).init(arena.allocator());
|
|
var opts = std.http.Client.FetchOptions{
|
|
.method = method,
|
|
.location = .{ .uri = uri },
|
|
.payload = payload,
|
|
.response_storage = .{ .dynamic = &response_storage },
|
|
};
|
|
|
|
var authorization_header: ?[]u8 = null;
|
|
defer if (authorization_header) |str| self.allocator.free(str);
|
|
|
|
if (self.token) |token| {
|
|
authorization_header = std.fmt.allocPrint(self.allocator, "Bearer {s}", .{token}) catch return FetchError.OutOfMemory;
|
|
opts.headers.authorization = .{ .override = authorization_header.? };
|
|
}
|
|
|
|
if (uri.query) |query| {
|
|
log.debug("fetch {} {s}?{s}", .{method, path, query.raw});
|
|
} else {
|
|
log.debug("fetch {} {s}", .{method, path});
|
|
}
|
|
|
|
const result = self.client.fetch(opts) catch return FetchError.RequestFailed;
|
|
const response_body = response_storage.items;
|
|
|
|
log.debug("fetch result {}", .{result.status});
|
|
|
|
if (result.status == .service_unavailable) {
|
|
return FetchError.ServerUnavailable;
|
|
} else if (result.status != .ok) {
|
|
return ArtifactsFetchResult{
|
|
.arena = arena,
|
|
.status = result.status
|
|
};
|
|
}
|
|
|
|
const parsed = json.parseFromSliceLeaky(json.Value, arena.allocator(), response_body, .{ .allocate = .alloc_if_needed }) catch return FetchError.ParseFailed;
|
|
if (parsed != json.Value.object) {
|
|
return FetchError.ParseFailed;
|
|
}
|
|
|
|
result_status = result.status;
|
|
|
|
if (options.paginated) {
|
|
const total_pages_i64 = json_utils.getInteger(parsed.object, "pages") orelse return FetchError.ParseFailed;
|
|
if (total_pages_i64 < 0) return FetchError.ParseFailed;
|
|
total_pages = @intCast(total_pages_i64);
|
|
|
|
const page_results = json_utils.getArray(parsed.object, "data") orelse return FetchError.ParseFailed;
|
|
fetch_results.appendSlice(page_results.items) catch return FetchError.OutOfMemory;
|
|
|
|
if (current_page >= total_pages) break;
|
|
} else {
|
|
result_body = parsed.object.get("data");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (options.paginated) {
|
|
result_body = json.Value{ .array = fetch_results };
|
|
}
|
|
|
|
return ArtifactsFetchResult{
|
|
.status = result_status,
|
|
.arena = arena,
|
|
.body = result_body
|
|
};
|
|
}
|
|
|
|
fn handleFetchError(
|
|
status: std.http.Status,
|
|
Error: type,
|
|
parseError: ?fn (status: std.http.Status) ?Error,
|
|
) ?Error {
|
|
if (status != .ok) {
|
|
if (Error != FetchError) {
|
|
if (parseError == null) {
|
|
@compileError("`parseError` must be defined, if `Error` is not `APIError`");
|
|
}
|
|
|
|
if (parseError.?(status)) |error_value| {
|
|
return error_value;
|
|
}
|
|
} else {
|
|
if (parseError != null) {
|
|
@compileError("`parseError` must be null");
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
fn fetchOptionalObject(
|
|
self: *Server,
|
|
Error: type,
|
|
parseError: ?fn (status: std.http.Status) ?Error,
|
|
Object: type,
|
|
parseObject: anytype,
|
|
parseObjectArgs: anytype,
|
|
fetchOptions: FetchOptions,
|
|
) Error!?Object {
|
|
if (@typeInfo(@TypeOf(parseObject)) != .Fn) {
|
|
@compileError("`parseObject` must be a function");
|
|
}
|
|
|
|
const result = try self.fetch(fetchOptions);
|
|
defer result.deinit();
|
|
|
|
if (handleFetchError(result.status, Error, parseError)) |error_value| {
|
|
return error_value;
|
|
}
|
|
if (result.status == .not_found) {
|
|
return null;
|
|
}
|
|
if (result.status != .ok) {
|
|
return FetchError.RequestFailed;
|
|
}
|
|
|
|
if (result.body == null) {
|
|
return FetchError.ParseFailed;
|
|
}
|
|
|
|
const body = json_utils.asObject(result.body.?) orelse return FetchError.ParseFailed;
|
|
return @call(.auto, parseObject, .{ &self.store, body } ++ parseObjectArgs) catch return FetchError.ParseFailed;
|
|
}
|
|
|
|
fn fetchObject(
|
|
self: *Server,
|
|
Error: type,
|
|
parseError: ?fn (status: std.http.Status) ?Error,
|
|
Object: type,
|
|
parseObject: anytype,
|
|
parseObjectArgs: anytype,
|
|
fetchOptions: FetchOptions
|
|
) Error!Object {
|
|
const result = try self.fetchOptionalObject(Error, parseError, Object, parseObject, parseObjectArgs, fetchOptions);
|
|
return result orelse return FetchError.RequestFailed;
|
|
}
|
|
|
|
fn fetchOptionalArray(
|
|
self: *Server,
|
|
allocator: Allocator,
|
|
Error: type,
|
|
parseError: ?fn (status: std.http.Status) ?Error,
|
|
Object: type,
|
|
parseObject: anytype,
|
|
parseObjectArgs: anytype,
|
|
fetchOptions: FetchOptions
|
|
) Error!?std.ArrayList(Object) {
|
|
if (@typeInfo(@TypeOf(parseObject)) != .Fn) {
|
|
@compileError("`parseObject` must be a function");
|
|
}
|
|
|
|
const result = try self.fetch(fetchOptions);
|
|
defer result.deinit();
|
|
|
|
if (handleFetchError(result.status, Error, parseError)) |error_value| {
|
|
return error_value;
|
|
}
|
|
if (result.status == .not_found) {
|
|
return null;
|
|
}
|
|
if (result.status != .ok) {
|
|
return FetchError.RequestFailed;
|
|
}
|
|
|
|
if (result.body == null) {
|
|
return FetchError.ParseFailed;
|
|
}
|
|
|
|
var array = std.ArrayList(Object).init(allocator);
|
|
errdefer {
|
|
if (std.meta.hasFn(Object, "deinit")) {
|
|
for (array.items) |*item| {
|
|
_ = item;
|
|
// TODO:
|
|
// item.deinit();
|
|
}
|
|
}
|
|
array.deinit();
|
|
}
|
|
|
|
const result_data = json_utils.asArray(result.body.?) orelse return FetchError.ParseFailed;
|
|
for (result_data.items) |result_item| {
|
|
const item_obj = json_utils.asObject(result_item) orelse return FetchError.ParseFailed;
|
|
|
|
const parsed_item = @call(.auto, parseObject, .{ &self.store, item_obj } ++ parseObjectArgs) catch return FetchError.ParseFailed;
|
|
array.append(parsed_item) catch return FetchError.OutOfMemory;
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
fn fetchArray(
|
|
self: *Server,
|
|
allocator: Allocator,
|
|
Error: type,
|
|
parseError: ?fn (status: std.http.Status) ?Error,
|
|
Object: type,
|
|
parseObject: anytype,
|
|
parseObjectArgs: anytype,
|
|
fetchOptions: FetchOptions
|
|
) Error!std.ArrayList(Object) {
|
|
const result = try self.fetchOptionalArray(allocator, Error, parseError, Object, parseObject, parseObjectArgs, fetchOptions);
|
|
return result orelse return FetchError.RequestFailed;
|
|
}
|
|
|
|
pub fn setURL(self: *Server, url: []const u8) !void {
|
|
const url_dupe = self.allocator.dupe(u8, url);
|
|
errdefer self.allocator.free(url_dupe);
|
|
|
|
const uri = try std.Uri.parse(url_dupe);
|
|
|
|
self.allocator.free(self.server);
|
|
self.server = url_dupe;
|
|
self.server_uri = uri;
|
|
}
|
|
|
|
pub fn setToken(self: *Server, token: ?[]const u8) !void {
|
|
var new_token: ?[]u8 = null;
|
|
if (token != null) {
|
|
new_token = try self.allocator.dupe(u8, token.?);
|
|
}
|
|
|
|
if (self.token) |str| self.allocator.free(str);
|
|
self.token = new_token;
|
|
}
|
|
|
|
pub fn prefetch(self: *Server) !void {
|
|
self.prefetched = false;
|
|
|
|
const resources = try self.getResources(.{});
|
|
defer resources.deinit();
|
|
|
|
const maps = try self.getMaps(.{});
|
|
defer maps.deinit();
|
|
|
|
const monsters = try self.getMonsters(.{});
|
|
defer monsters.deinit();
|
|
|
|
const items = try self.getItems(.{});
|
|
defer items.deinit();
|
|
|
|
self.prefetched = true;
|
|
}
|
|
|
|
pub fn prefetchCached(self: *Server, cache_path: []const u8) !void {
|
|
var status: ServerStatus = try self.getServerStatus();
|
|
defer status.deinit();
|
|
|
|
if (std.fs.openFileAbsolute(cache_path, .{})) |file| {
|
|
defer file.close();
|
|
|
|
if (self.store.load(status.version, file.reader())) {
|
|
self.prefetched = true;
|
|
return;
|
|
} else |_| { }
|
|
} else |_| { }
|
|
|
|
try self.prefetch();
|
|
|
|
const file = try std.fs.createFileAbsolute(cache_path, .{});
|
|
defer file.close();
|
|
try self.store.save(status.version, file.writer());
|
|
}
|
|
|
|
// ------------------------- Endpoints ------------------------
|
|
|
|
pub fn getServerStatus(self: *Server) FetchError!ServerStatus {
|
|
return try self.fetchObject(
|
|
FetchError,
|
|
null,
|
|
ServerStatus,
|
|
ServerStatus.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/" }
|
|
);
|
|
}
|
|
|
|
pub fn getCharacter(self: *Server, name: []const u8) FetchError!?Character {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/characters/{s}", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
var maybe_character = try self.fetchOptionalObject(
|
|
FetchError,
|
|
null,
|
|
Character,
|
|
Character.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = path }
|
|
);
|
|
|
|
if (maybe_character) |*character| {
|
|
errdefer character.deinit();
|
|
try self.store.putCharacter(character.*);
|
|
return character.*;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
pub fn listMyCharacters(self: *Server) FetchError!std.ArrayList(Character) {
|
|
const characters = try self.fetchArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
Character,
|
|
Character.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/my/characters" }
|
|
);
|
|
errdefer characters.deinit();
|
|
for (characters.items) |character| {
|
|
try self.store.putCharacter(character);
|
|
}
|
|
|
|
return characters;
|
|
}
|
|
|
|
pub fn actionFight(self: *Server, name: []const u8) errors.FightError!FightResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/fight", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.FightError,
|
|
errors.parseFightError,
|
|
FightResult,
|
|
FightResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionGather(self: *Server, name: []const u8) errors.GatherError!GatherResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/gathering", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.GatherError,
|
|
errors.parseGatherError,
|
|
GatherResult,
|
|
GatherResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionMove(self: *Server, name: []const u8, x: i64, y: i64) errors.MoveError!MoveResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/move", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"x\":{},\"y\":{} }}", .{x, y});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.MoveError,
|
|
errors.parseMoveError,
|
|
MoveResult,
|
|
MoveResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionBankDepositGold(
|
|
self: *Server,
|
|
name: []const u8,
|
|
quantity: u64
|
|
) errors.BankDepositGoldError!GoldTransactionResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/bank/deposit/gold", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"quantity\":{} }}", .{quantity});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.BankDepositGoldError,
|
|
errors.parseBankDepositGoldError,
|
|
GoldTransactionResult,
|
|
GoldTransactionResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionBankDepositItem(
|
|
self: *Server,
|
|
name: []const u8,
|
|
code: []const u8,
|
|
quantity: u64
|
|
) errors.BankDepositItemError!ItemTransactionResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/bank/deposit", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"code\":\"{s}\",\"quantity\":{} }}", .{code, quantity});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.BankDepositItemError,
|
|
errors.parseBankDepositItemError,
|
|
ItemTransactionResult,
|
|
ItemTransactionResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionBankWithdrawGold(
|
|
self: *Server,
|
|
name: []const u8,
|
|
quantity: u64
|
|
) errors.BankDepositGoldError!GoldTransactionResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/bank/withdraw/gold", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"quantity\":{} }}", .{quantity});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.BankWithdrawGoldError,
|
|
errors.parseBankWithdrawGoldError,
|
|
GoldTransactionResult,
|
|
GoldTransactionResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionBankWithdrawItem(
|
|
self: *Server,
|
|
name: []const u8,
|
|
code: []const u8,
|
|
quantity: u64
|
|
) errors.BankWithdrawItemError!ItemTransactionResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/bank/withdraw", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"code\":\"{s}\",\"quantity\":{} }}", .{code, quantity});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.BankWithdrawItemError,
|
|
errors.parseBankWithdrawItemError,
|
|
ItemTransactionResult,
|
|
ItemTransactionResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionCraft(
|
|
self: *Server,
|
|
name: []const u8,
|
|
code: []const u8,
|
|
quantity: u64
|
|
) !CraftResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/crafting", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"code\":\"{s}\",\"quantity\":{} }}", .{code, quantity});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.CraftError,
|
|
errors.parseCraftError,
|
|
CraftResult,
|
|
CraftResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionUnequip(
|
|
self: *Server,
|
|
name: []const u8,
|
|
slot: EquipmentSlot
|
|
) errors.UnequipError!UnequipResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/unequip", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"slot\":\"{s}\" }}", .{slot.name()});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.UnequipError,
|
|
errors.parseUnequipError,
|
|
UnequipResult,
|
|
UnequipResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn actionEquip(
|
|
self: *Server,
|
|
name: []const u8,
|
|
slot: EquipmentSlot,
|
|
code: []const u8
|
|
) errors.EquipError!EquipResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/equip", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const payload = try std.fmt.allocPrint(self.allocator, "{{ \"slot\":\"{s}\",\"code\":\"{s}\" }}", .{slot.name(), code});
|
|
defer self.allocator.free(payload);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.EquipError,
|
|
errors.parseEquipError,
|
|
EquipResult,
|
|
EquipResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path, .payload = payload }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn getBankGold(self: *Server) FetchError!u64 {
|
|
const result = try self.fetch(.{ .method = .GET, .path = "/my/bank/gold" });
|
|
defer result.deinit();
|
|
|
|
if (result.status != .ok) {
|
|
return FetchError.RequestFailed;
|
|
}
|
|
if (result.body == null) {
|
|
return FetchError.ParseFailed;
|
|
}
|
|
|
|
const data = json_utils.asObject(result.body.?) orelse return FetchError.RequestFailed;
|
|
const quantity = json_utils.getInteger(data, "quantity") orelse return FetchError.ParseFailed;
|
|
if (quantity < 0) return FetchError.ParseFailed;
|
|
|
|
return @intCast(quantity);
|
|
}
|
|
|
|
pub fn getBankItems(self: *Server, allocator: Allocator) FetchError!std.ArrayList(ItemQuantity) {
|
|
return self.fetchArray(
|
|
allocator,
|
|
FetchError,
|
|
null,
|
|
ItemQuantity,
|
|
ItemQuantity.parse, .{},
|
|
.{ .method = .GET, .path = "/my/bank/items", .paginated = true }
|
|
);
|
|
}
|
|
|
|
pub fn getBankItemQuantity(self: *Server, code: []const u8) FetchError!?u64 {
|
|
const query = try std.fmt.allocPrint(self.allocator, "item_code={s}", .{code});
|
|
defer self.allocator.free(query);
|
|
|
|
const maybe_items = try self.fetchOptionalArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
ItemQuantity,
|
|
ItemQuantity.parse, .{},
|
|
.{ .method = .GET, .path = "/my/bank/items", .query = query, .paginated = true }
|
|
);
|
|
if (maybe_items == null) {
|
|
return null;
|
|
}
|
|
|
|
const items = maybe_items.?;
|
|
defer items.deinit();
|
|
|
|
const list_items = items.list.items;
|
|
assert(list_items.len == 1);
|
|
assert(list_items[0].id == try self.getItemId(code));
|
|
|
|
return list_items[0].quantity;
|
|
}
|
|
|
|
pub fn getMap(self: *Server, x: i64, y: i64) FetchError!?MapTile {
|
|
if (self.store.getMap(x, y)) |map| {
|
|
return map;
|
|
}
|
|
|
|
if (self.prefetched) {
|
|
return null;
|
|
}
|
|
|
|
const path = try std.fmt.allocPrint(self.allocator, "/maps/{}/{}", .{x, y});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = self.fetchOptionalObject(
|
|
FetchError,
|
|
null,
|
|
MapTile,
|
|
MapTile.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = path }
|
|
);
|
|
|
|
if (result) |map| {
|
|
self.store.putMap(map);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub const MapOptions = struct {
|
|
code: ?[]const u8 = null,
|
|
type: ?MapContent.Type = null,
|
|
};
|
|
|
|
pub fn getMaps(self: *Server, opts: MapOptions) FetchError!std.ArrayList(MapTile) {
|
|
if (self.prefetched) {
|
|
return try self.store.getMaps(opts);
|
|
}
|
|
|
|
var query = std.ArrayList(u8).init(self.allocator);
|
|
defer query.deinit();
|
|
|
|
if (opts.code) |code| {
|
|
try appendQueryParam(&query, "content_code", code);
|
|
}
|
|
if (opts.type) |map_type| {
|
|
try appendQueryParam(&query, "content_type", MapContent.TypeUtils.toString(map_type));
|
|
}
|
|
|
|
const result = try self.fetchArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
MapTile,
|
|
MapTile.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/maps", .paginated = true, .page_size = 100, .query = query.items }
|
|
);
|
|
|
|
for (result.items) |map| {
|
|
try self.store.putMap(map);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn getItem(self: *Server, code: []const u8) FetchError!?Item {
|
|
if (self.store.getItem(code)) |item| {
|
|
return item;
|
|
}
|
|
|
|
if (self.prefetched) {
|
|
return null;
|
|
}
|
|
|
|
const path = try std.fmt.allocPrint(self.allocator, "/items/{s}", .{code});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchOptionalObject(
|
|
FetchError,
|
|
null,
|
|
ItemWithGE,
|
|
ItemWithGE.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = path }
|
|
);
|
|
|
|
if (result) |item_with_ge| {
|
|
try self.store.putItem(item_with_ge.item);
|
|
|
|
return item_with_ge.item;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
pub fn getItemById(self: *Server, id: Store.CodeId) FetchError!?Item {
|
|
const code = self.store.getCode(id) orelse return null;
|
|
return self.getItem(code);
|
|
}
|
|
|
|
pub const ItemOptions = struct {
|
|
craft_material: ?[]const u8 = null,
|
|
craft_skill: ?Skill = null,
|
|
min_level: ?u64 = null,
|
|
max_level: ?u64 = null,
|
|
name: ?[]const u8 = null,
|
|
type: ?Item.Type = null,
|
|
};
|
|
|
|
pub fn getItems(self: *Server, opts: ItemOptions) FetchError!std.ArrayList(Item) {
|
|
if (self.prefetched) {
|
|
return try self.store.getItems(opts);
|
|
}
|
|
|
|
var str_arena = std.heap.ArenaAllocator.init(self.allocator);
|
|
defer str_arena.deinit();
|
|
|
|
var query = std.ArrayList(u8).init(self.allocator);
|
|
defer query.deinit();
|
|
|
|
if (opts.craft_material) |craft_material| {
|
|
try appendQueryParam(&query, "craft_material", craft_material);
|
|
}
|
|
if (opts.min_level) |min_level| {
|
|
const min_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ min_level });
|
|
try appendQueryParam(&query, "min_level", min_level_str);
|
|
}
|
|
if (opts.max_level) |max_level| {
|
|
const max_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ max_level });
|
|
try appendQueryParam(&query, "max_level", max_level_str);
|
|
}
|
|
if (opts.name) |name| {
|
|
try appendQueryParam(&query, "name", name);
|
|
}
|
|
if (opts.type) |item_type| {
|
|
try appendQueryParam(&query, "type", Item.TypeUtils.toString(item_type));
|
|
}
|
|
|
|
const result = try self.fetchArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
Item,
|
|
Item.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/items", .paginated = true, .page_size = 100, .query = query.items }
|
|
);
|
|
errdefer result.deinit();
|
|
|
|
for (result.items) |item| {
|
|
try self.store.putItem(item);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn getResource(self: *Server, code: []const u8) FetchError!?Resource {
|
|
if (self.store.getResource(code)) |resource| {
|
|
return resource;
|
|
}
|
|
|
|
if (self.prefetched) {
|
|
return null;
|
|
}
|
|
|
|
const path = try std.fmt.allocPrint(self.allocator, "/resources/{s}", .{code});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchOptionalObject(
|
|
FetchError,
|
|
null,
|
|
Resource,
|
|
Resource.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = path }
|
|
);
|
|
|
|
if (result) |resource| {
|
|
try self.store.putResource(resource);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub const ResourceOptions = struct {
|
|
drop: ?[]const u8 = null,
|
|
max_level: ?u64 = null,
|
|
min_level: ?u64 = null,
|
|
skill: ?Resource.Skill = null,
|
|
};
|
|
|
|
pub fn getResources(self: *Server, opts: ResourceOptions) FetchError!std.ArrayList(Resource) {
|
|
if (self.prefetched) {
|
|
return self.store.getResources(opts);
|
|
}
|
|
|
|
var str_arena = std.heap.ArenaAllocator.init(self.allocator);
|
|
defer str_arena.deinit();
|
|
|
|
var query = std.ArrayList(u8).init(self.allocator);
|
|
defer query.deinit();
|
|
|
|
if (opts.drop) |drop| {
|
|
try appendQueryParam(&query, "drop", drop);
|
|
}
|
|
if (opts.min_level) |min_level| {
|
|
const min_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ min_level });
|
|
try appendQueryParam(&query, "min_level", min_level_str);
|
|
}
|
|
if (opts.max_level) |max_level| {
|
|
const max_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ max_level });
|
|
try appendQueryParam(&query, "max_level", max_level_str);
|
|
}
|
|
if (opts.skill) |skill| {
|
|
try appendQueryParam(&query, "skill", Resource.SkillUtils.toString(skill));
|
|
}
|
|
|
|
const result = try self.fetchArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
Resource,
|
|
Resource.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/resources", .paginated = true, .query = query.items }
|
|
);
|
|
errdefer result.deinit();
|
|
|
|
for (result.items) |resource| {
|
|
try self.store.putResource(resource);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn getMonster(self: *Server, code: []const u8) FetchError!?Monster {
|
|
if (self.store.getMonster(code)) |monster| {
|
|
return monster;
|
|
}
|
|
|
|
if (self.prefetched) {
|
|
return null;
|
|
}
|
|
|
|
const path = try std.fmt.allocPrint(self.allocator, "/monsters/{s}", .{code});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchOptionalObject(
|
|
FetchError,
|
|
null,
|
|
Monster,
|
|
Monster.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = path }
|
|
);
|
|
|
|
if (result) |monster| {
|
|
try self.store.putMonster(monster);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub const MonsterOptions = struct {
|
|
drop: ?[]const u8 = null,
|
|
max_level: ?u64 = null,
|
|
min_level: ?u64 = null,
|
|
};
|
|
|
|
pub fn getMonsters(self: *Server, opts: MonsterOptions) FetchError!std.ArrayList(Monster) {
|
|
if (self.prefetched) {
|
|
return try self.store.getMonsters(opts);
|
|
}
|
|
|
|
var str_arena = std.heap.ArenaAllocator.init(self.allocator);
|
|
defer str_arena.deinit();
|
|
|
|
var query = std.ArrayList(u8).init(self.allocator);
|
|
defer query.deinit();
|
|
|
|
if (opts.drop) |drop| {
|
|
try appendQueryParam(&query, "drop", drop);
|
|
}
|
|
if (opts.min_level) |min_level| {
|
|
const min_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ min_level });
|
|
try appendQueryParam(&query, "min_level", min_level_str);
|
|
}
|
|
if (opts.max_level) |max_level| {
|
|
const max_level_str = try std.fmt.allocPrint(str_arena.allocator(), "{}", .{ max_level });
|
|
try appendQueryParam(&query, "max_level", max_level_str);
|
|
}
|
|
|
|
const result = try self.fetchArray(
|
|
self.allocator,
|
|
FetchError,
|
|
null,
|
|
Monster,
|
|
Monster.parse, .{ self.allocator },
|
|
.{ .method = .GET, .path = "/monsters", .paginated = true, .query = query.items }
|
|
);
|
|
|
|
for (result.items) |monster| {
|
|
try self.store.putMonster(monster);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn acceptTask(self: *Server, name: []const u8) errors.AcceptTaskError!AcceptTaskResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/task/new", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.AcceptTaskError,
|
|
errors.parseAcceptTaskError,
|
|
AcceptTaskResult,
|
|
AcceptTaskResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|
|
|
|
pub fn completeTask(self: *Server, name: []const u8) errors.TaskCompleteError!CompleteTaskResult {
|
|
const path = try std.fmt.allocPrint(self.allocator, "/my/{s}/action/task/complete", .{name});
|
|
defer self.allocator.free(path);
|
|
|
|
const result = try self.fetchObject(
|
|
errors.TaskCompleteError,
|
|
errors.parseTaskCompleteError,
|
|
CompleteTaskResult,
|
|
CompleteTaskResult.parse, .{ self.allocator },
|
|
.{ .method = .POST, .path = path }
|
|
);
|
|
try self.store.putCharacter(result.character);
|
|
|
|
return result;
|
|
}
|