Advertisement
Guest User

Untitled

a guest
Jun 16th, 2019
482
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.87 KB | None | 0 0
  1. package postgre
  2.  
  3. import (
  4. "errors"
  5. "github.com/isa-mrs-tim6/Projekat/pkg/models"
  6. "strconv"
  7. "time"
  8. )
  9.  
  10. func (db *Store) GetReservationRewards() ([]models.ReservationReward, error) {
  11. var retVal []models.ReservationReward
  12. if err := db.Set("gorm:auto_preload", true).Find(&retVal).Error; err != nil {
  13. return retVal, err
  14. }
  15. return retVal, nil
  16. }
  17.  
  18. func (db *Store) UpdateReservationRewards(rewards []models.ReservationReward) {
  19. db.Delete(models.ReservationReward{})
  20. for _, v := range rewards {
  21. db.Create(v)
  22. }
  23. }
  24.  
  25. func (db *Store) GetReservation(reservationID uint) (models.Reservation, error) {
  26. var retVal models.Reservation
  27. if err := db.First(&retVal, "id = ?", reservationID).Error; err != nil {
  28. return retVal, err
  29. }
  30. return retVal, nil
  31. }
  32.  
  33. func (db *Store) GetReservationGraphData(id uint) ([]models.ReservationGraphData, error) {
  34. var retVal []models.ReservationGraphData
  35. if err := db.Table("flight_reservations").Select("flight_reservations.id, flight_reservations.price, flights.departure").
  36. Joins("JOIN flights ON flights.id = flight_reservations.flight_id").Where("flights.airline_id = ?", id).Scan(&retVal).
  37. Error; err != nil {
  38. return nil, err
  39. }
  40. return retVal, nil
  41. }
  42. func (db *Store) GetUserReservations(id uint) ([]models.ReservationDAO, error) {
  43. var reservations []models.ReservationDAO
  44. var masters []models.Reservation
  45. var slaves []models.Reservation
  46.  
  47. if err := db.Order("created_at desc").
  48. Where("user_id = ?", id).
  49. Preload("ReservationFlight.Flight.Origin").
  50. Preload("ReservationFlight.Flight.Destination").
  51. Preload("ReservationFlight.Flight.Layovers").
  52. Preload("ReservationFlight.Seat").
  53. Preload("ReservationFlight.Features").
  54. Preload("ReservationHotel.Rooms").
  55. Preload("ReservationHotel.Ratings").
  56. Preload("ReservationHotel.Features").
  57. Preload("ReservationHotel.Hotel").
  58. Preload("ReservationRentACar.RentACarCompany").
  59. Preload("ReservationRentACar.Vehicle").
  60. Find(&masters).Error; err != nil {
  61. return nil, err
  62. }
  63.  
  64. for _, res := range masters {
  65. db.Where("master_ref = ?", res.ID).
  66. Preload("ReservationFlight.Flight.Origin").
  67. Preload("ReservationFlight.Flight.Destination").
  68. Preload("ReservationFlight.Flight.Layovers").
  69. Preload("ReservationFlight.Seat").
  70. Preload("ReservationFlight.Features").
  71. Preload("ReservationHotel.Rooms").
  72. Preload("ReservationHotel.Ratings").
  73. Preload("ReservationHotel.Features").
  74. Preload("ReservationHotel.Hotel").
  75. Preload("ReservationRentACar.RentACarCompany").
  76. Preload("ReservationRentACar.Vehicle").
  77. Find(&slaves)
  78. reservations = append(reservations, models.ReservationDAO{Master: res, Slaves: slaves})
  79. }
  80.  
  81. return reservations, nil
  82. }
  83.  
  84. func (db *Store) ReserveVehicle(masterRef uint, params models.VehicleReservationParams, userID uint) error {
  85. var reservation models.RentACarReservation
  86. var vehicle models.Vehicle
  87. var location models.Location
  88.  
  89. tx := db.Begin()
  90.  
  91. reservation.CompanyID = params.CompanyID
  92.  
  93. if err := tx.Raw("SELECT * FROM vehicles WHERE id = ? FOR UPDATE", params.VehicleID).Scan(&vehicle).Error; err != nil {
  94. tx.Rollback()
  95. return err
  96. }
  97.  
  98. if err := tx.Where("id=?", params.LocationID).First(&location).Error; err != nil {
  99. tx.Rollback()
  100. return err
  101. }
  102.  
  103. reservation.Vehicle = vehicle
  104. reservation.Price = db.CalculatePriceVehicle(userID, params.Price)
  105. reservation.Location = location.Address.Address
  106.  
  107. start, _ := strconv.ParseInt(params.StartDate, 10, 64)
  108. end, _ := strconv.ParseInt(params.EndDate, 10, 64)
  109.  
  110. startDate := time.Unix(0, start*int64(time.Millisecond))
  111. endDate := time.Unix(0, end*int64(time.Millisecond))
  112.  
  113. reservation.Occupation.Beginning = startDate
  114. reservation.Occupation.End = endDate
  115.  
  116. // Grab master reservation
  117. var masterReservation models.Reservation
  118.  
  119. if err := tx.First(&masterReservation, masterRef).Error; err != nil {
  120. tx.Rollback()
  121. return err
  122. }
  123.  
  124. var racReservations []models.RentACarReservation
  125. if err := tx.Where("vehicle_id = ?", vehicle.ID).Find(&racReservations).Error; err != nil {
  126. tx.Rollback()
  127. return err
  128. }
  129. for _, res := range racReservations {
  130. if !(res.Occupation.Beginning.After(endDate) ||
  131. res.Occupation.End.Before(startDate)) {
  132. tx.Rollback()
  133. return errors.New("vehicle taken")
  134. }
  135. }
  136.  
  137. masterReservation.ReservationRentACar = reservation
  138. masterReservation.ReservationRentACarID = reservation.ID
  139.  
  140. if err := tx.Save(&masterReservation).Error; err != nil {
  141. tx.Rollback()
  142. return err
  143. }
  144.  
  145. // Get all associated reservations
  146. var reservations []models.Reservation
  147. if err := tx.Where("master_ref = ?", masterRef).Find(&reservations).Error; err != nil {
  148. tx.Rollback()
  149. return err
  150. }
  151.  
  152. for _, associatedReservation := range reservations {
  153. reservation := models.RentACarReservation{
  154. CompanyID: params.CompanyID,
  155. Vehicle: vehicle,
  156. Price: db.CalculatePriceVehicle(userID, params.Price),
  157. Location: location.Address.Address,
  158. Occupation: models.Occupation{
  159. Beginning: startDate,
  160. End: endDate,
  161. },
  162. }
  163. associatedReservation.ReservationRentACar = reservation
  164. associatedReservation.ReservationRentACarID = reservation.ID
  165. if err := tx.Save(&associatedReservation).Error; err != nil {
  166. tx.Rollback()
  167. return err
  168. }
  169. }
  170.  
  171. tx.Commit()
  172.  
  173. return nil
  174. }
  175.  
  176. func (db *Store) CalculatePriceVehicle(userID uint, originalPrice float64) float64 {
  177. price := float64(0.0)
  178.  
  179. var numOfReservations uint
  180. var reward models.ReservationReward
  181. db.Table("reservations").Where("user_id = ?", userID).Count(&numOfReservations)
  182. db.First(&reward, "required_number < ?", numOfReservations)
  183. if reward.PriceScale != 0 {
  184. price *= reward.PriceScale
  185. }
  186. return price
  187. }
  188.  
  189. func (db *Store) ReserveFlight(flightID uint64, params models.FlightReservationParams) (uint, error) {
  190. // Check parameters
  191.  
  192. tx := db.Begin()
  193.  
  194. if params.Users == nil || params.Seats == nil || len(params.Users) != len(params.Seats) || len(params.Users) == 0 {
  195. return 0, errors.New("invalid parameters")
  196. }
  197.  
  198. var seat models.Seat
  199.  
  200. if err := tx.Raw("SELECT * FROM seats WHERE id = ? FOR UPDATE", params.Seats[0].ID).Scan(&seat).Error; err != nil {
  201. tx.Rollback()
  202. return 0, err
  203. }
  204.  
  205. if seat.ReservationID != 0 {
  206. tx.Rollback()
  207. return 0, errors.New("seat taken")
  208. }
  209.  
  210. // Create master reservation, { Users[0], Seats[0] } combination
  211. masterReservation := models.Reservation{
  212. Passenger: models.Passenger{
  213. UserID: params.Users[0].ID,
  214. UserInfo: params.Users[0].UserInfo,
  215. },
  216. ReservationFlight: models.FlightReservation{
  217. Seat: &params.Seats[0],
  218. FlightID: uint(flightID),
  219. FlightRating: 0,
  220. CompanyRating: 0,
  221. IsQuickReserve: params.IsQuickReserve,
  222. Price: db.CalculatePriceFlight(uint(flightID), params.Seats[0].ID, params.Users[0].ID, nil, params.IsQuickReserve), // TODO Add support for features
  223. Features: nil, // TODO Add support for features
  224. },
  225. }
  226.  
  227. if err := tx.Create(&masterReservation).Error; err != nil {
  228. tx.Rollback()
  229. return 0, err
  230. }
  231.  
  232. for i := 1; i < len(params.Users); i++ {
  233. var friend models.User
  234. if params.Users[i].Email != "" { // Registered user
  235. tx.Where("email = ?", params.Users[i].Email).First(&friend)
  236. params.Users[i].ID = friend.ID
  237. params.Users[i].Name = friend.Name
  238. params.Users[i].Surname = friend.Surname
  239. params.Users[i].Passport = friend.Passport
  240. }
  241.  
  242. if err := tx.Raw("SELECT * FROM seats WHERE id = ? FOR UPDATE", params.Seats[i].ID).Scan(&seat).Error; err != nil {
  243. tx.Rollback()
  244. return 0, err
  245. }
  246.  
  247. if seat.ReservationID != 0 {
  248. tx.Rollback()
  249. return 0, errors.New("seat taken")
  250. }
  251.  
  252. reservation := models.Reservation{
  253. Passenger: models.Passenger{
  254. UserID: params.Users[i].ID,
  255. UserInfo: params.Users[i].UserInfo,
  256. },
  257. ReservationFlight: models.FlightReservation{
  258. Seat: &params.Seats[i],
  259. FlightID: uint(flightID),
  260. FlightRating: 0,
  261. CompanyRating: 0,
  262. IsQuickReserve: params.IsQuickReserve,
  263. Price: db.CalculatePriceFlight(uint(flightID), params.Seats[i].ID, params.Users[i].ID, nil, params.IsQuickReserve), // TODO Add support for features
  264. Features: nil, // TODO Add support for features
  265. },
  266. MasterRef: masterReservation.ID,
  267. }
  268. if err := tx.Create(&reservation).Error; err != nil {
  269. tx.Rollback()
  270. return 0, err
  271. }
  272. }
  273.  
  274. if err := tx.Commit().Error; err != nil {
  275. tx.Rollback()
  276. return 0, err
  277. }
  278.  
  279. return masterReservation.ID, nil
  280. }
  281.  
  282. func (db *Store) CalculatePriceFlight(flightID uint, seatID uint, userID uint, features []models.FeatureAirline, isQuickReserve bool) float64 {
  283. var flightPrices models.PriceList
  284. var seat models.Seat
  285. price := float64(0.0)
  286.  
  287. // Add seat price
  288. db.Table("flights").Select("price_economy, price_business, price_firstclass,"+
  289. "small_suitcase, big_suitcase, quick_reservation_price_scale").Where("id = ?", flightID).Scan(&flightPrices)
  290. db.Table("seats").Select("class").Where("id = ?", seatID).Scan(&seat)
  291. switch seat.Class {
  292. case "ECONOMIC":
  293. price += flightPrices.PriceECONOMY
  294. case "BUSINESS":
  295. price += flightPrices.PriceBUSINESS
  296. case "FIRST":
  297. price += flightPrices.PriceFIRSTCLASS
  298. }
  299. if isQuickReserve {
  300. price *= flightPrices.QuickReservationPriceScale
  301. }
  302.  
  303. // Add prices of features
  304. if features != nil {
  305. for _, feature := range features {
  306. price += feature.Price
  307. }
  308. }
  309.  
  310. // Add discount based on number of reservations
  311. var numOfReservations uint
  312. var reward models.ReservationReward
  313. db.Table("reservations").Where("user_id = ?", userID).Count(&numOfReservations)
  314. db.First(&reward, "required_number < ?", numOfReservations)
  315. if reward.PriceScale != 0 {
  316. price *= reward.PriceScale
  317. }
  318.  
  319. return price
  320. }
  321.  
  322. func (db *Store) ReserveHotel(masterReservationID uint, hotelID uint, userID uint,
  323. params models.HotelReservationParams) (uint, error) {
  324. // Check parameters
  325. if params.Rooms == nil || len(params.Rooms) == 0 {
  326. return 0, errors.New("invalid parameters")
  327. }
  328.  
  329. tx := db.Begin()
  330.  
  331. // Grab master reservation
  332. var masterReservation models.Reservation
  333. if err := tx.First(&masterReservation, masterReservationID).Error; err != nil{
  334. tx.Rollback()
  335. return 0, err
  336. }
  337.  
  338. var hReservations []models.HotelReservation
  339. var ids []uint
  340.  
  341. for _, room := range params.Rooms {
  342. ids = append(ids, room.ID)
  343. }
  344.  
  345. var rooms []models.Room
  346. if err := tx.Raw("SELECT * FROM rooms WHERE id in (?) FOR UPDATE", ids).Scan(&rooms).Error; err != nil{
  347. tx.Rollback()
  348. return 0, err
  349. }
  350.  
  351. if err := tx.Table("hotel_reservations").
  352. Joins("JOIN room_reservations on room_reservations.hotel_reservation_id = hotel_reservations.id").
  353. Where("room_reservations.room_id in (?) AND" +
  354. "(hotel_reservations.beginning BETWEEN ? AND ?) AND (hotel_reservations.end NOT BETWEEN ? AND ?)",
  355. ids ,params.From, params.To, params.From, params.To).
  356. Find(&hReservations).
  357. Error; err != nil{
  358. tx.Rollback()
  359. return 0, err
  360. }
  361.  
  362. if hReservations != nil && len(hReservations) != 0 {
  363. tx.Rollback()
  364. return 0, errors.New("room taken")
  365. }
  366.  
  367. // Create hotel reservation
  368. hotelReservation := models.HotelReservation{
  369. Rooms: params.Rooms,
  370. HotelID: hotelID,
  371. IsQuickReserve: params.IsQuickReserve,
  372. Occupation: models.Occupation{
  373. Beginning: params.From,
  374. End: params.To,
  375. },
  376. Ratings: nil,
  377. Features: params.Features,
  378. Price: db.CalculateHotelReservationPrice(userID, params.Rooms, params.Features, params.IsQuickReserve),
  379. }
  380. masterReservation.ReservationHotelID = hotelReservation.ID
  381. masterReservation.ReservationHotel = hotelReservation
  382. //db.Create(&hotelReservation)
  383. if err := tx.Save(&masterReservation).Error; err != nil{
  384. tx.Rollback()
  385. return 0, err
  386. }
  387.  
  388. // Get all associated reservations
  389. var reservations []models.Reservation
  390. if err := tx.Where("master_ref = ?", masterReservationID).Find(&reservations).Error; err != nil{
  391. tx.Rollback()
  392. return 0, err
  393. }
  394.  
  395. for _, reservation := range reservations {
  396. hotelReservation := models.HotelReservation{
  397. Rooms: params.Rooms,
  398. HotelID: hotelID,
  399. IsQuickReserve: params.IsQuickReserve,
  400. Occupation: models.Occupation{
  401. Beginning: params.From,
  402. End: params.To,
  403. },
  404. Ratings: nil,
  405. Features: params.Features,
  406. Price: db.CalculateHotelReservationPrice(userID, params.Rooms, params.Features, params.IsQuickReserve),
  407. }
  408. reservation.ReservationHotel = hotelReservation
  409. reservation.ReservationHotelID = hotelReservation.ID
  410. //db.Create(&hotelReservation)
  411. if err := tx.Save(&reservation).Error; err != nil{
  412. tx.Rollback()
  413. return 0, err
  414. }
  415. }
  416.  
  417. tx.Commit()
  418. return masterReservation.ID, nil
  419. }
  420.  
  421. func (db *Store) CalculateHotelReservationPrice(userID uint, sent []models.Room, features []*models.Feature,
  422. isQuickReserve bool) float64 {
  423. var foundRooms []models.Room
  424. var foundRoomIds []uint
  425. price := float64(0.0)
  426.  
  427. for _, v := range sent {
  428. foundRoomIds = append(foundRoomIds, v.ID)
  429. }
  430. db.Where(foundRoomIds).Find(&foundRooms)
  431.  
  432. // Add room prices
  433. for _, v := range foundRooms {
  434. price += v.Price
  435. }
  436.  
  437. for _, v := range features {
  438. price += v.Price
  439. }
  440.  
  441. if isQuickReserve {
  442. price *= 0.9
  443. }
  444.  
  445. // Add discount based on number of reservations
  446. var numOfReservations uint
  447. var reward models.ReservationReward
  448. db.Table("reservations").Where("user_id = ?", userID).Count(&numOfReservations)
  449. db.First(&reward, "required_number < ?", numOfReservations)
  450. if reward.PriceScale != 0 {
  451. price *= reward.PriceScale
  452. }
  453.  
  454. return price
  455. }
  456.  
  457. func (db *Store) CancelFlight(resID uint) error {
  458. var master models.Reservation
  459. var slaves []models.Reservation
  460.  
  461. db.Where("id = ?", resID).
  462. Preload("ReservationFlight.Flight.Origin").
  463. Preload("ReservationFlight.Flight.Destination").
  464. Preload("ReservationFlight.Flight.Layovers").
  465. Preload("ReservationFlight.Seat").
  466. Preload("ReservationFlight.Features").
  467. Preload("ReservationHotel.Rooms").
  468. Preload("ReservationHotel.Ratings").
  469. Preload("ReservationHotel.Features").
  470. Preload("ReservationHotel.Hotel").
  471. Preload("ReservationRentACar.RentACarCompany").
  472. Preload("ReservationRentACar.Vehicle").
  473. First(&master)
  474. db.Table("seats").Where("reservation_id = ?", master.ReservationFlight.Seat.ReservationID).
  475. Update("reservation_id", 0)
  476.  
  477. db.Where("id=?", master.ID).Delete(master.ReservationFlight)
  478. db.Where("id=?", master.ID).Delete(master.ReservationHotel)
  479. db.Where("id=?", master.ID).Delete(master.ReservationRentACar)
  480.  
  481. if master.MasterRef != 0 {
  482. db.Delete(&master)
  483. return nil
  484. }
  485.  
  486. db.Where("master_ref = ?", master.ID).
  487. Preload("ReservationFlight.Flight.Origin").
  488. Preload("ReservationFlight.Flight.Destination").
  489. Preload("ReservationFlight.Flight.Layovers").
  490. Preload("ReservationFlight.Seat").
  491. Preload("ReservationFlight.Features").
  492. Preload("ReservationHotel.Rooms").
  493. Preload("ReservationHotel.Ratings").
  494. Preload("ReservationHotel.Features").
  495. Preload("ReservationHotel.Hotel").
  496. Preload("ReservationRentACar.RentACarCompany").
  497. Preload("ReservationRentACar.Vehicle").
  498. Find(&slaves)
  499.  
  500. for _, slave := range slaves {
  501. db.Table("seats").Where("reservation_id = ?", slave.ReservationFlight.Seat.ReservationID).
  502. Update("reservation_id", 0)
  503.  
  504. db.Where("id=?", slave.ID).Delete(slave.ReservationFlight)
  505. db.Where("id=?", slave.ID).Delete(slave.ReservationHotel)
  506. db.Where("id=?", slave.ID).Delete(slave.ReservationRentACar)
  507. db.Delete(slave)
  508. }
  509.  
  510. db.Delete(&master)
  511. return nil
  512. }
  513.  
  514. func (db *Store) CancelHotel(resID uint) error {
  515. var master models.Reservation
  516. var slaves []models.Reservation
  517.  
  518. db.Where("id = ?", resID).
  519. Preload("ReservationFlight.Flight.Origin").
  520. Preload("ReservationFlight.Flight.Destination").
  521. Preload("ReservationFlight.Flight.Layovers").
  522. Preload("ReservationFlight.Seat").
  523. Preload("ReservationFlight.Features").
  524. Preload("ReservationHotel.Rooms").
  525. Preload("ReservationHotel.Ratings").
  526. Preload("ReservationHotel.Features").
  527. Preload("ReservationHotel.Hotel").
  528. Preload("ReservationRentACar.RentACarCompany").
  529. Preload("ReservationRentACar.Vehicle").
  530. First(&master)
  531.  
  532. if master.MasterRef != 0 {
  533. return nil
  534. }
  535.  
  536. db.Table("hotel_reservations").Where("id = ?", master.ReservationHotelID).
  537. Delete(master.ReservationHotel)
  538. db.Table("reservations").Where("id=?", master.ID).
  539. Update("reservation_hotel_id", 0)
  540.  
  541. db.Where("master_ref = ?", master.ID).
  542. Preload("ReservationFlight.Flight.Origin").
  543. Preload("ReservationFlight.Flight.Destination").
  544. Preload("ReservationFlight.Flight.Layovers").
  545. Preload("ReservationFlight.Seat").
  546. Preload("ReservationFlight.Features").
  547. Preload("ReservationHotel.Rooms").
  548. Preload("ReservationHotel.Ratings").
  549. Preload("ReservationHotel.Features").
  550. Preload("ReservationHotel.Hotel").
  551. Preload("ReservationRentACar.RentACarCompany").
  552. Preload("ReservationRentACar.Vehicle").
  553. Find(&slaves)
  554.  
  555. for _, slave := range slaves {
  556. db.Table("hotel_reservations").Where("id = ?", slave.ReservationHotelID).
  557. Delete(slave.ReservationHotel)
  558. db.Table("reservations").Where("id=?", slave.ID).
  559. Update("reservation_hotel_id", 0)
  560. }
  561. return nil
  562. }
  563.  
  564. func (db *Store) CancelVehicle(resID uint) error {
  565. var master models.Reservation
  566. var slaves []models.Reservation
  567.  
  568. db.Where("id = ?", resID).
  569. Preload("ReservationFlight.Flight.Origin").
  570. Preload("ReservationFlight.Flight.Destination").
  571. Preload("ReservationFlight.Flight.Layovers").
  572. Preload("ReservationFlight.Seat").
  573. Preload("ReservationFlight.Features").
  574. Preload("ReservationHotel.Rooms").
  575. Preload("ReservationHotel.Ratings").
  576. Preload("ReservationHotel.Features").
  577. Preload("ReservationHotel.Hotel").
  578. Preload("ReservationRentACar.RentACarCompany").
  579. Preload("ReservationRentACar.Vehicle").
  580. First(&master)
  581.  
  582. if master.MasterRef != 0 {
  583. return nil
  584. }
  585.  
  586. db.Table("rent_a_car_reservations").Where("id=?", master.ReservationRentACarID).
  587. Delete(master.ReservationRentACar)
  588. db.Table("reservations").Where("id=?", master.ID).
  589. Update("reservation_rent_a_car_id", 0)
  590.  
  591. db.Where("master_ref = ?", master.ID).
  592. Preload("ReservationFlight.Flight.Origin").
  593. Preload("ReservationFlight.Flight.Destination").
  594. Preload("ReservationFlight.Flight.Layovers").
  595. Preload("ReservationFlight.Seat").
  596. Preload("ReservationFlight.Features").
  597. Preload("ReservationHotel.Rooms").
  598. Preload("ReservationHotel.Ratings").
  599. Preload("ReservationHotel.Features").
  600. Preload("ReservationHotel.Hotel").
  601. Preload("ReservationRentACar.RentACarCompany").
  602. Preload("ReservationRentACar.Vehicle").
  603. Find(&slaves)
  604.  
  605. for _, slave := range slaves {
  606. db.Table("rent_a_car_reservations").Where("id=?", slave.ReservationRentACarID).
  607. Delete(slave.ReservationRentACar)
  608. db.Table("reservations").Where("id=?", slave.ID).
  609. Update("reservation_rent_a_car_id", 0)
  610. }
  611. return nil
  612. }
  613.  
  614. func (db *Store) GetQuickVehRes(id uint) ([]models.RentACarReservation, error) {
  615. var reservations []models.RentACarReservation
  616.  
  617. if err := db.Where("vehicle_id = ? AND is_quick_reserve = true", id).Find(&reservations).Error; err != nil {
  618. return reservations, err
  619. }
  620.  
  621. return reservations, nil
  622. }
  623.  
  624. func (db *Store) GetCompanyQuickVehicle(params models.VehicleQuickResParams) ([]models.RentACarReservation, error) {
  625. var reservations []models.RentACarReservation
  626. var retVal []models.RentACarReservation
  627. var masters []models.Reservation
  628.  
  629. db.Preload("ReservationRentACar").Find(&masters)
  630.  
  631. start, _ := strconv.ParseInt(params.StartDate, 10, 64)
  632. end, _ := strconv.ParseInt(params.EndDate, 10, 64)
  633.  
  634. startDate := time.Unix(0, start*int64(time.Millisecond))
  635. endDate := time.Unix(0, end*int64(time.Millisecond))
  636.  
  637. if err := db.Preload("Vehicle").
  638. Where("company_id = ? AND is_quick_reserve = true AND beginning = ? AND rent_a_car_reservations.end = ?",
  639. params.CompanyID, startDate, endDate).
  640. Find(&reservations).Error; err != nil {
  641. return retVal, err
  642. }
  643.  
  644. var found bool
  645.  
  646. for _, res := range reservations {
  647. found = false
  648. for _, master := range masters {
  649. if master.ReservationRentACarID == res.ID {
  650. found = true
  651. break
  652. }
  653. }
  654. if !found {
  655. retVal = append(retVal, res)
  656. }
  657. }
  658.  
  659. return retVal, nil
  660. }
  661.  
  662. func (db *Store) CompleteQuickResVehicle(params models.CompleteQuickResVehParams) error {
  663. var master models.Reservation
  664. var slave models.RentACarReservation
  665.  
  666. if err := db.Preload("ReservationRentACar").
  667. Where("id = ?", params.MasterID).First(&master).Error; err != nil {
  668. return err
  669. }
  670. if err := db.Where("id = ?", params.ReservationID).First(&slave).Error; err != nil {
  671. return err
  672. }
  673.  
  674. master.ReservationRentACar = slave
  675. master.ReservationRentACarID = slave.ID
  676.  
  677. if err := db.Save(&master).Error; err != nil {
  678. return err
  679. }
  680. return nil
  681. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement