Veebirakenduse loomine ASP.NET ja API abil

  1. Loome ASP.NET core web API

2. Muudame profiles -> projekti_nimi -> applicationUrl

Port on kirja pandud “Properties” kaustas olevas failis “launchSettings.json”, profiles -> projekti_nimi -> applicationUrl taga. Soovi korral võid seda vahetada. Lihtsuse huvides vahetan selle ära:

JSON
"applicationUrl": "https://localhost:4444;http://localhost:5119","

Tulemus:

3. Loome kaust nimega: Controllers ja loome seal WeatherController.cs ja kirjutame sisse:

C#
using Microsoft.AspNetCore.Mvc;

namespace VeebTARpv23.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherController> _logger;

        public WeatherController(ILogger<WeatherController> logger)
        {
            _logger = logger;
        }

        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }
}

4. Loome esimese api päringu

Selleks loome uue faili: PrimitiividController, millega saame teha päringuid primitiivsete tüüpidega.

Uue faili loomiseks vajuta kausta “Controllers” kausta peal parema klõpsuga, vali “add” ning võta “New Item…”. Pane loodud faili nimeks PrimitiividController.cs ning vali tühja API kontrolleri mall (API Controller – Empty).

C#
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace VeebTARpv23.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class PrimitiividController : ControllerBase
    {
        // GET: primitiivid/hello-world
        [HttpGet("hello-world")]
        public string HelloWorld()
        {
            return "Hello world at " + DateTime.Now;
        }

        // GET: primitiivid/hello-variable/mari
        [HttpGet("hello-variable/{nimi}")]
        public string HelloVariable(string nimi)
        {
            return "Hello " + nimi;
        }

        // GET: primitiivid/add/5/6
        [HttpGet("add/{nr1}/{nr2}")]
        public int AddNumbers(int nr1, int nr2)
        {
            return nr1 + nr2;
        }

        // GET: primitiivid/multiply/5/6
        [HttpGet("multiply/{nr1}/{nr2}")]
        public int Multiply(int nr1, int nr2)
        {
            return nr1 * nr2;
        }

        // GET: primitiivid/do-logs/5
        [HttpGet("do-logs/{arv}")]
        public void DoLogs(int arv)
        {
            for (int i = 0; i < arv; i++)
            {
                Console.WriteLine("See on logi nr " + i);
            }
        }
    }
}

Käivitame projekti ja avame ühe neist klikkime Try in out ja paneme mingit numbrit või sõna sõltub andme tüübist

Tulemuseks saame:

5. Loome uue Class nimega Toode, mudeli kautis

C#
namespace VeebTARpv23.Models
{
    public class Toode
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public double Price { get; set; }
        public bool IsActive { get; set; }

        public Toode(int id, string name, double price, bool isActive)
        {
            Id = id;
            Name = name;
            Price = price;
            IsActive = isActive;
        }
    }
}

6. Loome uue Controllerˇi nimega ToodeController.cs:

Sisse kirjutame:

C#
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using VeebTARpv23.Models;

namespace VeebTARpv23.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ToodeController : ControllerBase
    {
        private static List<Toode> _tooted = new List<Toode>{
        new Toode(1,"Koola", 1.5, true),
        new Toode(2,"Fanta", 1.0, false),
        new Toode(3,"Sprite", 1.7, true),
        new Toode(4,"Vichy", 2.0, true),
        new Toode(5,"Vitamin well", 2.5, true)
        };


        // https://localhost:7052/tooted
        [HttpGet]
        public List<Toode> Get()
        {
            return _tooted;
        }

        [HttpGet("kustuta/{index}")]
        public List<Toode> Delete(int index)
        {
            _tooted.RemoveAt(index);
            return _tooted;
        }

        [HttpGet("kustuta2/{index}")]
        public string Delete2(int index)
        {
            _tooted.RemoveAt(index);
            return "Kustutatud!";
        }

        [HttpGet("lisa/{id}/{nimi}/{hind}/{aktiivne}")]
        public List<Toode> Add(int id, string nimi, double hind, bool aktiivne)
        {
            Toode toode = new Toode(id, nimi, hind, aktiivne);
            _tooted.Add(toode);
            return _tooted;
        }

        [HttpGet("lisa")] // GET /tooted/lisa?id=1&nimi=Koola&hind=1.5&aktiivne=true
        public List<Toode> Add2([FromQuery] int id, [FromQuery] string nimi, [FromQuery] double hind, [FromQuery] bool aktiivne)
        {
            Toode toode = new Toode(id, nimi, hind, aktiivne);
            _tooted.Add(toode);
            return _tooted;
        }

        [HttpGet("hind-dollaritesse/{kurss}")] // GET /tooted/hind-dollaritesse/1.5
        public List<Toode> Dollaritesse(double kurss)
        {
            for (int i = 0; i < _tooted.Count; i++)
            {
                _tooted[i].Price = _tooted[i].Price * kurss;
            }
            return _tooted;
        }

        // või foreachina:

        [HttpGet("hind-dollaritesse2/{kurss}")] // GET /tooted/hind-dollaritesse2/1.5
        public List<Toode> Dollaritesse2(double kurss)
        {
            foreach (var t in _tooted)
            {
                t.Price = t.Price * kurss;
            }

            return _tooted;
        }
    }
}

Tulemusena saame:

Võttame näiteks /api/toode/lisa, lisame sinna toode id: 1 nimega TOODE1 ja hinnaga 12 ja aktiivsusega:True

7. Loome uue rakenduse ükskõik nimega näiteks frontend

Esimesena kirjutame terminali sisse: npx create-react-app
Pärast kommandiga cd läheme sinna sisse ja kui teil on installitud Visual studio code või mõni teine teksti redaktor võime kirjutata lihtsalt code .
Seal me loome faili server.js või app.js ja sisse kirjutame:

JavaScript
import { useEffect, useRef, useState } from 'react';
import './App.css';

function App() {
  const [tooted, setTooted] = useState([]);
  const idRef = useRef();
  const nameRef = useRef();
  const priceRef = useRef();
  const isActiveRef = useRef();
  const [isUsd, setUsd] = useState(false);

  useEffect(() => {
    fetch("https://localhost:4444/tooted")
      .then(res => res.json())
      .then(json => setTooted(json));
  }, []);

  function kustuta(index) {
    fetch("https://localhost:4444/tooted/kustuta/" + index)
      .then(res => res.json())
      .then(json => setTooted(json));
  }

  function lisa() {
    fetch(`https://localhost:4444/tooted/lisa/${Number(idRef.current.value)}/${nameRef.current.value}/${Number(priceRef.current.value)}/${isActiveRef.current.checked}`)
      .then(res => res.json())
      .then(json => setTooted(json));
  }

  function dollariteks() {
    const kurss = 1.1;
    setUsd(true);
    fetch("https://localhost:4444/tooted/hind-dollaritesse/" + kurss)
      .then(res => res.json())
      .then(json => setTooted(json));
  }

  function eurodeks() {
    const kurss = 0.9091;
    setUsd(false);
    fetch("https://localhost:4444/tooted/hind-dollaritesse/" + kurss)
      .then(res => res.json())
      .then(json => setTooted(json));
  }

  return (
    <div className="App">
      <label>ID</label> <br />
      <input ref={idRef} type="number" /> <br />
      <label>name</label> <br />
      <input ref={nameRef} type="text" /> <br />
      <label>price</label> <br />
      <input ref={priceRef} type="number" /> <br />
      <label>isActive</label> <br />
      <input ref={isActiveRef} type="checkbox" /> <br />
      <button onClick={() => lisa()}>Lisa</button>
      {tooted.map((toode, index) => 
        <div>
          <div>{toode.id}</div>
          <div>{toode.name}</div>
          <div>{toode.price.toFixed(2)}</div>
          <button onClick={() => kustuta(index)}>x</button>
        </div>)}
      {isUsd === false && <button onClick={() => dollariteks()}>Muuda dollariteks</button>}
      {isUsd === true && <button onClick={() => eurodeks()}>Muuda eurodeks</button>}
    </div>
  );
}

export default App;

Pärast kui me kirjutasime või lihtsalt kopeerisime siilt koodi me peame selle rakenduse käivitama, käivitame käsuga npm start
Rakendus käivitab pordil: localhost:3000

8. GET, POST päringuid POSTMAN rakenduses

Teeme lahti postman ja lisame uue päringu näiteks GET ja lisame sinna niisuguse lingi
https://localhost:4444/api/Toode

Klikkime nuppule SEND ja peame saatma vastuseks JSON faili kus on meie andmed kui me neid lisasime

Tulemus:

Selleks, et lisada vahetame päringu POST peale ja kirjutame niisuguse URL:
https://localhost:4444/api/Toode/lisa2

Otsime BODY -> RAW -> JSON ja kirjutame sinna sisse näiteks:

JSON
{
  "id": 3223121,
  "name": "bools",
  "price": 5,
  "isActive": true
}

Ja pärast klikkime SEND nuppu peale, kui teil tuleb mingi viga näiteks, et ei saa lisada, võib olla teil ei ole lihtsalt funktsiooni mis töötleb JSONˇi siis võime lisada näiteks

C#
[HttpPost("lisa2")]
public IActionResult LisaJson([FromBody] Toode toode)
{
    if (toode == null)
    {
        return BadRequest("JSON data is missing");
    }

    _tooted.Add(toode);
    return Ok(_tooted);
}

ja pärast seda vastuseks me peame saatma JSONˇi mida me saatsime

Tulemus:

9. API päring teise rakendusse: pakiautomaatide kättesaamine

Loome faili Controllers/ParcelMachineController.cs ja lisame sinna niisuguse koodi:

C#
    public class ParcelMachineController : ControllerBase
    {
        private readonly HttpClient _httpClient;

        public ParcelMachineController(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        [HttpGet]
        public async Task<IActionResult> GetParcelMachines()
        {
            var response = await _httpClient.GetAsync("https://www.omniva.ee/locations.json");
            var responseBody = await response.Content.ReadAsStringAsync();
            return Content(responseBody, "application/json");
        }
    }

Selleks, et see töötas siis lisame veel Programs.cs failisse sisse:

C#
builder.Services.AddHttpClient();

Nüüd me lisame App.jsx siise niisuguse koodi võime seda muuta kui tahame (mina muudsin), või adapteerime koodile mis meil juba on:

JavaScript
import { useEffect, useState } from 'react';
import './App.css';

function App() {
  const [pakiautomaadid, setPakiautomaadid] = useState([]);

  useEffect(() => {
    fetch("https://localhost:4444/parcelmachine")
      .then(res => res.json())
      .then(json => setPakiautomaadid(json));
  }, []);

  return (
    <div className="App">
      <select>
        {pakiautomaadid.map(automaat => 
            <option>
                {automaat.NAME}
            </option>)}
      </select>
    </div>
  );
}

export default App;

Minu App.jsx kui teile ei taha adapteerida:

JavaScript
import { useEffect, useRef, useState } from 'react';
import './App.css';

function App() {
  const [tooted, setTooted] = useState([]);
  const idRef = useRef();
  const nameRef = useRef();
  const priceRef = useRef();
  const isActiveRef = useRef();
  const [isUsd, setUsd] = useState(false);
  const [pakiautomaadid, setPakiautomaadid] = useState([]);
  const [valitudAutomaat, setValitudAutomaat] = useState('');
  const [automaatInfo, setAutomaatInfo] = useState(null);

  useEffect(() => {
    console.log('Fetching tooted from backend...');
    fetch("/tooted")
      .then(res => {
        console.log('Response status:', res.status);
        if (!res.ok) {
          throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
      })
      .then(json => {
        console.log('Received data:', json);
        setTooted(json);
      })
      .catch(error => {
        console.error('Error fetching tooted:', error);
        console.log('Make sure your backend server is running and the endpoint exists');
        setTooted([]);
      });

    // Fetch parcel machines
    fetch("/api/parcelmachine")
      .then(res => res.json())
      .then(json => setPakiautomaadid(json))
      .catch(error => console.error('Error fetching parcel machines:', error));
  }, []);

  function kustuta(index) {
    fetch("/tooted/kustuta/" + index)
      .then(res => {
        if (!res.ok) {
          throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
      })
      .then(json => setTooted(json))
      .catch(error => console.error('Error deleting item:', error));
  }

  function lisa() {
    fetch(`/tooted/lisa/${Number(idRef.current.value)}/${nameRef.current.value}/${Number(priceRef.current.value)}/${isActiveRef.current.checked}`)
      .then(res => {
        if (!res.ok) {
          throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
      })
      .then(json => setTooted(json))
      .catch(error => console.error('Error adding item:', error));
  }

  function dollariteks() {
    const kurss = 1.1;
    setUsd(true);
    fetch("/tooted/hind-dollaritesse/" + kurss)
      .then(res => {
        if (!res.ok) {
          throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
      })
      .then(json => setTooted(json))
      .catch(error => console.error('Error converting to dollars:', error));
  }

  function eurodeks() {
    const kurss = 0.9091;
    setUsd(false);
    fetch("/tooted/hind-dollaritesse/" + kurss)
      .then(res => {
        if (!res.ok) {
          throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
      })
      .then(json => setTooted(json))
      .catch(error => console.error('Error converting to euros:', error));
  }

  function vaataAutomaat() {
    if (!valitudAutomaat) {
      alert('Palun vali pakiautomaat!');
      return;
    }
    
    const automaat = pakiautomaadid.find(a => a.NAME === valitudAutomaat);
    if (automaat) {
      setAutomaatInfo(automaat);
      console.log('Valitud automaat:', automaat);
    }
  }

  return (
    <div className="App">
      <h2>Tooted (Products)</h2>
      <label>ID</label> <br />
      <input ref={idRef} type="number" /> <br />
      <label>name</label> <br />
      <input ref={nameRef} type="text" /> <br />
      <label>price</label> <br />
      <input ref={priceRef} type="number" /> <br />
      <label>isActive</label> <br />
      <input ref={isActiveRef} type="checkbox" /> <br />
      <button onClick={() => lisa()}>Lisa</button>
      {tooted.map((toode, index) => 
        <div key={index}>
          <div>{toode.id}</div>
          <div>{toode.name}</div>
          <div>{toode.price.toFixed(2)}</div>
          <button onClick={() => kustuta(index)}>x</button>
        </div>)}
      {isUsd === false && <button onClick={() => dollariteks()}>Muuda dollariteks</button>}
      {isUsd === true && <button onClick={() => eurodeks()}>Muuda eurodeks</button>}
      
      <hr />
      <h2>Pakiautomaadid (Parcel Machines)</h2>
      <select value={valitudAutomaat} onChange={(e) => setValitudAutomaat(e.target.value)}>
        <option value="">Vali pakiautomaat...</option>
        {pakiautomaadid.map((automaat, index) => 
          <option key={index} value={automaat.NAME}>
            {automaat.NAME}
          </option>
        )}
      </select>
      <br /><br />
      <button onClick={vaataAutomaat} disabled={!valitudAutomaat}>
        Vaata automaati
      </button>
      
      {automaatInfo && (
        <div style={{marginTop: '20px', padding: '10px', border: '1px solid #ccc', borderRadius: '5px'}}>
          <h3>Automaadi info:</h3>
          <p><strong>Nimi:</strong> {automaatInfo.NAME}</p>
          {automaatInfo.A1_NAME && <p><strong>Aadress:</strong> {automaatInfo.A1_NAME}</p>}
          {automaatInfo.A2_NAME && <p><strong>Linn:</strong> {automaatInfo.A2_NAME}</p>}
          {automaatInfo.A3_NAME && <p><strong>Maakond:</strong> {automaatInfo.A3_NAME}</p>}
          {automaatInfo.ZIP && <p><strong>Postiindeks:</strong> {automaatInfo.ZIP}</p>}
          {automaatInfo.X_COORDINATE && automaatInfo.Y_COORDINATE && (
            <p><strong>Koordinaadid:</strong> {automaatInfo.Y_COORDINATE}, {automaatInfo.X_COORDINATE}</p>
          )}
          {automaatInfo.comment_est && <p><strong>Kommentaar:</strong> {automaatInfo.comment_est}</p>}
        </div>
      )}
    </div>
  );
} 

export default App;

Tulemuseks näiteks saame:

10. API päring teise rakendusse: Elering hindade kättesaamine

Loome faili Controllers/NordpoolController.cs

Sinna sisse kirjutame näiteks:

C#
    public class NordpoolController : ControllerBase
    {
        private readonly HttpClient _httpClient;

        public NordpoolController(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        [HttpGet]
        public async Task<IActionResult> GetNordpoolPrices()
        {
            var response = await _httpClient.GetAsync("https://dashboard.elering.ee/api/nps/price");
            var responseBody = await response.Content.ReadAsStringAsync();
            return Content(responseBody, "application/json");
        }
    }

Ja App.jsx lisame:

JavaScript
import { useEffect, useState } from 'react';
import './App.css';

function App() {
  const [fi, setFi] = useState([]);
  const [ee, setEe] = useState([]);
  const [lv, setLv] = useState([]);
  const [lt, setLt] = useState([]);

  useEffect(() => {
    fetch("https://localhost:4444/nordpool")
      .then(res => res.json())
      .then(json => {
        setFi(json.data.fi);
        setEe(json.data.ee)
        setLv(json.data.lv)
        setLt(json.data.lt)
      });
  }, []);

  return (
    <div>
      <table style={{marginLeft: "100px"}}>
        <thead>
          <th style={{border: "1px solid #ddd", padding: "12px", backgroundColor: "#04AA6D"}}>Ajatempel</th>
          <th style={{border: "1px solid #ddd", padding: "12px", backgroundColor: "#04AA6D"}}>Hind</th>
        </thead>
        <tbody>
          <div style={{position: "absolute", left: "30px"}}>Soome</div>
          {fi.map(data => 
          <tr key={data.timestamp}>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{new Date(data.timestamp * 1000).toISOString()}</td>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{data.price}</td>
          </tr>)}
          <div style={{position: "absolute", left: "30px"}}>Eesti</div>
          {ee.map(data => 
          <tr key={data.timestamp}>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{new Date(data.timestamp * 1000).toISOString()}</td>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{data.price}</td>
          </tr>)}
          <div style={{position: "absolute", left: "30px"}}>Läti</div>
          {lv.map(data => 
          <tr key={data.timestamp}>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{new Date(data.timestamp * 1000).toISOString()}</td>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{data.price}</td>
          </tr>)}
          <div style={{position: "absolute", left: "30px"}}>Leedu</div>
          {lt.map(data => 
          <tr key={data.timestamp}>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{new Date(data.timestamp * 1000).toISOString()}</td>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{data.price}</td>
          </tr>)}
        </tbody>
      </table>
    </div>
  );
}

export default App;

Ise juba adapteeride enda koodiks kui te tahate )))

Tulemuseks saame näiteks:

Nüüd pärast seda kõikke me lisame

C#
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Text.Json;

namespace VeebTARpv23.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class NordpoolController : ControllerBase
    {
        private readonly HttpClient _httpClient;

        public NordpoolController(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        [HttpGet("{country}/{start}/{end}")]
        public async Task<IActionResult> GetNordPoolPrices(
            string country,
            string start,
            string end)
        {
            var response = await _httpClient.GetAsync(
                $"https://dashboard.elering.ee/api/nps/price?start={start}&end={end}");
            var responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);

            var jsonDoc = JsonDocument.Parse(responseBody);
            var dataProperty = jsonDoc.RootElement.GetProperty("data");

            string prices;

            switch (country)
            {
                case "ee":
                    prices = dataProperty.GetProperty("ee").ToString();
                    Console.WriteLine(responseBody);

                    return Content(prices, "application/json");

                case "lv":
                    prices = dataProperty.GetProperty("lv").ToString();
                    return Content(prices, "application/json");

                case "lt":
                    prices = dataProperty.GetProperty("lt").ToString();
                    return Content(prices, "application/json");

                case "fi":
                    prices = dataProperty.GetProperty("fi").ToString();
                    return Content(prices, "application/json");

                default:
                    return BadRequest("Invalid country code.");
            }
        }
    }
}

Ja lisame või adapteerime meie keskonnaks ise:

JavaScript
import { useRef } from 'react';
import { useEffect, useState } from 'react';
import './App.css';

function App() {
  const [prices, setPrices] = useState([]);
  const [chosenCountry, setChosenCountry] = useState("ee");
  const [start, setStart] = useState("");
  const [end, setEnd] = useState("");
  const startRef = useRef();
  const endRef = useRef();

  useEffect(() => {
    if (start !== "" && end !== "") {
      fetch("https://localhost:4444/nordpool/" + chosenCountry + "/" + start + "/" + end)
        .then(res => res.json())
        .then(json => {
          setPrices(json);
        });
    }
  }, [chosenCountry, start, end]);

  function updateStart() {
    const startIso = new Date(startRef.current.value).toISOString();
    setStart(startIso);
  }

  function updateEnd() {
    const endIso = new Date(endRef.current.value).toISOString();
    setEnd(endIso);
  }

  return (
    <div>
      <button onClick={() => setChosenCountry("fi")}>Soome</button>
      <button onClick={() => setChosenCountry("ee")}>Eesti</button>
      <button onClick={() => setChosenCountry("lv")}>Läti</button>
      <button onClick={() => setChosenCountry("lt")}>Leedu</button>
      <input ref={startRef} onChange={updateStart} type="datetime-local" />
      <input ref={endRef} onChange={updateEnd} type="datetime-local" />
      {prices.length > 0 && 
      <table style={{marginLeft: "100px"}}>
        <thead>
          <th style={{border: "1px solid #ddd", padding: "12px", backgroundColor: "#04AA6D"}}>Ajatempel</th>
          <th style={{border: "1px solid #ddd", padding: "12px", backgroundColor: "#04AA6D"}}>Hind</th>
        </thead>
        <tbody>
          <td style={{position: "absolute", left: "30px"}}>{chosenCountry}</td>
          {prices.map(data => 
          <tr key={data.timestamp}>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{new Date(data.timestamp * 1000).toISOString()}</td>
            <td style={{border: "1px solid #ddd", padding: "8px"}}>{data.price}</td>
          </tr>)}
        </tbody>
      </table>}
    </div>
  );
}

export default App;

Tulemuseks me võime saata näiteks:

11. API päring teise rakendusse: Makse

Loome Controllers/PaymentController.cs ja kirjutame sinna sisse näiteks:

C#
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

namespace VeebTARpv23.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class PaymentController : ControllerBase
    {
        private readonly HttpClient _httpClient;

        public PaymentController(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        [HttpGet("{sum}")]
        public async Task<IActionResult> MakePayment(string sum)
        {
            var paymentData = new
            {
                api_username = "e36eb40f5ec87fa2",
                account_name = "EUR3D1",
                amount = sum,
                order_reference = Math.Ceiling(new Random().NextDouble() * 999999),
                nonce = $"a9b7f7e7as{DateTime.Now}{new Random().NextDouble() * 999999}",
                timestamp = DateTime.Now,
                customer_url = "https://maksmine.web.app/makse"
            };

            var json = JsonSerializer.Serialize(paymentData);
            var content = new StringContent(json, Encoding.UTF8, "application/json");

            var client = new HttpClient();
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "ZTM2ZWI0MGY1ZWM4N2ZhMjo3YjkxYTNiOWUxYjc0NTI0YzJlOWZjMjgyZjhhYzhjZA==");

            var response = await client.PostAsync("https://igw-demo.every-pay.com/api/v4/payments/oneoff", content);

            if (response.IsSuccessStatusCode)
            {
                var responseContent = await response.Content.ReadAsStringAsync();
                var jsonDoc = JsonDocument.Parse(responseContent);
                var paymentLink = jsonDoc.RootElement.GetProperty("payment_link");
                return Ok(paymentLink);
            }
            else
            {
                return BadRequest("Payment failed.");
            }
        }
    }
}

Läheme Postman sisse ja teeme GET päringu näiteks sellise URLˇiga https://localhost:4444/api/payment/0.01

Saame näiteks sellis URL: https://payment.sandbox.lhv.ee/lp/q2zaxyd8q6/nXjxSePYOG

Läheme selle URL siise ja saame:

Võtame mis tahes panga, ma võttan LHV:

Siit me näeme, et on Sandbox võttame seda:

Võtame mis tahes kasutaja ja ma võttan Smart-ID ja siis lihtsalt klikkime Confirm

Ootame kuni ta töötleb selle tulemuse:

Tulemuseks me saame: