BookingServiceImpl.java

package com.ichalet.booking.service.impl;

 

import java.security.Principal;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

import org.joda.time.DateTime;

import org.joda.time.Days;

import org.joda.time.LocalDate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.PropertySource;

import org.springframework.core.env.Environment;

import org.springframework.http.HttpEntity;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpMethod;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.security.oauth2.client.OAuth2RestTemplate;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.client.RestTemplate;

 

import com.ichalet.booking.common.utils.CodeGenerator;

import com.ichalet.booking.common.utils.CodeOperations;

import com.ichalet.booking.common.view.ErrorMessages;

import com.ichalet.booking.common.view.ItemOrderRequestTemplate;

import com.ichalet.booking.common.view.OrderCancellationExecutionResponseTemplate;

import com.ichalet.booking.common.view.StartBookingChaletResponse;

import com.ichalet.booking.domain.entity.Booking;

import com.ichalet.booking.domain.entity.ChaletAvailabilityDates;

import com.ichalet.booking.domain.entity.ChaletAvailabilityDatesPK;

import com.ichalet.booking.domain.entity.ChaletDetails;

import com.ichalet.booking.domain.entity.ChaletRestrictions;

import com.ichalet.booking.domain.entity.DiscountCoupons;

import com.ichalet.booking.domain.entity.IndividualUser;

import com.ichalet.booking.domain.entity.LookupAvailabilityStatus;

import com.ichalet.booking.domain.entity.LookupBookingStatus;

import com.ichalet.booking.domain.entity.OrderCancellationExpirationExecution;

import com.ichalet.booking.domain.entity.PaymentDetails;

 

import com.ichalet.booking.domain.entity.ResortDetails;

import com.ichalet.booking.domain.entity.UserAccount;

import com.ichalet.booking.domain.model.ChaletRestrictionsModel;

import com.ichalet.booking.domain.model.LookupBookingStatusTemplate;

import com.ichalet.booking.domain.model.UserOwnerTemplete;

import com.ichalet.booking.domain.model.bookingDetailsTemplete;

import com.ichalet.booking.domain.model.chaletDetailTemplete;

import com.ichalet.booking.domain.model.discountCouponTemplete;

import com.ichalet.booking.domain.model.paymentDetailTemplete;

import com.ichalet.booking.domain.model.resortDetailTemplete;

import com.ichalet.booking.repository.BookRepository;

import com.ichalet.booking.repository.ChaletAvailabilityDateRepository;

import com.ichalet.booking.repository.ChaletDetailRepositroy;

import com.ichalet.booking.repository.ChaletRestrictionRepository;

import com.ichalet.booking.repository.DiscountCouponsRepository;

import com.ichalet.booking.repository.IndividualUserRepository;

import com.ichalet.booking.repository.LookupAvailabilityStatusRepository;

import com.ichalet.booking.repository.LookupBookingStatusRepository;

import com.ichalet.booking.repository.PaymentNeedsConfirmationRepository;

 

import com.ichalet.booking.repository.ResortRepository;

import com.ichalet.booking.repository.ResortSettingsRepository;

import com.ichalet.booking.repository.UserRepository;

import com.ichalet.booking.view.CustomResponseDataIsList;

import com.ichalet.booking.view.JsonResponseBuilder;

import com.ichalet.booking.view.JsonResponseBuilderGenerics;

import lombok.Getter;

 

@Service

@Transactional

@PropertySource(value = "classpath:RestURL.properties")

public class BookingServiceImpl {

 

    @Autowired

    private UserRepository userRepository;

    @Autowired

    private BookRepository bookRepository;

    @Autowired

    private OAuth2RestTemplate oauthRestTemplate;

    @Autowired

    private ChaletRestrictionRepository restriction;

    @Autowired

    private ResortRepository resortRepository;

    @Autowired

    private ChaletDetailRepositroy chaletDetailRepositroy;

    @Autowired

    private LookupBookingStatusRepository lookupBookingStatusRepository;

    private List<ChaletRestrictions> StartBookingChaletResponse;

    @Autowired

    private ChaletAvailabilityDateRepository chaletAvaliabilityDateRepository;

    @Autowired

    private ResortSettingsRepository resortSettingsRepository;

    @Autowired

    private IndividualUserRepository individualUserRepository;

    @Autowired

    private DiscountCouponsRepository discountCouponsRepository;

    @Autowired

    private PaymentNeedsConfirmationRepository paymentNeedsConfirmationRepository;

    @Autowired

    private LookupAvailabilityStatusRepository lookupAvailabilityStatusRepository;

    @Autowired

    private Environment env;

 

    public JsonResponseBuilder startBookingChalet(long chalet_Id, Date bookingDate, Date bookingStartDate,

            long userId) {

 

        ChaletDetails chaletDetails = chaletDetailRepositroy.findOne(chalet_Id);

        ChaletAvailabilityDatesPK avalibalitiyDate = new ChaletAvailabilityDatesPK(chalet_Id, bookingStartDate);

        ChaletAvailabilityDates chaletAvailabilityDate = chaletAvaliabilityDateRepository

                .findByChaletAvailabilityDatesPK(avalibalitiyDate);

        HttpHeaders headers = new HttpHeaders();

        headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));

        // MultiValueMap<String, String> body = new LinkedMultiValueMap<String,

        // String>();

        ItemOrderRequestTemplate request = new ItemOrderRequestTemplate(1L, (byte) 1, bookingDate.getTime(), bookingStartDate.getTime(),

                chaletAvailabilityDate.getPrice(), userId);

        HttpEntity<?> httpEntity = new HttpEntity<Object>(request, headers);

        // ResponseEntity<OrderCancellationExecutionResponseTemplate>

        // cancellationDeductions =

        // oauthRestTemplate.exchange("http://192.168.5.65:8086/generateExpirationExecuationTemplate",

        // HttpMethod.POST, httpEntity,

        // OrderCancellationExecutionResponseTemplate.class);

        RestTemplate rest = new RestTemplate();

        ResponseEntity<OrderCancellationExecutionResponseTemplate> cancellationDeductions = rest.exchange(

                "http://192.168.5.19:8086/generateExpirationExecuationTemplate", HttpMethod.POST, httpEntity,

                OrderCancellationExecutionResponseTemplate.class);

        List<ChaletRestrictions> restrictions = restriction.findByChaletDetails(chaletDetails);

        StartBookingChaletResponse disclaimerdata = new StartBookingChaletResponse();

 

        disclaimerdata.setCancellationDeduction(cancellationDeductions.getBody());

 

        if (restrictions != null) {

            List<ChaletRestrictionsModel> restrictionList = new ArrayList<>();

            for (ChaletRestrictions restrict : restrictions) {

                ChaletRestrictionsModel restriction = new ChaletRestrictionsModel(Long.valueOf(restrict.getChaletRestrictionsPK().getChaletRestrictionId() + ""),

                        restrict.getChaletDetails().getChaletId(),

                        restrict.getLookupChaletRestrictions().getChaletRestrictionId(),

                        restrict.getLookupChaletSubrestrictions().getChaletSubrestrictionId(),

                        restrict.getLookupChaletRestrictions().getChaletrestrictionEn(),

                        restrict.getLookupChaletSubrestrictions().getChaletsubrestrictionEn()

                );

                restrictionList.add(restriction);

            }

            disclaimerdata.setChaletRestrictions(restrictionList);

        }

 

        disclaimerdata.setResortNeedsApproval(resortSettingsRepository

                .findOne(chaletDetails.getResortDetails().getResortId()).

                getIsApprovalRequired());

 

        if (chaletDetails.getCustomRestrictions() != null) {

            disclaimerdata.setRestrictionText(chaletDetails.getCustomRestrictions());

        }

 

        disclaimerdata.setResortRules(resortSettingsRepository

                .findOne(chaletDetails.getResortDetails().getResortId()).getPolicyUrl());

        JsonResponseBuilder response = new JsonResponseBuilder();

        response.setStatus(ErrorMessages.statusSuccess);

        response.setErrorCode("booking.start-bookikng.success");

        response.setMessage(ErrorMessages.successMessage);

        response.add("disclaimerdata", disclaimerdata);

        return response;

    }

 

    public JsonResponseBuilder bookChalet(int resortId, long chaletId, long userIdTenant,

            Date bookingFromDate, Date bookingToDate, int numberOfNights, double totalPriceBeforeDiscount,

            List<OrderCancellationExpirationExecution> orderCancellationExpirationExecution) {

 

        JsonResponseBuilder response = new JsonResponseBuilder();

 

        int LocalNumberofNights = Days.daysBetween(new LocalDate(bookingFromDate), new LocalDate(bookingToDate))

                .getDays();

 

        double totalPrice = 0.00;

        for (int i = 0; i < LocalNumberofNights; i++) {

            DateTime dateTime = new DateTime(bookingFromDate);

            dateTime = dateTime.plusDays(i);

            ChaletAvailabilityDatesPK avalibalitiyDate = new ChaletAvailabilityDatesPK(chaletId, dateTime.toDate());

            ChaletAvailabilityDates chaletAvailabilityDate = chaletAvaliabilityDateRepository

                    .findByChaletAvailabilityDatesPK(avalibalitiyDate);

 

            if (chaletAvailabilityDate.getLookupAvailabilityStatus().getAvailabilityStatusId() != 2) {

                response.setStatus(ErrorMessages.statusErrorMessage);

                response.setErrorCode("booking.error.not-availabile");

                response.setMessage(ErrorMessages.chaletAvalilabiltyErrorMessage);

                return response;

 

            } else {

                totalPrice = totalPrice + chaletAvailabilityDate.getPrice();

            }

        }

 

        if (totalPrice != totalPriceBeforeDiscount || LocalNumberofNights != numberOfNights) {

 

            response.setStatus(ErrorMessages.statusErrorMessage);

            response.setErrorCode("booking.error.TotalPrice-or-Nights");

            response.setMessage(ErrorMessages.chaletPriceErrorMessage);

            return response;

        }

 

        for (int i = 0; i < LocalNumberofNights; i++) {

            DateTime dateTime = new DateTime(bookingFromDate);

            dateTime = dateTime.plusDays(i);

            ChaletAvailabilityDatesPK avalibalitiyDate = new ChaletAvailabilityDatesPK(chaletId, dateTime.toDate());

 

            ChaletAvailabilityDates chaletAvailabilityDate = chaletAvaliabilityDateRepository

                    .findByChaletAvailabilityDatesPK(avalibalitiyDate);

            LookupAvailabilityStatus stauts = lookupAvailabilityStatusRepository.findOne((short) 4);

            chaletAvailabilityDate.setLookupAvailabilityStatus(stauts);

            chaletAvaliabilityDateRepository.save(chaletAvailabilityDate);

        }

 

        Booking booking = new Booking();

        // ResortDetails resort= resortRepository.findOne(resortId);

        if (resortSettingsRepository.findOne(resortId).getIsApprovalRequired() == true) {

 

            booking.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 1));

            Calendar cal = Calendar.getInstance(); // creates calendar

            cal.setTime(new Date()); // sets calendar time/date

            cal.add(Calendar.HOUR_OF_DAY, lookupBookingStatusRepository.findOne((short) 1).getPendingHours());

            booking.setExpiryDateTimeBeforeConfirmation(cal.getTime());

        } else {

            booking.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 4));

            Calendar cal = Calendar.getInstance(); // creates calendar

            cal.setTime(new Date()); // sets calendar time/date

            cal.add(Calendar.HOUR_OF_DAY, lookupBookingStatusRepository.findOne((short) 4).getPendingHours()); // adds

            // //

            // hour

 

            booking.setExpiryDateTimeBeforeConfirmation(cal.getTime());

        }

        booking.setStatusDateTime(new Date());

        booking.setResortId(resortId);

        booking.setChaletDetails(chaletDetailRepositroy.findOne(chaletId));

        booking.setBookingDateTime(new Date());

        booking.setBookingCode("waitingid");

        booking.setBookingFromDate(bookingFromDate);

        booking.setBookingToDate(bookingToDate);

        IndividualUser iuser = individualUserRepository.findOne(userIdTenant);

        booking.setIndividualUser(iuser);

 

        bookRepository.save(booking);

        booking.setBookingCode(CodeGenerator.encrypt(booking.getBookingId().toString(), CodeOperations.Booking_Chalet));

        bookRepository.saveAndFlush(booking);

 

        for (OrderCancellationExpirationExecution o : orderCancellationExpirationExecution) {

            o.setBookingId(booking.getBookingId());

        }

 

        HttpHeaders headers = new HttpHeaders();

        headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));

        HttpEntity<?> httpEntity = new HttpEntity<Object>(orderCancellationExpirationExecution, headers);

        RestTemplate rest = new RestTemplate();

        ResponseEntity<List> cancellationDeductions = rest.exchange("http://192.168.5.19:8086/saveExpirationExecuation",

                HttpMethod.POST, httpEntity, List.class);

        response.setErrorCode("success");

        response.setMessage(ErrorMessages.successMessage);

        response.setStatus(ErrorMessages.statusSuccess);

        response.setNotificationsCount(0);

        response.setPointsAmount(0);

        response.setPointsCount(0);

        short statuss = booking.getLookupBookingStatus().getBookingStatusId();

        LookupBookingStatus bookingStatus = lookupBookingStatusRepository.findOne(statuss);

        LookupBookingStatusTemplate statusTemp = new LookupBookingStatusTemplate(bookingStatus);

        long bookingID = booking.getBookingId();

        String bookingCode = booking.getBookingCode();

        response.add("bookingStatus", statusTemp);

        response.add("bookingID", bookingID);

        response.add("bookingCode", bookingCode);

        return response;

 

    }

 

    //2.4

    public JsonResponseBuilder RejectChaletBooking(long bookingID, Principal principal) {

        JsonResponseBuilder responseBuilder = new JsonResponseBuilder();

        UserAccount user = userRepository.findByEmailAddress(principal.getName());

        //3=it mean user is resort only has privilage

        if (user.getLookupUserTypes().getUserTypeId() == 3) {

            Booking booking = bookRepository.findOne(bookingID);

            if (booking == null) {//if booking not found in DB

                responseBuilder.setStatus(ErrorMessages.statusError + "");

                responseBuilder.setMessage(ErrorMessages.chaletNotRegisterdMessage);

                return responseBuilder;

            }

            //3 = mean 'Resort Approval Request Rejectes'

            booking.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 3));

            booking.setExpiryDateTimeBeforeConfirmation(null);

            booking.setBookingToDate(null);

            bookRepository.saveAndFlush(booking);

            responseBuilder.setStatus(ErrorMessages.statusSuccess);

        } else {

            responseBuilder.setStatus(ErrorMessages.statusError + "");

            responseBuilder.setMessage("Invalid User Privilage Not Resort Admin");

        }

        return responseBuilder;

    }

 

    //2.5

    public JsonResponseBuilder AssignDiscountCoupon(long bookID, String bookCode, long discountCouponID, String couponCode, Principal principal) {

        Double TotalPriceAfterDiscount = null;

        Booking booking = null;

        DiscountCoupons discountCoupon = null;

 

        if (bookID != -1) {

            booking = bookRepository.findOne(bookID);

        } else {

            booking = bookRepository.findByBookingCode(bookCode);

        }

 

        if (discountCouponID != -1) {

            discountCoupon = discountCouponsRepository.findOne(discountCouponID);

        } else {

            discountCoupon = discountCouponsRepository.findByCouponCode(couponCode);

        }

 

        //validate discount coupon

        HttpHeaders headers = new HttpHeaders();

        headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));

 

        Map requestBody = new HashMap();//request Body Data

        requestBody.put("discountCode", discountCoupon.getCouponCode());

        requestBody.put("targetUserID", 1/*discountCoupon.getUser().getUserId()*/);

        requestBody.put("targetEntityID", discountCoupon.getTargetEntityId());

        requestBody.put("bookingId", booking.getBookingId());

 

        HttpEntity<?> httpEntity = new HttpEntity<>(requestBody, headers);

 

        //call Kero to check if this discount coupon is valid or not

        ResponseEntity<?> responseEntity = oauthRestTemplate.exchange(env.getProperty("useDiscountCoupon.url"), HttpMethod.POST, httpEntity, Map.class);

        Map body = (Map) responseEntity.getBody();

        JsonResponseBuilder jrb = new JsonResponseBuilder();//prepare to response

        if (!body.get("status").equals("0")) {// status 0 is this discount coupon INVALID

            if (discountCoupon.getDiscountValue() != null) {

                if (discountCoupon.getDiscountValue() > 0.0) { //do process

                    TotalPriceAfterDiscount = booking.getTotalPayment() - discountCoupon.getDiscountValue();

                }

            }

            if (discountCoupon.getDicountPercentage() != null) {

                if (discountCoupon.getDicountPercentage() > 0.0) { //do process

                    double discountval = (booking.getTotalPayment() * discountCoupon.getDicountPercentage()) / 100;

                    TotalPriceAfterDiscount = booking.getTotalPayment() - discountval;

                }

            }

            booking.setTotalPriceAfterDiscount(TotalPriceAfterDiscount);

            booking.setDiscountCoupons(discountCoupon);

            discountCoupon.setBooking(booking);

           

            discountCouponsRepository.saveAndFlush(discountCoupon);

            bookRepository.saveAndFlush(booking);

 

            jrb.setStatus(ErrorMessages.statusSuccess);

            jrb.setMessage(ErrorMessages.successMessage);

            jrb.add("totalPriceAfterDiscount", booking.getTotalPriceAfterDiscount());

        }//end if discount Coupon Is Valid or Not

        else {

            jrb.setMessage(body.get("message").toString());

            jrb.setStatus(body.get("status").toString());

        }

        return jrb;

    }

 

    public JsonResponseBuilder UnassignDiscountCoupon(Principal principal, long bookID, String bookCode) {

 

        Double TotalPriceBeforeDiscount = null;

        Booking booking = null;

 

        JsonResponseBuilder jrb = new JsonResponseBuilder();

        UserAccount userLogin = userRepository.findByEmailAddress(principal.getName());

 

        if (bookID != -1) {

            booking = bookRepository.findOne(bookID);

        } else {

            booking = bookRepository.findByBookingCode(bookCode);

        }

        //call Release Discount Coupon First before relase discount from booking vise verse

        //configure header

        HttpHeaders httpHeaders = new HttpHeaders();

        httpHeaders.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));

 

        //configure body Request

        Map<String, Object> bodyRequest = new HashMap<>();

        bodyRequest.put("discountId", booking.getDiscountCoupons().getCouponId());

 

        //merger header and body

        HttpEntity<?> httpEntity = new HttpEntity<>(bodyRequest, httpHeaders);

 

        Object STATUS = oauthRestTemplate.exchange(env.getProperty("releaseDiscountCoupon.url"), HttpMethod.POST, httpEntity, Map.class).getBody().get("status");

        if (STATUS.equals("1")) //sucess ONLY //it may confused by calling API from relase first as discount coupon has no booking id value so

        {

            if (userLogin.getUserId() == booking.getIndividualUser().getUserId()) {

                if (booking.getDiscountCoupons().getDiscountValue() != null) {

                    if (booking.getDiscountCoupons().getDiscountValue() > 0.0) { //do process

                        TotalPriceBeforeDiscount = booking.getTotalPriceAfterDiscount() + booking.getDiscountCoupons().getDiscountValue();

                        jrb.setStatus(ErrorMessages.statusSuccess);

                    }

                }

                if (booking.getDiscountCoupons().getDicountPercentage() != null) {

                    if (booking.getDiscountCoupons().getDicountPercentage() > 0.0) {

                        TotalPriceBeforeDiscount = booking.getTotalPriceAfterDiscount() + ((booking.getTotalPriceBeforeDiscount() * booking.getDiscountCoupons().getDicountPercentage()) / 100);

                        jrb.setStatus(ErrorMessages.statusSuccess);

                    }

                }

                booking.setTotalPriceBeforeDiscount(TotalPriceBeforeDiscount);

                booking.setTotalPriceAfterDiscount(null);

                booking.setDiscountCoupons(null);

                bookRepository.saveAndFlush(booking);

            }//condition if user has booking

        }

        return jrb;

    }

 

    //2.21

    public JsonResponseBuilderGenerics<?> GetMyChaletBookingDetails(long bookingID, String bookCode, Principal principal) {

        Booking bookingDB = null;

        if (bookingID != -1) {

            bookingDB = bookRepository.findOne(bookingID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

        //class generated to merge all templete in one json

        @Getter

        class ListMyChaletBookingWrapper {

 

            bookingDetailsTemplete bookDetailsTemplete;

            chaletDetailTemplete ChaletdetailTemplete;

            discountCouponTemplete couponTemplete;

            List paymentDetailTemplete;

            resortDetailTemplete resortDetailTemplete;

            List userBeneficiaries;

            UserOwnerTemplete UserOwnerTemplete;

            UserOwnerTemplete bookingUser;

 

            private ListMyChaletBookingWrapper(Booking Book, ChaletDetails chaletDetails, DiscountCoupons discountCoupons, ResortDetails resortDetail, List userBeneficiaries, UserAccount chaletOwner, UserAccount bookingUser, Set<PaymentDetails> paymentDetailTempletE) {

                bookDetailsTemplete = new bookingDetailsTemplete(Book);//booking item info detail

                ChaletdetailTemplete = new chaletDetailTemplete(chaletDetails);//chalet detail

                couponTemplete = new discountCouponTemplete(discountCoupons); //discount Coupon Item

                resortDetailTemplete = new resortDetailTemplete(resortDetail);

                this.userBeneficiaries = userBeneficiaries;

                UserOwnerTemplete = new UserOwnerTemplete(chaletOwner);

                this.bookingUser = new UserOwnerTemplete(bookingUser);

                paymentDetailTemplete = new ArrayList<>();

                for (PaymentDetails dt : paymentDetailTempletE) {

                    paymentDetailTemplete dt1 = new paymentDetailTemplete(dt);

                    paymentDetailTemplete.add(dt1);

                }

            }

        }

 

        ListMyChaletBookingWrapper bookingWrapper = null;

        //list to add benefi users per chalet id

        List benefi = new ArrayList<>();

        bookingDB.getChaletDetails().getIndividualUserSet().forEach((iu) -> {

            UserOwnerTemplete ownerTemplete = new UserOwnerTemplete(userRepository.findOne(iu.getUserId()));

            benefi.add(ownerTemplete);

        });

        //UserAccount userLogin = userRepository.findByEmailAddress(principal.getName());

        // if (userLogin.getUserId() == bookingDB.getIndividualUser().getUserId()) {

        bookingWrapper = new ListMyChaletBookingWrapper(bookingDB, bookingDB.getChaletDetails(), bookingDB.getDiscountCoupons(), bookingDB.getChaletDetails().getResortDetails(), benefi, userRepository.findOne(bookingDB.getChaletDetails().getIndividualUser().getUserId()), userRepository.findOne(bookingDB.getIndividualUser().getUserId()), bookingDB.getLookupPaymentMethods().getPaymentDetailsSet());

        // }//END if for users

        //prepare to response

        JsonResponseBuilderGenerics<ListMyChaletBookingWrapper> builderGenerics = new JsonResponseBuilderGenerics();

        builderGenerics.setData(bookingWrapper);

        builderGenerics.setStatus(ErrorMessages.statusSuccess);

        return builderGenerics;

    }

 

    //2.20

    public JsonResponseBuilderGenerics<?> GetChaletBookingMiniDetails(long bookingID, String bookCode, Principal principal) {

        @Getter

        class ListMyChaletBookingWrapper {

 

            bookingDetailsTemplete bookDetailsTemplete;

            chaletDetailTemplete ChaletdetailTemplete;

 

            private ListMyChaletBookingWrapper(Booking Book, ChaletDetails chaletDetails) {

                bookDetailsTemplete = new bookingDetailsTemplete(Book);//booking item info detail

                ChaletdetailTemplete = new chaletDetailTemplete(chaletDetails);//chalet detail

            }

        }

 

        Booking bookingDB = null;

        if (bookingID != -1) {

            bookingDB = bookRepository.findOne(bookingID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

        ListMyChaletBookingWrapper detailsTemplete = new ListMyChaletBookingWrapper(bookingDB, bookingDB.getChaletDetails());

        JsonResponseBuilderGenerics<ListMyChaletBookingWrapper> builderGenerics = new JsonResponseBuilderGenerics();

        builderGenerics.setData(detailsTemplete);

        builderGenerics.setStatus(ErrorMessages.statusSuccess);

        return builderGenerics;

    }

 

    //2.19

    public CustomResponseDataIsList ListMyChaletBooking(String emailAddress) {

        @Getter

        class ListMyChaletBookingWrapper {

 

            bookingDetailsTemplete bookDetailsTemplete;

            chaletDetailTemplete ChaletdetailTemplete;

            discountCouponTemplete couponTemplete;

 

            private ListMyChaletBookingWrapper(Booking Book, ChaletDetails chaletDetails, DiscountCoupons discountCoupons) {

                bookDetailsTemplete = new bookingDetailsTemplete(Book);//booking item info detail

                ChaletdetailTemplete = new chaletDetailTemplete(chaletDetails);//chalet detail

                couponTemplete = new discountCouponTemplete(discountCoupons); //discount Coupon Item

            }

 

        }

 

        CustomResponseDataIsList<ListMyChaletBookingWrapper> responseBuilder = new CustomResponseDataIsList();

        IndividualUser iu = new IndividualUser(userRepository.findByEmailAddress(emailAddress).getUserId());

        bookRepository.findByIndividualUserOrderByBookingFromDateAsc(iu).forEach((Book) -> {

            ListMyChaletBookingWrapper listMyChaletBookingClass = new ListMyChaletBookingWrapper(Book, Book.getChaletDetails(), Book.getDiscountCoupons());

            responseBuilder.getData().add(listMyChaletBookingClass);

        });

        responseBuilder.setStatus(ErrorMessages.statusSuccess);

        return responseBuilder;

    }

 

    //2.15      Check-in At Resort Gate

    public JsonResponseBuilder CheckInAtResortGate(Principal principal, long BookingID, String bookCode) {

        JsonResponseBuilder jrb = new JsonResponseBuilder();

 

        Booking bookingDB = null;

 

        if (BookingID != -1) {

            bookingDB = bookRepository.findOne(BookingID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

        UserAccount userLogin = userRepository.findByEmailAddress(principal.getName());

        //3=it mean user is resort only has privilage

        if (userLogin.getLookupUserTypes().getUserTypeId() == 3

                && (bookingDB.getLookupBookingStatus().getBookingStatusId() == 11// Booking Confirmed

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 12//Booking Confirmed & Protected

                )) {

            //Booking Status should updated to “Checked-in at Gate”

            bookingDB.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 15));

            bookingDB.setStatusDateTime(new Date());

            bookingDB.setCheckinDateTime(new Date());

            bookRepository.saveAndFlush(bookingDB);

            jrb.setStatus(ErrorMessages.statusSuccess);

        } else {

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("NO Check-In At Resort Gate");

        }

        return jrb;

    }

 

    //2.13      Delete My Booking

    public JsonResponseBuilder DeleteMyBooking(long bookID, String bookCode, Principal pricipal) {

        JsonResponseBuilder jrb = new JsonResponseBuilder();

 

        Booking bookingDB = null;

        if (bookID != -1) {

            bookingDB = bookRepository.findOne(bookID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

 

        UserAccount userLogin = userRepository.findByEmailAddress(pricipal.getName());

        // Users who have Bookings

        if (userLogin.getUserId() == bookingDB.getIndividualUser().getUserId()

                && (bookingDB.getLookupBookingStatus().getBookingStatusId() == 2//No Approval Response from Resort

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 3//Resort Approval Request Rejected

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 5//Booking Cancelled by Property Owner

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 9//Booking Ignored by Tenant

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 10//Booking Expired

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 14//Booking Cancelled by Tenant

                )) {

            bookingDB.setIsDeleted(true);

            bookRepository.saveAndFlush(bookingDB);

            jrb.setStatus(ErrorMessages.statusSuccess);

        } else {

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Chalet Booking Not Deleted");

        }

        return jrb;

    }

 

    // 2.10     Protect Chalet Booking

    public JsonResponseBuilder ProtectChaletBooking(long bookID, String bookCode, Principal pricipal) {

        JsonResponseBuilder jrb = new JsonResponseBuilder();

 

        Booking bookingDB = null;

        if (bookID != -1) {

            bookingDB = bookRepository.findOne(bookID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

        if (bookingDB == null) {//if no booking available in DB

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("booking Not Exist");

            return jrb;

        }

 

        UserAccount userLogin = userRepository.findByEmailAddress(pricipal.getName());

        // Users who have Bookings And Payment Statisfied AND IDENTIFIED  

        if (userLogin.getUserId() == bookingDB.getIndividualUser().getUserId() && userLogin.getIndividualUser().getIsIdentified()) {

//            TO proteced it must Total Payment = Total Price After Discount Value if has discount Id OR vise verse

            if ((bookingDB.getDiscountCoupons() != null && bookingDB.getTotalPayment() == bookingDB.getTotalPriceAfterDiscount()) || (bookingDB.getDiscountCoupons() == null && bookingDB.getTotalPayment() == bookingDB.getTotalPriceBeforeDiscount())) {

                bookingDB.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 12));//Booking Confirmed & Protected

                bookingDB.setStatusDateTime(new Date());

                bookRepository.saveAndFlush(bookingDB);

                jrb.setStatus(ErrorMessages.statusSuccess);

            } else {//else for calculation payment error

                jrb.setStatus(ErrorMessages.statusError + "");

                jrb.setMessage("Payment Calculation (total != before or after discount price)");

            }

        } else {//else for user not resort or not identified

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Chalet Booking Not Protected");

        }

        return jrb;

    }

 

    //2.11      Unprotect Chalet Booking

    public JsonResponseBuilder UnProtectChaletBooking(long bookID, String bookCode, Principal pricipal) {

        JsonResponseBuilder jrb = new JsonResponseBuilder();

 

        Booking bookingDB = null;

        if (bookID != -1) {

            bookingDB = bookRepository.findOne(bookID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

 

        if (bookingDB == null) {//if no booking available in DB

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("booking Not Exist");

            return jrb;

        }

 

        UserAccount userLogin = userRepository.findByEmailAddress(pricipal.getName());

        // Users who have Bookings And Payment Statisfied

        if (userLogin.getUserId() == bookingDB.getIndividualUser().getUserId()

                && bookingDB.getLookupBookingStatus().getBookingStatusId() == 12//Booking Confirmed & Protected

                ) {

            bookingDB.setLookupBookingStatus(lookupBookingStatusRepository.findOne((short) 11));//Booking Confirmed

            bookingDB.setStatusDateTime(new Date());

            bookRepository.saveAndFlush(bookingDB);

            jrb.setStatus(ErrorMessages.statusSuccess);

        } else {

            jrb.setStatus(ErrorMessages.statusError + "");

        }

 

        return jrb;

    }

 

    //2.12      Cancel Chalet Booking

    public void CancelChaletBooking(long BookID) {

 

    }

 

    //2.14      Check Chalet Booking Expiration PAYMENT INTEGRATION

    public void CheckChaletBookingExpiration(Principal principal) {

 

        bookRepository.findAll().forEach((bookRecord) -> {

            //I.Call the Function “Unassign Discount Coupon” if there’s an assigned Discount Coupon

            UnassignDiscountCoupon(principal, bookRecord.getBookingId(), "-1");

 

//            II.       Checking whether if there an “Order ID” for that Booking or not

            if (bookRecord.getOrders() != null) {//has Order ID

//            III.      Calling Function “List Order Payments” if the Booking has an “Order ID

            }

//            calling the Function “Refund Payment” for each Payment

 

            LookupBookingStatus BookStatus = null;

            if (bookRecord.getLookupBookingStatus().getBookingStatusId() == 1) {

                BookStatus = lookupBookingStatusRepository.findOne((short) 10);//No Approval Response from Resort

            }

            if (bookRecord.getLookupBookingStatus().getBookingStatusId() == 4 || bookRecord.getLookupBookingStatus().getBookingStatusId() == 6 || bookRecord.getLookupBookingStatus().getBookingStatusId() == 7) {

                BookStatus = lookupBookingStatusRepository.findOne((short) 10);//booking Expired

            }

 

            bookRecord.setLookupBookingStatus(BookStatus);

            bookRecord.setStatusDateTime(new Date());

            bookRecord.setExpiryDateTimeBeforeConfirmation(null);

            bookRecord.setBookingToDate(null);

            bookRecord.setTotalPayment(0);

 

        });

 

    }

 

    //2.16      Request Chalet Check-in

    public JsonResponseBuilder RequestChaletCheckIn(long bookID, String bookCode) {

        Booking bookingDB = null;

        if (bookID != -1) {

            bookingDB = bookRepository.findOne(bookID);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

        JsonResponseBuilder jrb = new JsonResponseBuilder();

        Calendar checkinTime = Calendar.getInstance();

        checkinTime.setTime(bookingDB.getCheckinDateTime());

 

        Calendar timeNow = Calendar.getInstance();

        timeNow.add(Calendar.HOUR, -1);

        //  check in before 1 houre And Maximum by end of day in the first Booking day

        if (Calendar.getInstance().get(Calendar.HOUR) - checkinTime.get(Calendar.HOUR) <= 1

                && new Date().before(bookingDB.getBookingFromDate())

                && (bookingDB.getLookupBookingStatus().getBookingStatusId() == 11 || bookingDB.getLookupBookingStatus().getBookingStatusId() == 12)) {

            bookingDB.setCheckinRequestDateTime(new Date());

            bookRepository.saveAndFlush(bookingDB);

            jrb.setStatus(ErrorMessages.statusSuccess);

        } else {

            jrb.setStatus(ErrorMessages.statusError + "");

        }

        return jrb;

    }

 

    //2.17      Check Initial-No-Show Booking

    public void CheckInitialNoShowBooking(long bookID, Principal principal) {

 

        Booking bookingDB = bookRepository.findOne(bookID);

        UserAccount userLogin = userRepository.findByEmailAddress(principal.getName());

 

        // Users who have Bookings And or User IS RESORT Privilage AND booking Available

        if ((userLogin.getUserId() == bookingDB.getIndividualUser().getUserId()

                || userLogin.getLookupUserTypes().getUserTypeId() == 5)

                && bookingDB.getLookupBookingStatus().getBookingStatusId() == 21) { //Initial No Show

            //return last avilable Day in that booking

            ChaletAvailabilityDates lastAvilableDay = chaletAvaliabilityDateRepository.findTopByChaletDetailsAndLookupAvailabilityStatus_availabilityStatusIdOrderByChaletAvailabilityDatesPK_availabilityDateDesc(

                    chaletDetailRepositroy.findOne(bookRepository.findOne(bookID).getChaletDetails().getChaletId()),

                    (short) 2);

 

            if (lastAvilableDay != null) {

                return;

            } else {

                return;

            }

 

        }

    }

 

    public JsonResponseBuilder ChangeChaletBookingStatus(long bookId, String bookCode, short statusId) {

 

        Booking bookingDB = null;

        if (bookId != -1) {

            bookingDB = bookRepository.findOne(bookId);

        } else {

            bookingDB = bookRepository.findByBookingCode(bookCode);

        }

 

        bookingDB.setLookupBookingStatus(lookupBookingStatusRepository.findOne(statusId));

        bookRepository.saveAndFlush(bookingDB);

        //prepare to response

        JsonResponseBuilder jrb = new JsonResponseBuilder();

        jrb.setStatus(ErrorMessages.statusSuccess);

        return jrb;

    }

 

    //2.23      Validate Booking Code

    public JsonResponseBuilder ValidateBookingCode(long resortId, String bookingCode) {

 

        Booking bookingDB = null;

        String prefix = bookingCode.substring(0, 2);

//        Chalet Booking

        if (prefix.equals("CB")) {

            bookingDB = bookRepository.findByBookingCode(bookingCode);

        }

        //Direct Booking

        if (prefix.equals("DB")) {

        }

        //Hotel Booking

        if (prefix.equals("HB")) {

        }

        JsonResponseBuilder jrb = new JsonResponseBuilder();

 

        if (bookingDB == null) {

            // Incorrect Booking Code (if Booking Code is not exist)

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Booking Code doesn't exist");

        } // Irrelevant Booking Code (if Booking Code is not relevant to that Resort)

        else if (bookingDB.getResortId() != resortId) {

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Booking Code doesn'tS relevant to that Resort");

        }//  Invalid Booking Duration (if Booking Start Date or Finish Date are not in range)

        else if (bookingDB.getBookingFromDate().before(new Date()) && bookingDB.getBookingToDate().before(new Date())) {

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Invalid Booking Duration");

            //Inactive Booking Code (if Booking Status is not one of the mentioned Status below)

        } else if (bookingDB.getLookupBookingStatus().getBookingStatusId() == 11

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 12

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 13

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 15

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 20

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 21

                || bookingDB.getLookupBookingStatus().getBookingStatusId() == 24) {

            jrb.setStatus(ErrorMessages.statusError + "");

            jrb.setMessage("Inactive Booking Code");

        } else {

            jrb.setStatus(ErrorMessages.statusSuccess);

            jrb.setMessage(ErrorMessages.successMessage.trim());

        }

        return jrb;

    }

 

}