public async Task <IActionResult> getAll(Guid employeeId)
{
List <Day> days = await _repository.GetAll(employeeId);
return(Ok(days));
}
public SearchVenueQueryResult Handle(SearchVenueQuery query)
{
List <FIL.Contracts.DataModels.SearchVenue> VenueResult = new List <Contracts.DataModels.SearchVenue>();
try
{
var citiesArray = query.CityName != null?query.CityName.Split(",") : null;
var eventCategoriesRepositoryData = _eventCategoryRepository.GetAll().Where(s => s.IsFeel == true);
var categories = query.Categories != null?query.Categories.Split(",") : null;
List <long> categoryList = new List <long>();
if (categories != null && categories.Count() > 0 && query.PlaceId == 0)
{
foreach (var item in categories)
{
try
{
var categoryInfo = eventCategoriesRepositoryData.FirstOrDefault(x => x.DisplayName == item).Id;
categoryList.Add(categoryInfo);
}
catch (Exception ex)
{
_logger.Log(Logging.Enums.LogCategory.Error, ex);
}
}
}
else if (categories != null && categories.Count() == 0 && query.PlaceId == 0)
{
var categoryInfo = eventCategoriesRepositoryData.FirstOrDefault(x => x.DisplayName == query.Categories).Id;
categoryList.Add(categoryInfo);
}
var cityLists = query.CityIds != null?_cityRepository.GetByCityIds(query.CityIds) : null;
var itineraryPlaces = query.PlaceId == 0 ? _eventRepository.GetAllItineraryPlaces(cityLists.Select(s => s.Id).ToList(), categoryList).GroupBy(x => x.Id, (key, group) => group.First()) :
_eventRepository.GetItinerarySearchPlaces(query.PlaceId).GroupBy(x => x.Id, (key, group) => group.First());
var placeWeekOpenDayList = _placeWeekOpenDaysRepository.GetByEventIds(itineraryPlaces.Select(s => (long)s.Id).Distinct().ToList());
var dayTimeMappingLists = _dayTimeMappingsRepository.GetAllByPlaceWeekOpenDays(placeWeekOpenDayList.Select(s => (long)s.Id).Distinct().ToList());
var placeHolidayDatesRepositoryLists = _placeHolidayDatesRepository.GetAllByEventIds(itineraryPlaces.Select(s => (long)s.Id).Distinct().ToList());
var placeVisitDurationRepositoryLists = _PlaceVisitDurationRepository.GetByEventIds(itineraryPlaces.Select(s => (long)s.Id).Distinct().ToList());
var eventDetails = _eventDetailRepository.GetByEventIds(itineraryPlaces.Select(s => (long)s.Id).Distinct().ToList()).Where(s => s.IsEnabled == true);
var eventTicketDetails = _eventTicketDetailRepository.GetByEventDetailIds(eventDetails.Select(s => (long)s.Id).Distinct().ToList()).Where(s => s.IsEnabled == true);
var eventTicketAttributes = _eventTicketAttributeRepository.GetByEventTicketDetailIds(eventTicketDetails.Select(s => (long)s.Id).Distinct().ToList()).Where(s => s.IsEnabled == true);
var ticketCategories = _ticketCategoryRepository.GetByTicketCategoryIds(eventTicketDetails.Select(s => (long)s.TicketCategoryId).Distinct().ToList());
var Days = _daysRepository.GetAll();
foreach (var currentPlace in itineraryPlaces)
{
var PlaceVisitDuration = placeVisitDurationRepositoryLists.FirstOrDefault(x => x.EventId == currentPlace.Id);
var placeWeekOpenDays = placeWeekOpenDayList.Where(x => x.EventId == currentPlace.Id);
var dayTimeMappings = dayTimeMappingLists.Where(s => placeWeekOpenDays.Any(p => p.Id == s.PlaceWeekOpenDayId));
SearchVenue searchVenue = new SearchVenue();
searchVenue.CategoryName = currentPlace.Category;
searchVenue.EventId = currentPlace.Id;
searchVenue.CityId = currentPlace.CityId;
searchVenue.EventSource = currentPlace.EventSource;
searchVenue.CityName = currentPlace.CityName;
searchVenue.CountryName = currentPlace.CountryName;
searchVenue.Currency = currentPlace.Currency;
searchVenue.EventName = currentPlace.Name;
searchVenue.EventAltId = currentPlace.AltId;
searchVenue.EventSlug = currentPlace.Slug;
searchVenue.Address = (currentPlace.AddressLineOne == null ? string.Empty : currentPlace.AddressLineOne) + "," + (currentPlace.AddressLineTwo == null ? string.Empty : currentPlace.AddressLineTwo);
searchVenue.Id = currentPlace.Id;
searchVenue.PlaceWeekOpenDays = placeWeekOpenDays.ToList();
searchVenue.DayTimeMappings = dayTimeMappings.ToList();
searchVenue.PlaceHolidaysList = placeHolidayDatesRepositoryLists.Where(x => x.EventId == currentPlace.Id).ToList();
searchVenue.EventDescription = currentPlace.EventDescription;
searchVenue.EventDetails = eventDetails.Where(x => x.EventId == currentPlace.Id).ToList();
searchVenue.EventTicketDetails = eventTicketDetails.Where(x => searchVenue.EventDetails.Any(s => s.Id == x.EventDetailId)).ToList();
searchVenue.EventTicketAttributes = eventTicketAttributes.Where(x => searchVenue.EventTicketDetails.Any(s => s.Id == x.EventTicketDetailId)).ToList();
searchVenue.ticketCategories = ticketCategories.Where(x => searchVenue.EventTicketDetails.Any(s => s.TicketCategoryId == x.Id)).ToList();
if (currentPlace.Latitude != null)
{
var latArr = currentPlace.Latitude.Split("E");
var longArr = currentPlace.Longitude.Split("E");
searchVenue.Latitude = latArr[0];
searchVenue.Longitude = longArr[0];
}
else
{
searchVenue.Latitude = null;
searchVenue.Longitude = null;
}
VenueResult.Add(searchVenue);
}
return(new SearchVenueQueryResult()
{
Venues = VenueResult.Distinct().ToList(), Days = Days.ToList()
});
}
catch (Exception e)
{
return(new SearchVenueQueryResult()
{
Venues = VenueResult.Distinct().ToList()
});
}
}
public GetPlaceInventoryQueryResult GetCalendarData(long eventId)
{
/*-------------------------- Regular Time --------------------------*/
var placeWeekOpenDays = _placeWeekOpenDaysRepository.GetByEventId(eventId).ToList();
var allDays = _daysRepository.GetAll().ToList();
var regular = new RegularViewModel();
if (placeWeekOpenDays.Any())
{
bool[] openDays = new bool[8];
var i = 0;
foreach (FIL.Contracts.DataModels.PlaceWeekOpenDays currentPlaceWeek in placeWeekOpenDays)
{
openDays[currentPlaceWeek.DayId] = true;
i = i + 1;
}
if (i == 7)
{
openDays[0] = true;
}
if (placeWeekOpenDays[0].IsSameTime)
{
i = 0;
var dayTimeMappings = _dayTimeMappingsRepository.GetAllByPlaceWeekOpenDay(placeWeekOpenDays[0].Id).ToList();
List <TimeViewModel> timeModels = new List <TimeViewModel>();
List <CustomTimeModelData> customTimeModels = new List <CustomTimeModelData>();
foreach (FIL.Contracts.DataModels.DayTimeMappings daysTime in dayTimeMappings)
{
var newTimeModel = new TimeViewModel();
newTimeModel.Id = i + 1;
newTimeModel.From = daysTime.StartTime;
newTimeModel.To = daysTime.EndTime;
i = i + 1;
timeModels.Add(newTimeModel);
}
regular.TimeModel = timeModels;
i = 0;
foreach (FIL.Contracts.DataModels.PlaceWeekOpenDays currentPlaceWeek in placeWeekOpenDays)
{
var newCustomTimeModel = new CustomTimeModelData();
timeModels = new List <TimeViewModel>();
var newTimeModel = new TimeViewModel();
var currentDay = _daysRepository.Get(currentPlaceWeek.DayId);
newCustomTimeModel.Id = i + 1;
newCustomTimeModel.Day = currentDay.Name;
newTimeModel.Id = i + 1;
newTimeModel.From = "";
newTimeModel.To = "";
timeModels.Add(newTimeModel);
newCustomTimeModel.Time = timeModels;
customTimeModels.Add(newCustomTimeModel);
i = i + 1;
}
regular.CustomTimeModel = customTimeModels;
}
else if (!placeWeekOpenDays[0].IsSameTime)
{
i = 0;
var dayTimeMappings = _dayTimeMappingsRepository.GetAllByPlaceWeekOpenDay(placeWeekOpenDays[0].Id).ToList();
List <TimeViewModel> timeModels = new List <TimeViewModel>();
List <CustomTimeModelData> customTimeModels = new List <CustomTimeModelData>();
var newTimeModel = new TimeViewModel();
newTimeModel.Id = i + 1;
newTimeModel.From = "";
newTimeModel.To = "";
timeModels.Add(newTimeModel);
regular.TimeModel = timeModels;
i = 0;
foreach (FIL.Contracts.DataModels.PlaceWeekOpenDays currentPlaceWeek in placeWeekOpenDays)
{
var newCustomTimeModel = new CustomTimeModelData();
var currentDayTimeMappings = _dayTimeMappingsRepository.GetAllByPlaceWeekOpenDay(currentPlaceWeek.Id).ToList();
var currentDay = _daysRepository.Get(currentPlaceWeek.DayId);
timeModels = new List <TimeViewModel>();
var index = 0;
foreach (FIL.Contracts.DataModels.DayTimeMappings currentTime in currentDayTimeMappings)
{
var currentTimeModel = new TimeViewModel();
currentTimeModel.Id = index + 1;
currentTimeModel.From = currentTime.StartTime;
currentTimeModel.To = currentTime.EndTime;
timeModels.Add(currentTimeModel);
index = index + 1;
}
newCustomTimeModel.Time = timeModels;
newCustomTimeModel.Day = currentDay.Name;
newCustomTimeModel.Id = i + 1;
customTimeModels.Add(newCustomTimeModel);
i = i + 1;
}
regular.CustomTimeModel = customTimeModels;
}
regular.IsSameTime = placeWeekOpenDays[0].IsSameTime;
regular.DaysOpen = openDays.OfType <bool>().ToList();
}
else
{
if (regular.CustomTimeModel == null)
{
regular.CustomTimeModel = new List <CustomTimeModelData>();
}
if (regular.TimeModel == null)
{
regular.TimeModel = new List <TimeViewModel>();
}
if (regular.DaysOpen == null)
{
bool[] openDays = new bool[8];
regular.DaysOpen = openDays.OfType <bool>().ToList();
}
regular.IsSameTime = true;
}
/*-------------------------- Season Time --------------------------*/
var season = new List <SeasonViewModel>();
var placeSeasonDetails = _placeSeasonDetailsRepository.GetByEventId(eventId).ToList();
var seasonIndex = 0;
foreach (FIL.Contracts.DataModels.PlaceSeasonDetails currentSeason in placeSeasonDetails)
{
var seasonDaysMappings = _seasonDaysMappingsRepository.GetByPlaceSeasonDetailId(currentSeason.Id).ToList();
var newSeasonViewModel = new SeasonViewModel();
List <TimeViewModel> timeModelList = new List <TimeViewModel>();
List <SpeecialDateSeasonTimeViewModel> speecialDateSeasonTimeList = new List <SpeecialDateSeasonTimeViewModel>();
bool[] openDays = new bool[8];
if (currentSeason.IsSameTime && seasonDaysMappings.Any())
{
var seasonSameTiming = _seasonDayTimeMappingsRepository.GetSeasonDaysMappings(seasonDaysMappings[0].Id).ToList();
var timeIndex = 0;
foreach (FIL.Contracts.DataModels.SeasonDaysTimeMapping currentSeasonTime in seasonSameTiming)
{
var timeModel = new TimeViewModel();
timeModel.Id = timeIndex;
timeModel.From = currentSeasonTime.StartTime;
timeModel.To = currentSeasonTime.EndTime;
timeIndex = timeIndex + 1;
timeModelList.Add(timeModel);
}
timeIndex = 0;
foreach (FIL.Contracts.DataModels.SeasonDaysMapping currentSeasonDay in seasonDaysMappings)
{
var speecialDateSeasonTime = new SpeecialDateSeasonTimeViewModel();
var currentDay = _daysRepository.Get(currentSeasonDay.DayId);
var timeModels = new List <TimeViewModel>();
var timeModel = new TimeViewModel();
timeModel.Id = 1;
timeModel.From = "";
timeModel.To = "";
timeModels.Add(timeModel);
speecialDateSeasonTime.Id = timeIndex + 1;
speecialDateSeasonTime.Day = currentDay.Name;
speecialDateSeasonTime.Time = timeModels;
openDays[currentSeasonDay.DayId] = true;
timeIndex = timeIndex + 1;
speecialDateSeasonTimeList.Add(speecialDateSeasonTime);
}
}
else if (!currentSeason.IsSameTime)
{
var timeIndex = 0;
var timeModel = new TimeViewModel();
timeModel.Id = 1;
timeModel.From = "";
timeModel.To = "";
timeModelList.Add(timeModel);
foreach (FIL.Contracts.DataModels.SeasonDaysMapping currentSeasonDay in seasonDaysMappings)
{
var speecialDateSeasonTime = new SpeecialDateSeasonTimeViewModel();
var currentDay = _daysRepository.Get(currentSeasonDay.DayId);
var timeModels = new List <TimeViewModel>();
var seasonSpecialTime = _seasonDayTimeMappingsRepository.GetSeasonDaysMappings(currentSeasonDay.Id);
var seasonTimeIndex = 0;
foreach (FIL.Contracts.DataModels.SeasonDaysTimeMapping currentSeasonDayTime in seasonSpecialTime)
{
timeModel = new TimeViewModel();
timeModel.Id = seasonTimeIndex + 1;
timeModel.To = currentSeasonDayTime.EndTime;
timeModel.From = currentSeasonDayTime.StartTime;
timeModels.Add(timeModel);
seasonTimeIndex = seasonTimeIndex + 1;
}
openDays[currentSeasonDay.DayId] = true;
speecialDateSeasonTime.Id = timeIndex + 1;
speecialDateSeasonTime.Day = currentDay.Name;
speecialDateSeasonTime.Time = timeModels;
speecialDateSeasonTimeList.Add(speecialDateSeasonTime);
timeIndex = timeIndex + 1;
}
}
newSeasonViewModel.Id = seasonIndex + 1;
newSeasonViewModel.SameTime = timeModelList;
newSeasonViewModel.Time = speecialDateSeasonTimeList;
newSeasonViewModel.StartDate = currentSeason.StartDate.AddHours(5).AddMinutes(30);
newSeasonViewModel.EndDate = currentSeason.EndDate.AddHours(5).AddMinutes(30);
newSeasonViewModel.Name = currentSeason.Name;
newSeasonViewModel.IsSameTime = currentSeason.IsSameTime;
newSeasonViewModel.DaysOpen = openDays.OfType <bool>().ToList();
seasonIndex = seasonIndex + 1;
season.Add(newSeasonViewModel);
}
/*-------------------------- Special day/Holiday Time --------------------------*/
var specialDay = new List <SpecialDayViewModel>();
var specialDays = _placeSpecialDayTimeMappingsRepository.GetAllByEventId(eventId);
var specialDayindex = 0;
foreach (FIL.Contracts.DataModels.PlaceSpecialDayTimeMappings currentSpecialDay in specialDays)
{
var newSpecialDay = new SpecialDayViewModel();
newSpecialDay.Id = specialDayindex + 1;
newSpecialDay.Name = currentSpecialDay.Name;
newSpecialDay.From = currentSpecialDay.StartTime;
newSpecialDay.To = currentSpecialDay.EndTime;
newSpecialDay.SpecialDate = currentSpecialDay.SpecialDate.AddHours(5).AddMinutes(30);
specialDayindex = specialDayindex + 1;
specialDay.Add(newSpecialDay);
}
return(new GetPlaceInventoryQueryResult
{
SeasonTimeModel = season,
SpecialDayModel = specialDay,
RegularTimeModel = regular
});
}
public TicketCategoryQueryResult Handle(TicketCategoryQuery query)
{
try
{
var eventDataModel = _eventRepository.GetByAltId(query.EventAltId);
var eventModel = AutoMapper.Mapper.Map <Contracts.Models.Event>(eventDataModel);
if (eventModel != null)
{
var ASIMonumentMapping = _aSIMonumentEventTableMappingRepository.GetByEventId(eventModel.Id);
var ASIMonument = new Contracts.Models.ASI.Item();
if (ASIMonumentMapping != null)
{
ASIMonument = Mapper.Map <Contracts.Models.ASI.Item>(_aSIMonumentRepository.Get(ASIMonumentMapping.ASIMonumentId));
}
var eventCategoryMappings = _eventCategoryMappingRepository.GetByEventId(eventModel.Id).FirstOrDefault();
var eventDetailModelDataModel = _eventDetailRepository.GetSubEventByEventId(eventModel.Id);
var eventDetailModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventDetail> >(eventDetailModelDataModel);
List <FIL.Contracts.Models.ASI.EventTimeSlotMapping> eventTimeSlotMappings = new List <Contracts.Models.ASI.EventTimeSlotMapping>();
List <EventVenueMappingTime> eventVenueMappingTimeModel = new List <EventVenueMappingTime>();
FIL.Contracts.Models.EventCategory subCategory = new FIL.Contracts.Models.EventCategory();
FIL.Contracts.Models.EventCategory category = new FIL.Contracts.Models.EventCategory();
try
{
var eventTimeSlot = _eventTimeSlotMappingRepository.GetByEventId(eventModel.Id);
eventTimeSlotMappings = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.ASI.EventTimeSlotMapping> >(eventTimeSlot).ToList();
}
catch (Exception e)
{
}
if (eventCategoryMappings != null)
{
var subCategoryDataModel = _eventCategoryRepository.Get(eventCategoryMappings.EventCategoryId);
if (subCategory != null)
{
subCategory = AutoMapper.Mapper.Map <Contracts.Models.EventCategory>(subCategoryDataModel);
var categoryDataModel = _eventCategoryRepository.Get(subCategory.EventCategoryId);
category = AutoMapper.Mapper.Map <Contracts.Models.EventCategory>(categoryDataModel);
}
}
var ticketCategoryType = _ticketCategoryTypesRepository.GetAll();
var ticketCategorySubType = _ticketCategorySubTypesRepository.GetAll();
var placeHolidyDatesDataModel = _placeHolidayDatesRepository.GetAllByEventId(eventDataModel.Id);
var placeHolidyDatesModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.PlaceHolidayDate> >(placeHolidyDatesDataModel);
var placeWeekOffDataModel = _placeWeekOffRepository.GetAllByEventId(eventDataModel.Id);
var placeWeekOffModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.PlaceWeekOff> >(placeWeekOffDataModel);
var placeDocumentDataModel = _placeCustomerDocumentTypeMappingRepository.GetAllByEventId(eventDataModel.Id);
var placeDocumentModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.PlaceCustomerDocumentTypeMapping> >(placeDocumentDataModel);
var placeOpenDays = _placeWeekOpenDaysRepository.GetByEventId(eventDataModel.Id);
var placeOpenDaysModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.PlaceWeekOpenDays> >(placeOpenDays);
var CustomerDocumentTypeDataModel = _customerDocumentTypeRepository.GetAll();
var CustomerDocumentTypeModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.CustomerDocumentType> >(CustomerDocumentTypeDataModel);
if (eventDetailModelDataModel != null && eventDetailModelDataModel.Any())
{
var eventDeliveryTypeDetailDataModel = _eventDeliveryTypeDetail.GetByEventDetailId(eventDetailModelDataModel.ElementAt(0).Id);
var eventDeliveryTypeDetailModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventDeliveryTypeDetail> >(eventDeliveryTypeDetailDataModel);
var RASVTicketTypeMappingsDataModel = _rasvTicketTypeMappingRepository.GetByEventDetailIds(eventDetailModelDataModel.Select(ed => ed.Id)).Where(sed => sed.IsEnabled == true);
var RASVTicketTypeMappingsModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.RASVTicketTypeMapping> >(RASVTicketTypeMappingsDataModel);
var venueDetailDataModel = _venueRepository.GetByVenueIds(eventDetailModel.Select(s => s.VenueId));
var venueDetailModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.Venue> >(venueDetailDataModel);
//Multiple Venue option for MOVE AROUND category.
var eventVenueMappingDataModel = _eventVenueMappingRepository.GetOneByEventId(eventModel.Id);
var eventVenueMappingModel = Mapper.Map <EventVenueMapping>(eventVenueMappingDataModel);
if (eventVenueMappingModel != null)
{
var eventVenueMappingTimeDataModel = _eventVenueMappingTimeRepository.GetAllByEventVenueMappingId(eventVenueMappingModel.Id);
eventVenueMappingTimeModel = Mapper.Map <IEnumerable <EventVenueMappingTime> >(eventVenueMappingTimeDataModel).ToList();
}
var CityList = venueDetailDataModel.Select(s => s.CityId);
var cityDetailDataModel = _cityRepository.GetByCityIds(CityList);
var cityModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.City> >(cityDetailDataModel);
var eventTicketDetailList = eventDetailModelDataModel.Select(s => s.Id);
var eventTicketDetailDataModel = _eventTicketDetailRepository.GetByEventDetailIds(eventTicketDetailList);
var eventTicketDetailModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventTicketDetail> >(eventTicketDetailDataModel);
// For Getting Pone venue Images
var pOneImageEventDetailMapping = new List <Contracts.Models.POne.POneImageEventDetailMapping>();
if (eventModel.EventSourceId == EventSource.POne)
{
var pOneEventDetailMappings = _pOneEventDetailMappingRepository.GetByEventDetailIds(eventTicketDetailModel.Select(s => s.EventDetailId).Distinct().ToList());
var allTicketCategories = _ticketCategoryRepository.GetByTicketCategoryIds(eventTicketDetailModel.Select(s => s.TicketCategoryId).Distinct().ToList());
var allPoneETD = _pOneEventTicketDetailRepository.GetByManyPOneEventDetail(pOneEventDetailMappings.Select(s => s.POneEventDetailId).Distinct().ToList());
foreach (var item in eventTicketDetailModel)
{
var pOneEventDetailMappingData = pOneEventDetailMappings.Where(s => s.ZoongaEventDetailId == item.EventDetailId).FirstOrDefault();
var tc = allTicketCategories.Where(s => s.Id == item.TicketCategoryId).FirstOrDefault();
var p1tc = _pOneTicketCategoryRepository.GetByName(tc.Name);
if (pOneEventDetailMappingData != null && p1tc != null)
{
var p1etd = allPoneETD.Where(s => (s.POneEventDetailId == pOneEventDetailMappingData.POneEventDetailId && s.POneTicketCategoryId == p1tc.POneId)).FirstOrDefault();
if (p1etd != null)
{
pOneImageEventDetailMapping.Add(new Contracts.Models.POne.POneImageEventDetailMapping
{
EventTicketDetailId = item.Id,
ImageUrl = p1etd.ImageUrl
});
}
}
}
}
var eventTicketDetailTicketCategoryMappings = _eventTicketDetailTicketCategoryTypeMappingRepository.GetByEventTicketDetails(eventTicketDetailModel.Select(s => s.Id).ToList());
var eventTicketDetailTicketCategoryMappingsModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventTicketDetailTicketCategoryTypeMapping> >(eventTicketDetailTicketCategoryMappings).ToList();
var matchAttribute = _matchAttributeRepository.GetByEventDetailIds(eventDetailModelDataModel.Select(ed => ed.Id).Distinct());
var team = _teamRepository.GetAll();
var data = _calendarProvider.GetCalendarData(eventModel.Id);
if (eventTicketDetailModel != null)
{
var ticketCategoryIdList = eventTicketDetailModel.Select(s => s.TicketCategoryId);
var ticketCategoryDataModel = _ticketCategoryRepository.GetByEventDetailIds(ticketCategoryIdList);
var ticketCategoryModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.TicketCategory> >(ticketCategoryDataModel);
var eventTicketDetailIdList = eventTicketDetailModel.Select(s => s.Id);
var eventTicketDetailIdDataModel = _eventTicketAttributeRepository.GetByEventTicketDetailId(eventTicketDetailIdList);
var eventTicketAttributeModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventTicketAttribute> >(eventTicketDetailIdDataModel);
var eventTicketAttributeIdList = eventTicketAttributeModel.Select(s => s.Id);
var ticketFeeDetailIdDataModel = _ticketFeeDetail.GetByEventTicketAttributeIds(eventTicketAttributeIdList);
var ticketFeeDetailModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.TicketFeeDetail> >(ticketFeeDetailIdDataModel);
var currencyList = eventTicketAttributeModel.Select(s => s.CurrencyId).Distinct().FirstOrDefault();
var currencyModel = AutoMapper.Mapper.Map <Contracts.Models.CurrencyType>(_currencyTypeRepository.Get(currencyList));
var days = _daysRepository.GetAll();
var daysModel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.Days> >(days);
var CountryRegionalOrganisation = _countryRegionalOrganisationMappingRepository.GetAll();
var eventAttribute = _eventAttributeRepository.GetByEventDetailIds(eventDetailModel.Select(s => (long)s.Id).ToList());
var Country = _countryRepository.GetAll();
var Countrymodel = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.Country> >(Country);
List <string> reginalOrganisation = new List <string>();
reginalOrganisation.AddRange(Enum.GetNames(typeof(FIL.Contracts.Enums.RegionalOrganisation)));
// For Tiqet's gettting Checkout Details
TiqetProductCheckoutDetail
tiqetCheckoutDetailsModel = new TiqetProductCheckoutDetail();
List <ValidWithVariantModel> validWithVariantList = new List <ValidWithVariantModel>();
if (eventModel.EventSourceId == EventSource.Tiqets)
{
var tiqetEventDetailMapping = _tiqetEventDetailMappingRepository.GetByEventDetailId(eventDetailModel.ElementAt(0).Id);
var tiqetCheckoutDetails = _tiqetProductCheckoutDetailRepository.GetByProductId(tiqetEventDetailMapping.ProductId);
tiqetCheckoutDetailsModel = Mapper.Map <TiqetProductCheckoutDetail>(tiqetCheckoutDetails);
// for checking valid with tiqetVariant details
var tiqetVariantDetails = _tiqetVariantDetailRepository.GetAllByProductId(tiqetCheckoutDetailsModel.ProductId);
List <long> eventTicketDetailIds = new List <long>();
foreach (var currentVariantDetail in tiqetVariantDetails)
{
if (currentVariantDetail.ValidWithVariantIds != null && currentVariantDetail.ValidWithVariantIds != "")
{
ValidWithVariantModel validWithVariantModel = new ValidWithVariantModel();
var validWithVariantIds = currentVariantDetail.ValidWithVariantIds.Split(",");
foreach (var currentValidvariantId in validWithVariantIds)
{
var currentValidVariantDetail = tiqetVariantDetails.Where(s => s.VariantId == Convert.ToInt64(currentValidvariantId)).FirstOrDefault();
if (currentValidVariantDetail != null)
{
var eventTicketDetailMapping = _tiqetEventTicketDetailMappingRepository.GetByTiqetVariantId(currentValidVariantDetail.Id);
eventTicketDetailIds.Add(eventTicketDetailMapping.EventTicketDetailId);
}
}
var currentEventTicketDetailMapping = _tiqetEventTicketDetailMappingRepository.GetByTiqetVariantId(currentVariantDetail.Id);
validWithVariantModel.EventTicketDetailId = currentEventTicketDetailMapping.EventTicketDetailId;
validWithVariantModel.ValidWithEventTicketDetailId = eventTicketDetailIds;
validWithVariantList.Add(validWithVariantModel);
}
}
}
// Check for Hoho Places if any
FIL.Contracts.DataModels.CitySightSeeingTicketDetail citySightSeeingTicketDetail = new FIL.Contracts.DataModels.CitySightSeeingTicketDetail();
var citySightSeeingEventDetailMapping = _citySightSeeingEventDetailMappingRepository.GetByEventDetailId(eventDetailModel.ElementAt(0).Id);
if (citySightSeeingEventDetailMapping != null)
{
var citySightSeeingTickets = _citySightSeeingTicketRepository.Get(citySightSeeingEventDetailMapping.CitySightSeeingTicketId);
citySightSeeingTicketDetail = _citySightSeeingTicketDetailRepository.GetByTicketId(citySightSeeingTickets.TicketId);
}
//Get Host Details for FIL Online Events
var eventHostMappingList = new List <FIL.Contracts.DataModels.EventHostMapping>();
var formattedDateString = "";
if (eventDataModel.MasterEventTypeId == MasterEventType.Online)
{
eventHostMappingList = _eventHostMappingRepository.GetAllByEventId(eventDataModel.Id).ToList();
var formattedDateTime = _localTimeZoneConvertProvider.ConvertToLocal(eventDetailModel.FirstOrDefault().StartDateTime, eventAttribute.FirstOrDefault().TimeZone);
formattedDateString = formattedDateTime.DayOfWeek + ", " + formattedDateTime.ToString(@"MMM dd, yyyy, hh:mm tt", new CultureInfo("en-US"));
}
//Get Recurrance Schedule
List <FIL.Contracts.Models.CreateEventV1.EventRecurranceScheduleModel> recurranceScheduleModels = new List <Contracts.Models.CreateEventV1.EventRecurranceScheduleModel>();
if (eventDetailModel.FirstOrDefault().EventFrequencyType == EventFrequencyType.Recurring)
{
recurranceScheduleModels = _getScheduleDetailProvider.GetScheduleDetails(eventDataModel.Id, DateTime.UtcNow, DateTime.UtcNow, false, true).Where(s => s.EndDateTime > DateTime.UtcNow).ToList();
}
try
{
return(new TicketCategoryQueryResult
{
Event = eventModel,
EventDetail = eventDetailModel,
EventTicketAttribute = eventTicketAttributeModel,
TicketFeeDetail = ticketFeeDetailModel,
Venue = venueDetailModel,
City = cityModel,
EventTicketDetail = eventTicketDetailModel,
TicketCategory = ticketCategoryModel,
CurrencyType = currencyModel,
RASVTicketTypeMappings = RASVTicketTypeMappingsModel,
EventDeliveryTypeDetails = eventDeliveryTypeDetailModel,
EventCategory = eventModel.EventCategoryId,
MatchAttribute = Mapper.Map <IEnumerable <MatchAttribute> >(matchAttribute),
Team = Mapper.Map <IEnumerable <Team> >(team),
PlaceCustomerDocumentTypeMappings = placeDocumentModel,
PlaceHolidayDates = placeHolidyDatesModel,
PlaceWeekOffs = placeWeekOffModel,
CustomerDocumentTypes = CustomerDocumentTypeModel,
TicketCategorySubTypes = ticketCategorySubType.ToList(),
TicketCategoryTypes = ticketCategoryType.ToList(),
EventTicketDetailTicketCategoryTypeMappings = eventTicketDetailTicketCategoryMappingsModel,
EventCategoryMappings = eventCategoryMappings,
RegularTimeModel = data.RegularTimeModel,
SeasonTimeModel = data.SeasonTimeModel,
SpecialDayModel = data.SpecialDayModel,
EventVenueMappings = eventVenueMappingModel,
EventVenueMappingTimes = eventVenueMappingTimeModel,
EventTimeSlotMappings = eventTimeSlotMappings,
PlaceWeekOpenDays = placeOpenDaysModel,
Days = daysModel,
CountryRegionalOrganisationMappings = CountryRegionalOrganisation.ToList(),
Countries = Countrymodel,
Category = category,
SubCategory = subCategory,
RegionalOrganisation = reginalOrganisation,
TiqetsCheckoutDetails = tiqetCheckoutDetailsModel,
ValidWithVariantModel = validWithVariantList,
CitySightSeeingTicketDetail = Mapper.Map <FIL.Contracts.Models.CitySightSeeing.CitySightSeeingTicketDetail>(citySightSeeingTicketDetail),
POneImageEventDetailMapping = pOneImageEventDetailMapping,
EventHostMapping = eventHostMappingList,
EventAttributes = eventAttribute.ToList(),
eventRecurranceScheduleModels = recurranceScheduleModels,
ASIMonument = ASIMonument,
FormattedDateString = formattedDateString
});
}
catch (Exception e)
{
return(new TicketCategoryQueryResult
{
});
}
}
else
{
return(new TicketCategoryQueryResult
{
Event = eventModel,
EventDetail = eventDetailModel,
EventTicketAttribute = null,
TicketFeeDetail = null,
Venue = venueDetailModel,
City = cityModel,
EventTicketDetail = eventTicketDetailModel,
TicketCategory = null,
CurrencyType = null,
RASVTicketTypeMappings = RASVTicketTypeMappingsModel,
EventDeliveryTypeDetails = eventDeliveryTypeDetailModel,
EventCategory = eventModel.EventCategoryId,
MatchAttribute = null,
Team = null,
CitySightSeeingTicketDetail = null
});
}
}
else
{
return(new TicketCategoryQueryResult {
});
}
}
else
{
return(new TicketCategoryQueryResult {
});
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
return(new TicketCategoryQueryResult {
});
}
}
public Event SaveToEvent(ChauffeurRoute route, ValueRetailVillage valueRetailVillage)
{
var eventName = CheckAndTranslateLanguage(route.ServiceType);
var @event = new Event
{
AltId = Guid.NewGuid(),
Name = $"Chauffeur {eventName} from {route.LocationHeader} to {valueRetailVillage.VillageName}",
EventCategoryId = ValueRetailEventCategoryConstant.ShoppingPackageParentCategory,
EventTypeId = EventType.Perennial,
Description = $"<p>{CheckAndTranslateLanguage(route.ServiceDescription)}</p>",
ClientPointOfContactId = 2,
FbEventId = null,
MetaDetails = null,
IsFeel = true,
EventSourceId = EventSource.ValueRetail,
TermsAndConditions = "",
IsPublishedOnSite = true,
PublishedDateTime = DateTime.Now,
PublishedBy = null,
TestedBy = null,
Slug = $"{eventName} {route.LocationHeader}".Replace(" ", "-"),
ModifiedBy = Guid.NewGuid(),
IsEnabled = true
};
try
{
var eventResult = _eventRepository.GetByEventName(@event.Name);
if (eventResult == null)
{
eventResult = _eventRepository.Save(@event);
}
var eventSiteIdMapping = _eventSiteIdMappingRepository.GetByEventId(eventResult.Id);
if (eventSiteIdMapping == null)
{
eventSiteIdMapping = _eventSiteIdMappingRepository.Save(new Contracts.DataModels.EventSiteIdMapping
{
EventId = eventResult.Id,
SortOrder = 999,
SiteId = Site.feelaplaceSite,
ModifiedBy = eventResult.ModifiedBy,
IsEnabled = true
});
}
var eventCategoryMapping = _eventCategoryMappingRepository.GetByEventId(eventResult.Id).FirstOrDefault();
if (eventCategoryMapping == null)
{
_eventCategoryMappingRepository.Save(new Contracts.DataModels.EventCategoryMapping
{
EventId = eventResult.Id,
EventCategoryId = ValueRetailEventCategoryConstant.ChauffeurDriveChildCategory,
ModifiedBy = eventResult.ModifiedBy,
IsEnabled = true
});
}
var days = _daysRepository.GetAll();
foreach (var day in days)
{
var placeweekOpenDays = _placeWeekOpenDaysRepository.GetByEventIdandDayId(eventResult.Id, day.Id);
if (placeweekOpenDays == null)
{
placeweekOpenDays = _placeWeekOpenDaysRepository.Save(new PlaceWeekOpenDays
{
AltId = Guid.NewGuid(),
EventId = eventResult.Id,
DayId = day.Id,
IsSameTime = false,
ModifiedBy = eventResult.ModifiedBy,
IsEnabled = true
});
}
}
return(eventResult);
}
catch (Exception ex)
{
_logger.Log(LogCategory.Error, ex);
return(new Event());
}
}
