# Send response: Microservice

## Example for making your first request

In this class, I will demonstrate the usage of all four HTTP methods. If you have previous experience with microservices, the material should be easily comprehensible.

{% tabs %}
{% tab title="service/player.service.ts" %}
{% hint style="info" %}
**Information**

This code fetches player data from MySQL for Spigot via a GET request with UUID as parameter. The SQL query selects the player record and returns first result as player data. Additional functionality such as inserting records recommended.
{% endhint %}

Service files are usually nested in the **/service(s)/\*** folder in your app. Files that end \
with **.service.ts**, hold the logic for when they get requested from our Spigot server.

<pre class="language-typescript" data-title="service/player.service.ts"><code class="lang-typescript">import { Router } from '@spigotmc/microservice';
import { connection } from '..';

/**
 * Create a new router for this service.
 */
const service = new Router();

/**
 * This is only one example of four methods
 */
service.get('/load', (query) => {
  /**
   * The UUID of the player gets passed through
   * the query because this is a GET request.
   */
  const uuid: string = query.uuid;

  /**
   * This is the query that gets executed.
   */
  const sql = `SELECT * FROM players WHERE uuid='${<a data-footnote-ref href="#user-content-fn-1">uuid</a>}'`;

  /**
   * Execute the query and wait for the result.
   */
  return new Promise((resolve, reject) => {
    connection.query(sql, (error, results) => {
      /**
       * Reject the promise if an error occured.
       */
      if (error) return reject(error);
      /**
       * Resolve the promise with player's data.
       */
      resolve(<a data-footnote-ref href="#user-content-fn-2">results[0]</a>);
    });
  });
});

/**
 * Other endpoints like `/coin_update`, etc.,
 * should be implemented in this same file.
 */
export { service as playerService };
</code></pre>

{% endtab %}

{% tab title="PlayerRepository.java" %}
{% code title="PlayerRepository.java" %}

```java
import micro.api.service.*;
import micro.api.payload.*;

public class PlayerRepository extends ServiceEndpoint {
   /**
    * This points to `http://localhost:5000/api/player`
    */
    public PlayerRepository() {
       super("/player");
    }

    /**
     * Example of GET request, get player's data.
     * @return a new PlayerClient object.
     */
    public PlayerClient loadPlayer(UUID uuid) {
        Query query = new Query();
        query.add("uuid", uuid.toString());

        return super.get("/load", PlayerClient.class, query);
    }
    
    /**
     * Example of POST request, update player's coins.
     * @return The updated PlayerClient object.
     */
    public PlayerClient addFriend(UUID uuid, UUID target) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("target", target.toString());

        return super.post("/friend_add", PlayerClient.class, body);
    }
    
    /**
     * Example of PUT request, update player's coins.
     * @return The updated PlayerClient object.
     */
    public PlayerClient updateCoins(UUID uuid, int amount) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("coins", amount);

        return super.put("/coin_update", PlayerClient.class, body);
    }
    
    /**
     * Example of DELETE request, delete player data.
     * @return The deleted PlayerClient object.
     */
    public PlayerClient deletePlayer(UUID uuid) {
        Query query = new Query();
        query.add("uuid", uuid.toString());
        
        return super.delete("/delete", PlayerClient.class, query);
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="PlayerClient.java" %}

<pre class="language-java" data-title="PlayerClient.java"><code class="lang-java">public class PlayerClient {
   /**
    * These fields will get initialized when
    * loading the player from the service.
    */
   private String uuid;
   private int level;
   private <a data-footnote-ref href="#user-content-fn-3">Rank</a> rank;
   private int coins;
   private List&#x3C;String> friends;

   public UUID getUUID() { 
      return UUID.fromString(uuid); 
   }

   public int getLevel() {
       return level;
   }

   public <a data-footnote-ref href="#user-content-fn-4">Rank</a> getRank() {
      return rank;
   }

   public int getCoins() {
      return coins;
   }

   public List&#x3C;String> getFriends() {
       return friends;
   }
} 
</code></pre>

{% endtab %}
{% endtabs %}

Once you made your first service file, you should import this in the `/api` router.

{% code title="routes.ts" %}

```typescript
import { Router } from '@spigotmc/microservice';
import { playerService } from './services/player.service';

/**
 * Create a new Router from the Microservice library.
 */ 
const router = new Router();

/**
 * Add any sub-routes to the main router.
 */
router.use('/player', playerService);

/**
 * Export the router so that we can use
 * it in the main class where you decl-
 * ared the microservice.
 */ 
export default router;
```

{% endcode %}

[^1]: `584fb027-57c8-456c-84d2-552e1d508a6a`

[^2]: `{` \
    &#x20;  `"id": 1,`

    &#x20;  `"uuid": "584fb027-57c8-456c-84d2-552e1d508a6a",`

    &#x20;  `"level": 10,`

    &#x20;  `"rank": "ADMIN",`

    &#x20;  `"coins": 500`

    `}`

[^3]: <pre class="language-java"><code class="lang-java"><strong>public enum Rank {
    </strong>    PLAYER,
        HELPER,
        MODERATOR,
        ADMIN,
        OWNER,
    }
    </code></pre>

[^4]: ```java
    public enum Rank {
        PLAYER,
        HELPER,
        MODERATOR,
        ADMIN,
        OWNER,
    }
    ```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://walkinthepark.gitbook.io/microservice-api/reference/intro-making-requests/send-response-microservice.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.