Implementing Functions

[TelloViz]

Function Implementation

After we finished implementing the skeleton classes, we moved on to implementing the functions within them. A few are finished, and a few in progress still.

Functions Implemented:

Backend.all_sets() -> list[Set]

Written by Christian

def all_sets(self) -> list[Set]:
        """
        Retrieves all available sets from the Pokemon TCG API.
        
        Returns:
            list[Set]: A list of Set objects retrieved from the API.
        """
        return Set.all()

---

Backend.construct_query(self, query_data: list[tuple[str, str, str]]) -> str

Written by Josh

def construct_query(self, query_data: list[tuple[str, str, str]]) -> str:
        """
        Constructs a query string from the given search parameters.
        Args:
            search_parameters (list[tuple[str,str,str]]): A list of tuples representing the search parameters.

        Returns:
            str: The constructed query string.
        """

        # Initialize an empty dictionary to hold query parts
        query_parts = {}

        # Loop through each item in the queryData list
        for item in query_data:
            # Extract the category, subcategory, and target from the item
            category = item[0]
            subcategory = item[1]
            target = item[2]

            # Prepare the target for the query string with quotes
            target = f'"{target}"'  # Enclose target in quotes

            # If the category is not already in query_parts, create a new list for it
            if category not in query_parts:
                query_parts[category] = []

            # Check if subcategory is provided
            if subcategory:
                if category:
                    # Create a string in the format "category.subcategory:target" 
                    # and add it to the list
                    query_parts[category].append(f"{category}.{subcategory}:{target}")
                else:
                    # If no category, just "subcategory:target"
                    query_parts[category].append(f"{subcategory}:{target}")
            else:
                if category:
                    # Create a string in the format "category:target" 
                    # and add it to the list
                    query_parts[category].append(f"{category}:{target}")
                else:
                    # If no category or subcategory, just "target"
                    query_parts[category].append(target)

        # Prepare to construct the final query
        final_query_parts = []

        # Loop through each list of items in query_parts
        for items in query_parts.values():
            # If there is more than one item in the list
            if len(items) > 1:
                # Combine the items with "OR" and add parentheses around them
                final_query_parts.append(f"({' OR '.join(items)})")
            else:
                # If there's only one item, still wrap it in parentheses
                final_query_parts.append(f"({items[0]})")

        # Join all parts with "AND" to form the final query string
        final_query = " AND ".join(final_query_parts)
        return final_query

---

BackendController.request_sets_retrieve(self)

Written by Christian

@Slot()
    def request_sets_retrieve(self):
        """
        ## Description:
            Provide an interface for the front end to retrieve all available sets.
        Args:
            params none
        """
        try:
            
            initHandler = inithandler.InitHandler()
            
            sets = initHandler.handle_sets_retrieve()
            
            setList = [{"name" : set.name} for set in sets]
            
            self.setsResults.emit(json.dumps(setList))
        
        except Exception as e:
            self.setsResults.emit(json.dump({"error": str(e)}))

---

request_search(self, params: list[tuple[str, str, str]])

Written by Josh

This function is periodically updated to accommodate more data needed by upgrades to the front end.

@Slot(list)
    def request_search(self, params: list[tuple[str, str, str]]):
        """
        ## Description:
            Provide an interface for the front end 
            to make search requests with the given search parameters.
        Args:
            params (list[tuple[str, str, str]]): 
                List of search parameter tuples of the form (category, subcategory, target)
        """
       # for param in params:
            #print("request_search called with params:")
            #print(param[0])
            #print(param[1])
            #print(param[2])

        try:
            search_handler = searchhandler.SearchHandler()            
            cards = search_handler.handle_request_search(params)

            if cards is not None:
                #print("Cards is not None")
                card_list = []

                for card in cards:
                      # Initialize ability names and descriptions
                    ability_1_Name = ""
                    ability_1_Text = ""
                    ability_1_Type = ""

                    ability_2_Name = ""
                    ability_2_Text = ""
                    ability_2_Type = ""

                    # Initialize attack names, descriptions, and costs
                    attack_1_Cost1 = attack_1_Cost2 = attack_1_Cost3 = attack_1_Cost4 = attack_1_Cost5 = ""
                    attack_1_Name = ""
                    attack_1_Text = ""                    
                    attack_1_Damg = ""
                    attack_1_Conv = 0

                    attack_2_Cost1 = attack_2_Cost2 = attack_2_Cost3 = attack_2_Cost4 = attack_2_Cost5 = ""
                    attack_2_Name = ""
                    attack_2_Text = ""                    
                    attack_2_Damg = ""
                    attack_2_Conv = 0

                    attack_3_Cost1 = attack_3_Cost2 = attack_3_Cost3 = attack_3_Cost4 = attack_3_Cost5 = ""
                    attack_3_Name = ""
                    attack_3_Text = ""                    
                    attack_3_Damg = ""
                    attack_3_Conv = 0

                    attack_4_Cost1 = attack_4_Cost2 = attack_4_Cost3 = attack_4_Cost4 = attack_4_Cost5 = ""
                    attack_4_Name = ""
                    attack_4_Text = ""                    
                    attack_4_Damg = ""
                    attack_4_Conv = 0

                    # Process abilities
                    if hasattr(card, 'abilities') and card.abilities is not None:
                        if len(card.abilities) > 0:
                            ability_1_Name = card.abilities[0].name
                            ability_1_Text = card.abilities[0].text if hasattr(card.abilities[0], 'text') else ""
                            ability_1_Type = card.abilities[0].type if hasattr(card.abilities[0], 'type') else ""
                        if len(card.abilities) > 1:
                            ability_2_Name = card.abilities[1].name
                            ability_2_Text = card.abilities[1].text if hasattr(card.abilities[1], 'text') else ""
                            ability_2_Type = card.abilities[1].type if hasattr(card.abilities[1], 'type') else ""

                    # Process attacks
                    if hasattr(card, 'attacks') and card.attacks is not None:

                        # Process Attack 1
                        if len(card.attacks) > 0:
                            attack_1_Cost = card.attacks[0].cost if hasattr(card.attacks[0], 'cost') else []
                            if len(attack_1_Cost) > 0:
                                attack_1_Cost1 = attack_1_Cost[0]
                            if len(attack_1_Cost) > 1:
                                attack_1_Cost2 = attack_1_Cost[1]
                            if len(attack_1_Cost) > 2:
                                attack_1_Cost3 = attack_1_Cost[2]
                            if len(attack_1_Cost) > 3:
                                attack_1_Cost4 = attack_1_Cost[3]
                            if len(attack_1_Cost) > 4:
                                attack_1_Cost5 = attack_1_Cost[4]
                            attack_1_Name = card.attacks[0].name
                            attack_1_Text = card.attacks[0].text if hasattr(card.attacks[0], 'text') else ""
                            attack_1_Damg = card.attacks[0].damage if hasattr(card.attacks[0], 'damage') else ""
                            attack_1_Conv = card.attacks[0].convertedEnergyCost if hasattr(card.attacks[0], 'convertedEnergyCost') else 0
                        
                        # Process Attack 2
                        if len(card.attacks) > 1:

                            attack_2_Cost = card.attacks[1].cost if hasattr(card.attacks[1], 'cost') else []
                            if len(attack_2_Cost) > 0:
                                attack_2_Cost1 = attack_2_Cost[0]
                            if len(attack_2_Cost) > 1:
                                attack_2_Cost2 = attack_2_Cost[1]
                            if len(attack_2_Cost) > 2:
                                attack_2_Cost3 = attack_2_Cost[2]
                            if len(attack_2_Cost) > 3:
                                attack_2_Cost4 = attack_2_Cost[3]
                            if len(attack_2_Cost) > 4:
                                attack_2_Cost5 = attack_2_Cost[4]
                            attack_2_Name = card.attacks[1].name
                            attack_2_Text = card.attacks[1].text if hasattr(card.attacks[1], 'text') else ""
                            attack_2_Damg = card.attacks[1].damage if hasattr(card.attacks[1], 'damage') else ""
                            attack_2_Conv = card.attacks[1].convertedEnergyCost if hasattr(card.attacks[1], 'convertedEnergyCost') else 0
                        
                        # Process Attack 3
                        if len(card.attacks) > 2:

                            attack_3_Cost = card.attacks[2].cost if hasattr(card.attacks[2], 'cost') else []
                            if len(attack_3_Cost) > 0:
                                attack_3_Cost1 = attack_3_Cost[0]
                            if len(attack_3_Cost) > 1:
                                attack_3_Cost2 = attack_3_Cost[1]
                            if len(attack_3_Cost) > 2:
                                attack_3_Cost3 = attack_3_Cost[2]
                            if len(attack_3_Cost) > 3:
                                attack_3_Cost4 = attack_3_Cost[3]
                            if len(attack_3_Cost) > 4:
                                attack_3_Cost5 = attack_3_Cost[4]
                            attack_3_Name = card.attacks[2].name
                            attack_3_Text = card.attacks[2].text if hasattr(card.attacks[2], 'text') else ""
                            attack_3_Damg = card.attacks[2].damage if hasattr(card.attacks[2], 'damage') else ""
                            attack_3_Conv = card.attacks[2].convertedEnergyCost if hasattr(card.attacks[2], 'convertedEnergyCost') else 0

                        # Process Attack 4
                        if len(card.attacks) > 3:
                            
                            attack_4_Cost = card.attacks[3].cost if hasattr(card.attacks[3], 'cost') else []
                            if len(attack_4_Cost) > 0:
                                attack_4_Cost1 = attack_4_Cost[0]
                            if len(attack_4_Cost) > 1:
                                attack_4_Cost2 = attack_4_Cost[1]
                            if len(attack_4_Cost) > 2:
                                attack_4_Cost3 = attack_4_Cost[2]
                            if len(attack_4_Cost) > 3:
                                attack_4_Cost4 = attack_4_Cost[3]
                            if len(attack_4_Cost) > 4:
                                attack_4_Cost5 = attack_4_Cost[4]
                            attack_4_Name = card.attacks[3].name
                            attack_4_Text = card.attacks[3].text if hasattr(card.attacks[3], 'text') else ""
                            attack_4_Damg = card.attacks[3].damage if hasattr(card.attacks[3], 'damage') else ""
                            attack_4_Conv = card.attacks[3].convertedEnergyCost if hasattr(card.attacks[3], 'convertedEnergyCost') else 0

                    # Append the card information to card_list
                    card_list.append({
                        "name": card.name,
                        "rarity": card.rarity,
                        "flavor": card.flavorText,
                        "imageUrl": card.images.large,
                        "set": card.set.name,
                        "setSymbol": card.set.images.symbol,
                        "setLogo": card.set.images.logo,

                        # Ability information
                        "ability1Name": ability_1_Name,
                        "ability1Text": ability_1_Text,
                        "ability1Type": ability_1_Type,

                        "ability2Name": ability_2_Name,
                        "ability2Text": ability_2_Text,
                        "ability2Type": ability_2_Type,

                        # Attack 1 information
                        "attack1Cost1": attack_1_Cost1,
                        "attack1Cost2": attack_1_Cost2,
                        "attack1Cost3": attack_1_Cost3,
                        "attack1Cost4": attack_1_Cost4,
                        "attack1Cost5": attack_1_Cost5,
                        "attack1Name": attack_1_Name,
                        "attack1Text": attack_1_Text,
                        "attack1Damage": attack_1_Damg,
                        "attack1ConvertedEnergyCost": attack_1_Conv,

                        # Attack 2 information
                        "attack2Cost1": attack_2_Cost1,
                        "attack2Cost2": attack_2_Cost2,
                        "attack2Cost3": attack_2_Cost3,
                        "attack2Cost4": attack_2_Cost4,
                        "attack2Cost5": attack_2_Cost5,
                        "attack2Name": attack_2_Name,
                        "attack2Text": attack_2_Text,
                        "attack2Damage": attack_2_Damg,
                        "attack2ConvertedEnergyCost": attack_2_Conv,

                        # Attack 3 information
                        "attack3Cost1": attack_3_Cost1,
                        "attack3Cost2": attack_3_Cost2,
                        "attack3Cost3": attack_3_Cost3,
                        "attack3Cost4": attack_3_Cost4,
                        "attack3Cost5": attack_3_Cost5,
                        "attack3Name": attack_3_Name,
                        "attack3Text": attack_3_Text,
                        "attack3Damage": attack_3_Damg,
                        "attack3ConvertedEnergyCost": attack_3_Conv,

                        # Attack 4 information
                        "attack4Cost1": attack_4_Cost1,
                        "attack4Cost2": attack_4_Cost2,
                        "attack4Cost3": attack_4_Cost3,
                        "attack4Cost4": attack_4_Cost4,
                        "attack4Cost5": attack_4_Cost5,
                        "attack4Name": attack_4_Name,
                        "attack4Text": attack_4_Text,
                        "attack4Damage": attack_4_Damg,
                        "attack4ConvertedEnergyCost": attack_4_Conv,
                    })

                # Emit the result as JSON
                #print("Card list to emit:", card_list)  # Debugging output

                self.searchResults.emit(json.dumps(card_list))

        except Exception as e:
            self.searchResults.emit(json.dumps({"error": str(e)}))

---

handle_sets_retrieve(self) -> list[Set]:

Written by Batu

from pokemontcgsdk import Set
import backend

class InitHandler:
    """
    Handles any front end requests for requesting data for the front end to initalize components.
    """

    def handle_sets_retrieve(self) -> list[Set]:
        """
        Description:
            Provide an interface for the front end to retrieve all available sets.
        Args:
            params none
        Returns:
            list[Set]
        """

        # call backend's all_sets function to retrieve sets
        return backend.Backend.all_sets(self)

[TelloViz]

Front End Functions

updateAttackInfo()

Written by Josh

    // Function to update attack information based on selectedIndex
    function updateAttackInfo() {
        //console.log("updateAttackInfo called...");
        if (cards[selectedIndex]) {
            // Update attack text fields first
            attack1Name.text = cards[selectedIndex].attack1Name || "Attack 1"
            attack1DescriptionDropText.text = cards[selectedIndex].attack1Text
                    || "No description available." // Fallback if no description

            attack2NameText.text = cards[selectedIndex].attack2Name
                    || "Attack 2"
            attack2DescriptionText.text = cards[selectedIndex].attack2Text
                    || "No description available." // Fallback if no description

            attack3NameText.text = cards[selectedIndex].attack3Name
                    || "Attack 3"
            attack3DescriptionText.text = cards[selectedIndex].attack3Text
                    || "No description available." // Fallback if no description

            attack4NameText.text = cards[selectedIndex].attack4Name
                    || "Attack 4"
            attack4DescriptionText.text = cards[selectedIndex].attack4Text
                    || "No description available." // Fallback if no description

            // Set visibility for each attack based on the card data
            attack1NameBlock.visible = cards[selectedIndex].attack1Name !== "Attack 1"
                    && cards[selectedIndex].attack1Name !== ""
            attack1DescriptionBlock.visible = attack1NameBlock.visible
            attack1DescriptionBlock.height = attack1DescriptionBlock.visible
                    && attack1DescriptionDropText.text === "No description available." ? 75 : 120

            attack2NameBlock.visible = cards[selectedIndex].attack2Name !== "Attack 2"
                    && cards[selectedIndex].attack2Name !== ""
            attack2DescriptionBlock.visible = attack2NameBlock.visible
            attack2DescriptionBlock.height = attack2DescriptionBlock.visible
                    && attack2DescriptionText.text === "No description available." ? 75 : 120

            attack3NameBlock.visible = cards[selectedIndex].attack3Name !== "Attack 3"
                    && cards[selectedIndex].attack3Name !== ""
            attack3DescriptionBlock.visible = attack3NameBlock.visible
            attack3DescriptionBlock.height = attack3DescriptionBlock.visible
                    && attack3DescriptionText.text === "No description available." ? 75 : 120

            attack4NameBlock.visible = cards[selectedIndex].attack4Name !== "Attack 4"
                    && cards[selectedIndex].attack4Name !== ""
            attack4DescriptionBlock.visible = attack4NameBlock.visible
            attack4DescriptionBlock.height = attack4DescriptionBlock.visible
                    && attack4DescriptionText.text === "No description available." ? 75 : 120
        }
    }

---

updateAbilityInfo()

Written by Josh

    // Function to update ability information based on selectedIndex
    function updateAbilityInfo() {
        // console.log("updateAbilityInfo called...");
        if (cards[selectedIndex]) {
            // Update ability text fields first
            ability1NameText.text = cards[selectedIndex].ability1Name
                    || "Ability 1"
            ability1DescriptionDropText.text = cards[selectedIndex].ability1Text
                    || "No description available."
            ability1TypeText.text = cards[selectedIndex].ability1Type || "N/A"

            ability2NameText.text = cards[selectedIndex].ability2Name
                    || "Ability 2"
            ability2DescriptionDropText.text = cards[selectedIndex].ability2Text
                    || "No description available."
            ability2TypeText.text = cards[selectedIndex].ability2Type || "N/A"

            // Set visibility for each ability based on the card data
            ability1NameBlock.visible = cards[selectedIndex].ability1Name !== "Ability 1"
                    && cards[selectedIndex].ability1Name !== ""
            ability1DescriptionBlock.visible = ability1NameBlock.visible
            ability1TypeBlock.visible = ability1NameBlock.visible
            ability1DescriptionBlock.height = ability1DescriptionBlock.visible
                    && ability1DescriptionDropText.text === "No description available." ? 75 : 136

            ability2NameBlock.visible = cards[selectedIndex].ability2Name !== "Ability 2"
                    && cards[selectedIndex].ability2Name !== ""
            ability2DescriptionBlock.visible = ability2NameBlock.visible
            ability2TypeBlock.visible = ability2NameBlock.visible
            ability2DescriptionBlock.height = ability2DescriptionBlock.visible
                    && ability2DescriptionDropText.text === "No description available." ? 75 : 136
        }
    }

---

resetAttackScroll()

Written by Josh

    // Resets the position of the column of attacks
    function resetAttackScroll() {
        attackScrollView.contentX = 0
        attackScrollView.contentY = 0
    }

---

onNextCard()

Written by Josh

    // Function to handle next button click
    function onNextCard() {
        if (selectedIndex < cards.length - 1) {
            selectedIndex++
            updateAttackInfo() // Update UI for the new selectedIndex
            updateAbilityInfo()
            resetAttackScroll()
        }
    }

---

onPrevCard()

Written by Josh

    // Function to handle next button click
    function onPrevCard() {
        if (selectedIndex >= 0) {
            selectedIndex--
            updateAttackInfo() // Update UI for the new selectedIndex
            updateAbilityInfo()
            resetAttackScroll()
        }
    }

---

onSetsResults(response)

Written by Josh

function onSetsResults(response) {
  var data = JSON.parse(response)
  setsModel.clear() // Clear existing items in the model
  
  if (data.error) {
      sets = [] // Clear the array of sets
      console.log("Error in the data received from backend.")
  } else {
      // Collect sets into an array
      var tempSets = []
  
      data.forEach(function (set) {
          // Collect each set object
          tempSets.push({
                            "name": set.name,
                            "selected": false
                        })
      })
  
      // Sort the array alphabetically by name
      tempSets.sort(function (a, b) {
          return a.name.localeCompare(
                      b.name) // Sort using localeCompare for alphabetical order
      })
  
      // Append sorted sets to the model
      tempSets.forEach(
                  function (sortedSet) {
                      setsModel.append(sortedSet)
                  })
    }
  }

---

onSearchResults(response)

Written by Josh

function onSearchResults(response) {
                    
    var data = JSON.parse(response)
    
    if (data.error) {
        console.log("Error in response:",
                    data.error) // Log the error message
        cards = []
    } else {
        cards = data.map(card => ({
            "name": card.name,
             "name": card.name,
            
            "imageUrl": card.imageUrl || "",
            
            "set": card.set,
            "setSymbol": card.setSymbol,
            "setLogo": card.setLogo,
            
            "ability1Name"// Abilities
            : card.ability1Name || "", 
            
            "ability1Text": card.ability1Text || "",
            "ability1Type": card.ability1Type || "",
            "ability2Name": card.ability2Name || "",
            "ability2Text": card.ability2Text || "",
            "ability2Type": card.ability2Type || "",
            
            // Attacks
            "attack1Name": card.attack1Name || "",
            "attack1Text": card.attack1Text || "",
            "attack1Damage": card.attack1Damage || "",
            "attack1ConvertedEnergyCost": card.attack1ConvertedEnergyCost || 0,
            
            "attack2Name": card.attack2Name || "",
            "attack2Text": card.attack2Text || "",
            "attack2Damage": card.attack2Damage || "",
            "attack2ConvertedEnergyCost": card.attack2ConvertedEnergyCost || 0,
            
            "attack3Name": card.attack3Name || "",
            "attack3Text": card.attack3Text || "",
            "attack3Damage": card.attack3Damage || "",
            "attack3ConvertedEnergyCost": card.attack3ConvertedEnergyCost || 0,
            
            "attack4Name": card.attack4Name || "",
            "attack4Text": card.attack4Text || "",
            "attack4Damage": card.attack4Damage || "",
            "attack4ConvertedEnergyCost": card.attack4ConvertedEnergyCost || 0,
            
            // Subtypes
            "subtype1" : card.subtype1 || "", 
            "subtype2": card.subtype2 || ""
        }))
        
        selectedIndex = 0; // Start with the first card
        updateAttackInfo();
        updateAbilityInfo();
        updateSubTypeInfo();
    }
    }