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/src/main/java/parkup/services
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • 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.