Veronika Milovzorova portfolio/ est

API veebirakendus

Back-end

  • Programmeerimiskeeled nagu näiteks Node.js, PHP, Python
  • Kompileeritud keeled nagu näiteks C#, Java
  • Andmete teisendamine
  • Tarkvaraarhitektuur
  • Turvaprobleemid, autentimine ja autoriseerimine
  • Andmebaaside haldamine

Frontend

  • Märgistus- ja veebikeeled nagu näiteks HTML, CSS, JavaScript ja nendes keeltes kasutatavad abiteegid nagu Sass või JQuery.
  • Asünkrooniliste päringute käsitlemine ja AJAX
  • Kasutajaliides (GUI)
  • Pilditöötlusprogrammid (GIMP või Photoshop)
  • Otsingumootorija jaoks optimeerimine
  • Ligipääsetavusega seotud probleemid

WeatherController

namespace veeb_Milovzorova.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();
        }
    }
}

PrimitiivController

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

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

        
        [HttpGet("add/{nr1}/{nr2}")]
        public int AddNumbers(int nr1, int nr2)
        {
            return nr1 + nr2;
        }

        
        [HttpGet("multiply/{nr1}/{nr2}")]
        public int Multiply(int nr1, int nr2)
        {
            return nr1 * nr2;
        }

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

        
        [HttpGet("random-number/{min}/{max}")]
        public ActionResult<int> GenerateRandomNumber(int min, int max)
        {
            if (min >= max)
            {
                return BadRequest("Min väärtus peab olema väiksem kui max väärtus.");
            }

            Random rand = new Random();
            int randomNumber = rand.Next(min, max + 1); // 
            return randomNumber;
        }

        
        [HttpGet("age/{birthYear}")]
        public ActionResult<string> CalculateAge(int birthYear)
        {
            int currentYear = DateTime.Now.Year;
            int age = currentYear - birthYear;

            
            bool hadBirthday = DateTime.Now >= new DateTime(currentYear, 1, 1).AddYears(age);

            if (!hadBirthday)
            {
                age--; 
            }

            return $"Oled {(hadBirthday ? age : age + 1)} aastat vana.";
        }
    }
}

Kuvab tervituse kuupäeva ja kellaaega

Annab tervituse ja nime

Lisab numbreid

Korrutab numbreid

do-logs/{arv}

Annab välja juhusliku arvu

Arvutab sünniaastat

Toode.cs

namespace veeb_Milovzorova.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;
    }
}

TootedController

namespace veeb_Milovzorova.Controllers
{
    [Route("api/tooted")]
    [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)
        };

        // GET /tooted
        [HttpGet]
        public ActionResult<List<Toode>> KoikTooted()
        {
            return Ok(_tooted);
        }

        // POST /tooted/lisa
        [HttpPost("lisa")]
        public ActionResult<List<Toode>> LisaToode([FromBody] Toode toode)
        {
            _tooted.Add(toode);
            return Ok(_tooted);
        }

        // DELETE /tooted/kustuta-koik
        [HttpDelete("kustuta-koik")]
        public ActionResult KustutaKoik()
        {
            _tooted.Clear();
            return Ok("Kõik tooted on kustutatud!");
        }

        // PATCH /tooted/hind-dollaritesse/{kurss}
        [HttpPatch("hind-dollaritesse/{kurss}")]
        public ActionResult<List<Toode>> UuendaKoigiToodeteHinnad(double kurss)
        {
            foreach (var toode in _tooted)
            {
                toode.Price *= kurss;
            }
            return Ok(_tooted);
        }

        // PUT /tooted/deaktiveeri-koik
        [HttpPut("deaktiveeri-koik")]
        public ActionResult<List<Toode>> DeaktiveeriKoik()
        {
            foreach (var toode in _tooted)
            {
                toode.IsActive = false;
            }
            return Ok(_tooted);
        }

        // GET /tooted/kalleim-toode
        [HttpGet("kalleim-toode")]
        public ActionResult<Toode> KalleimToode()
        {
            if (!_tooted.Any()) return NotFound("Tooteid ei ole saadaval!");
            var kalleimToode = _tooted.OrderByDescending(t => t.Price).FirstOrDefault();
            return Ok(kalleimToode);
        }
    }
}

näitab kõiki tooteid

lisab tooteid

kustutab kõik tooted

lisab kaubale määra

deaktiveerib kõik tooted valeks

näitab kõige kallimat toodet

ToodeController

namespace veeb_Milovzorova.Controllers
{
    [Route("api/toode")]
    [ApiController]
    public class ToodeController : 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)
        };

        // DELETE /toode/kustuta/{index}
        [HttpDelete("kustuta/{index}")]
        public ActionResult<List<Toode>> Kustuta(int index)
        {
            if (index < 1 || index > _tooted.Count) return NotFound("Toodet ei leitud!");
            _tooted.RemoveAt(index - 1);
            return Ok(_tooted);
        }

        // PUT /toode/lylitus-tegevus/{index}
        [HttpPut("lylitus-tegevus/{index}")]
        public ActionResult<List<Toode>> MuudaAktiivsust(int index)
        {
            if (index < 1 || index > _tooted.Count) return NotFound("Toodet ei leitud!");
            _tooted[index - 1].IsActive = !_tooted[index - 1].IsActive;
            return Ok(_tooted);
        }

        // PUT /toode/muuta-nimi/{index}/{uusNimi}
        [HttpPut("muuta-nimi/{index}/{uusNimi}")]
        public ActionResult<List<Toode>> MuudaNime(int index, string uusNimi)
        {
            if (index < 1 || index > _tooted.Count) return NotFound("Toodet ei leitud!");
            _tooted[index - 1].Name = uusNimi;
            return Ok(_tooted);
        }

        // PUT /toode/update-price/{index}/{kordaja}
        [HttpPut("uuendus-hind/{index}/{kordaja}")]
        public ActionResult<List<Toode>> UuendaHinda(int index, double kordaja)
        {
            if (index < 1 || index > _tooted.Count) return NotFound("Toodet ei leitud!");
            _tooted[index - 1].Price *= kordaja;
            return Ok(_tooted);
        }

        // GET /toode/{index}
        [HttpGet("{index}")]
        public ActionResult<Toode> SaadaToode(int index)
        {
            if (index < 1 || index > _tooted.Count) return NotFound("Toodet ei leitud!");
            return Ok(_tooted[index - 1]);
        }
    }
}

kustutab toode

muutab aktiivsust

muutab toode nimi

uuendab toode hinda

näitab toode id, mis oli valitud

kasutaja

kasutaja.cs
namespace veeb_Milovzorova.Models
{
    public class Kasutaja
    {
        public int Id { get; set; }
        public string KasutajaNimi { get; set; }
        public string Parool { get; set; }
        public string Eesnimi { get; set; }
        public string Perenimi { get; set; }

        public Kasutaja(int id, string kasutajaNimi, string parool, string eesnimi, string perenimi)
        {
            Id = id;
            KasutajaNimi = kasutajaNimi;
            Parool = parool;
            Eesnimi = eesnimi;
            Perenimi = perenimi;
        }
    }
}
KasutajaController 
namespace veeb_Milovzorova.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class KasutajaController : ControllerBase
    {
        private static List<Kasutaja> _kasutajad = new()
        {
            new Kasutaja(1, "ver1", "ver123", "Veronika", "Milovzorova"),
            
        };

        // GET /api/kasutaja
        [HttpGet]
        public ActionResult<List<Kasutaja>> Get()
        {
            return Ok(_kasutajad);
        }

        // GET /api/kasutaja/{id}
        [HttpGet("{id}")]
        public ActionResult<Kasutaja> Get(int id)
        {
            var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == id);
            if (kasutaja == null)
            {
                return NotFound("Kasutajat ei leitud!");
            }
            return Ok(kasutaja);
        }

        private static int _nextId = 1;
        // POST /api/kasutaja
        [HttpPost]
        public ActionResult<Kasutaja> Create([FromBody] Kasutaja kasutaja)
        {
            kasutaja.Id = _nextId++; // Увеличиваем _nextId для следующего пользователя
            _kasutajad.Add(kasutaja);
            return CreatedAtAction(nameof(Get), new { id = kasutaja.Id }, kasutaja);
        }

        // PUT /api/kasutaja/{id}
        [HttpPut("{id}")]
        public ActionResult Update(int id, [FromBody] Kasutaja kasutaja)
        {
            var existingUser = _kasutajad.FirstOrDefault(k => k.Id == id);
            if (existingUser == null)
            {
                return NotFound("Kasutajat ei leitud!");
            }

            existingUser.KasutajaNimi = kasutaja.KasutajaNimi;
            existingUser.Parool = kasutaja.Parool;
            existingUser.Eesnimi = kasutaja.Eesnimi;
            existingUser.Perenimi = kasutaja.Perenimi;

            return NoContent();
        }

        // DELETE /api/kasutaja/{id}
        [HttpDelete("{id}")]
        public ActionResult Delete(int id)
        {
            var kasutaja = _kasutajad.FirstOrDefault(k => k.Id == id);
            if (kasutaja == null)
            {
                return NotFound("Kasutajat ei leitud!");
            }
            _kasutajad.Remove(kasutaja);
            return NoContent();
        }
    }
}

Tagastab kõigi kasutajate loendi

Tagastab kasutaja määratud identifikaatoriga {id}

Loob uue kasutaja

Värskendab teavet olemasoleva kasutaja kohta määratud ID-ga

Kustutab määratud identifikaatoriga {id} kasutaja

ParcelMachineController.cs

namespace veeb_Milovzorova.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    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");
        }
    }
}

näitab kõik pakiautomaatid

Nordpool

NoordpoolController.cs
namespace veeb_Milovzorova.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.");
            }
        }
    }
}

GET/api/Nordpool/{country}/{start}/{end}

payment

PaymentController.cs
namespace veeb_Milovzorova.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.");
            }
        }
    }
}

annab linki maksmiseks

frontend

app.js 

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

function App() {
  const [tooted, setTooted] = useState([]);
  const [kasutajad, setKasutajad] = useState([]);
  const [selectedUser, setSelectedUser] = useState(null);
  const nameRef = useRef();
  const priceRef = useRef();
  const isActiveRef = useRef();

  useEffect(() => {
    fetchUsers();
  }, []);

  function fetchUsers() {
    fetch("http://localhost:5124/api/kasutaja")
      .then(res => {
        if (!res.ok) throw new Error(`Network response was not ok: ${res.statusText}`);
        return res.json();
      })
      .then(json => setKasutajad(json))
      .catch(error => console.error('Error fetching users:', error));
  }

  function fetchProductsForUser(userId) {
    fetch(`http://localhost:5124/api/tooted/user/${userId}`)
      .then(res => res.json())
      .then(json => setTooted(json))
      .catch(error => console.error('Error fetching products:', error));
  }

  function handleUserChange(event) {
    const userId = event.target.value;
    setSelectedUser(userId);
    fetchProductsForUser(userId);
  }


  function addProductToUser() {
    if (!selectedUser) {
      alert("Palun vali kasutaja.");
      return;
    }

    const name = nameRef.current.value;
    const price = Number(priceRef.current.value);
    const isActive = isActiveRef.current.checked;

    fetch('http://localhost:5124/api/tooted', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        userId: selectedUser,
        name,
        price,
        isActive
      })
    })
      .then(res => {
        if (!res.ok) throw new Error(`POST failed: ${res.statusText}`);
        return res.json();
      })
      .then(newProduct => {
        setTooted(prev => [...prev, newProduct]);
        fetchProductsForUser(selectedUser); 
       
        nameRef.current.value = '';
        priceRef.current.value = '';
        isActiveRef.current.checked = false;
      })
      .catch(error => console.error('Error adding product:', error));
  }

  
  function deleteProduct(productId) {
    fetch(`http://localhost:5124/api/tooted/kustuta/${productId}`, {
      method: 'DELETE'
    })
      .then(res => {
        if (!res.ok) throw new Error(`Delete failed: ${res.statusText}`);
        
        setTooted(prev => prev.filter(toode => toode.id !== productId));
      })
      .catch(error => console.error('Error deleting product:', error));
  }

  return (
    <div className="App">
      <h1>Kasutaja toodete haldus</h1>

      <label>Vali kasutaja</label><br />
      <select onChange={handleUserChange} value={selectedUser || ''}>
        <option value="" disabled>Vali kasutaja</option>
        {kasutajad.map(user => (
          <option key={user.id} value={user.id}>{user.kasutajanimi}</option>
        ))}
      </select>

      <h2>Lisa toode</h2>
      <label>Toote nimi</label><br />
      <input ref={nameRef} type="text" /><br />
      <label>Hind</label><br />
      <input ref={priceRef} type="number" /><br />
      <label>Aktiivne</label><br />
      <input ref={isActiveRef} type="checkbox" /><br />
      <button onClick={addProductToUser}>Lisa toode kasutajale</button>

      <h2>Tooted valitud kasutajale</h2>
      {tooted.length > 0 ? (
        tooted.map(toode => (
          <div key={toode.id} style={{ border: '1px solid #ccc', marginBottom: '10px', padding: '5px' }}>
            <div><strong>ID:</strong> {toode.id}</div>
            <div><strong>Nimi:</strong> {toode.name}</div>
            <div><strong>Hind:</strong> {toode.price}</div>
            <div><strong>Aktiivne:</strong> {toode.isActive ? 'Jah' : 'Ei'}</div>
            <button onClick={() => deleteProduct(toode.id)}>Kustuta</button>
          </div>
        ))
      ) : (
        <p>Valitud kasutajal puuduvad tooted.</p>
      )}
    </div>
  );
}

export default App;
et
et en_US