· 8 years ago · Jan 22, 2018, 08:50 AM
1-- -----------------------------------------------------
2-- Create hibernate_sequence
3-- -----------------------------------------------------
4
5DROP SEQUENCE IF EXISTS hibernate_sequence;
6CREATE SEQUENCE hibernate_sequence
7 INCREMENT 1
8 MINVALUE 1
9 MAXVALUE 9223372036854775807
10 START 20
11 CACHE 1;
12ALTER TABLE hibernate_sequence
13 OWNER TO viktor_kulygin;
14
15-- -----------------------------------------------------
16-- Table `event`
17-- -----------------------------------------------------
18CREATE TABLE IF NOT EXISTS event (
19 id INT NOT NULL,
20 event_type VARCHAR(255) NULL,
21 event_location VARCHAR(255) NULL,
22 event_start_date TIMESTAMP(0) NULL,
23 event_end_date TIMESTAMP(0) NULL,
24 event_time VARCHAR(255) NULL,
25 event_cost INT NULL,
26 event_link VARCHAR(255) NULL,
27 PRIMARY KEY (id))
28;
29
30-- -----------------------------------------------------
31-- Table `date_exception`
32-- -----------------------------------------------------
33CREATE TABLE IF NOT EXISTS date_exception (
34 id INT NOT NULL,
35 event_date_ex TIMESTAMP(0) NULL,
36 event_id INT NULL,
37 PRIMARY KEY (id, event_id)
38 ,
39 CONSTRAINT fk_date_exception_event
40 FOREIGN KEY (event_id)
41 REFERENCES event (id)
42 ON DELETE NO ACTION
43 ON UPDATE NO ACTION)
44;
45
46CREATE INDEX fk_date_exception_event_idx ON date_exception (event_id ASC);
47
48@Entity
49@Table(name = "event")
50public class Event {
51
52 @Id
53 @GeneratedValue(strategy = GenerationType.SEQUENCE)
54 private long id;
55
56 @Column(name = "event_type")
57 private String eventType;
58
59 @Column(name = "event_location")
60 private String eventLocation;
61
62 @Column(name = "event_start_date")
63 @Type(type = "org.jadira.usertype.dateandtime.joda.PersistentLocalDateTime")
64 @DateTimeFormat(pattern = "yyyy/dd/mm H:m:s:S")
65 private LocalDateTime eventStartDate;
66
67 @Column(name = "event_end_date")
68 @Type(type = "org.jadira.usertype.dateandtime.joda.PersistentLocalDateTime")
69 @DateTimeFormat(pattern = "yyyy/dd/mm H:m:s:S")
70 private LocalDateTime eventEndDate;
71
72 @Column(name = "event_time")
73 private String eventTime;
74
75 @Column(name = "event_cost")
76 private long eventCost;
77
78 @Column(name = "event_link")
79 private String eventLink;
80
81 @OneToMany(fetch = FetchType.EAGER,mappedBy = "event")
82 private Set<DateException> dateExceptions;
83
84 public Event() {
85 }
86
87 public Event(String eventType, String eventLocation, LocalDateTime eventStartDate, LocalDateTime eventEndDate, String eventTime, long eventCost, String eventLink) {
88 this.eventType = eventType;
89 this.eventLocation = eventLocation;
90 this.eventStartDate = eventStartDate;
91 this.eventEndDate = eventEndDate;
92 this.eventTime = eventTime;
93 this.eventCost = eventCost;
94 this.eventLink = eventLink;
95 }
96
97 public long getId() {
98 return id;
99 }
100
101 public void setId(long id) {
102 this.id = id;
103 }
104
105 public String getEventType() {
106 return eventType;
107 }
108
109 public void setEventType(String eventType) {
110 this.eventType = eventType;
111 }
112
113 public String getEventLocation() {
114 return eventLocation;
115 }
116
117 public void setEventLocation(String eventLocation) {
118 this.eventLocation = eventLocation;
119 }
120
121 public LocalDateTime getEventStartDate() {
122 return eventStartDate;
123 }
124
125 public void setEventStartDate(LocalDateTime eventStartDate) {
126 this.eventStartDate = eventStartDate;
127 }
128
129 public LocalDateTime getEventEndDate() {
130 return eventEndDate;
131 }
132
133 public void setEventEndDate(LocalDateTime eventEndDate) {
134 this.eventEndDate = eventEndDate;
135 }
136
137 public String getEventTime() {
138 return eventTime;
139 }
140
141 public void setEventTime(String eventTime) {
142 this.eventTime = eventTime;
143 }
144
145 public long getEventCost() {
146 return eventCost;
147 }
148
149 public void setEventCost(long eventCost) {
150 this.eventCost = eventCost;
151 }
152
153 public String getEventLink() {
154 return eventLink;
155 }
156
157 public void setEventLink(String eventLink) {
158 this.eventLink = eventLink;
159 }
160
161 public Set<DateException> getDateExceptions() {
162 return dateExceptions;
163 }
164
165 public void setDateExceptions(Set<DateException> dateExceptions) {
166 this.dateExceptions = dateExceptions;
167 }
168}
169
170@Entity
171@Table(name = "date_exception")
172public class DateException {
173
174 @Id
175 @GeneratedValue(strategy = GenerationType.SEQUENCE)
176 private long id;
177
178 @Column(name = "event_date_ex")
179 @Type(type = "org.jadira.usertype.dateandtime.joda.PersistentLocalDateTime")
180 @DateTimeFormat(pattern = "yyyy/dd/mm H:m:s:S")
181 private LocalDateTime eventDateEx;
182
183 @JoinColumn(name = "event_id")
184 @ManyToOne
185 private Event event;
186
187 public DateException() {
188 }
189
190 public DateException(LocalDateTime eventDateEx) {
191 this.eventDateEx = eventDateEx;
192 }
193
194 public long getId() {
195 return id;
196 }
197
198 public void setId(long id) {
199 this.id = id;
200 }
201
202 public LocalDateTime getEventDateEx() {
203 return eventDateEx;
204 }
205
206 public void setEventDateEx(LocalDateTime eventDateEx) {
207 this.eventDateEx = eventDateEx;
208 }
209
210 public Event getEvent() {
211 return event;
212 }
213
214 public void setEvent(Event event) {
215 this.event = event;
216 }
217}
218
219public interface DateExceptionRepository extends CrudRepository<DateException, Long> {
220}
221
222public interface EventRepository extends CrudRepository<Event, Long> {
223 Page<Event> findAll(Pageable pageable);
224}
225
226public interface EventService {
227
228 Event getEventById(Long eventId);
229 Event createEvent(String eventType, String eventLocation, LocalDateTime eventStartDate, LocalDateTime eventEndDate, String eventTime, long eventCost, String eventLink);
230 void deleteEventById(Long eventId);
231 Event addExceptionToEvent(Event event, LocalDateTime eventDateEx);
232 Page<Event> findAllEvents(PageRequest pageRequest);
233}
234
235@Service
236public class EventServiceImpl implements EventService {
237
238 @Autowired
239 private EventRepository eventRepository;
240
241 @Override
242 public Event getEventById(Long eventId) {
243 return eventRepository.findOne(eventId);
244 }
245
246 @Override
247 public Event createEvent(String eventType, String eventLocation, LocalDateTime eventStartDate, LocalDateTime eventEndDate, String eventTime, long eventCost, String eventLink) {
248 Event event = new Event(eventType, eventLocation, eventStartDate, eventEndDate, eventTime, eventCost, eventLink);
249 return eventRepository.save(event);
250 }
251
252 @Override
253 public void deleteEventById(Long eventId) {
254 eventRepository.delete(eventId);
255 }
256
257 @Override
258 public Event addExceptionToEvent(Event event, LocalDateTime eventDateEx) {
259 DateException dateException = new DateException(eventDateEx);
260 Set<DateException> dateExceptionSet = new HashSet<>();
261 dateExceptionSet.add(dateException);
262 event.setDateExceptions(dateExceptionSet);
263 return eventRepository.save(event);
264 }
265
266 @Override
267 public Page<Event> findAllEvents(PageRequest pageRequest) {
268 Page<Event> events = eventRepository.findAll(pageRequest);
269 return events;
270 }
271}
272
273@RestController
274@RequestMapping("/event")
275public class EventController {
276
277 @Autowired
278 EventService eventService;
279
280 @Autowired
281 DateExceptionRepository dateExceptionRepository;
282
283 @RequestMapping(value = "/{id}", method = RequestMethod.GET)
284 public ResponseEntity<?> getEvent(@PathVariable("id") Long eventId) {
285 Event event = eventService.getEventById(eventId);
286 if (event == null) {
287 return getErrorResponseBody(ApplicationErrorTypes.EVENT_ID_NOT_FOUND);
288 }
289 return new ResponseEntity<>(convert(event), HttpStatus.OK);
290 }
291
292 @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
293 public ResponseEntity<?> deleteEvent(@PathVariable("id") Long eventId) {
294 Event event = eventService.getEventById(eventId);
295 if (event == null) {
296 return getErrorResponseBody(ApplicationErrorTypes.EVENT_ID_NOT_FOUND);
297 }
298 eventService.deleteEventById(eventId);
299 return new ResponseEntity<>(null, HttpStatus.OK);
300 }
301
302 @RequestMapping(value = "/create", method = RequestMethod.PUT)
303 public ResponseEntity<?> createEvent(@RequestBody EventDTO eventDTO) {
304 LocalDateTime startEventDate = eventDTO.getEventStartDate() == null ? null : eventDTO.getEventStartDate().getLocalDateData();
305 LocalDateTime endEventDate = eventDTO.getEventEndDate() == null ? null : eventDTO.getEventEndDate().getLocalDateData();
306 Event event = eventService.createEvent(eventDTO.getEventType(), eventDTO.getEventLocation(), startEventDate,
307 endEventDate, eventDTO.getEventTime(), eventDTO.getEventCost(), eventDTO.getEventLink());
308 return new ResponseEntity<>(convert(event), HttpStatus.OK);
309 }
310
311 @RequestMapping(value = "/{id}/addException", method = RequestMethod.POST)
312 public ResponseEntity<?> addExceptionToEvent(@PathVariable("id") Long eventId, @RequestBody DateExceptionDTO dateExceptionDTO) {
313 Event event = eventService.getEventById(eventId);
314 if (event == null) {
315 return getErrorResponseBody(ApplicationErrorTypes.EVENT_ID_NOT_FOUND);
316 }
317 LocalDateTime eventDateEx = dateExceptionDTO.getEventDateEx() == null ? null : dateExceptionDTO.getEventDateEx().getLocalDateData();
318 event = eventService.addExceptionToEvent(event, eventDateEx);
319 return new ResponseEntity<>(convert(event), HttpStatus.OK);
320 }
321
322 @RequestMapping(value = "/findAllPagination", method = RequestMethod.GET)
323 public ResponseEntity<?> getAllEventsPagination(@RequestParam("page") Long page, @RequestParam("pageSize") Long pageSize) {
324 Page<Event> events = eventService.findAllEvents(new PageRequest(page.intValue(), pageSize.intValue(), new Sort(Sort.Direction.ASC, "id")));
325 List<Event> resultListOfEvents = events.getContent();
326 if (resultListOfEvents.size() == 0) {
327 return getErrorResponseBody(ApplicationErrorTypes.EVENTS_LIST_IS_EMPTY_OR_PAGE_NOT_EXIST);
328 }
329 return new ResponseEntity<>(convert(resultListOfEvents), HttpStatus.OK);
330 }
331
332 private EventDTO convert(Event model) {
333 return (model == null) ? null : new EventDTO(model);
334 }
335
336 private EventListDTO convert(List<Event> dbModel) {
337 return (dbModel == null) ? null : new EventListDTO(dbModel);
338 }
339
340 private ResponseEntity<ErrorResponseBody> getErrorResponseBody(ApplicationErrorTypes errorType) {
341 return new ResponseEntity<>(new ErrorResponseBody(errorType), HttpStatus.NOT_FOUND);
342 }
343}