Veebirakenduste loomine API päringute abil

Primitiivid

Kontrolleri kontuur

  1. Marsruudid ja HTTP-meetodid:
    • Kõik meetodid kasutavad HTTP GET-i ja võtavad parameetrid otse URL-ist, muutes need kättesaadavaks marsruutide kaudu kujul /primitiivid/{action}/{parameetrid}.
  2. Põhilised aritmeetilised operatsioonid:
    • Kontroller pakub meetodeid põhiliste matemaatiliste operatsioonide, nagu liitmine ja korrutamine, jaoks.
  3. Konsooli logimine:
    • DoLogs meetod näitab, kuidas saab API abil logida teateid serveri poolel.
  4. Lihtne andmetöötlus:
    • Kontroller tagastab lihtsaid primitiivseid väärtusi (string, int) ja teostab põhilisi operatsioone, mistõttu on see ideaalne näide lihtsa API struktuuri ja toimimise demonstreerimiseks.

See kontroller on kasulik API arenduse esmaseks sissejuhatuseks, demonstreerides põhilisi operatsioone ja tööd URL-parameetritega ASP.NET Core’is.

[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);
            }
        }

Toode

Kontrolleri kontuur

  1. Staatiline objekt: Kontroller haldab ühte staatilist objekti _toode, ja kõik muudatused objektis jäävad rakenduse töötamise ajal serveri mällu. Andmeid ei salvestata ja need nullistatakse rakenduse taaskäivitamisel.
  2. Marsruudid:
    • Iga meetod on seotud oma marsruudiga. Need marsruudid kasutavad HTTP GET päringuid, et teha erinevaid toiminguid objektiga _toode.
  3. Meetodid objekti manipuleerimiseks:
    • Read (GetToode) – tagastab toote praeguse seisundi.
    • Hinnamuutus (SuurendaHinda, KorrutaHind) – Suurendab hinda kindla summa võrra või korrutab seda antud teguriga.
    • Change Activity (MuudaAktiivsus) – Muudab toote aktiivsuse olekut.
    • Nime muutmine (MuudaNimi) – Võimaldab määrata tootele uue nime.
  4. Memory Processing (Mälutöötlus) : Kontroller teostab operatsioone mällu salvestatud objektiga ja ei kasuta andmebaasi. See muudab selle sobivaks demonstratsiooniks, kuid ebapraktiliseks tootmiskeskkonnas, sest andmeid ei salvestata pärast rakenduse sulgemist.
namespace veeb.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;
    }
}

        // GET: toode
        [HttpGet]
        public Toode GetToode()
        {
            return _toode;
        }
        // GET: toode/suurenda-hinda
        [HttpGet("suurenda-hinda")]
        public Toode SuurendaHinda()
        {
            _toode.Price += 1;
            return _toode;
        }
        // GET: toode/muuda-aktiivsus
        [HttpGet("muuda-aktiivsus")]
        public Toode MuudaAktiivsus()
        {
            _toode.IsActive = !_toode.IsActive;
            return _toode;
        }
        // GET: toode/muuda-nimi/{nimi}
        [HttpGet("muuda-nimi/{nimi}")]
        public Toode MuudaNimi(string nimi)
        {
            _toode.Name = nimi;
            return _toode;
        }
        // GET: toode/korruta-hind/{kordaja}
        [HttpGet("korruta-hind/{kordaja}")]
        public Toode KorrutaHind(double kordaja)
        {
            _toode.Price *= kordaja;
            return _toode;
        }

Tooted

Kontrolleri kontuur

  1. Andmete struktuur: Kontrolleri töötab toodete staatilise loeteluga, mis võimaldab teil teostada CRUD-operatsioone ilma andmebaasiga ühendamata.
  2. Marsruudid: Marsruudid on korraldatud toimingute kaupa (Get, Add, Delete, UpdatePrices, UpdateProduct) ja iga marsruut võimaldab toodete kogumi haldamist.
  3. CRUD-operatsioonid:
    • Read (GET) – Kõigi toodete otsimine.
    • Create (POST) – uue toote lisamine.
    • Delete (DELETE) – tootekustutamine indeksi järgi.
    • Hinnamuutus (PATCH) – kõigi toodete hinna korrutamine teguriga.
    • Uuendamine (PUT) – Teabeuuendamine konkreetse toote kohta.
  4. Veakäitlus: Meetod UpdateProduct tagastab 404 Not Found, kui määratud Id-ga toodet ei leita, mis aitab vältida ebaõigeid andmemuudatusi.

Kontroller pakub kõiki vajalikke operatsioone toodete kollektsiooni haldamiseks ja sobib põhiliseks CRUD-rakenduseks.

    [Route("api/[controller]")]
    [ApiController]
    public class TootedController : ControllerBase
    {
        private static List<Toode> _tooted = new()
        {
            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)
        };

        [HttpGet]
        public List<Toode> Get()
        {
            return _tooted;
        }

        [HttpDelete("kustuta/{index}")]
        public List<Toode> Delete(int index)
        {
            _tooted.RemoveAt(index-1);
            return _tooted;
        }
        [HttpPost("lisa")]
        public List<Toode> Add([FromBody] Toode toode)
        {
            _tooted.Add(toode);
            return _tooted;
        }
        [HttpPatch("hind-dollaritesse/{kurss}")]
        public List<Toode> UpdatePrices(double kurss)
        {
            foreach (var toode in _tooted)
            {
                toode.Price *= kurss;
            }
            return _tooted;
        }
        // PUT: https://localhost:4444/tooted/uuenda
        [HttpPut("uuenda")]
        public IActionResult UpdateProduct([FromBody] Toode updatedToode)
        {
            var existingToode = _tooted.FirstOrDefault(t => t.Id == updatedToode.Id);
            if (existingToode == null)
            {
                return NotFound("Toodet ei leitud.");
            }

            existingToode.Name = updatedToode.Name;
            existingToode.Price = updatedToode.Price;
            existingToode.IsActive = updatedToode.IsActive;

            return Ok(existingToode);
        }
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> 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();
    }
}

Kasutaja/Toode

Kontrolleri kontuur

  1. Andmete struktuur: Kontroller töötab demoandmetega, mis esindavad kasutajate nimekirja, millest igaühel on erinev toodete nimekiri.
  2. Marsruudid: Kõik marsruudid kasutavad kasutaja ID-d (kasutajaId), et leida õige kasutaja ja mõnel juhul toote ID-d (toodeId), et tegeleda konkreetse tootega.
  3. CRUD-operatsioonid:
    • Read (GET) – kasutaja tootenimekirja otsimine.
    • Create (POST) – uue toote lisamine kasutaja nimekirja.
    • Delete (DELETE) – Toote kustutamine kasutaja nimekirjast.
    • Update (PUT) – Uuendab konkreetse kasutaja toote andmeid.
  4. Veakäitlus: Kui kasutaja või toode puudub, tagastatakse staatus 404 Not Found koos asjakohase sõnumiga.

See kontroller võimaldab töötada iga kasutaja toodetega kui üksteise sisseehitatud üksustega ja pakub põhilisi meetodeid nende haldamiseks.

private static List<Kasutaja> _kasutajad = new()
{
    new Kasutaja(1, "kasutaja1", "parool1", "Jaan", "Tamm")
    {
        Tooted = new List<Toode>
        {
            new Toode(1, "Toode1", 10.0, true),
            new Toode(2, "Toode2", 15.0, true)
        }
    },
    new Kasutaja(2, "kasutaja2", "parool2", "Mari", "Kask")
    {
        Tooted = new List<Toode>
        {
            new Toode(3, "Toode3", 20.0, true),
            new Toode(4, "Toode4", 25.0, false)
        }
    }
};

// GET: api/kasutajadtooted/{kasutajaId}/tooted
[HttpGet("{kasutajaId}/tooted")]
public ActionResult<List<Toode>> GetProducts(int kasutajaId)
{
    var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == kasutajaId);
    if (kasutaja == null)
    {
        return NotFound("Kasutajat ei leitud.");
    }
    return Ok(kasutaja.Tooted);
}

        // POST: api/kasutajadtooted/{kasutajaId}/lisa
        [HttpPost("{kasutajaId}/lisa")]
        public ActionResult<List<Toode>> AddProduct(int kasutajaId, [FromBody] Toode newToode)
        {
            var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == kasutajaId);
            if (kasutaja == null)
            {
                return NotFound("Kasutajat ei leitud.");
            }

            kasutaja.Tooted.Add(newToode);
            return Ok(kasutaja.Tooted);
        }
        // DELETE: api/kasutajadtooted/{kasutajaId}/kustuta/{toodeId}
        [HttpDelete("{kasutajaId}/kustuta/{toodeId}")]
        public ActionResult<List<Toode>> DeleteProduct(int kasutajaId, int toodeId)
        {
            var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == kasutajaId);
            if (kasutaja == null)
            {
                return NotFound("Kasutajat ei leitud.");
            }

            var toode = kasutaja.Tooted.FirstOrDefault(t => t.Id == toodeId);
            if (toode == null)
            {
                return NotFound("Toodet ei leitud.");
            }

            kasutaja.Tooted.Remove(toode);
            return Ok(kasutaja.Tooted);
        }

        // PUT: api/kasutajadtooted/{kasutajaId}/uuenda
        [HttpPut("{kasutajaId}/uuenda")]
        public IActionResult UpdateProduct(int kasutajaId, [FromBody] Toode updatedToode)
        {
            var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == kasutajaId);
            if (kasutaja == null)
            {
                return NotFound("Kasutajat ei leitud.");
            }

            var existingToode = kasutaja.Tooted.FirstOrDefault(t => t.Id == updatedToode.Id);
            if (existingToode == null)
            {
                return NotFound("Toodet ei leitud.");
            }

            existingToode.Name = updatedToode.Name;
            existingToode.Price = updatedToode.Price;
            existingToode.IsActive = updatedToode.IsActive;

            return Ok(existingToode);
        }