diff --git a/src/main/java/rs/raf/demo/bootstrap/BootstrapData.java b/src/main/java/rs/raf/demo/bootstrap/BootstrapData.java index 09229274..8b0a7b69 100644 --- a/src/main/java/rs/raf/demo/bootstrap/BootstrapData.java +++ b/src/main/java/rs/raf/demo/bootstrap/BootstrapData.java @@ -1,6 +1,5 @@ package rs.raf.demo.bootstrap; -import net.bytebuddy.utility.RandomString; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; @@ -8,10 +7,12 @@ import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.stereotype.Component; import rs.raf.demo.model.*; +import rs.raf.demo.model.enums.PolZaposlenog; +import rs.raf.demo.model.enums.RadnaPozicija; +import rs.raf.demo.model.enums.StatusZaposlenog; import rs.raf.demo.model.enums.TipDokumenta; import rs.raf.demo.model.enums.TipFakture; import rs.raf.demo.repositories.*; -import rs.raf.demo.responses.KnjizenjeResponse; import java.util.*; @@ -27,6 +28,10 @@ public class BootstrapData implements CommandLineRunner { private final KontnaGrupaRepository kontnaGrupaRepository; private final KontoRepository kontoRepository; private final KnjizenjeRepository knjizenjeRepository; + private final ZaposleniRepository zaposleniRepository; + private final StazRepository stazRepository; + private final PlataRepository plataRepository; + private final KoeficijentRepository koeficijentRepository; @Autowired public BootstrapData(UserRepository userRepository, @@ -36,7 +41,11 @@ public BootstrapData(UserRepository userRepository, KontoRepository kontoRepository, KontnaGrupaRepository kontnaGrupaRepository, KnjizenjeRepository knjizenjeRepository, - PreduzeceRepository preduzeceRepository) { + PreduzeceRepository preduzeceRepository, + ZaposleniRepository zaposleniRepository, + StazRepository stazRepository, + PlataRepository plataRepository, + KoeficijentRepository koeficijentRepository) { this.userRepository = userRepository; this.permissionRepository = permissionRepository; this.fakturaRepository = fakturaRepository; @@ -45,6 +54,10 @@ public BootstrapData(UserRepository userRepository, this.kontoRepository = kontoRepository; this.knjizenjeRepository = knjizenjeRepository; this.kontnaGrupaRepository = kontnaGrupaRepository; + this.zaposleniRepository = zaposleniRepository; + this.stazRepository = stazRepository; + this.plataRepository = plataRepository; + this.koeficijentRepository = koeficijentRepository; } private Preduzece getDefaultPreduzece(){ @@ -192,15 +205,21 @@ public void run(String... args) throws Exception { Konto konto1 = new Konto(); konto1.setDuguje(1000.0); konto1.setPotrazuje(500.0); + konto1.setKnjizenje(knj1); + konto1.setKontnaGrupa(kg1); konto1 = kontoRepository.save(konto1); Konto konto2 = new Konto(); konto2.setDuguje(2000.0); + konto2.setKnjizenje(knj1); + konto2.setKontnaGrupa(kg1); konto2.setPotrazuje(1000.0); kontoRepository.save(konto2); Konto konto3 = new Konto(); konto3.setDuguje(0.0); + konto3.setKnjizenje(knj1); + konto3.setKontnaGrupa(kg1); konto3.setPotrazuje(1000.0); kontoRepository.save(konto3); @@ -217,6 +236,46 @@ public void run(String... args) throws Exception { konto3.setKnjizenje(knjizenje); kontoRepository.save(konto1); + Staz staz = new Staz(); + staz.setPocetakRada(new Date()); + staz.setKrajRada(null); + stazRepository.save(staz); + + List stazevi = new ArrayList<>(); + stazevi.add(staz); + + Zaposleni zaposleni = new Zaposleni(); + zaposleni.setIme("Marko"); + zaposleni.setPrezime("Markovic"); + zaposleni.setPocetakRadnogOdnosa(new Date()); + zaposleni.setJmbg("1234567890123"); + zaposleni.setPol(PolZaposlenog.MUSKO); + zaposleni.setStatusZaposlenog(StatusZaposlenog.ZAPOSLEN); + zaposleni.setDatumRodjenja(new Date()); + zaposleni.setRadnaPozicija(RadnaPozicija.DIREKTOR); + zaposleni.setStaz(stazevi); + zaposleniRepository.save(zaposleni); + + Plata plata = new Plata(); + plata.setNetoPlata(100000.0); + plata.setZaposleni(zaposleni); + plata.setDatumOd(new Date()); + plata.setDatumDo(null); + plataRepository.save(plata); + + Koeficijent koeficijent = new Koeficijent(); + koeficijent.setKoeficijentPoreza(1d); + koeficijent.setNezaposlenost1(2d); + koeficijent.setNezaposlenost2(10d); + koeficijent.setPenzionoOsiguranje1(5d); + koeficijent.setPenzionoOsiguranje2(50d); + koeficijent.setNajnizaOsnovica(1d); + koeficijent.setNajvisaOsnovica(1d); + koeficijent.setZdravstvenoOsiguranje1(5d); + koeficijent.setZdravstvenoOsiguranje2(5d); + koeficijent.setPoreskoOslobadjanje(23.4); + koeficijentRepository.save(koeficijent); + log.info("Data loaded!"); } } diff --git a/src/main/java/rs/raf/demo/controllers/GlavnaKnjigaController.java b/src/main/java/rs/raf/demo/controllers/GlavnaKnjigaController.java index 504d6a51..39f6ad5c 100644 --- a/src/main/java/rs/raf/demo/controllers/GlavnaKnjigaController.java +++ b/src/main/java/rs/raf/demo/controllers/GlavnaKnjigaController.java @@ -29,18 +29,21 @@ public GlavnaKnjigaController(KontoService kontoService) { this.searchUtil = new SearchUtil<>(); } - @GetMapping(value = "/{kontnaGrupa}", - produces = MediaType.APPLICATION_JSON_VALUE) + @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity getPreduzeceById( - @PathVariable("kontnaGrupa") String kontnaGrupa, @RequestParam(name = "search", required = false, defaultValue = "") String search, @RequestParam(defaultValue = ApiUtil.DEFAULT_PAGE) @Min(ApiUtil.MIN_PAGE) Integer page, @RequestParam(defaultValue = ApiUtil.DEFAULT_SIZE) @Min(ApiUtil.MIN_SIZE) @Max(ApiUtil.MAX_SIZE) Integer size, @RequestParam(defaultValue = "kontoId") String[] sort ) { Pageable pageSort = ApiUtil.resolveSortingAndPagination(page, size, sort); - if (search.length() > 0) search += ","; - Specification spec = this.searchUtil.getSpec(search + "kontnaGrupa:" + kontnaGrupa + ","); - return ResponseEntity.ok(this.kontoService.findAllGlavnaKnjigaResponse(spec, pageSort)); + Specification spec = this.searchUtil.getSpec(search); + return ResponseEntity.ok(this.kontoService.findAllGlavnaKnjigaResponseWithFilter(spec, pageSort)); + } + + @GetMapping(value = "/all", + produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getAll() { + return ResponseEntity.ok(this.kontoService.findAllGlavnaKnjigaResponse()); } } diff --git a/src/main/java/rs/raf/demo/controllers/KoeficijentController.java b/src/main/java/rs/raf/demo/controllers/KoeficijentController.java new file mode 100644 index 00000000..d866e827 --- /dev/null +++ b/src/main/java/rs/raf/demo/controllers/KoeficijentController.java @@ -0,0 +1,40 @@ +package rs.raf.demo.controllers; + +import io.swagger.v3.oas.annotations.security.SecurityRequirement; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import rs.raf.demo.model.Koeficijent; +import rs.raf.demo.services.IService; +import rs.raf.demo.services.impl.KoeficijentService; + +import javax.persistence.EntityNotFoundException; + +@CrossOrigin +@RestController +@SecurityRequirement(name = "bearerAuth") +@RequestMapping("/api/koeficijenti") +public class KoeficijentController { + private final IService koeficijentService; + + public KoeficijentController(KoeficijentService koeficijentService) { + this.koeficijentService = koeficijentService; + } + + @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity findAll() { + return ResponseEntity.ok(koeficijentService.findAll()); + } + + @PutMapping(produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity update(@RequestBody Koeficijent koeficijent) { + if (koeficijentService.findById(koeficijent.getKoeficijentId()).isPresent()) + return ResponseEntity.ok(koeficijentService.save(koeficijent)); + throw new EntityNotFoundException(); + } + + @PostMapping(produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity create(@RequestBody Koeficijent koeficijent) { + return ResponseEntity.ok(koeficijentService.save(koeficijent)); + } +} diff --git a/src/main/java/rs/raf/demo/controllers/PlataRestController.java b/src/main/java/rs/raf/demo/controllers/PlataRestController.java new file mode 100644 index 00000000..a45a89ab --- /dev/null +++ b/src/main/java/rs/raf/demo/controllers/PlataRestController.java @@ -0,0 +1,85 @@ +package rs.raf.demo.controllers; + +import io.swagger.v3.oas.annotations.security.SecurityRequirement; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import rs.raf.demo.model.Plata; +import rs.raf.demo.requests.PlataRequest; +import rs.raf.demo.services.impl.PlataService; +import rs.raf.demo.utils.SearchUtil; + +import javax.persistence.EntityNotFoundException; +import javax.validation.Valid; +import java.util.Optional; + +@CrossOrigin +@RestController +@SecurityRequirement(name = "bearerAuth") +@RequestMapping("/api") +public class PlataRestController { + private final PlataService plataService; + private final SearchUtil searchUtil; + + public PlataRestController(PlataService plataService) { + this.plataService = plataService; + this.searchUtil = new SearchUtil<>(); + } + + @GetMapping(value = "/zaposleni/{id}/plata", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getPlataForZaposleni(@PathVariable("id") Long zaposleniId) { + return ResponseEntity.ok(this.plataService.findByZaposleniZaposleniId(zaposleniId)); + } + + @GetMapping(value = "/plata", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getPlata(@RequestParam(name = "search", required = false, defaultValue = "") String search) { + Specification spec = this.searchUtil.getSpec(search); + return ResponseEntity.ok(this.plataService.findAll(spec)); + } + + @GetMapping(value = "/plata/all", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getAllPlata() { + return ResponseEntity.ok(this.plataService.findAll()); + } + + @GetMapping(value = "/plata/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getPlataById(@PathVariable("id") Long plataId) { + Optional optionalPlata = this.plataService.findById(plataId); + if (optionalPlata.isPresent()) + return ResponseEntity.ok(optionalPlata.get()); + throw new EntityNotFoundException(); + } + + @PostMapping(value = "/plata", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity newPlata(@Valid @RequestBody PlataRequest plata) { + try { + return ResponseEntity.ok(this.plataService.save(plata)); + } catch (Exception e) { + throw new EntityNotFoundException(); + } + } + + @PutMapping(value = "/plata", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity editPlata(@Valid @RequestBody PlataRequest plata) { + Optional optionalPlata = this.plataService.findById(plata.getPlataId()); + if (optionalPlata.isPresent()) { + try { + return ResponseEntity.ok(this.plataService.save(plata)); + } catch (Exception e) { + throw new EntityNotFoundException(); + } + } + throw new EntityNotFoundException(); + } + + @DeleteMapping(value = "/plata/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity deletePlata(@PathVariable("id") Long plataId) { + Optional optionalPlata = this.plataService.findById(plataId); + if (optionalPlata.isPresent()) { + this.plataService.deleteById(plataId); + return ResponseEntity.ok().build(); + } + throw new EntityNotFoundException(); + } +} diff --git a/src/main/java/rs/raf/demo/controllers/ZaposleniRestController.java b/src/main/java/rs/raf/demo/controllers/ZaposleniRestController.java new file mode 100644 index 00000000..bd2ebe42 --- /dev/null +++ b/src/main/java/rs/raf/demo/controllers/ZaposleniRestController.java @@ -0,0 +1,82 @@ +package rs.raf.demo.controllers; + +import io.swagger.v3.oas.annotations.security.SecurityRequirement; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import rs.raf.demo.model.Zaposleni; +import rs.raf.demo.services.IZaposleniService; +import rs.raf.demo.specifications.RacunSpecificationsBuilder; + +import javax.persistence.EntityNotFoundException; +import javax.validation.Valid; +import java.util.List; +import java.util.Optional; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +@CrossOrigin +@RestController +@SecurityRequirement(name = "bearerAuth") +@RequestMapping("/api/zaposleni") +public class ZaposleniRestController { + + private final IZaposleniService iZaposleniService; + + public ZaposleniRestController(IZaposleniService iZaposleniService) { + this.iZaposleniService = iZaposleniService; + + } + + @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity createZaposleni(@Valid @RequestBody Zaposleni zaposleni) { + return ResponseEntity.ok(iZaposleniService.save(zaposleni)); + } + + @PutMapping(value = "/{id}", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity updateZaposleni(@Valid @RequestBody Zaposleni zaposleni, @PathVariable Long id) { + if (iZaposleniService.findById(id).isPresent()) + return ResponseEntity.ok(iZaposleniService.updateZaposleni(zaposleni)); + throw new EntityNotFoundException(); + } + + @DeleteMapping(value = "/{id}") + public ResponseEntity zaposleniOtkaz(@PathVariable("id") Long id) { + Optional optionalZaposleni = iZaposleniService.findById(id); + if(optionalZaposleni.isPresent()){ + return ResponseEntity.ok(iZaposleniService.otkazZaposleni(optionalZaposleni.get())); + } + throw new EntityNotFoundException(); + } + + @GetMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity getZaposleniId(@PathVariable("id") Long id) { + Optional optionalZaposleni = iZaposleniService.findById(id); + if (optionalZaposleni.isPresent()) { + return ResponseEntity.ok(iZaposleniService.findById(id)); + } + throw new EntityNotFoundException(); + } + + @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE) + public ResponseEntity search(@RequestParam(name = "search") String search) { + RacunSpecificationsBuilder builder = new RacunSpecificationsBuilder<>(); + + Pattern pattern = Pattern.compile("(\\w+?)(:|<|>)(\\w+?),"); + Matcher matcher = pattern.matcher(search + ","); + while (matcher.find()) { + builder.with(matcher.group(1), matcher.group(2), matcher.group(3)); + } + + Specification spec = builder.build(); + + List result = iZaposleniService.findAll(spec); + + if (result.isEmpty()) { + throw new EntityNotFoundException(); + } + + return ResponseEntity.ok(result); + } +} diff --git a/src/main/java/rs/raf/demo/model/Koeficijent.java b/src/main/java/rs/raf/demo/model/Koeficijent.java new file mode 100644 index 00000000..ffe17a4e --- /dev/null +++ b/src/main/java/rs/raf/demo/model/Koeficijent.java @@ -0,0 +1,42 @@ +package rs.raf.demo.model; + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import java.util.Date; + +@Entity +@Getter +@Setter +public class Koeficijent { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long koeficijentId; + @Column + private Double penzionoOsiguranje1; + @Column + private Double penzionoOsiguranje2; + @Column + private Double zdravstvenoOsiguranje1; + @Column + private Double zdravstvenoOsiguranje2; + @Column + private Double nezaposlenost1; + @Column + private Double nezaposlenost2; + @Column + private Double najnizaOsnovica; + @Column + private Double najvisaOsnovica; + @Column + private Double poreskoOslobadjanje; + @Column + private Double koeficijentPoreza; + @Column + private boolean status; + @Column + private Date date; + +} diff --git a/src/main/java/rs/raf/demo/model/KontnaGrupa.java b/src/main/java/rs/raf/demo/model/KontnaGrupa.java index 52e48984..5bc8f51f 100644 --- a/src/main/java/rs/raf/demo/model/KontnaGrupa.java +++ b/src/main/java/rs/raf/demo/model/KontnaGrupa.java @@ -21,8 +21,8 @@ public class KontnaGrupa { @Column(nullable = false) @NotBlank(message = "Naziv konta je obavezan") private String nazivKonta; - @OneToMany(mappedBy = "kontnaGrupa", fetch = FetchType.EAGER) @JsonIgnore + @OneToMany(mappedBy = "kontnaGrupa", fetch = FetchType.EAGER) private List konto; diff --git a/src/main/java/rs/raf/demo/model/Konto.java b/src/main/java/rs/raf/demo/model/Konto.java index c7ed86ed..0df53398 100644 --- a/src/main/java/rs/raf/demo/model/Konto.java +++ b/src/main/java/rs/raf/demo/model/Konto.java @@ -19,10 +19,10 @@ public class Konto { @Column private Double duguje; @ManyToOne - @JoinColumn(name = "kontnaGrupaId") + @JoinColumn(name = "kontnaGrupaId", nullable = false) private KontnaGrupa kontnaGrupa; @ManyToOne @JsonIgnore - @JoinColumn(name = "knjizenjeId") + @JoinColumn(name = "knjizenjeId", nullable = false) private Knjizenje knjizenje; } diff --git a/src/main/java/rs/raf/demo/model/Plata.java b/src/main/java/rs/raf/demo/model/Plata.java new file mode 100644 index 00000000..39347592 --- /dev/null +++ b/src/main/java/rs/raf/demo/model/Plata.java @@ -0,0 +1,58 @@ +package rs.raf.demo.model; + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Entity +@Getter +@Setter +public class Plata { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long plataId; + @Column + private Double porez; + @Column + private Double doprinos1; + @Column + private Double doprinos2; + @Column + @NotNull(message = "netoPlata je obavezna") + private Double netoPlata; + @Column + private Double brutoPlata; + @Column + private Double ukupanTrosakZarade; + @Column(nullable = false) + private Date datumOd; + @Column + private Date datumDo; + @Column + private String komentar; + @ManyToOne + @JoinColumn(name = "zaposleniId") + private Zaposleni zaposleni; + + public void izracunajDoprinose(Koeficijent koeficijent) { + double b; + if (this.netoPlata < koeficijent.getNajnizaOsnovica()) { + b = (this.netoPlata - 1.93 + (koeficijent.getNajnizaOsnovica() * 19.9)) / 0.9; + } + else if (this.netoPlata < koeficijent.getNajvisaOsnovica()) { + b = (this.netoPlata - 1.93) / 0.701; + } + else { + b = (this.netoPlata - 1.93 + (koeficijent.getNajvisaOsnovica() * 19.9)) / 0.9; + } + this.doprinos1 = b * (koeficijent.getPenzionoOsiguranje1() + koeficijent.getZdravstvenoOsiguranje1() + koeficijent.getNezaposlenost1()); + this.doprinos2 = b * (koeficijent.getPenzionoOsiguranje2() + koeficijent.getZdravstvenoOsiguranje2() + koeficijent.getNezaposlenost2()); + this.porez = (b - koeficijent.getPoreskoOslobadjanje()) * koeficijent.getKoeficijentPoreza(); + this.brutoPlata = this.netoPlata + this.porez; + this.ukupanTrosakZarade = this.brutoPlata + this.doprinos2; + } +} diff --git a/src/main/java/rs/raf/demo/model/Preduzece.java b/src/main/java/rs/raf/demo/model/Preduzece.java index 6c661103..b76f3e30 100644 --- a/src/main/java/rs/raf/demo/model/Preduzece.java +++ b/src/main/java/rs/raf/demo/model/Preduzece.java @@ -45,8 +45,10 @@ public class Preduzece { private String webAdresa; @Column private String komentar; - @JsonIgnore @OneToMany(mappedBy = "preduzece", fetch = FetchType.EAGER) private List fakture; + @JsonIgnore + @OneToMany(mappedBy = "preduzece") + private List zaposleni; } diff --git a/src/main/java/rs/raf/demo/model/Staz.java b/src/main/java/rs/raf/demo/model/Staz.java new file mode 100644 index 00000000..bc740f7f --- /dev/null +++ b/src/main/java/rs/raf/demo/model/Staz.java @@ -0,0 +1,22 @@ +package rs.raf.demo.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.*; +import java.util.Date; + +@Entity +@Getter +@Setter +public class Staz { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long stazId; + @Column + private Date pocetakRada; + @Column + private Date krajRada; +} diff --git a/src/main/java/rs/raf/demo/model/Zaposleni.java b/src/main/java/rs/raf/demo/model/Zaposleni.java new file mode 100644 index 00000000..6960eb3c --- /dev/null +++ b/src/main/java/rs/raf/demo/model/Zaposleni.java @@ -0,0 +1,68 @@ +package rs.raf.demo.model; + +import lombok.Getter; +import lombok.Setter; +import lombok.Value; +import rs.raf.demo.model.enums.PolZaposlenog; +import rs.raf.demo.model.enums.RadnaPozicija; +import rs.raf.demo.model.enums.StatusZaposlenog; + +import javax.persistence.*; +import javax.validation.constraints.*; +import java.util.Date; +import java.util.List; + +@Entity +@Getter +@Setter +public class Zaposleni { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long zaposleniId; + @Column(nullable = false) + @NotBlank(message = "Ime je obavezno") + private String ime; + @Column(nullable = false) + @NotBlank(message = "Prezime je obavezno") + private String prezime; + @Column + private String imeRoditelja; + @Column(nullable = false) + private Date pocetakRadnogOdnosa; + @Column(nullable = false) + @NotBlank(message = "JMBG je obavezan") + @Size(min = 13,max = 13) + @Pattern(regexp="^(0|[1-9][0-9]*)$") + private String jmbg; + @Column(nullable = false) + @NotNull(message = "Pol je obavezan") + @Enumerated(EnumType.STRING) + private PolZaposlenog pol; + @Column(nullable = false) + private Date datumRodjenja; + @Column + private String adresa; + @Column + private String grad; + @Column + private String brojRacuna; + @Column + private String stepenObrazovanja; + @Column + private Long brojRadneKnjizice; + @OneToMany + private List staz; + @Column + @Enumerated(EnumType.STRING) + private StatusZaposlenog statusZaposlenog; + @Column + private String komentar; + @ManyToOne + @JoinColumn(name = "preduzeceId") + private Preduzece preduzece; + @Column + @Enumerated(EnumType.STRING) + private RadnaPozicija radnaPozicija; + +} diff --git a/src/main/java/rs/raf/demo/model/enums/PolZaposlenog.java b/src/main/java/rs/raf/demo/model/enums/PolZaposlenog.java new file mode 100644 index 00000000..23e00c26 --- /dev/null +++ b/src/main/java/rs/raf/demo/model/enums/PolZaposlenog.java @@ -0,0 +1,6 @@ +package rs.raf.demo.model.enums; + +public enum PolZaposlenog { + + MUSKO,ZENSKO +} diff --git a/src/main/java/rs/raf/demo/model/enums/RadnaPozicija.java b/src/main/java/rs/raf/demo/model/enums/RadnaPozicija.java new file mode 100644 index 00000000..dced2cb4 --- /dev/null +++ b/src/main/java/rs/raf/demo/model/enums/RadnaPozicija.java @@ -0,0 +1,20 @@ +package rs.raf.demo.model.enums; + +public enum RadnaPozicija { + DIREKTOR("direktor"),RADNIK("radnik"),MENADZER("menadzer"); + + public final String label; + + RadnaPozicija(String label) { + this.label = label; + } + + public static RadnaPozicija valueOfLabel(String label) { + for (RadnaPozicija type : values()) { + if (type.label.equals(label.toLowerCase())) { + return type; + } + } + return null; + } +} diff --git a/src/main/java/rs/raf/demo/model/enums/StatusZaposlenog.java b/src/main/java/rs/raf/demo/model/enums/StatusZaposlenog.java new file mode 100644 index 00000000..39fd995f --- /dev/null +++ b/src/main/java/rs/raf/demo/model/enums/StatusZaposlenog.java @@ -0,0 +1,20 @@ +package rs.raf.demo.model.enums; + +public enum StatusZaposlenog { + ZAPOSLEN("zaposlen"),NEZAPOSLEN("nezaposlen"); + + public final String label; + + StatusZaposlenog(String zaposlen) { + this.label = zaposlen; + } + + public static StatusZaposlenog valueOfLabel(String label) { + for (StatusZaposlenog type : values()) { + if (type.label.equals(label.toLowerCase())) { + return type; + } + } + return null; + } +} diff --git a/src/main/java/rs/raf/demo/relations/RadnaPozicijaRelations.java b/src/main/java/rs/raf/demo/relations/RadnaPozicijaRelations.java new file mode 100644 index 00000000..bfb764d3 --- /dev/null +++ b/src/main/java/rs/raf/demo/relations/RadnaPozicijaRelations.java @@ -0,0 +1,37 @@ +package rs.raf.demo.relations; + +import rs.raf.demo.exceptions.OperationNotSupportedException; +import rs.raf.demo.model.enums.RadnaPozicija; +import rs.raf.demo.model.enums.TipFakture; + +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Root; + +public class RadnaPozicijaRelations extends RacunRelations{ + + private final Expression radnaPozicijaExpression; + private final RadnaPozicija radnaPozicija; + + public RadnaPozicijaRelations(Root root, CriteriaBuilder builder, String key, String val) { + super(root, builder, key, val); + radnaPozicijaExpression = root.get("radnaPozicija").as(RadnaPozicija.class); + radnaPozicija = RadnaPozicija.valueOfLabel(val); + } + + @Override + public Predicate greaterThanOrEqualTo() { + throw new OperationNotSupportedException(String.format("Relacija > nije implementirana za TipFakture [key:%s,val%s]", key, val)); + } + + @Override + public Predicate lessThanOrEqualTo() { + throw new OperationNotSupportedException(String.format("Relacija < nije implementirana za TipFakture [key:%s,val%s]",key,val)); + } + + @Override + public Predicate equalTo() { + return this.builder.equal(radnaPozicijaExpression, radnaPozicija); + } +} diff --git a/src/main/java/rs/raf/demo/relations/StatusZaposlenogRelations.java b/src/main/java/rs/raf/demo/relations/StatusZaposlenogRelations.java new file mode 100644 index 00000000..0bce74aa --- /dev/null +++ b/src/main/java/rs/raf/demo/relations/StatusZaposlenogRelations.java @@ -0,0 +1,38 @@ +package rs.raf.demo.relations; + +import rs.raf.demo.exceptions.OperationNotSupportedException; +import rs.raf.demo.model.enums.RadnaPozicija; +import rs.raf.demo.model.enums.StatusZaposlenog; + +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.Expression; +import javax.persistence.criteria.Predicate; +import javax.persistence.criteria.Root; + +public class StatusZaposlenogRelations extends RacunRelations{ + + private final Expression statusZaposlenogExpression; + private final StatusZaposlenog statusZaposlenog; + + public StatusZaposlenogRelations(Root root, CriteriaBuilder builder, String key, String val) { + super(root, builder, key, val); + statusZaposlenogExpression = root.get("statusZaposlenog").as(StatusZaposlenog.class); + statusZaposlenog = StatusZaposlenog.valueOfLabel(val); + } + + @Override + public Predicate greaterThanOrEqualTo() { + throw new OperationNotSupportedException(String.format("Relacija > nije implementirana za TipFakture [key:%s,val%s]", key, val)); + } + + @Override + public Predicate lessThanOrEqualTo() { + throw new OperationNotSupportedException(String.format("Relacija < nije implementirana za TipFakture [key:%s,val%s]",key,val)); + } + + @Override + public Predicate equalTo() { + return this.builder.equal(statusZaposlenogExpression, statusZaposlenog); + } + +} diff --git a/src/main/java/rs/raf/demo/repositories/KoeficijentRepository.java b/src/main/java/rs/raf/demo/repositories/KoeficijentRepository.java new file mode 100644 index 00000000..d7f99375 --- /dev/null +++ b/src/main/java/rs/raf/demo/repositories/KoeficijentRepository.java @@ -0,0 +1,10 @@ +package rs.raf.demo.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import rs.raf.demo.model.Koeficijent; + +@Repository +public interface KoeficijentRepository extends JpaRepository { + public Koeficijent findTopByOrderByDateDesc(); +} diff --git a/src/main/java/rs/raf/demo/repositories/PlataRepository.java b/src/main/java/rs/raf/demo/repositories/PlataRepository.java new file mode 100644 index 00000000..bae1393f --- /dev/null +++ b/src/main/java/rs/raf/demo/repositories/PlataRepository.java @@ -0,0 +1,19 @@ +package rs.raf.demo.repositories; + +import org.springframework.data.jpa.domain.Specification; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import rs.raf.demo.model.Plata; + +import java.util.List; +import java.util.Optional; + +@Repository +public interface PlataRepository extends JpaRepository { + + public List findByZaposleniZaposleniId(Long zaposleniId); + + public Optional findByPlataId(Long plataId); + + public List findAll(Specification spec); +} diff --git a/src/main/java/rs/raf/demo/repositories/StazRepository.java b/src/main/java/rs/raf/demo/repositories/StazRepository.java new file mode 100644 index 00000000..66d00dd0 --- /dev/null +++ b/src/main/java/rs/raf/demo/repositories/StazRepository.java @@ -0,0 +1,9 @@ +package rs.raf.demo.repositories; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import rs.raf.demo.model.Staz; + +@Repository +public interface StazRepository extends JpaRepository { +} diff --git a/src/main/java/rs/raf/demo/repositories/ZaposleniRepository.java b/src/main/java/rs/raf/demo/repositories/ZaposleniRepository.java new file mode 100644 index 00000000..667fe1b4 --- /dev/null +++ b/src/main/java/rs/raf/demo/repositories/ZaposleniRepository.java @@ -0,0 +1,14 @@ +package rs.raf.demo.repositories; + +import org.springframework.data.jpa.domain.Specification; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +import rs.raf.demo.model.Zaposleni; + +import java.util.List; + +@Repository +public interface ZaposleniRepository extends JpaRepository { + List findAll(Specification spec); + +} diff --git a/src/main/java/rs/raf/demo/requests/PlataRequest.java b/src/main/java/rs/raf/demo/requests/PlataRequest.java new file mode 100644 index 00000000..d8842cd7 --- /dev/null +++ b/src/main/java/rs/raf/demo/requests/PlataRequest.java @@ -0,0 +1,23 @@ +package rs.raf.demo.requests; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.Getter; +import lombok.Setter; + +import javax.validation.constraints.NotNull; +import java.util.Date; + +@Data +@AllArgsConstructor +@Getter +@Setter +public class PlataRequest { + private Long plataId; + @NotNull(message = "netoPlata je obavezna") + private Double netoPlata; + @NotNull(message = "datum je obavezan") + private Date datum; + @NotNull(message = "zaposleniId je obavezan") + private Long zaposleniId; +} diff --git a/src/main/java/rs/raf/demo/responses/BilansResponse.java b/src/main/java/rs/raf/demo/responses/BilansResponse.java new file mode 100644 index 00000000..94e26c66 --- /dev/null +++ b/src/main/java/rs/raf/demo/responses/BilansResponse.java @@ -0,0 +1,11 @@ +package rs.raf.demo.responses; + +public class BilansResponse { + + private String brojKonta; + private int brojStavki; + private String nazivKonta; + private Double duguje; + private Double potrazuje; + private Double saldo; +} diff --git a/src/main/java/rs/raf/demo/services/IStazService.java b/src/main/java/rs/raf/demo/services/IStazService.java new file mode 100644 index 00000000..6bb39bbe --- /dev/null +++ b/src/main/java/rs/raf/demo/services/IStazService.java @@ -0,0 +1,7 @@ +package rs.raf.demo.services; + +import rs.raf.demo.model.Staz; +import rs.raf.demo.model.Zaposleni; + +public interface IStazService extends IService { +} diff --git a/src/main/java/rs/raf/demo/services/IZaposleniService.java b/src/main/java/rs/raf/demo/services/IZaposleniService.java new file mode 100644 index 00000000..800064bf --- /dev/null +++ b/src/main/java/rs/raf/demo/services/IZaposleniService.java @@ -0,0 +1,15 @@ +package rs.raf.demo.services; + +import org.springframework.data.jpa.domain.Specification; +import rs.raf.demo.model.Zaposleni; + + +import java.util.List; + +public interface IZaposleniService extends IService { + + List findAll(Specification spec); + Zaposleni otkazZaposleni(Zaposleni zaposleni); + Zaposleni updateZaposleni(Zaposleni zaposleni); + +} \ No newline at end of file diff --git a/src/main/java/rs/raf/demo/services/impl/KoeficijentService.java b/src/main/java/rs/raf/demo/services/impl/KoeficijentService.java new file mode 100644 index 00000000..0557c9c9 --- /dev/null +++ b/src/main/java/rs/raf/demo/services/impl/KoeficijentService.java @@ -0,0 +1,42 @@ +package rs.raf.demo.services.impl; + +import org.springframework.stereotype.Service; +import rs.raf.demo.model.Koeficijent; +import rs.raf.demo.repositories.KoeficijentRepository; +import rs.raf.demo.services.IService; + +import java.util.List; +import java.util.Optional; + +@Service +public class KoeficijentService implements IService { + public final KoeficijentRepository koeficijentRepository; + + public KoeficijentService(KoeficijentRepository koeficijentRepository) { + this.koeficijentRepository = koeficijentRepository; + } + + @Override + public S save(S var1) { + return this.koeficijentRepository.save(var1); + } + + @Override + public Optional findById(Long var1) { + return this.koeficijentRepository.findById(var1); + } + + @Override + public List findAll() { + return this.koeficijentRepository.findAll(); + } + + @Override + public void deleteById(Long var1) { + this.koeficijentRepository.deleteById(var1); + } + + public Koeficijent getCurrentKoeficijent() { + return this.koeficijentRepository.findTopByOrderByDateDesc(); + } +} diff --git a/src/main/java/rs/raf/demo/services/impl/KontoService.java b/src/main/java/rs/raf/demo/services/impl/KontoService.java index 644a38ee..9980ad55 100644 --- a/src/main/java/rs/raf/demo/services/impl/KontoService.java +++ b/src/main/java/rs/raf/demo/services/impl/KontoService.java @@ -56,7 +56,11 @@ public List findAll(Specification spec) { return this.kontoRepository.findAll(spec); } - public Page findAllGlavnaKnjigaResponse(Specification spec, Pageable pageSort) { + public Page findAllGlavnaKnjigaResponseWithFilter(Specification spec, Pageable pageSort) { return this.kontoConverter.convert(this.kontoRepository.findAll(spec, pageSort).getContent()); } + + public Page findAllGlavnaKnjigaResponse() { + return this.kontoConverter.convert(this.kontoRepository.findAll()); + } } diff --git a/src/main/java/rs/raf/demo/services/impl/PlataService.java b/src/main/java/rs/raf/demo/services/impl/PlataService.java new file mode 100644 index 00000000..340a1302 --- /dev/null +++ b/src/main/java/rs/raf/demo/services/impl/PlataService.java @@ -0,0 +1,91 @@ +package rs.raf.demo.services.impl; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.stereotype.Service; +import rs.raf.demo.model.Konto; +import rs.raf.demo.model.Plata; +import rs.raf.demo.model.Zaposleni; +import rs.raf.demo.repositories.PlataRepository; +import rs.raf.demo.requests.PlataRequest; +import rs.raf.demo.services.IService; +import rs.raf.demo.utils.SearchUtil; + +import javax.persistence.EntityNotFoundException; + +import java.util.Date; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +@Service +public class PlataService implements IService { + private final PlataRepository plataRepository; + @Autowired + private IService zaposleniService; + private final KoeficijentService koeficijentService; + + private SearchUtil searchUtil; + + public PlataService(PlataRepository plataRepository, KoeficijentService koeficijentService) { + this.plataRepository = plataRepository; + this.koeficijentService = koeficijentService; + this.searchUtil = new SearchUtil(); + } + + @Override + public S save(S var1) { + return this.plataRepository.save(var1); + } + + public Plata save(PlataRequest plataRequest) { + Optional optionalZaposleni = zaposleniService.findById(plataRequest.getZaposleniId()); + + if(!optionalZaposleni.isPresent()) { + throw new EntityNotFoundException(); + } + + Zaposleni zaposleni = optionalZaposleni.get(); + updateDatumDoNaStarojPlati(zaposleni); + Plata plata = new Plata(); + plata.setNetoPlata(plataRequest.getNetoPlata()); + plata.setDatumOd(plataRequest.getDatum()); + plata.setZaposleni(zaposleni); + plata.izracunajDoprinose(this.koeficijentService.getCurrentKoeficijent()); + return this.plataRepository.save(plata); + } + + private void updateDatumDoNaStarojPlati(Zaposleni zaposleni) { + List plate = plataRepository.findAll() + .stream() + .filter(plata -> plata.getZaposleni().getZaposleniId().equals(zaposleni.getZaposleniId()) && plata.getDatumDo() == null) + .collect(Collectors.toList()); + + Plata plata = plate.get(0); + plata.setDatumDo(new Date()); + plataRepository.save(plata); + } + + @Override + public Optional findById(Long var1) { + return this.plataRepository.findByPlataId(var1); + } + + @Override + public List findAll() { + return this.plataRepository.findAll(); + } + + public List findAll(Specification spec) { + return this.plataRepository.findAll(spec); + } + + @Override + public void deleteById(Long var1) { + this.plataRepository.deleteById(var1); + } + + public List findByZaposleniZaposleniId(Long zaposleniId) { + return this.plataRepository.findByZaposleniZaposleniId(zaposleniId); + } +} diff --git a/src/main/java/rs/raf/demo/services/impl/StazService.java b/src/main/java/rs/raf/demo/services/impl/StazService.java new file mode 100644 index 00000000..6e1b9de2 --- /dev/null +++ b/src/main/java/rs/raf/demo/services/impl/StazService.java @@ -0,0 +1,39 @@ +package rs.raf.demo.services.impl; + +import org.springframework.stereotype.Service; +import rs.raf.demo.model.Staz; +import rs.raf.demo.repositories.StazRepository; +import rs.raf.demo.services.IStazService; + +import java.util.List; +import java.util.Optional; + +@Service +public class StazService implements IStazService { + + private final StazRepository stazRepository; + + public StazService(StazRepository stazRepository) { + this.stazRepository = stazRepository; + } + + @Override + public S save(S staz) { + return stazRepository.save(staz); + } + + @Override + public Optional findById(Long id) { + return stazRepository.findById(id); + } + + @Override + public List findAll() { + return stazRepository.findAll(); + } + + @Override + public void deleteById(Long id) { + stazRepository.deleteById(id); + } +} diff --git a/src/main/java/rs/raf/demo/services/impl/ZaposleniService.java b/src/main/java/rs/raf/demo/services/impl/ZaposleniService.java new file mode 100644 index 00000000..fe4370d6 --- /dev/null +++ b/src/main/java/rs/raf/demo/services/impl/ZaposleniService.java @@ -0,0 +1,111 @@ +package rs.raf.demo.services.impl; + +import org.springframework.data.jpa.domain.Specification; +import org.springframework.stereotype.Service; +import rs.raf.demo.exceptions.OperationNotSupportedException; +import rs.raf.demo.model.Staz; +import rs.raf.demo.model.Zaposleni; +import rs.raf.demo.model.enums.StatusZaposlenog; +import rs.raf.demo.repositories.ZaposleniRepository; +import rs.raf.demo.services.IZaposleniService; + + +import javax.persistence.EntityNotFoundException; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; + +@Service +public class ZaposleniService implements IZaposleniService{ + + + private final ZaposleniRepository zaposleniRepository; + private final StazService stazService; + + + public ZaposleniService(ZaposleniRepository zaposleniRepository, StazService stazService) { + this.zaposleniRepository = zaposleniRepository; + this.stazService = stazService; + } + + @Override + public S save(S zaposleni) { + Staz newStaz = new Staz(); + newStaz.setPocetakRada(new Date()); + newStaz.setKrajRada(null); + stazService.save(newStaz); + + zaposleni.setStaz(List.of(newStaz)); + zaposleni.setStatusZaposlenog(StatusZaposlenog.ZAPOSLEN); + + return zaposleniRepository.save(zaposleni); + } + + @Override + public Optional findById(Long id) { + return zaposleniRepository.findById(id); + } + + @Override + public List findAll() { + return zaposleniRepository.findAll(); + } + + @Override + public void deleteById(Long id) { + zaposleniRepository.deleteById(id); + } + + @Override + public List findAll(Specification spec) { + return zaposleniRepository.findAll(spec); + } + + @Override + public Zaposleni otkazZaposleni(Zaposleni zaposleni) { + + Optional currZaposleni = zaposleniRepository.findById(zaposleni.getZaposleniId()); + + currZaposleni.get().setStatusZaposlenog(StatusZaposlenog.NEZAPOSLEN); + for(Staz staz : currZaposleni.get().getStaz()){ + if(staz.getKrajRada() == null){ + staz.setKrajRada(new Date()); + stazService.save(staz); + } + } + + return zaposleniRepository.save(currZaposleni.get()); + } + + @Override + public Zaposleni updateZaposleni(Zaposleni zaposleni) { + + Optional currZaposleni = zaposleniRepository.findById(zaposleni.getZaposleniId()); + + if(!currZaposleni.isPresent()){ + throw new EntityNotFoundException(); + } + + if(currZaposleni.get().getStatusZaposlenog().equals(StatusZaposlenog.ZAPOSLEN) && zaposleni.getStatusZaposlenog().equals(StatusZaposlenog.NEZAPOSLEN)) { + throw new OperationNotSupportedException("Nije dozvoljeno update statusa u nezaposlen na ovoj ruti."); + } + + if(currZaposleni.get().getStatusZaposlenog().equals(StatusZaposlenog.NEZAPOSLEN) && zaposleni.getStatusZaposlenog().equals(StatusZaposlenog.ZAPOSLEN)) { + Staz newStaz = new Staz(); + newStaz.setPocetakRada(new Date()); + newStaz.setKrajRada(null); + stazService.save(newStaz); + + List stazLista = zaposleniRepository.findById(zaposleni.getZaposleniId()).get().getStaz(); + stazLista.add(newStaz); + zaposleni.setStaz(stazLista); + + }else{ + List stazLista = zaposleniRepository.findById(zaposleni.getZaposleniId()).get().getStaz(); + zaposleni.setStaz(stazLista); + } + + return zaposleniRepository.save(zaposleni); + } +} \ No newline at end of file diff --git a/src/main/java/rs/raf/demo/specifications/RacunSpecification.java b/src/main/java/rs/raf/demo/specifications/RacunSpecification.java index c0cdbf9f..fbc680c8 100644 --- a/src/main/java/rs/raf/demo/specifications/RacunSpecification.java +++ b/src/main/java/rs/raf/demo/specifications/RacunSpecification.java @@ -6,6 +6,8 @@ import rs.raf.demo.model.Dokument; import rs.raf.demo.model.KontnaGrupa; import rs.raf.demo.model.Preduzece; +import rs.raf.demo.model.enums.RadnaPozicija; +import rs.raf.demo.model.enums.StatusZaposlenog; import rs.raf.demo.model.enums.TipFakture; import rs.raf.demo.relations.*; @@ -47,6 +49,12 @@ private RacunRelations getRelations(Root root, CriteriaBuilder builder, Cl if (KontnaGrupa.class == keyType) { return new KontnaGrupaRelations<>(root, builder, key, val); } + if (RadnaPozicija.class == keyType) { + return new RadnaPozicijaRelations(root, builder, key, val); + } + if (StatusZaposlenog.class == keyType) { + return new StatusZaposlenogRelations(root, builder, key, val); + } throw new OperationNotSupportedException(String.format("Josuvek nije podrzano filtriranje po tipu %s(%s)", key, keyType)); } @@ -55,6 +63,13 @@ private RacunRelations getRelations(Root root, CriteriaBuilder builder, Cl public Predicate toPredicate (Root root, CriteriaQuery query, CriteriaBuilder builder) { + // mgojkovic: Poseban slucaj gde nam treba join kako bismo radili filter po poljima koja nisu kljuc, + // join radi samo sa equal trenutno (nezavisno od prosledjene operacije), treba generalizovati + if (isJoiningRequired(criteria.getKey())) { + Expression exception = getExpresionForJoinedTable(root); + return builder.equal(exception, criteria.getValue().toString()); + } + Class keyType = root.get(criteria.getKey()).getJavaType(); RacunRelations relations = getRelations(root,builder,keyType,criteria.getKey(),criteria.getValue().toString()); @@ -70,6 +85,16 @@ private RacunRelations getRelations(Root root, CriteriaBuilder builder, Cl throw new OperationNotSupportedException(String.format("Nepoznata operacija \"%s\"",criteria.getOperation())); } + private Expression getExpresionForJoinedTable(Root root) { + String[] tableAndField = criteria.getKey().split("_"); + Join groupJoin = root.join(tableAndField[0]); + return groupJoin.get(tableAndField[1]); + } + + private boolean isJoiningRequired(String key) { + return key.contains("_"); + } + @Override public boolean equals(Object o) { if (this == o) { diff --git a/src/test/java/rs/raf/demo/utils/PlataTest.java b/src/test/java/rs/raf/demo/utils/PlataTest.java new file mode 100644 index 00000000..898430bd --- /dev/null +++ b/src/test/java/rs/raf/demo/utils/PlataTest.java @@ -0,0 +1,100 @@ +package rs.raf.demo.utils; + +import org.junit.Test; +import rs.raf.demo.model.Koeficijent; +import rs.raf.demo.model.Plata; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class PlataTest { + @Test + public void IzracunavanjeDoprinosa1() { + Double netoPlata = 30000.0; + Double ocekivanaBrutoPlata = 6998222.999999999; + Double ocekivaniDoprinosi1 = 1.4250833769999998E7; + Double ocekivaniDoprinosi2 = 1.1565375144999998E7; + Double ocekivaniPorez = 6968222.999999999; + Double ocekivaniTrosakZarade = 1.8563598144999996E7; + + Koeficijent koeficijent = new Koeficijent(); + koeficijent.setNajnizaOsnovica(30880.0); + koeficijent.setNajvisaOsnovica(441440.0); + koeficijent.setPoreskoOslobadjanje(19300.0); + koeficijent.setKoeficijentPoreza(10.0); + koeficijent.setPenzionoOsiguranje1(14.0); + koeficijent.setPenzionoOsiguranje2(11.0); + koeficijent.setZdravstvenoOsiguranje1(5.15); + koeficijent.setZdravstvenoOsiguranje2(5.15); + koeficijent.setNezaposlenost1(0.75); + koeficijent.setNezaposlenost2(0.0); + + Plata plata = new Plata(); + plata.setNetoPlata(netoPlata); + plata.izracunajDoprinose(koeficijent); + assertEquals(plata.getBrutoPlata(), ocekivanaBrutoPlata); + assertEquals(plata.getDoprinos1(), ocekivaniDoprinosi1); + assertEquals(plata.getDoprinos2(), ocekivaniDoprinosi2); + assertEquals(plata.getPorez(), ocekivaniPorez); + assertEquals(plata.getUkupanTrosakZarade(), ocekivaniTrosakZarade); + } + @Test + public void IzracunavanjeDoprinosa2() { + Double netoPlata = 150000.0; + Double ocekivanaBrutoPlata = 2096772.7532097008; + Double ocekivaniDoprinosi1 = 4258147.7788873045; + Double ocekivaniDoprinosi2 = 3455732.9964336664; + Double ocekivaniPorez = 1946772.7532097008; + Double ocekivaniTrosakZarade = 5552505.749643367; + + Koeficijent koeficijent = new Koeficijent(); + koeficijent.setNajnizaOsnovica(30880.0); + koeficijent.setNajvisaOsnovica(441440.0); + koeficijent.setPoreskoOslobadjanje(19300.0); + koeficijent.setKoeficijentPoreza(10.0); + koeficijent.setPenzionoOsiguranje1(14.0); + koeficijent.setPenzionoOsiguranje2(11.0); + koeficijent.setZdravstvenoOsiguranje1(5.15); + koeficijent.setZdravstvenoOsiguranje2(5.15); + koeficijent.setNezaposlenost1(0.75); + koeficijent.setNezaposlenost2(0.0); + + Plata plata = new Plata(); + plata.setNetoPlata(netoPlata); + plata.izracunajDoprinose(koeficijent); + assertEquals(plata.getBrutoPlata(), ocekivanaBrutoPlata); + assertEquals(plata.getDoprinos1(), ocekivaniDoprinosi1); + assertEquals(plata.getDoprinos2(), ocekivaniDoprinosi2); + assertEquals(plata.getPorez(), ocekivaniPorez); + assertEquals(plata.getUkupanTrosakZarade(), ocekivaniTrosakZarade); + } + @Test + public void IzracunavanjeDoprinosa3() { + Double netoPlata = 450000.0; + Double ocekivanaBrutoPlata = 1.0286426744444445E8; + Double ocekivaniDoprinosi1 = 2.0418846221444443E8; + Double ocekivaniDoprinosi2 = 1.6571073692277777E8; + Double ocekivaniPorez = 1.0241426744444445E8; + Double ocekivaniTrosakZarade = 2.685750043672222E8; + + Koeficijent koeficijent = new Koeficijent(); + koeficijent.setNajnizaOsnovica(30880.0); + koeficijent.setNajvisaOsnovica(441440.0); + koeficijent.setPoreskoOslobadjanje(19300.0); + koeficijent.setKoeficijentPoreza(10.0); + koeficijent.setPenzionoOsiguranje1(14.0); + koeficijent.setPenzionoOsiguranje2(11.0); + koeficijent.setZdravstvenoOsiguranje1(5.15); + koeficijent.setZdravstvenoOsiguranje2(5.15); + koeficijent.setNezaposlenost1(0.75); + koeficijent.setNezaposlenost2(0.0); + + Plata plata = new Plata(); + plata.setNetoPlata(netoPlata); + plata.izracunajDoprinose(koeficijent); + assertEquals(plata.getBrutoPlata(), ocekivanaBrutoPlata); + assertEquals(plata.getDoprinos1(), ocekivaniDoprinosi1); + assertEquals(plata.getDoprinos2(), ocekivaniDoprinosi2); + assertEquals(plata.getPorez(), ocekivaniPorez); + assertEquals(plata.getUkupanTrosakZarade(), ocekivaniTrosakZarade); + } +}