Changeset f6bc52d


Ignore:
Timestamp:
11/04/21 16:59:49 (3 years ago)
Author:
DavidTrajkovski <davidtrajkovski11@…>
Branches:
master
Children:
9504a09
Parents:
ce6ad22
Message:

fixed delete methods

Location:
sources/app
Files:
6 added
42 deleted
26 edited
3 moved

Legend:

Unmodified
Added
Removed

  • sources/app/ParkUp.iml

    rce6ad22 rf6bc52d  
    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>
    133  <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>
    254    <facet type="jpa" name="JPA">
    265      <configuration>
    … …  
    3716      <configuration />
    3817    </facet>
     18    <facet type="web" name="Web">
     19      <configuration>
     20        <webroots />
     21      </configuration>
     22    </facet>
    3923  </component>
    4024  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_11">
    … …  
    4428      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
    4529      <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" />
    4930      <excludeFolder url="file://$MODULE_DIR$/target" />
    5031    </content>
    5132    <orderEntry type="inheritedJdk" />
    52     <orderEntry type="library" name="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER" level="application" />
    5333    <orderEntry type="sourceFolder" forTests="false" />
    5434    <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

    rce6ad22 rf6bc52d  
    66    private final String email;
    77    private final String password;
     8    private final String mobile;
    89
    9     public RegistrationRequest(String firstName, String lastName, String email, String password) {
     10    public RegistrationRequest(String firstName, String lastName, String email, String password, String mobile) {
    1011        this.firstName = firstName;
    1112        this.lastName = lastName;
    1213        this.email = email;
    1314        this.password = password;
     15        this.mobile = mobile;
    1416    }
    1517
    … …  
    3032    }
    3133
     34    public String getMobile(){
     35        return mobile;
     36    }
     37
    3238}

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

    rce6ad22 rf6bc52d  
    55import parkup.configs.email.EmailSender;
    66import parkup.configs.email.EmailValidator;
    7 import parkup.configs.token.ConfirmationToken;
     7import parkup.configs.token.ConfirmationTokenW;
    88import parkup.configs.token.ConfirmationTokenService;
    9 import parkup.entities.Administrator;
    10 import parkup.services.AdministratorService;
     9import parkup.entities.Vraboten;
     10import parkup.services.VrabotenService;
    1111
    1212import javax.transaction.Transactional;
    … …  
    1414
    1515@Service
    16 public class RegistrationService {
    17     private final AdministratorService administratorService;
     16public class RegistrationServiceW {
     17    private final VrabotenService vrabotenService;
    1818    private final EmailValidator emailValidator;
    1919    private final ConfirmationTokenService confirmationTokenService;
    … …  
    2121
    2222    @Autowired
    23     public RegistrationService(AdministratorService administratorService, EmailValidator emailValidator,
    24                                ConfirmationTokenService confirmationTokenService, EmailSender emailSender) {
    25         this.administratorService = administratorService;
     23    public RegistrationServiceW(VrabotenService vrabotenService, EmailValidator emailValidator,
     24                                 ConfirmationTokenService confirmationTokenService, EmailSender emailSender) {
     25        this.vrabotenService = vrabotenService;
    2626        this.emailValidator = emailValidator;
    2727        this.confirmationTokenService = confirmationTokenService;
    … …  
    3737        }
    3838
    39         String token = administratorService.signUpAdministrator(
    40                 new Administrator(
     39        String token = vrabotenService.signUpVraboten(
     40                new Vraboten(
    4141                        request.getFirstName(),
    4242                        request.getLastName(),
    4343                        request.getEmail(),
    44                         request.getPassword()
     44                        request.getPassword(),
     45                        request.getMobile()
    4546                )
    4647        );
    4748
    48         String link = "http://localhost:8080/administrator/registration/confirm?token=" + token;
     49        String link = "http://localhost:8080/vraboten/registration/confirm?token=" + token;
    4950        emailSender.send(
    5051                request.getEmail(),
    … …  
    5657    @Transactional
    5758    public String confirmToken(String token) {
    58         ConfirmationToken confirmationToken = confirmationTokenService
    59                 .getToken(token)
     59        ConfirmationTokenW confirmationTokenW = confirmationTokenService
     60                .getTokenW(token)
    6061                .orElseThrow(() ->
    6162                        new IllegalStateException("token not found"));
    6263
    63         if (confirmationToken.getConfirmedAt() != null) {
     64        if (confirmationTokenW.getConfirmedAt() != null) {
    6465            throw new IllegalStateException("email already confirmed");
    6566        }
    6667
    67         LocalDateTime expiredAt = confirmationToken.getExpiresAt();
     68        LocalDateTime expiredAt = confirmationTokenW.getExpiresAt();
    6869
    6970        if (expiredAt.isBefore(LocalDateTime.now())) {
    … …  
    7172        }
    7273
    73         confirmationTokenService.setConfirmedAt(token);
     74        confirmationTokenService.setConfirmedAtW(token);
    7475
    75         administratorService.enableAdministrator(confirmationToken.getAdministrator().getEmail());
     76        vrabotenService.enableVraboten(confirmationTokenW.getRegistriranParkirac().getEmail());
    7677        return "confirmed";
    7778    }

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

    rce6ad22 rf6bc52d  
    99import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    1010import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    11 import parkup.services.AdministratorService;
     11import parkup.services.RegistriranParkiracService;
     12import parkup.services.VrabotenService;
    1213
     14@EnableWebSecurity
    1315@Configuration
    14 @EnableWebSecurity
    1516public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
     17        private final VrabotenService vrabotenService;
     18        private final BCryptPasswordEncoder bCryptPasswordEncoder;
     19        private final RegistriranParkiracService registriranParkiracService;
    1620
    17     private final AdministratorService administratorService;
    18     private final BCryptPasswordEncoder bCryptPasswordEncoder;
     21        public WebSecurityConfig(VrabotenService vrabotenService, BCryptPasswordEncoder bCryptPasswordEncoder, RegistriranParkiracService registriranParkiracService) {
     22            this.vrabotenService = vrabotenService;
     23            this.bCryptPasswordEncoder = bCryptPasswordEncoder;
     24            this.registriranParkiracService = registriranParkiracService;
     25        }
    1926
    20     public WebSecurityConfig(AdministratorService administratorService, BCryptPasswordEncoder bCryptPasswordEncoder) {
    21         this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    22         this.administratorService = administratorService;
     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        }
     39
     40        @Override
     41        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
     42            auth.authenticationProvider(daoAuthenticationProviderW());
     43            auth.authenticationProvider(daoAuthenticationProviderRP());
     44        }
     45
     46        @Bean
     47        public DaoAuthenticationProvider daoAuthenticationProviderW() {
     48            DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
     49            provider.setPasswordEncoder(bCryptPasswordEncoder);
     50            provider.setUserDetailsService(vrabotenService);
     51            return provider;
     52        }
     53
     54        @Bean
     55        public DaoAuthenticationProvider daoAuthenticationProviderRP(){
     56            DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
     57            provider.setPasswordEncoder(bCryptPasswordEncoder);
     58            provider.setUserDetailsService(registriranParkiracService);
     59            return provider;
     60        }
     61
    2362    }
    24 
    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     }
    36 
    37     @Override
    38     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    39         auth.authenticationProvider(daoAuthenticationProvider());
    40     }
    41 
    42     @Bean
    43     public DaoAuthenticationProvider daoAuthenticationProvider(){
    44         DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
    45         provider.setPasswordEncoder(bCryptPasswordEncoder);
    46         provider.setUserDetailsService(administratorService);
    47         return provider;
    48     }
    49 }

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

    rce6ad22 rf6bc52d  
    1111
    1212@Repository
    13 public interface ConfirmationTokenRepository extends JpaRepository<ConfirmationToken,Integer> {
     13public interface ConfirmationTokenRepositoryW extends JpaRepository<ConfirmationTokenW,Integer> {
    1414
    15     Optional<ConfirmationToken> findByToken(String token);
     15    Optional<ConfirmationTokenW> findByToken(String token);
     16
     17    void deleteByVraboten_VrabotenId(int vraboten_id);
    1618
    1719    @Transactional
    1820    @Modifying
    19     @Query("UPDATE ConfirmationToken c " +
     21    @Query("UPDATE ConfirmationTokenW c " +
    2022            "SET c.confirmedAt = ?2 " +
    2123            "WHERE c.token = ?1")

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

    rce6ad22 rf6bc52d  
    99public class ConfirmationTokenService {
    1010
    11     private final ConfirmationTokenRepository confirmationTokenRepository;
     11    private final ConfirmationTokenRepositoryRP confirmationTokenRepositoryRP;
     12    private final ConfirmationTokenRepositoryW confirmationTokenRepositoryW;
    1213
    13     public ConfirmationTokenService(ConfirmationTokenRepository confirmationTokenRepository) {
    14         this.confirmationTokenRepository = confirmationTokenRepository;
     14    public ConfirmationTokenService(ConfirmationTokenRepositoryRP confirmationTokenRepositoryRP, ConfirmationTokenRepositoryW confirmationTokenRepositoryW) {
     15        this.confirmationTokenRepositoryRP = confirmationTokenRepositoryRP;
     16        this.confirmationTokenRepositoryW = confirmationTokenRepositoryW;
    1517    }
    1618
    17     public void saveConfirmationToken(ConfirmationToken token){
    18         confirmationTokenRepository.save(token);
     19    public void saveConfirmationTokenRP(ConfirmationTokenRP token){
     20        confirmationTokenRepositoryRP.save(token);
    1921    }
    2022
    21     public Optional<ConfirmationToken> getToken(String token) {
    22         return confirmationTokenRepository.findByToken(token);
     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);
    2331    }
    2432
    25     public int setConfirmedAt(String token) {
    26         return confirmationTokenRepository.updateConfirmedAt(token, LocalDateTime.now());
     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());
    2746    }
    2847}

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

    rce6ad22 rf6bc52d  
    11package parkup.configs.token;
    22
    3 import parkup.entities.Administrator;
     3import parkup.entities.Vraboten;
    44
    55import javax.persistence.*;
    … …  
    77
    88@Entity
    9 public class ConfirmationToken {
     9public class ConfirmationTokenW {
    1010
    1111    @Id
    1212    @Column(name = "confirmation_token_id")
    1313    @SequenceGenerator(
    14             name="confirmation_token_generator",
    15             sequenceName = "confirmation_token_sequence",
     14            name="confirmation_token_sequence_generator_W",
     15            sequenceName = "confirmation_token_sequence_W",
    1616            allocationSize = 1,
    17             initialValue = 900
     17            initialValue = 1200
    1818    )
    1919    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    2020            strategy = GenerationType.SEQUENCE,
    21             generator = "confirmation_token_sequence_generator"
     21            generator = "confirmation_token_sequence_generator_W"
    2222    )
    2323    private int id;
    … …  
    3434    private LocalDateTime confirmedAt;
    3535
    36     @ManyToOne
    37     @JoinColumn(nullable = false, name = "administrator_id")
    38     //many confirmation tokens to one administrator
    39     private Administrator administrator;
     36    @ManyToOne(cascade = {CascadeType.ALL})
     37    @JoinColumn(nullable = false, name = "vraboten_id")
     38    //many confirmation tokens to one registriranParkirac
     39    private Vraboten vraboten;
    4040
    41     public ConfirmationToken() {}
     41    public ConfirmationTokenW() {}
    4242
    43     public ConfirmationToken(int id, String token, LocalDateTime createdAt, LocalDateTime expiresAt, Administrator administrator) {
     43    public ConfirmationTokenW(int id, String token, LocalDateTime createdAt, LocalDateTime expiresAt, Vraboten vraboten) {
    4444        this.id = id;
    4545        this.token = token;
    4646        this.createdAt = createdAt;
    4747        this.expiresAt = expiresAt;
    48         this.administrator = administrator;
     48        this.vraboten = vraboten;
    4949    }
    5050
    51     public ConfirmationToken(String token, LocalDateTime createdAt, LocalDateTime expiresAt, Administrator administrator) {
     51    public ConfirmationTokenW(String token, LocalDateTime createdAt, LocalDateTime expiresAt, Vraboten vraboten) {
    5252        this.token = token;
    5353        this.createdAt = createdAt;
    5454        this.expiresAt = expiresAt;
    55         this.administrator = administrator;
     55        this.vraboten = vraboten;
    5656    }
    5757
    … …  
    9696    }
    9797
    98     public Administrator getAdministrator() {
    99         return administrator;
     98    public Vraboten getRegistriranParkirac() {
     99        return vraboten;
    100100    }
    101101
    102     public void setAdministrator(Administrator administrator) {
    103         this.administrator = administrator;
     102    public void setRegistriranParkirac(Vraboten vraboten) {
     103        this.vraboten = vraboten;
    104104    }
    105105}

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

    rce6ad22 rf6bc52d  
    22
    33import java.util.List;
     4import java.util.Optional;
     5
    46import org.springframework.beans.factory.annotation.Autowired;
    57import org.springframework.web.bind.annotation.*;
    68import parkup.configs.RegistrationRequest;
    7 import parkup.configs.RegistrationService;
     9import parkup.configs.RegistrationServiceRP;
    810import parkup.entities.Administrator;
    911import parkup.services.AdministratorService;
    … …  
    1214public class AdministratorController {
    1315    private final AdministratorService administratorService;
    14     private final RegistrationService registrationService;
     16    private final RegistrationServiceRP registrationServiceRP;
    1517
    1618    @Autowired
    17     public AdministratorController(AdministratorService administratorService, RegistrationService registrationService) {
     19    public AdministratorController(AdministratorService administratorService, RegistrationServiceRP registrationServiceRP) {
    1820        this.administratorService = administratorService;
    19         this.registrationService = registrationService;
     21        this.registrationServiceRP = registrationServiceRP;
    2022    }
    2123
    … …  
    3638
    3739    @PostMapping({"/administrator"})
    38     public void addAdministrator(@RequestBody Administrator administrator) {
    39         this.administratorService.addAdministrator(administrator);
     40    public Optional<Administrator> addAdministrator(@RequestBody Administrator administrator) {
     41        return this.administratorService.addAdministrator(administrator);
    4042    }
    4143
    4244    @PutMapping({"/administrator/{administratorId}"})
    43     public void updateAdministrator(@PathVariable int administratorId, @RequestBody Administrator administrator) {
    44         this.administratorService.updateAdministrator(administratorId, administrator.getFirstName(), administrator.getLastName(), administrator.getMobile(), administrator.getEmail());
     45    public Administrator updateAdministrator(@PathVariable int administratorId, @RequestBody Administrator administrator) {
     46        return this.administratorService.updateAdministrator(administratorId, administrator.getFirstName(), administrator.getLastName(), administrator.getMobile(), administrator.getEmail());
    4547    }
    4648
    4749    @DeleteMapping({"/administrator/{administratorId}"})
    48     public void deleteAdministrator(@PathVariable int administratorId) {
    49         this.administratorService.deleteAdministrator(administratorId);
     50    public Optional<Administrator> deleteAdministrator(@PathVariable int administratorId) {
     51        return this.administratorService.deleteAdministrator(administratorId);
    5052    }
    5153
    5254    @PostMapping({"/administrator/registration"})
    5355    public String register(@RequestBody RegistrationRequest request){
    54         return registrationService.register(request);
     56        return registrationServiceRP.register(request);
    5557    }
    5658
    5759    @GetMapping(path = "/administrator/registration/confirm")
    5860    public String confirm(@RequestParam("token") String token) {
    59         return registrationService.confirmToken(token);
     61        return registrationServiceRP.confirmToken(token);
    6062    }
    6163}

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

    rce6ad22 rf6bc52d  
    77
    88import java.util.List;
     9import java.util.Optional;
    910
    1011@RestController
    … …  
    3334
    3435    @PostMapping({"/parkingSession"})
    35     public void addParkingSession(@RequestBody ParkingSession parkingSession) {
     36    public Optional<ParkingSession> addParkingSession(@RequestBody ParkingSession parkingSession) {
    3637        //System.out.println("???????");
    37         parkingSessionService.addParkingSession(parkingSession);
     38        return this.parkingSessionService.addParkingSession(parkingSession);
    3839    }
    3940
    4041    @PutMapping({"/parkingSession/{parkingSessionId}"})
    4142    public void updateParkingSession(@PathVariable int parkingSessionId, @RequestBody ParkingSession parkingSession) {
    42         parkingSessionService.updateParkingSession(parkingSessionId, parkingSession.getTimeStart(), parkingSession.getTimeEnd());
     43        parkingSessionService.updateParkingSession(parkingSessionId,
     44                parkingSession.getTimeStart(), parkingSession.getTimeEnd(), parkingSession.getTablica());
    4345    }
    4446
    4547    @DeleteMapping({"/parkingSession/{parkingSessionId}"})
    46     public void deleteParkingSession(@PathVariable int parkingSessionId) {
    47         parkingSessionService.deleteParkingSession(parkingSessionId);
     48    public Optional<ParkingSession> deleteParkingSession(@PathVariable int parkingSessionId) {
     49        return this.parkingSessionService.deleteParkingSession(parkingSessionId);
    4850    }
    4951}

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

    rce6ad22 rf6bc52d  
    77
    88import java.util.List;
     9import java.util.Optional;
    910
    1011@RestController
    … …  
    3334
    3435    @PostMapping({"/parkingSpace"})
    35     public void addParkingSpace(@RequestBody ParkingSpace parkingSpace) {
     36    public Optional<ParkingSpace> addParkingSpace(@RequestBody ParkingSpace parkingSpace) {
    3637        //System.out.println("???????");
    37         parkingSpaceService.addParkingSpace(parkingSpace);
     38        return this.parkingSpaceService.addParkingSpace(parkingSpace);
    3839    }
    3940
    4041    @PutMapping({"/parkingSpace/{parkingSpaceId}"})
    4142    public void updateParkingSpace(@PathVariable int parkingSpaceId, @RequestBody ParkingSpace parkingSpace) {
    42         parkingSpaceService.updateParkingSpace(parkingSpaceId, parkingSpace.getPsName(), parkingSpace.isTaken(), parkingSpace.isHandicaped());
     43        parkingSpaceService.updateParkingSpace(parkingSpaceId, parkingSpace.getPsName(), parkingSpace.isTaken(),
     44                parkingSpace.isHandicaped(), parkingSpace.getLat(), parkingSpace.getLng());
    4345    }
    4446
    4547    @DeleteMapping({"/parkingSpace/{parkingSpaceId}"})
    46     public void deleteParkingSpace(@PathVariable int parkingSpaceId) {
    47         parkingSpaceService.deleteParkingSpace(parkingSpaceId);
     48    public Optional<ParkingSpace> deleteParkingSpace(@PathVariable int parkingSpaceId) {
     49        return this.parkingSpaceService.deleteParkingSpace(parkingSpaceId);
    4850    }
    4951}

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

    rce6ad22 rf6bc52d  
    77
    88import java.util.List;
     9import java.util.Optional;
    910
    1011@RestController
    … …  
    3233    }
    3334
     35    @GetMapping({"parkingZone/parkingZoneNames"})
     36    public List<String> getParkingZoneNames(){
     37        return this.parkingZoneService.getAllParkingZoneNames();
     38    }
     39
    3440    @PostMapping({"/parkingZone"})
    35     public void addParkingZone(@RequestBody ParkingZone parkingZone) {
    36         //System.out.println("???????");
    37         parkingZoneService.addParkingZone(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);
    3848    }
    3949
    4050    @PutMapping({"/parkingZone/{parkingZoneId}"})
    41     public void updateParkingZone(@PathVariable int parkingZoneId, @RequestBody ParkingZone parkingZone) {
    42         parkingZoneService.updateParkingZone(parkingZoneId, parkingZone.getPzName(), parkingZone.getPrice(), parkingZone.getCapacity(), parkingZone.getWorkHours(),parkingZone.getLocation());
     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());
    4355    }
    4456
    4557    @DeleteMapping({"/parkingZone/{parkingZoneId}"})
    46     public void deleteParkingZone(@PathVariable int parkingZoneId) {
    47         parkingZoneService.deleteParkingZone(parkingZoneId);
     58    public Optional<ParkingZone> deleteParkingZone(@PathVariable int parkingZoneId) {
     59        return this.parkingZoneService.deleteParkingZone(parkingZoneId);
    4860    }
    4961}

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

    rce6ad22 rf6bc52d  
    22
    33import java.util.List;
     4import java.util.Optional;
     5
    46import org.springframework.beans.factory.annotation.Autowired;
    5 import org.springframework.web.bind.annotation.DeleteMapping;
    6 import org.springframework.web.bind.annotation.GetMapping;
    7 import org.springframework.web.bind.annotation.PathVariable;
    8 import org.springframework.web.bind.annotation.PostMapping;
    9 import org.springframework.web.bind.annotation.PutMapping;
    10 import org.springframework.web.bind.annotation.RequestBody;
    11 import org.springframework.web.bind.annotation.RestController;
     7import org.springframework.web.bind.annotation.*;
     8import parkup.configs.RegistrationRequest;
     9import parkup.configs.RegistrationServiceRP;
    1210import parkup.entities.RegistriranParkirac;
    1311import parkup.services.RegistriranParkiracService;
    … …  
    1614public class RegistriranParkiracController {
    1715    private final RegistriranParkiracService registriranParkiracService;
     16    private final RegistrationServiceRP registrationServiceRP;
    1817
    1918    @Autowired
    20     public RegistriranParkiracController(RegistriranParkiracService registriranParkiracService) {
     19    public RegistriranParkiracController(RegistriranParkiracService registriranParkiracService, RegistrationServiceRP registrationServiceRP) {
    2120        this.registriranParkiracService = registriranParkiracService;
     21        this.registrationServiceRP = registrationServiceRP;
    2222    }
    2323
    … …  
    3838
    3939    @PostMapping({"/registriranParkirac"})
    40     public void addRegistriranParkirac(@RequestBody RegistriranParkirac regPark) {
    41         this.registriranParkiracService.addRegPark(regPark);
     40    public Optional<RegistriranParkirac> addRegistriranParkirac(@RequestBody RegistriranParkirac regPark) {
     41        return this.registriranParkiracService.addRegPark(regPark);
    4242    }
    4343
    4444    @PutMapping({"/registriranParkirac/{regParkId}"})
    45     public void updateRegistriranParkirac(@PathVariable int regParkId, @RequestBody RegistriranParkirac regPark) {
    46         this.registriranParkiracService.updateRegPark(regParkId, regPark.getName(), regPark.getSurname(), regPark.getMobile(), regPark.getEmail());
     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());
    4747    }
    4848
    4949    @DeleteMapping({"/registriranParkirac/{regParkId}"})
    50     public void deleteRegistriranParkirac(@PathVariable int regParkId) {
    51         this.registriranParkiracService.deleteRegPark(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);
    5262    }
    5363}

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

    rce6ad22 rf6bc52d  
    22
    33import java.util.List;
     4import java.util.Optional;
     5
    46import org.springframework.beans.factory.annotation.Autowired;
    5 import org.springframework.web.bind.annotation.DeleteMapping;
    6 import org.springframework.web.bind.annotation.GetMapping;
    7 import org.springframework.web.bind.annotation.PathVariable;
    8 import org.springframework.web.bind.annotation.PostMapping;
    9 import org.springframework.web.bind.annotation.PutMapping;
    10 import org.springframework.web.bind.annotation.RequestBody;
    11 import org.springframework.web.bind.annotation.RestController;
     7import org.springframework.web.bind.annotation.*;
     8import parkup.configs.RegistrationRequest;
     9import parkup.configs.RegistrationServiceW;
    1210import parkup.entities.Vraboten;
    1311import parkup.services.VrabotenService;
     12import parkup.data.VrabotenDemo;
    1413
    1514@RestController
    1615public class VrabotenController {
    1716    private final VrabotenService vrabotenService;
     17    private final RegistrationServiceW registrationServiceW;
    1818
    1919    @Autowired
    20     public VrabotenController(VrabotenService vrabotenService) {
     20    public VrabotenController(VrabotenService vrabotenService, RegistrationServiceW registrationServiceW) {
    2121        this.vrabotenService = vrabotenService;
     22        this.registrationServiceW = registrationServiceW;
    2223    }
    2324
    … …  
    3738    }
    3839
     40    @GetMapping({"/vraboten/vrabotenDemo"})
     41    public List<VrabotenDemo> getVraboteniDemos(){
     42        return this.vrabotenService.getAllVraboteniDemos();
     43    }
     44
    3945    @PostMapping({"/vraboten"})
    40     public void addVraboten(@RequestBody Vraboten vraboten) {
    41         this.vrabotenService.addVraboten(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);
    4253    }
    4354
    4455    @PutMapping({"/vraboten/{vrabotenId}"})
    45     public void updateVraboten(@PathVariable int vrabotenId, @RequestBody Vraboten vraboten) {
    46         this.vrabotenService.updateVraboten(vrabotenId, vraboten.getFirstName(), vraboten.getLastName(), vraboten.getMobile(), vraboten.getEmail());
     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());
    4759    }
    4860
    4961    @DeleteMapping({"/vraboten/{vrabotenId}"})
    50     public void deleteVraboten(@PathVariable int vrabotenId) {
    51         this.vrabotenService.deleteVraboten(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);
    5274    }
    5375}

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

    rce6ad22 rf6bc52d  
    11package parkup.data;
    22
    3 import javax.persistence.Entity;
    4 import javax.persistence.Id;
     3import javax.persistence.*;
    54
    65@Entity
    76public class Tablicka {
    87    @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    )
    918    private int tablicaId;
     19
    1020    private String tablica;
    1121

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

    rce6ad22 rf6bc52d  
    11package parkup.entities;
     2
     3import parkup.data.Tablicka;
    24
    35import javax.persistence.*;
    … …  
    911    @Column(name = "parking_session_id")
    1012    @SequenceGenerator(
    11             name="parking_session_generator",
     13            name="parking_session_sequence_generator",
    1214            sequenceName = "parking_session_sequence",
    1315            allocationSize = 1,
    14             initialValue = 700
     16            initialValue = 800
    1517    )
    1618    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    … …  
    2628    private String timeEnd;
    2729
     30    @OneToOne(cascade = {CascadeType.ALL})
     31    @JoinColumn(name = "reg_tablicka", nullable = false)
     32    private Tablicka tablica;
     33
    2834    public ParkingSession() {}
    2935
    30     public ParkingSession(int pssId, String timeStart, String timeEnd) {
     36    public ParkingSession(int pssId, String timeStart, String timeEnd, Tablicka tablica) {
    3137        this.pssId = pssId;
    3238        this.timeStart = timeStart;
    3339        this.timeEnd = timeEnd;
     40        this.tablica = tablica;
    3441    }
    3542
    36     public ParkingSession(String timeStart, String timeEnd) {
     43    public ParkingSession(String timeStart, String timeEnd, Tablicka tablica) {
    3744        this.timeStart = timeStart;
    3845        this.timeEnd = timeEnd;
     46        this.tablica = tablica;
    3947    }
    4048
    … …  
    6270        this.timeEnd = timeEnd;
    6371    }
     72
     73    public Tablicka getTablica() {
     74        return tablica;
     75    }
     76
     77    public void setTablica(Tablicka tablica) {
     78        this.tablica = tablica;
     79    }
    6480}

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

    rce6ad22 rf6bc52d  
    99    @Column(name = "parking_space_id")
    1010    @SequenceGenerator(
    11             name="parking_space_generator",
     11            name="parking_space_sequence_generator",
    1212            sequenceName = "parking_space_sequence",
    1313            allocationSize = 1,
    14             initialValue = 600
     14            initialValue = 700
    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
    3141    public ParkingSpace() {}
    3242
    33     public ParkingSpace(int psId, String psName, boolean isTaken, boolean isHandicaped) {
     43    public ParkingSpace(int psId, String psName, boolean isTaken, boolean isHandicaped, float lat, float lng) {
    3444        this.psId = psId;
    3545        this.psName = psName;
    3646        this.isTaken = isTaken;
    3747        this.isHandicaped = isHandicaped;
     48        this.lat = lat;
     49        this.lng = lng;
    3850    }
    3951
    40     public ParkingSpace(String psName, boolean isTaken, boolean isHandicaped) {
     52    public ParkingSpace(String psName, boolean isTaken, boolean isHandicaped, float lat, float lng) {
    4153        this.psName = psName;
    4254        this.isTaken = isTaken;
    4355        this.isHandicaped = isHandicaped;
     56        this.lat = lat;
     57        this.lng = lng;
    4458    }
    4559
    … …  
    7589        this.isHandicaped = isHandicaped;
    7690    }
     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    }
    77107}
    78108

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

    rce6ad22 rf6bc52d  
    11package parkup.entities;
     2
     3import parkup.data.ParkingZoneLocation;
    24
    35import javax.persistence.*;
    … …  
    1012    @Id
    1113    @SequenceGenerator(
    12             name="parking_zone_generator",
     14            name="parking_zone_sequence_generator",
    1315            sequenceName = "parking_zone_sequence",
    1416            allocationSize = 1,
    15             initialValue = 500
     17            initialValue = 600
    1618    )
    1719    @GeneratedValue(    //za postgres treba sequence da se namesti i ime na generator mi ga davamo kako od gore sto e
    … …  
    3133    private int capacity;
    3234
    33     @Column(name = "work_hours")
    34     private String workHours;
     35    @Column(name = "vreme_od")  //za rabotni casovi od:
     36    private int from;
    3537
    36     @Column(name = "location")
     38    @Column(name = "vreme_do")    //za rabotni casovi do:
     39    private int to;
     40
     41    @Column(name = "lokacija")
    3742    private String location;
    3843
    … …  
    4045    private int zafateniMesta;
    4146
     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
    4254    @OneToMany(cascade = {CascadeType.ALL})
    43     @JoinColumn(name = "parkingSpaces", nullable = false)
    4455    private List<ParkingSpace> parkingSpaces;
    4556
    46     public ParkingZone() {
     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;
    4767        this.zafateniMesta = 0;
    4868        this.parkingSpaces = new ArrayList<ParkingSpace>();
    4969    }
    5070
    51     public ParkingZone(int pzId, String pzName, int price, int capacity, String workHours, String location, List<ParkingSpace> parkingSpaces) {
     71    public ParkingZone(int pzId, String pzName, int price, int capacity, String location, List<ParkingSpace> parkingSpaces, String color, int from, int to) {
    5272        this.pzId = pzId;
    5373        this.pzName = pzName;
    5474        this.price = price;
    5575        this.capacity = capacity;
    56         this.workHours = workHours;
    5776        this.location = location;
    5877        this.zafateniMesta = 0;
    5978        this.parkingSpaces = parkingSpaces;
     79        this.color = color;
     80        this.from = from;
     81        this.to = to;
    6082    }
    6183
    62     public ParkingZone(String pzName, int price, int capacity, String workHours, String location, List<ParkingSpace> parkingSpaces) {
     84    public ParkingZone(String pzName, int price, int capacity, String location, List<ParkingSpace> parkingSpaces, String color, int from, int to) {
    6385        this.pzName = pzName;
    6486        this.price = price;
    6587        this.capacity = capacity;
    66         this.workHours = workHours;
    6788        this.location = location;
    6889        this.zafateniMesta = 0;
    6990        this.parkingSpaces = parkingSpaces;
     91        this.color = color;
     92        this.from = from;
     93        this.to = to;
    7094    }
    7195
    … …  
    102126    }
    103127
    104     public String getWorkHours() {
    105         return this.workHours;
    106     }
    107 
    108     public void setWorkHours(String workHours) {
    109         this.workHours = workHours;
    110     }
    111 
    112128    public String getLocation() {
    113129        return this.location;
    … …  
    125141
    126142    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    }
    127183}

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

    rce6ad22 rf6bc52d  
    22
    33import java.util.ArrayList;
     4import java.util.Collection;
     5import java.util.Collections;
    46import java.util.List;
    57import javax.persistence.*;
    68
     9import org.springframework.security.core.GrantedAuthority;
     10import org.springframework.security.core.authority.SimpleGrantedAuthority;
     11import org.springframework.security.core.userdetails.UserDetails;
    712import parkup.data.Tablicka;
    813
    914@Entity
    1015@Table(name = "registriranParkirac")
    11 public class RegistriranParkirac {
     16public class RegistriranParkirac implements UserDetails {
    1217    @Id
    1318    @SequenceGenerator(
    … …  
    3338    private String password;
    3439
    35     @OneToMany
     40    @OneToMany(cascade ={CascadeType.ALL})
    3641    @Column(name = "regTablicki")
    3742    private List<Tablicka> regTablicki;
    … …  
    4651    private String role;
    4752
     53    private boolean locked;
     54
     55    private boolean enabled;
     56
    4857    public RegistriranParkirac() {
    49 
    5058        this.regTablicki = new ArrayList<Tablicka>();
    51         this.role = "ROLE_REGISTIRAN_PARKIRAC";
     59        this.role = "ROLE_REGISTRIRAN_PARKIRAC";
    5260    }
    5361
    … …  
    6068        this.email = email;
    6169        this.mobile = mobile;
    62         this.role = "ROLE_REGISTIRAN_PARKIRAC";
     70        this.role = "ROLE_REGISTRIRAN_PARKIRAC";
    6371    }
    6472
    … …  
    7078        this.email = email;
    7179        this.mobile = mobile;
    72         this.role = "ROLE_REGISTIRAN_PARKIRAC";
     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";
    7390    }
    7491
    … …  
    95112    public void setSurname(String surname) {
    96113        this.surname = surname;
    97     }
    98 
    99     public String getPassword() {
    100         return password;
    101     }
    102 
    103     public void setPassword(String password) {
    104         this.password = password;
    105114    }
    106115
    … …  
    132141
    133142    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    }
    134182}
    135183

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

    rce6ad22 rf6bc52d  
    11package parkup.entities;
    22
    3 import parkup.data.Tablicka;
     3import org.springframework.security.core.GrantedAuthority;
     4import org.springframework.security.core.userdetails.UserDetails;
     5import parkup.data.VrabotenDemo;
    46
    57import javax.persistence.*;
    68import java.util.ArrayList;
     9import java.util.Collection;
    710import java.util.List;
    811
    912@Entity
    1013@Table(name = "vraboten")
    11 public class Vraboten {
     14public class Vraboten implements UserDetails {
    1215    @Id
    1316    @SequenceGenerator(
    … …  
    4952    private String status;
    5053
    51     @Column(name = "account")
    52     private boolean account;
     54    @Column(name="locked")
     55    private boolean locked;
     56
     57    @Column(name = "enabled")
     58    private boolean enabled;
     59
    5360
    5461    public Vraboten() {
    5562        this.role = "ROLE_VRABOTEN";
    5663        this.parkingZones = new ArrayList<ParkingZone>();
    57         this.account = true;
     64        this.enabled = false;
    5865        this.status = "neRaboti";
    5966    }
    … …  
    6875        this.parkingZones = parkingZones;
    6976        this.role = "ROLE_VRABOTEN";
    70         this.account = true;
     77        this.enabled = false;
    7178        this.status = "neRaboti";
    7279    }
    … …  
    8087        this.parkingZones = parkingZones;
    8188        this.role = "ROLE_VRABOTEN";
    82         this.account = true;
     89        this.enabled = false;
    8390        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";
    84103    }
    85104
    … …  
    116135    }
    117136
     137    @Override
     138    public Collection<? extends GrantedAuthority> getAuthorities() {
     139        return null;
     140    }
     141
    118142    public String getPassword() {
    119143        return password;
    120144    }
    121145
     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;
     173    }
     174
    122175    public void setPassword(String password) {
    123176        this.password = password;
    … …  
    144197    public void setStatus(String status) {this.status = status;}
    145198
    146     public boolean isAccount() {return account;}
    147 
    148     public void setAccount(boolean account) {this.account = account;}
     199    public boolean isAccount() {return enabled;}
     200
     201    public void setAccount(boolean account) {this.enabled = account;}
    149202}

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

    rce6ad22 rf6bc52d  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
     5import org.springframework.stereotype.Repository;
    56import parkup.entities.Guest;
    67
     8@Repository
    79public interface GuestRepository extends JpaRepository<Guest, Integer> {
    810    Guest findByGuestId(int id);

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

    rce6ad22 rf6bc52d  
    22
    33import org.springframework.data.jpa.repository.JpaRepository;
     4import org.springframework.stereotype.Repository;
    45import parkup.entities.ParkingZone;
    56
     7@Repository
    68public interface ParkingZoneRepository extends JpaRepository<ParkingZone, Integer> {
    79    ParkingZone findByPzId(int id);

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

    rce6ad22 rf6bc52d  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
     5import org.springframework.data.jpa.repository.Modifying;
     6import org.springframework.data.jpa.repository.Query;
     7import org.springframework.stereotype.Repository;
    58import parkup.entities.RegistriranParkirac;
    69
     10import javax.transaction.Transactional;
     11
     12@Repository
    713public interface RegistriranParkiracRepository extends JpaRepository<RegistriranParkirac, Integer> {
    814    RegistriranParkirac findByRegParkId(int regParkId);
    … …  
    1117
    1218    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);
    1325}

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

    rce6ad22 rf6bc52d  
    33import java.util.Optional;
    44import org.springframework.data.jpa.repository.JpaRepository;
     5import org.springframework.data.jpa.repository.Modifying;
     6import org.springframework.data.jpa.repository.Query;
     7import org.springframework.stereotype.Repository;
    58import parkup.entities.Vraboten;
    69
     10import javax.transaction.Transactional;
     11
     12@Repository
    713public interface VrabotenRepository extends JpaRepository<Vraboten, Integer> {
    814    Vraboten findByVrabotenId(int id);
    … …  
    1117
    1218    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);
    1325}

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

    rce6ad22 rf6bc52d  
    11package parkup.services;
    22
    3 import java.time.LocalDateTime;
    43import java.util.List;
    54import java.util.Objects;
    … …  
    1413import org.springframework.stereotype.Service;
    1514import parkup.configs.email.EmailValidator;
    16 import parkup.configs.token.ConfirmationToken;
    1715import parkup.configs.token.ConfirmationTokenService;
    1816import parkup.entities.Administrator;
    … …  
    4240    }
    4341
    44     public void addAdministrator(Administrator administrator) {
     42    public Optional<Administrator> addAdministrator(Administrator administrator) {
    4543        Optional<Administrator> administratorOpt = this.administratorRepository.findAdministratorByEmail(administrator.getEmail());
    4644        if (administratorOpt.isPresent()) {
    4745            throw new IllegalStateException("Email already taken, try adding an administrator with a different valid email address");
    4846        } else {
    49             System.out.println(administrator);
    50             this.administratorRepository.save(administrator);
     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            }
    5154        }
     55        return administratorOpt;
    5256    }
    5357
    5458    @Transactional
    55     public void updateAdministrator(int administratorId, String firstName, String lastName, String mobile, String email) {
     59    public Administrator updateAdministrator(int administratorId, String firstName, String lastName, String mobile, String email) {
    5660        Optional<Administrator> administratorOpt = Optional.ofNullable(this.administratorRepository.findByAdministratorId(administratorId));
    5761        if (administratorOpt.isPresent()) {
    … …  
    6266                    throw new IllegalStateException("email taken");
    6367                }
    64 
    6568                administratorNov.setEmail(email);
     69            }else{
     70                throw new IllegalStateException("email not valid");
    6671            }
    6772
    … …  
    7782                administratorNov.setMobile(mobile);
    7883            }
     84            return administratorNov;
    7985        }
     86        else {
     87            throw new IllegalStateException("Administrator doesn't exist, therefore can't be updated");
     88        }
     89
    8090    }
    8191
    82     public void deleteAdministrator(int administratorId) {
     92    public Optional<Administrator> deleteAdministrator(int administratorId) {
    8393        Optional<Administrator> administratorOpt = Optional.ofNullable(this.administratorRepository.findByAdministratorId(administratorId));
    8494        if (administratorOpt.isPresent()) {
    … …  
    8797            throw new IllegalStateException("Administrator doesn't exist, therefore can't be deleted");
    8898        }
     99        return administratorOpt;
    89100    }
    90101
    … …  
    126137
    127138        String token = UUID.randomUUID().toString();
    128         ConfirmationToken confirmationToken = new ConfirmationToken(
    129                 token,
    130                 LocalDateTime.now(),
    131                 LocalDateTime.now().plusMinutes(15),
    132                 administrator
    133         );
     139        //ConfirmationTokenRP confirmationToken = new ConfirmationTokenRP(
     140        //        token,
     141        //        LocalDateTime.now(),
     142        //        LocalDateTime.now().plusMinutes(15),
     143        //        administrator
     144        //);
    134145
    135         confirmationTokenService.saveConfirmationToken(confirmationToken);
     146        //confirmationTokenService.saveConfirmationToken(confirmationToken);
    136147
    137148        // TODO: SEND EMAIL

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

    rce6ad22 rf6bc52d  
    33import org.springframework.beans.factory.annotation.Autowired;
    44import org.springframework.stereotype.Service;
     5import parkup.data.Tablicka;
    56import parkup.entities.ParkingSession;
    67import parkup.repositories.ParkingSessionRepository;
    78
     9import javax.transaction.Transactional;
    810import java.util.List;
    911import java.util.Objects;
    … …  
    2830    }
    2931
    30     public void updateParkingSession(int parkingSessionId, String timeStart, String timeEnd) {
     32    @Transactional
     33    public void updateParkingSession(int parkingSessionId, String timeStart, String timeEnd, Tablicka tablicka) {
    3134        Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSessionId));
    3235        if (parkingSessionOpt.isPresent()) {
    3336            ParkingSession parkingSessionNov = parkingSessionRepository.findByPssId(parkingSessionId);
     37
    3438            if(!parkingSessionNov.getTimeStart().equals(timeStart) && !parkingSessionNov.getTimeStart().equals(timeEnd))
    3539                parkingSessionNov.setTimeStart(timeStart);
    … …  
    3741            if(!parkingSessionNov.getTimeEnd().equals(timeEnd) && !parkingSessionNov.getTimeEnd().equals(timeStart))
    3842                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");
    3949        }
    4050    }
    4151
    42     public void deleteParkingSession(int parkingSessionId) {
     52    public Optional<ParkingSession> deleteParkingSession(int parkingSessionId) {
    4353        Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSessionId));
    4454        if (parkingSessionOpt.isPresent()) {
    4555            parkingSessionRepository.deleteByPssId(parkingSessionId);
     56            return parkingSessionOpt;
    4657        } else {
    4758            throw new IllegalStateException("ParkingSpace doesn't exist, therefore can't be deleted");
    … …  
    4960    }
    5061
    51     public void addParkingSession(ParkingSession parkingSession) {
    52         Optional <ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSession.getPssId()));
     62    public Optional<ParkingSession> addParkingSession(ParkingSession parkingSession) {
     63        Optional<ParkingSession> parkingSessionOpt = Optional.ofNullable(parkingSessionRepository.findByPssId(parkingSession.getPssId()));
    5364        if (parkingSessionOpt.isPresent()) {
    5465            throw new IllegalStateException("ID already taken, ParkingSession cannot be added");
    … …  
    5667            System.out.println(parkingSession);
    5768            parkingSessionRepository.save(parkingSession);
     69            return parkingSessionOpt;
    5870        }
    5971    }

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

    rce6ad22 rf6bc52d  
    66import parkup.repositories.ParkingSpaceRepository;
    77
     8import javax.transaction.Transactional;
    89import java.util.List;
    910import java.util.Objects;
    … …  
    2829    }
    2930
    30     public void addParkingSpace(ParkingSpace parkingSpace) {
    31         Optional <ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsName(parkingSpace.getPsName()));
     31    public Optional<ParkingSpace> addParkingSpace(ParkingSpace parkingSpace) {
     32        Optional<ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsName(parkingSpace.getPsName()));
    3233        if (parkingSpaceOpt.isPresent()) {
    3334            throw new IllegalStateException("Name already taken, try adding a ParkingZone with a different name");
    … …  
    3637            parkingSpaceRepository.save(parkingSpace);
    3738        }
     39        return parkingSpaceOpt;
    3840    }
    3941
    40     public void updateParkingSpace(int parkingSpaceId, String psName, boolean taken, boolean handicaped) {
     42    @Transactional
     43    public ParkingSpace updateParkingSpace(int parkingSpaceId, String psName, boolean taken, boolean handicaped, float lat, float lng) {
    4144        Optional<ParkingSpace> ParkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsId(parkingSpaceId));
    4245        if (ParkingSpaceOpt.isPresent()) {
    … …  
    5861                ParkingSpaceNov.setHandicaped(handicaped);
    5962            }
     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");
    6074        }
    6175    }
    6276
    63     public void deleteParkingSpace(int parkingSpaceId) {
     77    @Transactional
     78    public Optional<ParkingSpace> deleteParkingSpace(int parkingSpaceId) {
    6479        Optional<ParkingSpace> parkingSpaceOpt = Optional.ofNullable(parkingSpaceRepository.findByPsId(parkingSpaceId));
    6580        if (parkingSpaceOpt.isPresent()) {
    … …  
    6883            throw new IllegalStateException("ParkingSpace doesn't exist, therefore can't be deleted");
    6984        }
     85        return parkingSpaceOpt;
    7086    }
    7187}

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

    rce6ad22 rf6bc52d  
    22
    33import org.springframework.beans.factory.annotation.Autowired;
     4import org.springframework.data.jpa.repository.Modifying;
    45import org.springframework.stereotype.Service;
    5 import parkup.entities.Administrator;
     6import parkup.data.ParkingZoneLocation;
     7import parkup.entities.ParkingSpace;
    68import parkup.entities.ParkingZone;
    79import parkup.repositories.ParkingZoneRepository;
    810
    911import javax.transaction.Transactional;
     12import java.util.ArrayList;
    1013import java.util.List;
    1114import java.util.Objects;
    … …  
    3033    }
    3134
    32     public void addParkingZone(ParkingZone parkingZone) {   //zavisno vo koj grad ili opstina i napravi proverki pred dodavanje, implementiraj u naredna faza
     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
    3345        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzName(parkingZone.getPzName()));
    3446        if (parkingZoneOpt.isPresent()) {
    … …  
    3850            parkingZoneRepository.save(parkingZone);
    3951        }
     52        return parkingZoneOpt;
    4053    }
    4154
     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
    4267    @Transactional
    43     public void updateParkingZone(int parkingZoneId, String pzName, int price, int capacity, String workHours, String location) {
     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) {
    4471        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzId(parkingZoneId));
    4572        if (parkingZoneOpt.isPresent()) {
    … …  
    6289            }
    6390
    64             if (workHours != null && workHours.length() > 0 && !Objects.equals(parkingZoneNov.getWorkHours(), workHours)) {
    65                 parkingZoneNov.setWorkHours(workHours);
    66             }
    67 
    6891            if (location != null && location.length() > 0 && !Objects.equals(parkingZoneNov.getLocation(), location)) {
    6992                parkingZoneNov.setLocation(location);
    7093            }
     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");
    71119        }
    72120    }
    73121
    74     public void deleteParkingZone(int parkingZoneId) {
     122    @Transactional
     123    public Optional<ParkingZone> deleteParkingZone(int parkingZoneId) {
    75124        Optional<ParkingZone> parkingZoneOpt = Optional.ofNullable(parkingZoneRepository.findByPzId(parkingZoneId));
    76125        if (parkingZoneOpt.isPresent()) {
    … …  
    79128            throw new IllegalStateException("ParkingZone doesn't exist, therefore can't be deleted");
    80129        }
     130        return parkingZoneOpt;
    81131    }
    82132}

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

    rce6ad22 rf6bc52d  
    11package parkup.services;
    22
     3import java.time.LocalDateTime;
    34import java.util.List;
    45import java.util.Objects;
    56import java.util.Optional;
     7import java.util.UUID;
    68import javax.transaction.Transactional;
    79import org.springframework.beans.factory.annotation.Autowired;
     10import org.springframework.data.jpa.repository.Modifying;
     11import org.springframework.security.core.userdetails.UserDetails;
     12import org.springframework.security.core.userdetails.UserDetailsService;
     13import org.springframework.security.core.userdetails.UsernameNotFoundException;
     14import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    815import org.springframework.stereotype.Service;
     16import parkup.configs.email.EmailValidator;
     17import parkup.configs.token.ConfirmationTokenRP;
     18import parkup.configs.token.ConfirmationTokenService;
     19import parkup.data.Tablicka;
    920import parkup.entities.RegistriranParkirac;
    1021import parkup.repositories.RegistriranParkiracRepository;
    1122
    1223@Service
    13 public class RegistriranParkiracService {
     24public class RegistriranParkiracService implements UserDetailsService {
    1425    private final RegistriranParkiracRepository registriranParkiracRepository;
     26    private final BCryptPasswordEncoder bCryptPasswordEncoder;
     27    private final ConfirmationTokenService confirmationTokenService;
     28    private EmailValidator emailValidator;
    1529
    1630    @Autowired
    17     public RegistriranParkiracService(RegistriranParkiracRepository registriranParkiracRepository) {
     31    public RegistriranParkiracService(RegistriranParkiracRepository registriranParkiracRepository, BCryptPasswordEncoder bCryptPasswordEncoder, ConfirmationTokenService confirmationTokenService) {
    1832        this.registriranParkiracRepository = registriranParkiracRepository;
     33        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
     34        this.confirmationTokenService = confirmationTokenService;
    1935    }
    2036
    … …  
    2339    }
    2440
    25     public void addRegPark(RegistriranParkirac regPark) {
     41    public Optional<RegistriranParkirac> addRegPark(RegistriranParkirac regPark) {
    2642        Optional<RegistriranParkirac> regParkOpt = this.registriranParkiracRepository.findRegistriranParkiracByEmail(regPark.getEmail());
    2743        if (regParkOpt.isPresent()) {
    2844            throw new IllegalStateException("Email already taken, try adding a registriranParkirac with a different valid email address");
    2945        } else {
    30             System.out.println(regPark);
    31             this.registriranParkiracRepository.save(regPark);
     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            }
    3253        }
     54        return regParkOpt;
    3355    }
    3456
    3557    @Transactional
    36     public void updateRegPark(int regParkId, String name, String surname, String mobile, String email) {
     58    public RegistriranParkirac updateRegPark(int regParkId, String name, String surname, String mobile, String email,List<Tablicka> regTablicki) {
    3759        Optional<RegistriranParkirac> regParkOpt = Optional.ofNullable(this.registriranParkiracRepository.findByRegParkId(regParkId));
    3860        if (regParkOpt.isPresent()) {
    … …  
    5880                regParkNov.setMobile(mobile);
    5981            }
     82            regParkNov.setRegTablicki(regTablicki);
     83            return regParkNov;
     84        }else{
     85            throw new IllegalStateException("RegistriranParkirac doesn't exist, therefore can't be updated");
    6086        }
    6187    }
    6288
    63     public void deleteRegPark(int regParkId) {
     89    @Transactional
     90    @Modifying
     91    public Optional<RegistriranParkirac> deleteRegPark(int regParkId) {
    6492        Optional<RegistriranParkirac> regPark = Optional.ofNullable(this.registriranParkiracRepository.findByRegParkId(regParkId));
    6593        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);
    6697            this.registriranParkiracRepository.deleteByRegParkId(regParkId);
    6798        } else {
    6899            throw new IllegalStateException("RegistriranParkirac doesn't exist, therefore can't be deleted");
    69100        }
     101        return regPark;
    70102    }
    71103
    … …  
    74106        return regPark.orElse(null);
    75107    }
     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    }
    76155}

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

    rce6ad22 rf6bc52d  
    11package parkup.services;
    22
    3 import java.util.List;
    4 import java.util.Objects;
    5 import java.util.Optional;
    6 import java.util.UUID;
     3import java.time.LocalDateTime;
     4import java.util.*;
    75import javax.transaction.Transactional;
    86import org.springframework.beans.factory.annotation.Autowired;
     7import org.springframework.data.jpa.repository.Modifying;
     8import org.springframework.security.core.userdetails.UserDetails;
     9import org.springframework.security.core.userdetails.UserDetailsService;
     10import org.springframework.security.core.userdetails.UsernameNotFoundException;
     11import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    912import org.springframework.stereotype.Service;
     13import parkup.configs.token.ConfirmationTokenW;
     14import parkup.configs.token.ConfirmationTokenService;
    1015import parkup.entities.Vraboten;
    1116import parkup.repositories.VrabotenRepository;
     17import parkup.data.VrabotenDemo;
    1218
    1319@Service
    14 public class VrabotenService {
     20public class VrabotenService implements UserDetailsService {
    1521    private final VrabotenRepository vrabotenRepository;
     22    private final BCryptPasswordEncoder bCryptPasswordEncoder;
     23    private final ConfirmationTokenService confirmationTokenService;
    1624
    1725    @Autowired
    18     public VrabotenService(VrabotenRepository vrabotenRepository) {
     26    public VrabotenService(VrabotenRepository vrabotenRepository, BCryptPasswordEncoder bCryptPasswordEncoder, ConfirmationTokenService confirmationTokenService) {
    1927        this.vrabotenRepository = vrabotenRepository;
     28        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
     29        this.confirmationTokenService = confirmationTokenService;
    2030    }
    2131
    … …  
    2939    }
    3040
    31     public void addVraboten(Vraboten vraboten) {
     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) {
    3252        Optional<Vraboten> vrabotenOpt = this.vrabotenRepository.findVrabotenByEmail(vraboten.getEmail());
    3353        if (vrabotenOpt.isPresent()) {
    3454            throw new IllegalStateException("Email already taken, try adding a vraboten with a different valid email address");
    3555        } else {
    36             System.out.println(vraboten);
    37             this.vrabotenRepository.save(vraboten);
     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            }
    3863        }
     64        return vrabotenOpt;
    3965    }
    4066
    4167    @Transactional
    42     public void updateVraboten(int vrabotenId, String firstName, String lastName, String mobile, String email) {
     68    public Vraboten updateVraboten(int vrabotenId, String firstName, String lastName, String mobile, String email, String status) {
    4369        Optional<Vraboten> vrabotenOpt = Optional.ofNullable(this.vrabotenRepository.findByVrabotenId(vrabotenId));
    4470        if (vrabotenOpt.isPresent()) {
    … …  
    4975                    throw new IllegalStateException("email taken");
    5076                }
    51 
    5277                vrabotenNov.setEmail(email);
     78            } else {
     79                throw new IllegalStateException("email not valid");
    5380            }
    5481
    … …  
    6491                vrabotenNov.setMobile(mobile);
    6592            }
     93
     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;
    66103        }
    67     }
     104        else{
     105            throw new IllegalStateException("Vraboten doesn't exist, therefore can't be updated");
     106        }
     107    }//za menjanje password da se implementira
    68108
    69     public void deleteVraboten(int vrabotenId) {
     109    @Modifying
     110    @Transactional
     111    public Optional<Vraboten> deleteVraboten(int vrabotenId) {
    70112        Optional<Vraboten> vrabotenOpt = Optional.ofNullable(this.vrabotenRepository.findByVrabotenId(vrabotenId));
    71113        if (vrabotenOpt.isPresent()) {
     114            //TODO da povikamo metod od ConfirmationTokenService za brisenje na ConfirmationTokenW
     115            this.confirmationTokenService.deleteByVraboten_VrabotenId(vrabotenId);
    72116            this.vrabotenRepository.deleteByVrabotenId(vrabotenId);
    73117        } else {
    74118            throw new IllegalStateException("Vraboten doesn't exist, therefore can't be deleted");
    75119        }
     120        return vrabotenOpt;
    76121    }
     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
    77178}
Note: See TracChangeset for help on using the changeset viewer.