Changes in / [9504a09:3a58bd6]


Ignore:
Location:
sources/app
Files:
45 added
9 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • sources/app/ParkUp.iml

    r9504a09 r3a58bd6  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
     3  <component name="EclipseModuleManager">
     4    <conelement value="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" />
     5    <src_description expected_position="2">
     6      <src_folder value="file://$MODULE_DIR$/src/main/java" expected_position="0" />
     7      <src_folder value="file://$MODULE_DIR$/src/main/resources" expected_position="1" />
     8      <src_folder value="file://$MODULE_DIR$/src/test/java" expected_position="2" />
     9      <src_folder value="file://$MODULE_DIR$/target/generated-sources/annotations" expected_position="5" />
     10      <src_folder value="file://$MODULE_DIR$/target/generated-test-sources/test-annotations" expected_position="6" />
     11    </src_description>
     12  </component>
    313  <component name="FacetManager">
     14    <facet type="web" name="Web">
     15      <configuration>
     16        <webroots />
     17        <sourceRoots>
     18          <root url="file://$MODULE_DIR$/src/main/java" />
     19          <root url="file://$MODULE_DIR$/src/main/resources" />
     20          <root url="file://$MODULE_DIR$/target/generated-sources/annotations" />
     21          <root url="file://$MODULE_DIR$/target/generated-test-sources/test-annotations" />
     22        </sourceRoots>
     23      </configuration>
     24    </facet>
    425    <facet type="jpa" name="JPA">
    526      <configuration>
    … …  
    1637      <configuration />
    1738    </facet>
    18     <facet type="web" name="Web">
    19       <configuration>
    20         <webroots />
    21       </configuration>
    22     </facet>
    2339  </component>
    2440  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_11">
    … …  
    2844      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
    2945      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
     46      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
     47      <sourceFolder url="file://$MODULE_DIR$/target/generated-sources/annotations" isTestSource="false" />
     48      <sourceFolder url="file://$MODULE_DIR$/target/generated-test-sources/test-annotations" isTestSource="false" />
    3049      <excludeFolder url="file://$MODULE_DIR$/target" />
    3150    </content>
    3251    <orderEntry type="inheritedJdk" />
     52    <orderEntry type="library" name="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" level="application" />
    3353    <orderEntry type="sourceFolder" forTests="false" />
    3454    <orderEntry type="library" name="Maven: org.springframework.boot:spring-boot-starter-data-jdbc:2.4.5" level="project" />

  • sources/app/src/main/java/parkup/configs/RegistrationRequest.java

    r9504a09 r3a58bd6  
    66    private final String email;
    77    private final String password;
    8     private final String mobile;
    98
    10     public RegistrationRequest(String firstName, String lastName, String email, String password, String mobile) {
     9    public RegistrationRequest(String firstName, String lastName, String email, String password) {
    1110        this.firstName = firstName;
    1211        this.lastName = lastName;
    1312        this.email = email;
    1413        this.password = password;
    15         this.mobile = mobile;
    1614    }
    1715
    … …  
    3230    }
    3331
    34     public String getMobile(){
    35         return mobile;
    36     }
    37 
    3832}

  • sources/app/src/main/java/parkup/configs/WebSecurityConfig.java

    r9504a09 r3a58bd6  
    99import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    1010import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    11 import parkup.services.RegistriranParkiracService;
    12 import parkup.services.VrabotenService;
     11import parkup.services.AdministratorService;
    1312
     13@Configuration
    1414@EnableWebSecurity
    15 @Configuration
    1615public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    17         private final VrabotenService vrabotenService;
    18         private final BCryptPasswordEncoder bCryptPasswordEncoder;
    19         private final RegistriranParkiracService registriranParkiracService;
    2016
    21         public WebSecurityConfig(VrabotenService vrabotenService, BCryptPasswordEncoder bCryptPasswordEncoder, RegistriranParkiracService registriranParkiracService) {
    22             this.vrabotenService = vrabotenService;
    23             this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    24             this.registriranParkiracService = registriranParkiracService;
    25         }
     17    private final AdministratorService administratorService;
     18    private final BCryptPasswordEncoder bCryptPasswordEncoder;
    2619
    27         @Override
    28         protected void configure(HttpSecurity http) throws Exception {
    29             http
    30                     .csrf().disable()
    31                     .authorizeRequests()
    32                         .antMatchers("/vraboten/registration/**")
    33                         .permitAll()
    34                         .antMatchers("/registriranParkirac/registration/**")
    35                         .permitAll()
    36                     .anyRequest()
    37                     .authenticated().and().formLogin();
    38         }
     20    public WebSecurityConfig(AdministratorService administratorService, BCryptPasswordEncoder bCryptPasswordEncoder) {
     21        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
     22        this.administratorService = administratorService;
     23    }
    3924
    40         @Override
    41         protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    42             auth.authenticationProvider(daoAuthenticationProviderW());
    43             auth.authenticationProvider(daoAuthenticationProviderRP());
    44         }
     25    @Override
     26    protected void configure(HttpSecurity http) throws Exception {
     27        http
     28                .csrf().disable()
     29                .authorizeRequests()
     30                    .antMatchers("/administrator/registration/**")
     31                    .permitAll()
     32                .anyRequest()
     33                .authenticated().and()
     34                .formLogin();
     35    }
    4536
    46         @Bean
    47         public DaoAuthenticationProvider daoAuthenticationProviderW() {
    48             DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
    49             provider.setPasswordEncoder(bCryptPasswordEncoder);
    50             provider.setUserDetailsService(vrabotenService);
    51             return provider;
    52         }
     37    @Override
     38    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
     39        auth.authenticationProvider(daoAuthenticationProvider());
     40    }
    5341
    54         @Bean
    55         public DaoAuthenticationProvider daoAuthenticationProviderRP(){
    56             DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
    57             provider.setPasswordEncoder(bCryptPasswordEncoder);
    58             provider.setUserDetailsService(registriranParkiracService);
    59             return provider;
    60         }
    61 
     42    @Bean
     43    public DaoAuthenticationProvider daoAuthenticationProvider(){
     44        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
     45        provider.setPasswordEncoder(bCryptPasswordEncoder);
     46        provider.setUserDetailsService(administratorService);
     47        return provider;
    6248    }
     49}

  • sources/app/src/main/java/parkup/configs/token/ConfirmationTokenService.java

    r9504a09 r3a58bd6  
    99public class ConfirmationTokenService {
    1010
    11     private final ConfirmationTokenRepositoryRP confirmationTokenRepositoryRP;
    12     private final ConfirmationTokenRepositoryW confirmationTokenRepositoryW;
     11    private final ConfirmationTokenRepository confirmationTokenRepository;
    1312
    14     public ConfirmationTokenService(ConfirmationTokenRepositoryRP confirmationTokenRepositoryRP, ConfirmationTokenRepositoryW confirmationTokenRepositoryW) {
    15         this.confirmationTokenRepositoryRP = confirmationTokenRepositoryRP;
    16         this.confirmationTokenRepositoryW = confirmationTokenRepositoryW;
     13    public ConfirmationTokenService(ConfirmationTokenRepository confirmationTokenRepository) {
     14        this.confirmationTokenRepository = confirmationTokenRepository;
    1715    }
    1816
    19     public void saveConfirmationTokenRP(ConfirmationTokenRP token){
    20         confirmationTokenRepositoryRP.save(token);
     17    public void saveConfirmationToken(ConfirmationToken token){
     18        confirmationTokenRepository.save(token);
    2119    }
    2220
    23     public void saveConfirmationTokenW(ConfirmationTokenW token){
    24         confirmationTokenRepositoryW.save(token);}
    25 
    26     public Optional<ConfirmationTokenRP> getTokenRP(String token) {
    27         return confirmationTokenRepositoryRP.findByToken(token);
    28     }
    29     public Optional<ConfirmationTokenW> getTokenW(String token){
    30         return confirmationTokenRepositoryW.findByToken(token);
     21    public Optional<ConfirmationToken> getToken(String token) {
     22        return confirmationTokenRepository.findByToken(token);
    3123    }
    3224
    33     public void deleteByVraboten_VrabotenId(int vraboten_id){
    34         confirmationTokenRepositoryW.deleteByVraboten_VrabotenId(vraboten_id);
    35     }
    36 
    37     public void deleteByRegistriranParkirac_RegParkId(int regParkId){
    38         confirmationTokenRepositoryRP.deleteByRegistriranParkirac_RegParkId(regParkId);
    39     }
    40 
    41     public int setConfirmedAtRP(String token) {
    42         return confirmationTokenRepositoryRP.updateConfirmedAt(token, LocalDateTime.now());
    43     }
    44     public int setConfirmedAtW(String token){
    45         return confirmationTokenRepositoryW.updateConfirmedAt(token,LocalDateTime.now());
     25    public int setConfirmedAt(String token) {
     26        return confirmationTokenRepository.updateConfirmedAt(token, LocalDateTime.now());
    4627    }
    4728}

  • sources/app/src/main/java/parkup/controllers/AdministratorController.java

    r9504a09 r3a58bd6  
    22
    33import java.util.List;
    4 import java.util.Optional;
    5 
    64import org.springframework.beans.factory.annotation.Autowired;
    75import org.springframework.web.bind.annotation.*;
    86import parkup.configs.RegistrationRequest;
    9 import parkup.configs.RegistrationServiceRP;
     7import parkup.configs.RegistrationService;
    108import parkup.entities.Administrator;
    119import parkup.services.AdministratorService;
    … …  
    1412public class AdministratorController {
    1513    private final AdministratorService administratorService;
    16     private final RegistrationServiceRP registrationServiceRP;
     14    private final RegistrationService registrationService;
    1715
    1816    @Autowired
    19     public AdministratorController(AdministratorService administratorService, RegistrationServiceRP registrationServiceRP) {
     17    public AdministratorController(AdministratorService administratorService, RegistrationService registrationService) {
    2018        this.administratorService = administratorService;
    21         this.registrationServiceRP = registrationServiceRP;
     19        this.registrationService = registrationService;
    2220    }
    2321
    … …  
    3836
    3937    @PostMapping({"/administrator"})
    40     public Optional<Administrator> addAdministrator(@RequestBody Administrator administrator) {
    41         return this.administratorService.addAdministrator(administrator);
     38    public void addAdministrator(@RequestBody Administrator administrator) {
     39        this.administratorService.addAdministrator(administrator);
    4240    }
    4341
    4442    @PutMapping({"/administrator/{administratorId}"})
    45     public Administrator updateAdministrator(@PathVariable int administratorId, @RequestBody Administrator administrator) {
    46         return this.administratorService.updateAdministrator(administratorId, administrator.getFirstName(), administrator.getLastName(), administrator.getMobile(), administrator.getEmail());
     43    public void updateAdministrator(@PathVariable int administratorId, @RequestBody Administrator administrator) {
     44        this.administratorService.updateAdministrator(administratorId, administrator.getFirstName(), administrator.getLastName(), administrator.getMobile(), administrator.getEmail());
    4745    }
    4846
    4947    @DeleteMapping({"/administrator/{administratorId}"})
    50     public Optional<Administrator> deleteAdministrator(@PathVariable int administratorId) {
    51         return this.administratorService.deleteAdministrator(administratorId);
     48    public void deleteAdministrator(@PathVariable int administratorId) {
     49        this.administratorService.deleteAdministrator(administratorId);
    5250    }
    5351
    5452    @PostMapping({"/administrator/registration"})
    5553    public String register(@RequestBody RegistrationRequest request){
    56         return registrationServiceRP.register(request);
     54        return registrationService.register(request);
    5755    }
    5856
    5957    @GetMapping(path = "/administrator/registration/confirm")
    6058    public String confirm(@RequestParam("token") String token) {
    61         return registrationServiceRP.confirmToken(token);
     59        return registrationService.confirmToken(token);
    6260    }
    6361}

  • sources/app/src/main/java/parkup/controllers/ParkingSessionController.java

    r9504a09 r3a58bd6  
    77
    88import java.util.List;
    9 import java.util.Optional;
    109
    1110@RestController
    … …  
    3433
    3534    @PostMapping({"/parkingSession"})
    36     public Optional<ParkingSession> addParkingSession(@RequestBody ParkingSession parkingSession) {
     35    public void addParkingSession(@RequestBody ParkingSession parkingSession) {
    3736        //System.out.println("???????");
    38         return this.parkingSessionService.addParkingSession(parkingSession);
     37        parkingSessionService.addParkingSession(parkingSession);
    3938    }
    4039
    4140    @PutMapping({"/parkingSession/{parkingSessionId}"})
    4241    public void updateParkingSession(@PathVariable int parkingSessionId, @RequestBody ParkingSession parkingSession) {
    43         parkingSessionService.updateParkingSession(parkingSessionId,
    44                 parkingSession.getTimeStart(), parkingSession.getTimeEnd(), parkingSession.getTablica());
     42        parkingSessionService.updateParkingSession(parkingSessionId, parkingSession.getTimeStart(), parkingSession.getTimeEnd());
    4543    }
    4644
    4745    @DeleteMapping({"/parkingSession/{parkingSessionId}"})
    48     public Optional<ParkingSession> deleteParkingSession(@PathVariable int parkingSessionId) {
    49         return this.parkingSessionService.deleteParkingSession(parkingSessionId);
     46    public void deleteParkingSession(@PathVariable int parkingSessionId) {
     47        parkingSessionService.deleteParkingSession(parkingSessionId);
    5048    }
    5149}

  • sources/app/src/main/java/parkup/controllers/ParkingSpaceController.java

    r9504a09 r3a58bd6  
    77
    88import java.util.List;
    9 import java.util.Optional;
    109
    1110@RestController
    … …  
    3433
    3534    @PostMapping({"/parkingSpace"})
    36     public Optional<ParkingSpace> addParkingSpace(@RequestBody ParkingSpace parkingSpace) {
     35    public void addParkingSpace(@RequestBody ParkingSpace parkingSpace) {
    3736        //System.out.println("???????");
    38         return this.parkingSpaceService.addParkingSpace(parkingSpace);
     37        parkingSpaceService.addParkingSpace(parkingSpace);
    3938    }
    4039
    4140    @PutMapping({"/parkingSpace/{parkingSpaceId}"})
    4241    public void updateParkingSpace(@PathVariable int parkingSpaceId, @RequestBody ParkingSpace parkingSpace) {
    43         parkingSpaceService.updateParkingSpace(parkingSpaceId, parkingSpace.getPsName(), parkingSpace.isTaken(),
    44                 parkingSpace.isHandicaped(), parkingSpace.getLat(), parkingSpace.getLng());
     42        parkingSpaceService.updateParkingSpace(parkingSpaceId, parkingSpace.getPsName(), parkingSpace.isTaken(), parkingSpace.isHandicaped());
    4543    }
    4644
    4745    @DeleteMapping({"/parkingSpace/{parkingSpaceId}"})
    48     public Optional<ParkingSpace> deleteParkingSpace(@PathVariable int parkingSpaceId) {
    49         return this.parkingSpaceService.deleteParkingSpace(parkingSpaceId);
     46    public void deleteParkingSpace(@PathVariable int parkingSpaceId) {
     47        parkingSpaceService.deleteParkingSpace(parkingSpaceId);
    5048    }
    5149}

  • sources/app/src/main/java/parkup/controllers/ParkingZoneController.java

    r9504a09 r3a58bd6  
    77
    88import java.util.List;
    9 import java.util.Optional;
    109
    1110@RestController
    … …  
    3332    }
    3433
    35     @GetMapping({"parkingZone/parkingZoneNames"})
    36     public List<String> getParkingZoneNames(){
    37         return this.parkingZoneService.getAllParkingZoneNames();
    38     }
    39 
    4034    @PostMapping({"/parkingZone"})
    41     public Optional<ParkingZone> addParkingZone(@RequestBody ParkingZone parkingZone) {
    42         return this.parkingZoneService.addParkingZone(parkingZone);
    43     }
    44 
    45     @PostMapping("/parkingZoneName")
    46     public ParkingZone addParkingZoneName(@RequestBody String name){
    47         return this.parkingZoneService.addParkingZoneNameOnly(name);
     35    public void addParkingZone(@RequestBody ParkingZone parkingZone) {
     36        //System.out.println("???????");
     37        parkingZoneService.addParkingZone(parkingZone);
    4838    }
    4939
    5040    @PutMapping({"/parkingZone/{parkingZoneId}"})
    51     public ParkingZone updateParkingZone(@PathVariable int parkingZoneId, @RequestBody ParkingZone parkingZone) {
    52         return this.parkingZoneService.updateParkingZone(parkingZoneId, parkingZone.getPzName(), parkingZone.getPrice(), parkingZone.getCapacity(),
    53                 parkingZone.getLocation(), parkingZone.getFrom(), parkingZone.getTo(), parkingZone.getColor(),
    54                 parkingZone.getParkingSpaces(), parkingZone.getParkingZoneLocation());
     41    public void updateParkingZone(@PathVariable int parkingZoneId, @RequestBody ParkingZone parkingZone) {
     42        parkingZoneService.updateParkingZone(parkingZoneId, parkingZone.getPzName(), parkingZone.getPrice(), parkingZone.getCapacity(), parkingZone.getWorkHours(),parkingZone.getLocation());
    5543    }
    5644
    5745    @DeleteMapping({"/parkingZone/{parkingZoneId}"})
    58     public Optional<ParkingZone> deleteParkingZone(@PathVariable int parkingZoneId) {
    59         return this.parkingZoneService.deleteParkingZone(parkingZoneId);
     46    public void deleteParkingZone(@PathVariable int parkingZoneId) {
     47        parkingZoneService.deleteParkingZone(parkingZoneId);
    6048    }
    6149}

  • sources/app/src/main/java/parkup/controllers/RegistriranParkiracController.java

    r9504a09 r3a58bd6  
    22
    33import java.util.List;
    4 import java.util.Optional;
    5 
    64import org.springframework.beans.factory.annotation.Autowired;
    7 import org.springframework.web.bind.annotation.*;
    8 import parkup.configs.RegistrationRequest;
    9 import parkup.configs.RegistrationServiceRP;
     5import org.springframework.web.bind.annotation.DeleteMapping;
     6import org.springframework.web.bind.annotation.GetMapping;
     7import org.springframework.web.bind.annotation.PathVariable;
     8import org.springframework.web.bind.annotation.PostMapping;
     9import org.springframework.web.bind.annotation.PutMapping;
     10import org.springframework.web.bind.annotation.RequestBody;
     11import org.springframework.web.bind.annotation.RestController;
    1012import parkup.entities.RegistriranParkirac;
    1113import parkup.services.RegistriranParkiracService;
    … …  
    1416public class RegistriranParkiracController {
    1517    private final RegistriranParkiracService registriranParkiracService;
    16     private final RegistrationServiceRP registrationServiceRP;
    1718
    1819    @Autowired
    19     public RegistriranParkiracController(RegistriranParkiracService registriranParkiracService, RegistrationServiceRP registrationServiceRP) {
     20    public RegistriranParkiracController(RegistriranParkiracService registriranParkiracService) {
    2021        this.registriranParkiracService = registriranParkiracService;
    21         this.registrationServiceRP = registrationServiceRP;
    2222    }
    2323
    … …  
    3838
    3939    @PostMapping({"/registriranParkirac"})
    40     public Optional<RegistriranParkirac> addRegistriranParkirac(@RequestBody RegistriranParkirac regPark) {
    41         return this.registriranParkiracService.addRegPark(regPark);
     40    public void addRegistriranParkirac(@RequestBody RegistriranParkirac regPark) {
     41        this.registriranParkiracService.addRegPark(regPark);
    4242    }
    4343
    4444    @PutMapping({"/registriranParkirac/{regParkId}"})
    45     public RegistriranParkirac updateRegistriranParkirac(@PathVariable int regParkId, @RequestBody RegistriranParkirac regPark) {
    46         return this.registriranParkiracService.updateRegPark(regParkId, regPark.getName(), regPark.getSurname(), regPark.getMobile(), regPark.getEmail(),regPark.getRegTablicki());
     45    public void updateRegistriranParkirac(@PathVariable int regParkId, @RequestBody RegistriranParkirac regPark) {
     46        this.registriranParkiracService.updateRegPark(regParkId, regPark.getName(), regPark.getSurname(), regPark.getMobile(), regPark.getEmail());
    4747    }
    4848
    4949    @DeleteMapping({"/registriranParkirac/{regParkId}"})
    50     public Optional<RegistriranParkirac> deleteRegistriranParkirac(@PathVariable int regParkId) {
    51         return this.registriranParkiracService.deleteRegPark(regParkId);
    52     }
    53 
    54     @PostMapping({"/registriranParkirac/registration"})
    55     public String register(@RequestBody RegistrationRequest request){
    56         return registrationServiceRP.register(request);
    57     }
    58 
    59     @GetMapping(path = "/registriranParkirac/registration/confirm")
    60     public String confirm(@RequestParam("token") String token) {
    61         return registrationServiceRP.confirmToken(token);
     50    public void deleteRegistriranParkirac(@PathVariable int regParkId) {
     51        this.registriranParkiracService.deleteRegPark(regParkId);
    6252    }
    6353}

  • sources/app/src/main/java/parkup/controllers/VrabotenController.java

    r9504a09 r3a58bd6  
    22
    33import java.util.List;
    4 import java.util.Optional;
    5 
    64import org.springframework.beans.factory.annotation.Autowired;
    7 import org.springframework.web.bind.annotation.*;
    8 import parkup.configs.RegistrationRequest;
    9 import parkup.configs.RegistrationServiceW;
     5import org.springframework.web.bind.annotation.DeleteMapping;
     6import org.springframework.web.bind.annotation.GetMapping;
     7import org.springframework.web.bind.annotation.PathVariable;
     8import org.springframework.web.bind.annotation.PostMapping;
     9import org.springframework.web.bind.annotation.PutMapping;
     10import org.springframework.web.bind.annotation.RequestBody;
     11import org.springframework.web.bind.annotation.RestController;
    1012import parkup.entities.Vraboten;
    1113import parkup.services.VrabotenService;
    12 import parkup.data.VrabotenDemo;
    1314
    1415@RestController
    1516public class VrabotenController {
    1617    private final VrabotenService vrabotenService;
    17     private final RegistrationServiceW registrationServiceW;
    1818
    1919    @Autowired
    20     public VrabotenController(VrabotenService vrabotenService, RegistrationServiceW registrationServiceW) {
     20    public VrabotenController(VrabotenService vrabotenService) {
    2121        this.vrabotenService = vrabotenService;
    22         this.registrationServiceW = registrationServiceW;
    2322    }
    2423
    … …  
    3837    }
    3938
    40     @GetMapping({"/vraboten/vrabotenDemo"})
    41     public List<VrabotenDemo> getVraboteniDemos(){
    42         return this.vrabotenService.getAllVraboteniDemos();
    43     }
    44 
    4539    @PostMapping({"/vraboten"})
    46     public Optional<Vraboten> addVraboten(@RequestBody Vraboten vraboten) {
    47         return this.vrabotenService.addVraboten(vraboten);
    48     }
    49 
    50     @PostMapping({"/vraboten/{vrabotenId}"})
    51     public void lockVraboten(@PathVariable int vrabotenId) {
    52         this.vrabotenService.lockVrabotenAcc(vrabotenId);
     40    public void addVraboten(@RequestBody Vraboten vraboten) {
     41        this.vrabotenService.addVraboten(vraboten);
    5342    }
    5443
    5544    @PutMapping({"/vraboten/{vrabotenId}"})
    56     public Vraboten updateVraboten(@PathVariable int vrabotenId, @RequestBody Vraboten vraboten) {
    57         return this.vrabotenService.updateVraboten(vrabotenId, vraboten.getFirstName(), vraboten.getLastName(),
    58                 vraboten.getMobile(), vraboten.getEmail(), vraboten.getStatus());
     45    public void updateVraboten(@PathVariable int vrabotenId, @RequestBody Vraboten vraboten) {
     46        this.vrabotenService.updateVraboten(vrabotenId, vraboten.getFirstName(), vraboten.getLastName(), vraboten.getMobile(), vraboten.getEmail());
    5947    }
    6048
    6149    @DeleteMapping({"/vraboten/{vrabotenId}"})
    62     public Optional<Vraboten> deleteVraboten(@PathVariable int vrabotenId) {
    63         return this.vrabotenService.deleteVraboten(vrabotenId);
    64     }
    65 
    66     @PostMapping({"/vraboten/registration"})
    67     public String register(@RequestBody RegistrationRequest request){
    68         return registrationServiceW.register(request);
    69     }
    70 
    71     @GetMapping(path = "/vraboten/registration/confirm")
    72     public String confirm(@RequestParam("token") String token) {
    73         return registrationServiceW.confirmToken(token);
     50    public void deleteVraboten(@PathVariable int vrabotenId) {
     51        this.vrabotenService.deleteVraboten(vrabotenId);
    7452    }
    7553}

  • sources/app/src/main/java/parkup/data/Tablicka.java

    r9504a09 r3a58bd6  
    11package parkup.data;
    22
    3 import javax.persistence.*;
     3import javax.persistence.Entity;
     4import javax.persistence.Id;
    45
    56@Entity
    67public class Tablicka {
    78    @Id
    8     @SequenceGenerator(
    9             name="tablicka_sequence_generator",
    10             sequenceName = "tablicka_sequence",
    11             allocationSize = 1,
    12             initialValue = 1000
    13     )
    14     @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    15             strategy = GenerationType.SEQUENCE,
    16             generator = "tablicka_sequence_generator"
    17     )
    189    private int tablicaId;
    19 
    2010    private String tablica;
    2111

  • sources/app/src/main/java/parkup/entities/ParkingSession.java

    r9504a09 r3a58bd6  
    11package parkup.entities;
    2 
    3 import parkup.data.Tablicka;
    42
    53import javax.persistence.*;
    … …  
    119    @Column(name = "parking_session_id")
    1210    @SequenceGenerator(
    13             name="parking_session_sequence_generator",
     11            name="parking_session_generator",
    1412            sequenceName = "parking_session_sequence",
    1513            allocationSize = 1,
    16             initialValue = 800
     14            initialValue = 700
    1715    )
    1816    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    … …  
    2826    private String timeEnd;
    2927
    30     @OneToOne(cascade = {CascadeType.ALL})
    31     @JoinColumn(name = "reg_tablicka", nullable = false)
    32     private Tablicka tablica;
    33 
    3428    public ParkingSession() {}
    3529
    36     public ParkingSession(int pssId, String timeStart, String timeEnd, Tablicka tablica) {
     30    public ParkingSession(int pssId, String timeStart, String timeEnd) {
    3731        this.pssId = pssId;
    3832        this.timeStart = timeStart;
    3933        this.timeEnd = timeEnd;
    40         this.tablica = tablica;
    4134    }
    4235
    43     public ParkingSession(String timeStart, String timeEnd, Tablicka tablica) {
     36    public ParkingSession(String timeStart, String timeEnd) {
    4437        this.timeStart = timeStart;
    4538        this.timeEnd = timeEnd;
    46         this.tablica = tablica;
    4739    }
    4840
    … …  
    7062        this.timeEnd = timeEnd;
    7163    }
    72 
    73     public Tablicka getTablica() {
    74         return tablica;
    75     }
    76 
    77     public void setTablica(Tablicka tablica) {
    78         this.tablica = tablica;
    79     }
    8064}

  • sources/app/src/main/java/parkup/entities/ParkingSpace.java

    r9504a09 r3a58bd6  
    99    @Column(name = "parking_space_id")
    1010    @SequenceGenerator(
    11             name="parking_space_sequence_generator",
     11            name="parking_space_generator",
    1212            sequenceName = "parking_space_sequence",
    1313            allocationSize = 1,
    14             initialValue = 700
     14            initialValue = 600
    1515    )
    1616    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    … …  
    2929    private boolean isHandicaped;
    3030
    31     @Column(name = "latitude")
    32     private float lat;
    33 
    34     @Column(name = "longitude")
    35     private float lng;
    36 
    37     @OneToOne(cascade = {CascadeType.ALL})
    38     @JoinColumn(name = "parking_zona")
    39     private ParkingZone parkingZone;
    40 
    4131    public ParkingSpace() {}
    4232
    43     public ParkingSpace(int psId, String psName, boolean isTaken, boolean isHandicaped, float lat, float lng) {
     33    public ParkingSpace(int psId, String psName, boolean isTaken, boolean isHandicaped) {
    4434        this.psId = psId;
    4535        this.psName = psName;
    4636        this.isTaken = isTaken;
    4737        this.isHandicaped = isHandicaped;
    48         this.lat = lat;
    49         this.lng = lng;
    5038    }
    5139
    52     public ParkingSpace(String psName, boolean isTaken, boolean isHandicaped, float lat, float lng) {
     40    public ParkingSpace(String psName, boolean isTaken, boolean isHandicaped) {
    5341        this.psName = psName;
    5442        this.isTaken = isTaken;
    5543        this.isHandicaped = isHandicaped;
    56         this.lat = lat;
    57         this.lng = lng;
    5844    }
    5945
    … …  
    8975        this.isHandicaped = isHandicaped;
    9076    }
    91 
    92     public float getLat() {
    93         return lat;
    94     }
    95 
    96     public void setLat(float lat) {
    97         this.lat = lat;
    98     }
    99 
    100     public float getLng() {
    101         return lng;
    102     }
    103 
    104     public void setLng(float lng) {
    105         this.lng = lng;
    106     }
    10777}
    10878

  • sources/app/src/main/java/parkup/entities/ParkingZone.java

    r9504a09 r3a58bd6  
    11package parkup.entities;
    2 
    3 import parkup.data.ParkingZoneLocation;
    42
    53import javax.persistence.*;
    … …  
    1210    @Id
    1311    @SequenceGenerator(
    14             name="parking_zone_sequence_generator",
     12            name="parking_zone_generator",
    1513            sequenceName = "parking_zone_sequence",
    1614            allocationSize = 1,
    17             initialValue = 600
     15            initialValue = 500
    1816    )
    1917    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    … …  
    3331    private int capacity;
    3432
    35     @Column(name = "vreme_od")  //za rabotni casovi od:
    36     private int from;
     33    @Column(name = "work_hours")
     34    private String workHours;
    3735
    38     @Column(name = "vreme_do")    //za rabotni casovi do:
    39     private int to;
    40 
    41     @Column(name = "lokacija")
     36    @Column(name = "location")
    4237    private String location;
    4338
    … …  
    4540    private int zafateniMesta;
    4641
    47     @Column(name = "color")
    48     private String color;
    49 
    50     @ManyToMany(cascade = {CascadeType.ALL})
    51     @JoinColumn(name="odgovorniLica",nullable = true)
    52     private List<Vraboten> odgovorniLica;
    53 
    5442    @OneToMany(cascade = {CascadeType.ALL})
     43    @JoinColumn(name = "parkingSpaces", nullable = false)
    5544    private List<ParkingSpace> parkingSpaces;
    5645
    57     @OneToOne(cascade = {CascadeType.ALL})
    58     private ParkingZoneLocation parkingZoneLocation;
    59 
    60    public ParkingZone() {
    61        this.zafateniMesta = 0;
    62        this.parkingSpaces = new ArrayList<ParkingSpace>();
    63    }
    64 
    65     public ParkingZone(String pzName) {
    66         this.pzName = pzName;
     46    public ParkingZone() {
    6747        this.zafateniMesta = 0;
    6848        this.parkingSpaces = new ArrayList<ParkingSpace>();
    6949    }
    7050
    71     public ParkingZone(int pzId, String pzName, int price, int capacity, String location, List<ParkingSpace> parkingSpaces, String color, int from, int to) {
     51    public ParkingZone(int pzId, String pzName, int price, int capacity, String workHours, String location, List<ParkingSpace> parkingSpaces) {
    7252        this.pzId = pzId;
    7353        this.pzName = pzName;
    7454        this.price = price;
    7555        this.capacity = capacity;
     56        this.workHours = workHours;
    7657        this.location = location;
    7758        this.zafateniMesta = 0;
    7859        this.parkingSpaces = parkingSpaces;
    79         this.color = color;
    80         this.from = from;
    81         this.to = to;
    8260    }
    8361
    84     public ParkingZone(String pzName, int price, int capacity, String location, List<ParkingSpace> parkingSpaces, String color, int from, int to) {
     62    public ParkingZone(String pzName, int price, int capacity, String workHours, String location, List<ParkingSpace> parkingSpaces) {
    8563        this.pzName = pzName;
    8664        this.price = price;
    8765        this.capacity = capacity;
     66        this.workHours = workHours;
    8867        this.location = location;
    8968        this.zafateniMesta = 0;
    9069        this.parkingSpaces = parkingSpaces;
    91         this.color = color;
    92         this.from = from;
    93         this.to = to;
    9470    }
    9571
    … …  
    126102    }
    127103
     104    public String getWorkHours() {
     105        return this.workHours;
     106    }
     107
     108    public void setWorkHours(String workHours) {
     109        this.workHours = workHours;
     110    }
     111
    128112    public String getLocation() {
    129113        return this.location;
    … …  
    141125
    142126    public void setParkingSpaces(List<ParkingSpace> parkingSpaces) {this.parkingSpaces = parkingSpaces;}
    143 
    144     public String getColor() {
    145         return color;
    146     }
    147 
    148     public void setColor(String color) {
    149         this.color = color;
    150     }
    151 
    152     public int getFrom() {
    153         return from;
    154     }
    155 
    156     public void setFrom(int from) {
    157         this.from = from;
    158     }
    159 
    160     public int getTo() {
    161         return to;
    162     }
    163 
    164     public void setTo(int to) {
    165         this.to = to;
    166     }
    167 
    168     public ParkingZoneLocation getParkingZoneLocation() {
    169         return parkingZoneLocation;
    170     }
    171 
    172     public void setParkingZoneLocation(ParkingZoneLocation parkingZoneLocation) {
    173         this.parkingZoneLocation = parkingZoneLocation;
    174     }
    175 
    176     public List<Vraboten> getOdgovorniLica() {
    177         return odgovorniLica;
    178     }
    179 
    180     public void setOdgovorniLica(List<Vraboten> odgovorniLica) {
    181         this.odgovorniLica = odgovorniLica;
    182     }
    183127}

  • sources/app/src/main/java/parkup/entities/RegistriranParkirac.java

    r9504a09 r3a58bd6  
    22
    33import java.util.ArrayList;
    4 import java.util.Collection;
    5 import java.util.Collections;
    64import java.util.List;
    75import javax.persistence.*;
    86
    9 import org.springframework.security.core.GrantedAuthority;
    10 import org.springframework.security.core.authority.SimpleGrantedAuthority;
    11 import org.springframework.security.core.userdetails.UserDetails;
    127import parkup.data.Tablicka;
    138
    149@Entity
    1510@Table(name = "registriranParkirac")
    16 public class RegistriranParkirac implements UserDetails {
     11public class RegistriranParkirac {
    1712    @Id
    1813    @SequenceGenerator(
    … …  
    3833    private String password;
    3934
    40     @OneToMany(cascade ={CascadeType.ALL})
     35    @OneToMany
    4136    @Column(name = "regTablicki")
    4237    private List<Tablicka> regTablicki;
    … …  
    5146    private String role;
    5247
    53     private boolean locked;
     48    public RegistriranParkirac() {
    5449
    55     private boolean enabled;
    56 
    57     public RegistriranParkirac() {
    5850        this.regTablicki = new ArrayList<Tablicka>();
    59         this.role = "ROLE_REGISTRIRAN_PARKIRAC";
     51        this.role = "ROLE_REGISTIRAN_PARKIRAC";
    6052    }
    6153
    … …  
    6860        this.email = email;
    6961        this.mobile = mobile;
    70         this.role = "ROLE_REGISTRIRAN_PARKIRAC";
     62        this.role = "ROLE_REGISTIRAN_PARKIRAC";
    7163    }
    7264
    … …  
    7870        this.email = email;
    7971        this.mobile = mobile;
    80         this.role = "ROLE_REGISTRIRAN_PARKIRAC";
    81     }
    82 
    83     public RegistriranParkirac(String name, String surname, String email, String password, String mobile) {
    84         this.name = name;
    85         this.surname = surname;
    86         this.password = password;
    87         this.email = email;
    88         this.mobile = mobile;
    89         this.role = "ROLE_REGISTRIRAN_PARKIRAC";
     72        this.role = "ROLE_REGISTIRAN_PARKIRAC";
    9073    }
    9174
    … …  
    11295    public void setSurname(String surname) {
    11396        this.surname = surname;
     97    }
     98
     99    public String getPassword() {
     100        return password;
     101    }
     102
     103    public void setPassword(String password) {
     104        this.password = password;
    114105    }
    115106
    … …  
    141132
    142133    public void setRole(String role) {this.role = role;}
    143 
    144     @Override
    145     public Collection<? extends GrantedAuthority> getAuthorities() {
    146         SimpleGrantedAuthority authority = new SimpleGrantedAuthority(role);
    147         return Collections.singleton(authority);
    148     }
    149 
    150     public String getPassword() {
    151         return password;
    152     }
    153 
    154     public void setPassword(String password) {
    155         this.password = password;
    156     }
    157 
    158     @Override
    159     public String getUsername() {
    160         return email;
    161     }
    162 
    163     @Override
    164     public boolean isAccountNonExpired() {
    165         return true;
    166     }
    167 
    168     @Override
    169     public boolean isAccountNonLocked() {
    170         return !locked;
    171     }
    172 
    173     @Override
    174     public boolean isCredentialsNonExpired() {
    175         return true;
    176     }
    177 
    178     @Override
    179     public boolean isEnabled() {
    180         return enabled;
    181     }
    182134}
    183135

  • sources/app/src/main/java/parkup/entities/Vraboten.java

    r9504a09 r3a58bd6  
    11package parkup.entities;
    22
    3 import org.springframework.security.core.GrantedAuthority;
    4 import org.springframework.security.core.userdetails.UserDetails;
    5 import parkup.data.VrabotenDemo;
     3import parkup.data.Tablicka;
    64
    75import javax.persistence.*;
    86import java.util.ArrayList;
    9 import java.util.Collection;
    107import java.util.List;
    118
    129@Entity
    1310@Table(name = "vraboten")
    14 public class Vraboten implements UserDetails {
     11public class Vraboten {
    1512    @Id
    1613    @SequenceGenerator(
    … …  
    5249    private String status;
    5350
    54     @Column(name="locked")
    55     private boolean locked;
    56 
    57     @Column(name = "enabled")
    58     private boolean enabled;
    59 
     51    @Column(name = "account")
     52    private boolean account;
    6053
    6154    public Vraboten() {
    6255        this.role = "ROLE_VRABOTEN";
    6356        this.parkingZones = new ArrayList<ParkingZone>();
    64         this.enabled = false;
     57        this.account = true;
    6558        this.status = "neRaboti";
    6659    }
    … …  
    7568        this.parkingZones = parkingZones;
    7669        this.role = "ROLE_VRABOTEN";
    77         this.enabled = false;
     70        this.account = true;
    7871        this.status = "neRaboti";
    7972    }
    … …  
    8780        this.parkingZones = parkingZones;
    8881        this.role = "ROLE_VRABOTEN";
    89         this.enabled = false;
     82        this.account = true;
    9083        this.status = "neRaboti";
    91     }
    92 
    93     public Vraboten(String firstName, String lastName, String email, String password, String mobile) {
    94         this.firstName=firstName;
    95         this.lastName=lastName;
    96         this.email=email;
    97         this.password=password;
    98         this.mobile=mobile;
    99         this.parkingZones=new ArrayList<>();
    100         this.enabled=false;
    101         this.status="neRaboti";
    102         this.role="ROLE_VRABOTEN";
    10384    }
    10485
    … …  
    135116    }
    136117
    137     @Override
    138     public Collection<? extends GrantedAuthority> getAuthorities() {
    139         return null;
    140     }
    141 
    142118    public String getPassword() {
    143119        return password;
    144     }
    145 
    146     @Override
    147     public String getUsername() {
    148         return email;
    149     }
    150 
    151     @Override
    152     public boolean isAccountNonExpired() {
    153         return true;
    154     }
    155 
    156     @Override
    157     public boolean isAccountNonLocked() {
    158         return !locked;
    159     }
    160 
    161     public void lockVraboten(){
    162         this.locked = !locked;
    163     }
    164 
    165     @Override
    166     public boolean isCredentialsNonExpired() {
    167         return true;
    168     }
    169 
    170     @Override
    171     public boolean isEnabled() {
    172         return enabled;
    173120    }
    174121
    … …  
    197144    public void setStatus(String status) {this.status = status;}
    198145
    199     public boolean isAccount() {return enabled;}
     146    public boolean isAccount() {return account;}
    200147
    201     public void setAccount(boolean account) {this.enabled = account;}
     148    public void setAccount(boolean account) {this.account = account;}
    202149}

  • sources/app/src/main/java/parkup/repositories/GuestRepository.java

    r9504a09 r3a58bd6  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
    5 import org.springframework.stereotype.Repository;
    65import parkup.entities.Guest;
    76
    8 @Repository
    97public interface GuestRepository extends JpaRepository<Guest, Integer> {
    108    Guest findByGuestId(int id);

  • sources/app/src/main/java/parkup/repositories/ParkingZoneRepository.java

    r9504a09 r3a58bd6  
    22
    33import org.springframework.data.jpa.repository.JpaRepository;
    4 import org.springframework.stereotype.Repository;
    54import parkup.entities.ParkingZone;
    65
    7 @Repository
    86public interface ParkingZoneRepository extends JpaRepository<ParkingZone, Integer> {
    97    ParkingZone findByPzId(int id);

  • sources/app/src/main/java/parkup/repositories/RegistriranParkiracRepository.java

    r9504a09 r3a58bd6  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
    5 import org.springframework.data.jpa.repository.Modifying;
    6 import org.springframework.data.jpa.repository.Query;
    7 import org.springframework.stereotype.Repository;
    85import parkup.entities.RegistriranParkirac;
    96
    10 import javax.transaction.Transactional;
    11 
    12 @Repository
    137public interface RegistriranParkiracRepository extends JpaRepository<RegistriranParkirac, Integer> {
    148    RegistriranParkirac findByRegParkId(int regParkId);
    … …  
    1711
    1812    Optional<RegistriranParkirac> findRegistriranParkiracByEmail(String email);
    19 
    20     @Transactional
    21     @Modifying
    22     @Query("UPDATE RegistriranParkirac rp " +
    23             "SET rp.enabled = TRUE WHERE rp.email = ?1")
    24     int enableRegistriranParkirac(String email);
    2513}

  • sources/app/src/main/java/parkup/repositories/VrabotenRepository.java

    r9504a09 r3a58bd6  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
    5 import org.springframework.data.jpa.repository.Modifying;
    6 import org.springframework.data.jpa.repository.Query;
    7 import org.springframework.stereotype.Repository;
    85import parkup.entities.Vraboten;
    96
    10 import javax.transaction.Transactional;
    11 
    12 @Repository
    137public interface VrabotenRepository extends JpaRepository<Vraboten, Integer> {
    148    Vraboten findByVrabotenId(int id);
    … …  
    1711
    1812    Optional<Vraboten> findVrabotenByEmail(String email);
    19 
    20     @Transactional
    21     @Modifying
    22     @Query("UPDATE Vraboten v " +
    23             "SET v.enabled = TRUE WHERE v.email = ?1")
    24     int enableVraboten(String email);
    2513}

  • sources/app/src/main/java/parkup/services/AdministratorService.java

    r9504a09 r3a58bd6  
    11package parkup.services;
    22
     3import java.time.LocalDateTime;
    34import java.util.List;
    45import java.util.Objects;
    … …  
    1314import org.springframework.stereotype.Service;
    1415import parkup.configs.email.EmailValidator;
     16import parkup.configs.token.ConfirmationToken;
    1517import parkup.configs.token.ConfirmationTokenService;
    1618import parkup.entities.Administrator;
    … …  
    4042    }
    4143
    42     public Optional<Administrator> addAdministrator(Administrator administrator) {
     44    public void addAdministrator(Administrator administrator) {
    4345        Optional<Administrator> administratorOpt = this.administratorRepository.findAdministratorByEmail(administrator.getEmail());
    4446        if (administratorOpt.isPresent()) {
    4547            throw new IllegalStateException("Email already taken, try adding an administrator with a different valid email address");
    4648        } else {
    47             if (administrator.getEmail() != null && administrator.getEmail().length() > 1 && administrator.getEmail().contains("@")) {
    48                 //System.out.println(regPark);
    49                 this.administratorRepository.save(administrator);
    50             }
    51             else {
    52                 throw new IllegalStateException("email not valid");
    53             }
     49            System.out.println(administrator);
     50            this.administratorRepository.save(administrator);
    5451        }
    55         return administratorOpt;
    5652    }
    5753
    5854    @Transactional
    59     public Administrator updateAdministrator(int administratorId, String firstName, String lastName, String mobile, String email) {
     55    public void updateAdministrator(int administratorId, String firstName, String lastName, String mobile, String email) {
    6056        Optional<Administrator> administratorOpt = Optional.ofNullable(this.administratorRepository.findByAdministratorId(administratorId));
    6157        if (administratorOpt.isPresent()) {
    … …  
    6662                    throw new IllegalStateException("email taken");
    6763                }
     64
    6865                administratorNov.setEmail(email);
    69             }else{
    70                 throw new IllegalStateException("email not valid");
    7166            }
    7267
    … …  
    8277                administratorNov.setMobile(mobile);
    8378            }
    84             return administratorNov;
    8579        }
    86         else {
    87             throw new IllegalStateException("Administrator doesn't exist, therefore can't be updated");
    88         }
    89 
    9080    }
    9181
    92     public Optional<Administrator> deleteAdministrator(int administratorId) {
     82    public void deleteAdministrator(int administratorId) {
    9383        Optional<Administrator> administratorOpt = Optional.ofNullable(this.administratorRepository.findByAdministratorId(administratorId));
    9484        if (administratorOpt.isPresent()) {
    … …  
    9787            throw new IllegalStateException("Administrator doesn't exist, therefore can't be deleted");
    9888        }
    99         return administratorOpt;
    10089    }
    10190
    … …  
    137126
    138127        String token = UUID.randomUUID().toString();
    139         //ConfirmationTokenRP confirmationToken = new ConfirmationTokenRP(
    140         //        token,
    141         //        LocalDateTime.now(),
    142         //        LocalDateTime.now().plusMinutes(15),
    143         //        administrator
    144         //);
     128        ConfirmationToken confirmationToken = new ConfirmationToken(
     129                token,
     130                LocalDateTime.now(),
     131                LocalDateTime.now().plusMinutes(15),
     132                administrator
     133        );
    145134
    146         //confirmationTokenService.saveConfirmationToken(confirmationToken);
     135        confirmationTokenService.saveConfirmationToken(confirmationToken);
    147136
    148137        // TODO: SEND EMAIL

  • sources/app/src/main/java/parkup/services/ParkingSessionService.java

    r9504a09 r3a58bd6  
    33import org.springframework.beans.factory.annotation.Autowired;
    44import org.springframework.stereotype.Service;
    5 import parkup.data.Tablicka;
    65import parkup.entities.ParkingSession;
    76import parkup.repositories.ParkingSessionRepository;
    87
    9 import javax.transaction.Transactional;
    108import java.util.List;
    119import java.util.Objects;
    … …  
    3028    }
    3129
    32     @Transactional
    33     public void updateParkingSession(int parkingSessionId, String timeStart, String timeEnd, Tablicka tablicka) {
     30    public void updateParkingSession(int parkingSessionId, String timeStart, String timeEnd) {
    3431        Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSessionId));
    3532        if (parkingSessionOpt.isPresent()) {
    3633            ParkingSession parkingSessionNov = parkingSessionRepository.findByPssId(parkingSessionId);
    37 
    3834            if(!parkingSessionNov.getTimeStart().equals(timeStart) && !parkingSessionNov.getTimeStart().equals(timeEnd))
    3935                parkingSessionNov.setTimeStart(timeStart);
    … …  
    4137            if(!parkingSessionNov.getTimeEnd().equals(timeEnd) && !parkingSessionNov.getTimeEnd().equals(timeStart))
    4238                parkingSessionNov.setTimeEnd(timeEnd);
    43 
    44             if(tablicka!=null && !Objects.equals(parkingSessionNov.getTablica(),tablicka)){
    45                 parkingSessionNov.setTablica(tablicka);
    46             }
    47         }else{
    48             throw new IllegalStateException("The ParkingSession does not exist");
    4939        }
    5040    }
    5141
    52     public Optional<ParkingSession> deleteParkingSession(int parkingSessionId) {
     42    public void deleteParkingSession(int parkingSessionId) {
    5343        Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSessionId));
    5444        if (parkingSessionOpt.isPresent()) {
    5545            parkingSessionRepository.deleteByPssId(parkingSessionId);
    56             return parkingSessionOpt;
    5746        } else {
    5847            throw new IllegalStateException("ParkingSpace doesn't exist, therefore can't be deleted");
    … …  
    6049    }
    6150
    62     public Optional<ParkingSession> addParkingSession(ParkingSession parkingSession) {
    63         Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSession.getPssId()));
     51    public void addParkingSession(ParkingSession parkingSession) {
     52        Optional <ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSession.getPssId()));
    6453        if (parkingSessionOpt.isPresent()) {
    6554            throw new IllegalStateException("ID already taken, ParkingSession cannot be added");
    … …  
    6756            System.out.println(parkingSession);
    6857            parkingSessionRepository.save(parkingSession);
    69             return parkingSessionOpt;
    7058        }
    7159    }

  • sources/app/src/main/java/parkup/services/ParkingSpaceService.java

    r9504a09 r3a58bd6  
    66import parkup.repositories.ParkingSpaceRepository;
    77
    8 import javax.transaction.Transactional;
    98import java.util.List;
    109import java.util.Objects;
    … …  
    2928    }
    3029
    31     public Optional<ParkingSpace> addParkingSpace(ParkingSpace parkingSpace) {
    32         Optional<ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsName(parkingSpace.getPsName()));
     30    public void addParkingSpace(ParkingSpace parkingSpace) {
     31        Optional <ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsName(parkingSpace.getPsName()));
    3332        if (parkingSpaceOpt.isPresent()) {
    3433            throw new IllegalStateException("Name already taken, try adding a ParkingZone with a different name");
    … …  
    3736            parkingSpaceRepository.save(parkingSpace);
    3837        }
    39         return parkingSpaceOpt;
    4038    }
    4139
    42     @Transactional
    43     public ParkingSpace updateParkingSpace(int parkingSpaceId, String psName, boolean taken, boolean handicaped, float lat, float lng) {
     40    public void updateParkingSpace(int parkingSpaceId, String psName, boolean taken, boolean handicaped) {
    4441        Optional<ParkingSpace> ParkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsId(parkingSpaceId));
    4542        if (ParkingSpaceOpt.isPresent()) {
    … …  
    6158                ParkingSpaceNov.setHandicaped(handicaped);
    6259            }
    63 
    64             if(lat!=0 && !Objects.equals(ParkingSpaceNov.getLat(), lat)){
    65                 ParkingSpaceNov.setLat(lat);
    66             }
    67 
    68             if(lng!=0 && !Objects.equals(ParkingSpaceNov.getLng(), lng)){
    69                 ParkingSpaceNov.setLng(lng);
    70             }
    71             return ParkingSpaceNov;
    72         }else{
    73             throw new IllegalStateException("ParkingSpace does not exist");
    7460        }
    7561    }
    7662
    77     @Transactional
    78     public Optional<ParkingSpace> deleteParkingSpace(int parkingSpaceId) {
     63    public void deleteParkingSpace(int parkingSpaceId) {
    7964        Optional<ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsId(parkingSpaceId));
    8065        if (parkingSpaceOpt.isPresent()) {
    … …  
    8368            throw new IllegalStateException("ParkingSpace doesn't exist, therefore can't be deleted");
    8469        }
    85         return parkingSpaceOpt;
    8670    }
    8771}

  • sources/app/src/main/java/parkup/services/ParkingZoneService.java

    r9504a09 r3a58bd6  
    22
    33import org.springframework.beans.factory.annotation.Autowired;
    4 import org.springframework.data.jpa.repository.Modifying;
    54import org.springframework.stereotype.Service;
    6 import parkup.data.ParkingZoneLocation;
    7 import parkup.entities.ParkingSpace;
     5import parkup.entities.Administrator;
    86import parkup.entities.ParkingZone;
    97import parkup.repositories.ParkingZoneRepository;
    108
    119import javax.transaction.Transactional;
    12 import java.util.ArrayList;
    1310import java.util.List;
    1411import java.util.Objects;
    … …  
    3330    }
    3431
    35     public List<String> getAllParkingZoneNames() {
    36         List<ParkingZone> parkingZones = this.parkingZoneRepository.findAll();
    37         List<String> parkingZonesNames = new ArrayList<>();
    38         for (ParkingZone pz : parkingZones){
    39             parkingZonesNames.add(pz.getPzName());
    40         }
    41         return parkingZonesNames;
    42     }
    43 
    44     public Optional<ParkingZone> addParkingZone(ParkingZone parkingZone) {   //zavisno vo koj grad ili opstina i napravi proverki pred dodavanje, implementiraj u naredna faza
     32    public void addParkingZone(ParkingZone parkingZone) {   //zavisno vo koj grad ili opstina i napravi proverki pred dodavanje, implementiraj u naredna faza
    4533        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzName(parkingZone.getPzName()));
    4634        if (parkingZoneOpt.isPresent()) {
    … …  
    5038            parkingZoneRepository.save(parkingZone);
    5139        }
    52         return parkingZoneOpt;
    5340    }
    5441
    55     public ParkingZone addParkingZoneNameOnly(String name) {
    56         Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzName(name));
    57         if (parkingZoneOpt.isPresent()) {
    58             throw new IllegalStateException("Name already taken, try adding a ParkingZone with a different name");
    59         } else {
    60             ParkingZone parkingZone = new ParkingZone(name.trim());
    61             parkingZoneRepository.save(parkingZone);
    62             return parkingZone;
    63         }
    64     }
    65 
    66     //TODO prati niza od objekti ParkingSpaces i prati objekt ParkingZoneLocation
    6742    @Transactional
    68     public ParkingZone updateParkingZone(int parkingZoneId, String pzName, int price, int capacity,
    69                                          String location, int from, int to, String color,
    70                                          List<ParkingSpace> parkingSpaces, ParkingZoneLocation parkingZoneLocation) {
     43    public void updateParkingZone(int parkingZoneId, String pzName, int price, int capacity, String workHours, String location) {
    7144        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzId(parkingZoneId));
    7245        if (parkingZoneOpt.isPresent()) {
    … …  
    8962            }
    9063
     64            if (workHours != null && workHours.length() > 0 && !Objects.equals(parkingZoneNov.getWorkHours(), workHours)) {
     65                parkingZoneNov.setWorkHours(workHours);
     66            }
     67
    9168            if (location != null && location.length() > 0 && !Objects.equals(parkingZoneNov.getLocation(), location)) {
    9269                parkingZoneNov.setLocation(location);
    9370            }
    94 
    95             if (from != 0 && !Objects.equals(parkingZoneNov.getFrom(), from)) {
    96                 parkingZoneNov.setFrom(from);
    97             }
    98 
    99             if (to != 0 && !Objects.equals(parkingZoneNov.getTo(), to)) {
    100                 parkingZoneNov.setTo(to);
    101             }
    102 
    103             if (color != null && color.length() > 0 && !Objects.equals(parkingZoneNov.getColor(), color)) {
    104                 parkingZoneNov.setColor(color);
    105             }
    106 
    107             if(parkingZoneLocation!=null){
    108                 parkingZoneNov.setParkingZoneLocation(parkingZoneLocation);
    109             }
    110 
    111             if(!parkingSpaces.isEmpty()){
    112                 //TODO kreiraj lista od parkingSpaces, ni gi prakja false isHandicaped i isTaken
    113                 parkingZoneNov.setParkingSpaces(parkingSpaces);
    114             }
    115 
    116             return parkingZoneNov;
    117         } else {
    118             throw new IllegalStateException("There ParkingZone does not exist");
    11971        }
    12072    }
    12173
    122     @Transactional
    123     public Optional<ParkingZone> deleteParkingZone(int parkingZoneId) {
     74    public void deleteParkingZone(int parkingZoneId) {
    12475        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzId(parkingZoneId));
    12576        if (parkingZoneOpt.isPresent()) {
    … …  
    12879            throw new IllegalStateException("ParkingZone doesn't exist, therefore can't be deleted");
    12980        }
    130         return parkingZoneOpt;
    13181    }
    13282}

  • sources/app/src/main/java/parkup/services/RegistriranParkiracService.java

    r9504a09 r3a58bd6  
    11package parkup.services;
    22
    3 import java.time.LocalDateTime;
    43import java.util.List;
    54import java.util.Objects;
    65import java.util.Optional;
    7 import java.util.UUID;
    86import javax.transaction.Transactional;
    97import org.springframework.beans.factory.annotation.Autowired;
    10 import org.springframework.data.jpa.repository.Modifying;
    11 import org.springframework.security.core.userdetails.UserDetails;
    12 import org.springframework.security.core.userdetails.UserDetailsService;
    13 import org.springframework.security.core.userdetails.UsernameNotFoundException;
    14 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    158import org.springframework.stereotype.Service;
    16 import parkup.configs.email.EmailValidator;
    17 import parkup.configs.token.ConfirmationTokenRP;
    18 import parkup.configs.token.ConfirmationTokenService;
    19 import parkup.data.Tablicka;
    209import parkup.entities.RegistriranParkirac;
    2110import parkup.repositories.RegistriranParkiracRepository;
    2211
    2312@Service
    24 public class RegistriranParkiracService implements UserDetailsService {
     13public class RegistriranParkiracService {
    2514    private final RegistriranParkiracRepository registriranParkiracRepository;
    26     private final BCryptPasswordEncoder bCryptPasswordEncoder;
    27     private final ConfirmationTokenService confirmationTokenService;
    28     private EmailValidator emailValidator;
    2915
    3016    @Autowired
    31     public RegistriranParkiracService(RegistriranParkiracRepository registriranParkiracRepository, BCryptPasswordEncoder bCryptPasswordEncoder, ConfirmationTokenService confirmationTokenService) {
     17    public RegistriranParkiracService(RegistriranParkiracRepository registriranParkiracRepository) {
    3218        this.registriranParkiracRepository = registriranParkiracRepository;
    33         this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    34         this.confirmationTokenService = confirmationTokenService;
    3519    }
    3620
    … …  
    3923    }
    4024
    41     public Optional<RegistriranParkirac> addRegPark(RegistriranParkirac regPark) {
     25    public void addRegPark(RegistriranParkirac regPark) {
    4226        Optional<RegistriranParkirac> regParkOpt = this.registriranParkiracRepository.findRegistriranParkiracByEmail(regPark.getEmail());
    4327        if (regParkOpt.isPresent()) {
    4428            throw new IllegalStateException("Email already taken, try adding a registriranParkirac with a different valid email address");
    4529        } else {
    46             if (regPark.getEmail() != null && regPark.getEmail().length() > 1 && regPark.getEmail().contains("@")) {
    47                 //System.out.println(regPark);
    48                 this.registriranParkiracRepository.save(regPark);
    49             }
    50             else {
    51                 throw new IllegalStateException("email not valid");
    52             }
     30            System.out.println(regPark);
     31            this.registriranParkiracRepository.save(regPark);
    5332        }
    54         return regParkOpt;
    5533    }
    5634
    5735    @Transactional
    58     public RegistriranParkirac updateRegPark(int regParkId, String name, String surname, String mobile, String email,List<Tablicka> regTablicki) {
     36    public void updateRegPark(int regParkId, String name, String surname, String mobile, String email) {
    5937        Optional<RegistriranParkirac> regParkOpt = Optional.ofNullable(this.registriranParkiracRepository.findByRegParkId(regParkId));
    6038        if (regParkOpt.isPresent()) {
    … …  
    8058                regParkNov.setMobile(mobile);
    8159            }
    82             regParkNov.setRegTablicki(regTablicki);
    83             return regParkNov;
    84         }else{
    85             throw new IllegalStateException("RegistriranParkirac doesn't exist, therefore can't be updated");
    8660        }
    8761    }
    8862
    89     @Transactional
    90     @Modifying
    91     public Optional<RegistriranParkirac> deleteRegPark(int regParkId) {
     63    public void deleteRegPark(int regParkId) {
    9264        Optional<RegistriranParkirac> regPark = Optional.ofNullable(this.registriranParkiracRepository.findByRegParkId(regParkId));
    9365        if (regPark.isPresent()) {
    94             //TODO da povikamo metod od ConfirmationTokenService za brisenje na ConfirmationTokenRP *DONE
    95             //TODO da se izbrisat tablicki i da ne se dupliraat istite tablicki pri update ili add na nov registriranParkirac
    96             this.confirmationTokenService.deleteByRegistriranParkirac_RegParkId(regParkId);
    9766            this.registriranParkiracRepository.deleteByRegParkId(regParkId);
    9867        } else {
    9968            throw new IllegalStateException("RegistriranParkirac doesn't exist, therefore can't be deleted");
    10069        }
    101         return regPark;
    10270    }
    10371
    … …  
    10674        return regPark.orElse(null);
    10775    }
    108 
    109     @Override
    110     public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
    111         return registriranParkiracRepository.findRegistriranParkiracByEmail(email)
    112                 .orElseThrow(() ->
    113                         new UsernameNotFoundException("Email not found"));
    114 
    115     }
    116 
    117     public String signUpRegistriranParkirac(RegistriranParkirac registriranParkirac){
    118         boolean registriranParkiracExists = registriranParkiracRepository
    119                 .findRegistriranParkiracByEmail(registriranParkirac.getEmail())
    120                 .isPresent();
    121         if(registriranParkiracExists){
    122             // TODO check if attributes are the same and
    123             // TODO if email not confirmed send confirmation email
    124 
    125             throw new IllegalStateException("Email already taken");
    126         }
    127 
    128         String encodedPassword = bCryptPasswordEncoder
    129                 .encode(registriranParkirac.getPassword());
    130 
    131         registriranParkirac.setPassword(encodedPassword);
    132 
    133         registriranParkiracRepository.save(registriranParkirac);
    134 
    135         // TODO: Send confirmation token
    136 
    137         String token = UUID.randomUUID().toString();
    138         ConfirmationTokenRP confirmationTokenRP = new ConfirmationTokenRP(
    139                 token,
    140                 LocalDateTime.now(),
    141                 LocalDateTime.now().plusMinutes(15),
    142                 registriranParkirac
    143         );
    144 
    145         confirmationTokenService.saveConfirmationTokenRP(confirmationTokenRP);
    146 
    147         // TODO: SEND EMAIL
    148 
    149         return token;
    150     }
    151 
    152     public int enableRegistriranParkirac(String email) {
    153         return registriranParkiracRepository.enableRegistriranParkirac(email);
    154     }
    15576}

  • sources/app/src/main/java/parkup/services/VrabotenService.java

    r9504a09 r3a58bd6  
    11package parkup.services;
    22
    3 import java.time.LocalDateTime;
    4 import java.util.*;
     3import java.util.List;
     4import java.util.Objects;
     5import java.util.Optional;
     6import java.util.UUID;
    57import javax.transaction.Transactional;
    68import org.springframework.beans.factory.annotation.Autowired;
    7 import org.springframework.data.jpa.repository.Modifying;
    8 import org.springframework.security.core.userdetails.UserDetails;
    9 import org.springframework.security.core.userdetails.UserDetailsService;
    10 import org.springframework.security.core.userdetails.UsernameNotFoundException;
    11 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    129import org.springframework.stereotype.Service;
    13 import parkup.configs.token.ConfirmationTokenW;
    14 import parkup.configs.token.ConfirmationTokenService;
    1510import parkup.entities.Vraboten;
    1611import parkup.repositories.VrabotenRepository;
    17 import parkup.data.VrabotenDemo;
    1812
    1913@Service
    20 public class VrabotenService implements UserDetailsService {
     14public class VrabotenService {
    2115    private final VrabotenRepository vrabotenRepository;
    22     private final BCryptPasswordEncoder bCryptPasswordEncoder;
    23     private final ConfirmationTokenService confirmationTokenService;
    2416
    2517    @Autowired
    26     public VrabotenService(VrabotenRepository vrabotenRepository, BCryptPasswordEncoder bCryptPasswordEncoder, ConfirmationTokenService confirmationTokenService) {
     18    public VrabotenService(VrabotenRepository vrabotenRepository) {
    2719        this.vrabotenRepository = vrabotenRepository;
    28         this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    29         this.confirmationTokenService = confirmationTokenService;
    3020    }
    3121
    … …  
    3929    }
    4030
    41     public List<VrabotenDemo> getAllVraboteniDemos() {
    42         List<Vraboten> vraboteni = this.vrabotenRepository.findAll();
    43         List<VrabotenDemo> vrabotenDemos = new ArrayList<>();
    44         for (Vraboten v : vraboteni){
    45             VrabotenDemo vd = new VrabotenDemo(v.getFirstName(), v.getLastName(), v.getEmail());
    46             vrabotenDemos.add(vd);
    47         }
    48         return vrabotenDemos;
    49     }
    50 
    51     public Optional<Vraboten> addVraboten(Vraboten vraboten) {
     31    public void addVraboten(Vraboten vraboten) {
    5232        Optional<Vraboten> vrabotenOpt = this.vrabotenRepository.findVrabotenByEmail(vraboten.getEmail());
    5333        if (vrabotenOpt.isPresent()) {
    5434            throw new IllegalStateException("Email already taken, try adding a vraboten with a different valid email address");
    5535        } else {
    56             if (vraboten.getEmail() != null && vraboten.getEmail().length() > 1 && vraboten.getEmail().contains("@")) {
    57                 //System.out.println(vraboten);
    58                 this.vrabotenRepository.save(vraboten);
    59             }
    60             else{
    61                 throw new IllegalStateException("email not valid");
    62             }
     36            System.out.println(vraboten);
     37            this.vrabotenRepository.save(vraboten);
    6338        }
    64         return vrabotenOpt;
    6539    }
    6640
    6741    @Transactional
    68     public Vraboten updateVraboten(int vrabotenId, String firstName, String lastName, String mobile, String email, String status) {
     42    public void updateVraboten(int vrabotenId, String firstName, String lastName, String mobile, String email) {
    6943        Optional<Vraboten> vrabotenOpt = Optional.ofNullable(this.vrabotenRepository.findByVrabotenId(vrabotenId));
    7044        if (vrabotenOpt.isPresent()) {
    … …  
    7549                    throw new IllegalStateException("email taken");
    7650                }
     51
    7752                vrabotenNov.setEmail(email);
    78             } else {
    79                 throw new IllegalStateException("email not valid");
    8053            }
    8154
    … …  
    9164                vrabotenNov.setMobile(mobile);
    9265            }
     66        }
     67    }
    9368
    94             if (mobile != null && status.length() > 0 && !Objects.equals(vrabotenNov.getStatus(), status)) {
    95                 if(status.equals("raboti") || status.equals("ne raboti") || status.equals("na odmor") || status.equals("na boleduvanje")){
    96                     vrabotenNov.setStatus(status);
    97                 }else{
    98                     throw new IllegalStateException("Please enter one of the following statuses: 'raboti', 'ne raboti', 'na odmor', 'na boleduvanje'");
    99                 }
    100             }
    101 
    102             return vrabotenNov;
    103         }
    104         else{
    105             throw new IllegalStateException("Vraboten doesn't exist, therefore can't be updated");
    106         }
    107     }//za menjanje password da se implementira
    108 
    109     @Modifying
    110     @Transactional
    111     public Optional<Vraboten> deleteVraboten(int vrabotenId) {
     69    public void deleteVraboten(int vrabotenId) {
    11270        Optional<Vraboten> vrabotenOpt = Optional.ofNullable(this.vrabotenRepository.findByVrabotenId(vrabotenId));
    11371        if (vrabotenOpt.isPresent()) {
    114             //TODO da povikamo metod od ConfirmationTokenService za brisenje na ConfirmationTokenW
    115             this.confirmationTokenService.deleteByVraboten_VrabotenId(vrabotenId);
    11672            this.vrabotenRepository.deleteByVrabotenId(vrabotenId);
    11773        } else {
    11874            throw new IllegalStateException("Vraboten doesn't exist, therefore can't be deleted");
    11975        }
    120         return vrabotenOpt;
    12176    }
    122 
    123     @Transactional
    124     public void lockVrabotenAcc(int vrabotenId) {
    125         Vraboten vrabotenOpt = this.vrabotenRepository.findByVrabotenId(vrabotenId);
    126         if (vrabotenOpt!=null) {
    127             vrabotenOpt.lockVraboten();
    128         } else {
    129             throw new IllegalStateException("Vraboten doesn't exist, therefore his account can't be locked/unlocked");
    130         }
    131     }//dali treba da stoi @Transactional gore nad funkcijata?
    132 
    133     @Override
    134     public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
    135         return vrabotenRepository.findVrabotenByEmail(email)
    136                 .orElseThrow(() ->
    137                         new UsernameNotFoundException("Email not found"));
    138     }
    139     public String signUpVraboten(Vraboten vraboten){
    140         boolean vrabotenExists = vrabotenRepository
    141                 .findVrabotenByEmail(vraboten.getEmail())
    142                 .isPresent();
    143         if(vrabotenExists){
    144             // TODO check if attributes are the same and
    145             // TODO if email not confirmed send confirmation email
    146 
    147             throw new IllegalStateException("Email already taken");
    148         }
    149 
    150         String encodedPassword = bCryptPasswordEncoder
    151                 .encode(vraboten.getPassword());
    152 
    153         vraboten.setPassword(encodedPassword);
    154 
    155         vrabotenRepository.save(vraboten);
    156 
    157         // TODO: Send confirmation token
    158 
    159         String token = UUID.randomUUID().toString();
    160         ConfirmationTokenW confirmationTokenW = new ConfirmationTokenW(
    161                 token,
    162                 LocalDateTime.now(),
    163                 LocalDateTime.now().plusMinutes(15),
    164                 vraboten
    165         );
    166 
    167         confirmationTokenService.saveConfirmationTokenW(confirmationTokenW);
    168 
    169         // TODO: SEND EMAIL
    170 
    171         return token;
    172     }
    173 
    174     public int enableVraboten(String email) {
    175         return vrabotenRepository.enableVraboten(email);
    176     }
    177 
    17877}
Note: See TracChangeset for help on using the changeset viewer.