How to use mage.cards.decks.importer

public DeckCardLists importDeck(String file) {
  return importDeck(file, null);
}

public static DeckImporter getDeckImporter(String file) {
 if (file == null) {
  return null;
 } if (file.toLowerCase(Locale.ENGLISH).endsWith("dec")) {
  return new DecDeckImporter();
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("mwdeck")) {
  return new MWSDeckImporter();
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("txt")) {
  return new TxtDeckImporter(haveSideboardSection(file));
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("dck")) {
  return new DckDeckImporter();
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("dek")) {
  return new DekDeckImporter();
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("cod")) {
  return new CodDeckImporter();
 } else if (file.toLowerCase(Locale.ENGLISH).endsWith("o8d")) {
  return new O8dDeckImporter();
 } else {
  return null;
 }
}

public static DeckCardLists importDeckFromFile(String file) {
 return importDeckFromFile(file, new StringBuilder());
}

public static DeckCardLists importDeckFromFile(String file, StringBuilder errorMessages) {
 DeckImporter deckImporter = getDeckImporter(file);
 if (deckImporter != null) {
  return deckImporter.importDeck(file, errorMessages);
 } else {
  return new DeckCardLists();
 }
}

@Override
public DeckCardLists importDeck(String filename, StringBuilder errorMessages) {
 try {
  Document doc = getXmlDocument(filename);
  DeckCardLists decklist = new DeckCardLists();
  List<Node> mainCards = getNodes(doc, "/deck/section[@name='Main']/card");
  decklist.setCards(mainCards.stream()
    .flatMap(toDeckCardInfo(getCardLookup(), errorMessages))
    .collect(Collectors.toList()));
  List<Node> sideboardCards = getNodes(doc, "/deck/section[@name='Sideboard']/card");
  decklist.setSideboard(sideboardCards.stream()
    .flatMap(toDeckCardInfo(getCardLookup(), errorMessages))
    .collect(Collectors.toList()));
  return decklist;
 } catch (Exception e) {
  logger.error("Error loading deck", e);
  errorMessages.append("There was an error loading the deck.");
  return new DeckCardLists();
 }
}

@Override
public DeckCardLists importDeck(String filename, StringBuilder errorMessages) {
 try {
  Document doc = getXmlDocument(filename);
  DeckCardLists decklist = new DeckCardLists();
  List<Node> mainCards = getNodes(doc, "/cockatrice_deck/zone[@name='main']/card");
  decklist.setCards(mainCards.stream()
    .flatMap(toDeckCardInfo(getCardLookup(), errorMessages))
    .collect(Collectors.toList()));
  List<Node> sideboardCards = getNodes(doc, "/cockatrice_deck/zone[@name='side']/card");
  decklist.setSideboard(sideboardCards.stream()
    .flatMap(toDeckCardInfo(getCardLookup(), errorMessages))
    .collect(Collectors.toList()));
  getNodes(doc, "/cockatrice_deck/deckname")
    .forEach(n -> decklist.setName(n.getTextContent().trim()));
  return decklist;
 } catch (Exception e) {
  logger.error("Error loading deck", e);
  errorMessages.append("There was an error loading the deck.");
  return new DeckCardLists();
 }
}

private void btnCheatActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnCheatActionPerformed
  DckDeckImporter deckImporter = new DckDeckImporter();
  SessionHandler.cheat(gameId, playerId, deckImporter.importDeck("cheat.dck"));
}

public DeckCardLists importDeck(String file) {
 return importDeck(file, new StringBuilder());
}

private static Function<Node, Stream<DeckCardInfo>> toDeckCardInfo(CardLookup lookup, StringBuilder errors) {
 return node -> {
  String name = node.getTextContent();
  Optional<CardInfo> cardInfo = lookup.lookupCardInfo(name);
  if (cardInfo.isPresent()) {
   CardInfo info = cardInfo.get();
   return Collections.nCopies(
     getQuantityFromNode(node),
     new DeckCardInfo(info.getName(), info.getCardNumber(), info.getSetCode())).stream();
  } else {
   errors.append("Could not find card: '").append(name).append("'\n");
   return Stream.empty();
  }
 };
}

private static Function<Node, Stream<DeckCardInfo>> toDeckCardInfo(CardLookup lookup, StringBuilder errors) {
 return node -> {
  String name = node.getAttributes().getNamedItem("name").getNodeValue().trim();
  Optional<CardInfo> cardInfo = lookup.lookupCardInfo(name);
  if (cardInfo.isPresent()) {
   CardInfo info = cardInfo.get();
   return Collections.nCopies(
     getQuantityFromNode(node),
     new DeckCardInfo(info.getName(), info.getCardNumber(), info.getSetCode())).stream();
  } else {
   errors.append("Could not find card: '").append(name).append("'\n");
   return Stream.empty();
  }
 };
}

try {
  int num = Integer.parseInt(lineNum);
  Optional<CardInfo> cardLookup = getCardLookup().lookupCardInfo(lineName);
  if (!cardLookup.isPresent()) {
    sbMessage.append("Could not find card: '").append(lineName).append("' at line ").append(lineCount).append('\n');

criteria.name(lineName);
criteria.setCodes(setCode);
List<CardInfo> cards = getCardLookup().lookupCardInfo(criteria);
if (!cards.isEmpty()) {
  cardInfo = cards.get(RandomUtil.nextInt(cards.size()));
cardInfo = getCardLookup().lookupCardInfo(lineName).orElse(null);

String line = scanner.nextLine().trim();
lineCount++;
readLine(line, deckList);

@Override
protected void readLine(String line, DeckCardLists deckList) {
  if (line.isEmpty() || line.startsWith("#") || !line.contains("<Cards CatID")) {
    return;
  }
  try {
    // e.g. <Cards CatID="61202" Quantity="1" Sideboard="false" Name="Vildin-Pack Outcast" />
    Integer cardCount = Integer.parseInt(extractAttribute(line, "Quantity"));
    String cardName = extractAttribute(line, "Name");
    boolean isSideboard = "true".equals(extractAttribute(line, "Sideboard"));
    CardInfo cardInfo = CardRepository.instance.findPreferedCoreExpansionCard(cardName, true);
    if (cardInfo == null) {
      sbMessage.append("Could not find card: '").append(cardName).append("' at line ").append(lineCount).append('\n');
    } else {
      for (int i = 0; i < cardCount; i++) {
        DeckCardInfo deckCardInfo = new DeckCardInfo(cardInfo.getName(), cardInfo.getCardNumber(), cardInfo.getSetCode());
        if(isSideboard) {
          deckList.getSideboard().add(deckCardInfo);
        } else {
          deckList.getCards().add(deckCardInfo);
        }
      }
    }
  }catch (NumberFormatException nfe) {
    sbMessage.append("Invalid number: ").append(extractAttribute(line, "Quantity")).append(" at line ").append(lineCount).append('\n');
  }
}

private void btnCheatActionPerformed(java.awt.event.ActionEvent evt) {
  SessionHandler.cheat(gameId, playerId, DeckImporter.importDeckFromFile("cheat.dck"));
}

public boolean joinTable(UUID roomId, UUID tableId) throws IOException, ClassNotFoundException {
  if (this.cbPlayerType.getSelectedItem() != PlayerType.HUMAN) {
    return SessionHandler.joinTable(roomId, tableId, this.newPlayerPanel.getPlayerName(), (PlayerType) this.cbPlayerType.getSelectedItem(), this.newPlayerPanel.getLevel(), DeckImporter.importDeckFromFile(this.newPlayerPanel.getDeckFile()), "");
  }
  return true;
}

private void btnOKActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnOKActionPerformed
  Session session = SessionHandler.getSession();
  try {
    PreferencesDialog.saveValue(PreferencesDialog.KEY_NEW_TABLE_PASSWORD_JOIN, txtPassword.getText());
    if (isTournament) {
      joined = session.joinTournamentTable(roomId, tableId, this.newPlayerPanel.getPlayerName(), PlayerType.HUMAN, 1, DeckImporter.importDeckFromFile(this.newPlayerPanel.getDeckFile()), this.txtPassword.getText());
    } else {
      joined = session.joinTable(roomId, tableId, this.newPlayerPanel.getPlayerName(), PlayerType.HUMAN, 1, DeckImporter.importDeckFromFile(this.newPlayerPanel.getDeckFile()), this.txtPassword.getText());
    }
    
  } catch (Exception ex) {
    handleError(ex);
  }
  this.hideDialog();
}//GEN-LAST:event_btnOKActionPerformed

  @Override
  public void windowClosed(WindowEvent e) {
    Deck newDeck = null;
    StringBuilder errorMessages = new StringBuilder();
    MageFrame.getDesktop().setCursor(new Cursor(Cursor.WAIT_CURSOR));
    try {
      newDeck = Deck.load(DeckImporter.importDeckFromFile(dialog.getTmpPath(), errorMessages), true, true);
      processAndShowImportErrors(errorMessages);
      if (newDeck != null) {
        deck = newDeck;
        refreshDeck();
      }
    } catch (GameException e1) {
      JOptionPane.showMessageDialog(MageFrame.getDesktop(), e1.getMessage(), "Error loading deck", JOptionPane.ERROR_MESSAGE);
    } finally {
      MageFrame.getDesktop().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
    }
  }
});

  @Override
  public void windowClosed(WindowEvent e) {
    Deck deckToAppend = null;
    StringBuilder errorMessages = new StringBuilder();
    MageFrame.getDesktop().setCursor(new Cursor(Cursor.WAIT_CURSOR));
    try {
      deckToAppend = Deck.load(DeckImporter.importDeckFromFile(dialog.getTmpPath(), errorMessages), true, true);
      processAndShowImportErrors(errorMessages);
      if (deckToAppend != null) {
        deck = Deck.append(deckToAppend, deck);
        refreshDeck();
      }
    } catch (GameException e1) {
      JOptionPane.showMessageDialog(MageFrame.getDesktop(), e1.getMessage(), "Error loading deck", JOptionPane.ERROR_MESSAGE);
    } finally {
      MageFrame.getDesktop().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
    }
  }
});

private void btnGenDeckActionPerformed(ActionEvent evt) {
  try {
    MageFrame.getDesktop().setCursor(new Cursor(Cursor.WAIT_CURSOR));
    String path = DeckGenerator.generateDeck();
    deck = Deck.load(DeckImporter.importDeckFromFile(path), true, true);
  } catch (GameException ex) {
    JOptionPane.showMessageDialog(MageFrame.getDesktop(), ex.getMessage(), "Error loading generated deck", JOptionPane.ERROR_MESSAGE);
  } catch (DeckGeneratorException ex) {
    JOptionPane.showMessageDialog(MageFrame.getDesktop(), ex.getMessage(), "Generator error", JOptionPane.ERROR_MESSAGE);
  } finally {
    MageFrame.getDesktop().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
  }
  refreshDeck();
}
// Variables declaration - do not modify//GEN-BEGIN:variables