138 lines
3.5 KiB
TypeScript
138 lines
3.5 KiB
TypeScript
import Dexie from "dexie";
|
|
import { Card, CardFilter } from "./types";
|
|
|
|
class CardDatabase extends Dexie {
|
|
public cards: Dexie.Table<Card, string>;
|
|
|
|
public constructor() {
|
|
super("CardDatabase");
|
|
this.version(1).stores({
|
|
cards: "ID,Set,Type,Cost,Power"
|
|
});
|
|
this.cards = this.table("cards");
|
|
}
|
|
}
|
|
|
|
export let Database = new CardDatabase();
|
|
|
|
export async function getCards(filter: CardFilter) {
|
|
let table = Database.cards;
|
|
// Get best IDB index
|
|
let query: Dexie.Collection<Card, string>;
|
|
|
|
if (filter.Powers && filter.Powers.length > 0) {
|
|
query = table.where("Power").anyOf(filter.Powers);
|
|
} else if (filter.Costs && filter.Costs.length > 0) {
|
|
query = table.where("Cost").anyOf(filter.Costs);
|
|
} else if (filter.Sets && filter.Sets.length > 0) {
|
|
query = table.where("Set").anyOf(filter.Sets);
|
|
} else if (filter.Types && filter.Types.length > 0) {
|
|
query = table.where("Type").anyOf(filter.Types);
|
|
} else {
|
|
if (
|
|
filter.Name ||
|
|
filter.Rules ||
|
|
filter.Traits ||
|
|
filter.Rarities ||
|
|
filter.Elements
|
|
) {
|
|
query = table.toCollection();
|
|
} else {
|
|
// Nothing to query, return everything
|
|
return await table.toArray();
|
|
}
|
|
}
|
|
|
|
return await query
|
|
.filter(x => {
|
|
if (filter.Name) {
|
|
if (
|
|
!`${x.Name}, ${x.Subname}`
|
|
.toLowerCase()
|
|
.includes(filter.Name.toLowerCase())
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Rules) {
|
|
if (
|
|
!`${x.Keywords.join(" ~ ")} ~ ${x.Text}`
|
|
.toLowerCase()
|
|
.includes(filter.Rules.toLowerCase())
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Traits && filter.Traits.length > 0) {
|
|
let found = false;
|
|
for (const trait of x.Traits) {
|
|
if (filter.Traits.includes(trait)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Sets && filter.Sets.length > 0) {
|
|
if (!filter.Sets.includes(x.Set)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Types && filter.Types.length > 0) {
|
|
if (!filter.Types.includes(x.Type)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Elements && filter.Elements.length > 0) {
|
|
let found = false;
|
|
for (const element of x.Element) {
|
|
if (filter.Elements.includes(element)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (x.Requirement) {
|
|
for (const element in x.Requirement) {
|
|
if (filter.Elements.includes(element)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (x.ProblemRequirement) {
|
|
for (const element in x.ProblemRequirement) {
|
|
if (filter.Elements.includes(element)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Powers && filter.Powers.length > 0) {
|
|
if (
|
|
typeof x.Power === "undefined" ||
|
|
!filter.Powers.includes(x.Power)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Costs && filter.Costs.length > 0) {
|
|
if (typeof x.Cost === "undefined" || !filter.Costs.includes(x.Cost)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (filter.Rarities && filter.Rarities.length > 0) {
|
|
if (!filter.Rarities.includes(x.Rarity)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
})
|
|
.toArray();
|
|
}
|