public ItineraryTicketQueryResult Handle(ItineraryTicketQuery query)
{
ItineraryTicketQueryResult itineraryTicketQueryResult = new ItineraryTicketQueryResult();
foreach (Int64 eventId in query.eventIds)
{
ItineraryTicketDetails itineraryTicketDetails = new ItineraryTicketDetails();
itineraryTicketDetails.eventId = eventId;
List <Contracts.DataModels.EventDetail> eventDetail = _eventDetailRepository.GetAllByEventId(eventId).Where(u => u.IsEnabled == true).Distinct().ToList();
List <Contracts.DataModels.EventTicketDetail> eventTicketDetail = _eventTicketDetailRepository.GetAllByEventDetailIds(eventDetail.Select(u => u.Id).Distinct().ToList()).Where(u => u.IsEnabled == true).Distinct().ToList();
List <Contracts.DataModels.EventTicketAttribute> eventTicketAttribute = _eventTicketAttributeRepository.GetByEventTicketDetailIds(eventTicketDetail.Select(u => u.Id).ToList()).Distinct().ToList();
List <Contracts.DataModels.TicketCategory> ticketCategory = _ticketCategoryRepository.GetByEventDetailIds(eventTicketDetail.Select(u => u.TicketCategoryId).ToList()).Distinct().ToList();
itineraryTicketDetails.eventDetails = AutoMapper.Mapper.Map <List <Contracts.Models.EventDetails> >(eventDetail);
itineraryTicketDetails.eventTicketDetails = AutoMapper.Mapper.Map <List <Contracts.Models.EventTicketDetail> >(eventTicketDetail);
itineraryTicketDetails.eventTicketAttributes = AutoMapper.Mapper.Map <List <Contracts.Models.EventTicketAttribute> >(eventTicketAttribute);
itineraryTicketDetails.ticketCategories = AutoMapper.Mapper.Map <List <Contracts.Models.TicketCategory> >(ticketCategory);
itineraryTicketQueryResult.itineraryTicketDetails.Add(itineraryTicketDetails);
}
return(itineraryTicketQueryResult);
}
public WebEventLearnPageQueryResults Handle(EventLearnPageQuery query)
{
var eventDataModel = _eventRepository.GetByAltId(query.EventAltId);
var eventModel = AutoMapper.Mapper.Map <Contracts.Models.Event>(eventDataModel);
if (eventModel != null)
{
var eventDetailDataModel = _eventDetailRepository.GetAllByEventId(eventDataModel.Id);
var eventDetailModel = AutoMapper.Mapper.Map <List <Contracts.Models.EventDetail> >(eventDetailDataModel);
var venueDataModel = _venueRepository.GetByVenueIds(eventDetailDataModel.Select(s => s.VenueId).Distinct());
var venueModel = AutoMapper.Mapper.Map <List <Contracts.Models.Venue> >(venueDataModel);
var cityDataModel = _cityRepository.GetByCityIds(venueDataModel.Select(s => s.CityId));
var cityModel = AutoMapper.Mapper.Map <List <Contracts.Models.City> >(cityDataModel);
var stateDataModel = _stateRepository.GetByStateIds(cityDataModel.Select(s => s.StateId));
var stateModel = AutoMapper.Mapper.Map <List <Contracts.Models.State> >(stateDataModel);
var countryDataModel = _countryRepository.GetByCountryIds(stateDataModel.Select(s => s.CountryId));
var countryModel = AutoMapper.Mapper.Map <List <Contracts.Models.Country> >(countryDataModel);
var eventGallaryDataModel = _eventGalleryImageRepository.GetByEventId(eventModel.Id);
var galleryDataModel = AutoMapper.Mapper.Map <List <Contracts.Models.EventGalleryImage> >(eventGallaryDataModel);
var ratingDataModel = _ratingRepository.GetByEventId(eventDataModel.Id);
var ratingModel = AutoMapper.Mapper.Map <List <Contracts.Models.Rating> >(ratingDataModel);
var userdataModel = _userRepository.GetByUserIds(ratingModel.Select(s => s.UserId).Distinct());
var userModel = AutoMapper.Mapper.Map <List <Contracts.Models.UserProfile> >(userdataModel);
var eventCategoryDataModel = _eventCategoryRepository.Get(eventModel.EventCategoryId);
var eventCategoryModel = AutoMapper.Mapper.Map <Contracts.Models.EventCategory>(eventCategoryDataModel);
return(new WebEventLearnPageQueryResults
{
EventType = (EventType)eventModel.EventTypeId != 0 ? (EventType)eventModel.EventTypeId : EventType.Regular,
EventCategory = eventCategoryModel,
Event = eventModel,
EventDetail = eventDetailModel,
Venue = venueModel,
City = cityModel,
Rating = ratingModel,
User = userModel,
State = stateModel,
Country = countryModel,
EventGalleryImage = galleryDataModel
});
}
else
{
return(new WebEventLearnPageQueryResults
{
});
}
}
public ReportSubEventsQueryResult Handle(ReportSubEventsQuery query)
{
List <FIL.Contracts.Models.EventDetail> subEventList = new List <FIL.Contracts.Models.EventDetail>();
List <EventDetail> subEventFinalList = new List <EventDetail>();
var userDetail = _userRepository.GetByAltId(query.UserAltId);
var eventDetail = _eventRepository.GetByAltId(query.EventAltId);
var assignedEvents = _eventsUserMappingRepository.GetByUserIdAndEventId(userDetail.Id, eventDetail.Id);
List <FIL.Contracts.Models.EventDetail> subEvents = new List <FIL.Contracts.Models.EventDetail>();
if (userDetail.RolesId != 1)
{
subEvents = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDetail> >(_eventDetailRepository.GetByEventDetailIds(assignedEvents.Select(s => s.EventDetailId)));
}
else
{
subEvents = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDetail> >(_eventDetailRepository.GetAllByEventId(eventDetail.Id));
}
for (int k = 0; k < subEvents.Count; k = k + 2000)
{
var eventDetailBatcher = subEvents.Skip(k).Take(2000);
if (query.EventAltId.ToString().ToUpper() == "E6B318DB-0945-4F96-841A-F58AED54EFCB")
{
var venues = _venueRepository.GetByVenueIds(eventDetailBatcher.Select(s => s.VenueId).Distinct());
foreach (var item in venues)
{
subEventList.Add(new FIL.Contracts.Models.EventDetail
{
Id = item.Id,
Name = item.Name
});
}
}
else
{
subEventList = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDetail> >(eventDetailBatcher.OrderBy(o => o.StartDateTime));
}
subEventFinalList = subEventFinalList.Concat(AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDetail> >(subEventList)).ToList();
}
return(new ReportSubEventsQueryResult
{
SubEvents = subEventFinalList
});
}
public GetPlaceInventoryQueryResult Handle(GetPlaceInventoryQuery query)
{
try
{
var eventData = _eventRepository.GetByAltId(query.PlaceAltId);
var eventModel = AutoMapper.Mapper.Map <FIL.Contracts.Models.Event>(eventData);
List <string> TicketValidityTypes = new List <string>();
List <string> DeliveryTypes = new List <string>();
foreach (FIL.Contracts.Enums.TicketValidityTypes ticketValidity in Enum.GetValues(typeof(FIL.Contracts.Enums.TicketValidityTypes)))
{
TicketValidityTypes.Add(ticketValidity.ToString());
}
foreach (FIL.Contracts.Enums.DeliveryTypes DeliveryType in Enum.GetValues(typeof(FIL.Contracts.Enums.DeliveryTypes)))
{
DeliveryTypes.Add(DeliveryType.ToString());
}
var eventDetail = _eventDetailRepository.GetAllByEventId(eventData.Id);
var eventDetailModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDetail> >(eventDetail).Where(s => s.IsEnabled == true).ToList();
var eventTicketDetils = _eventTicketDetail.GetByEventDetailId(eventDetail.ElementAt(0).Id).Where(s => s.IsEnabled == true);
var eventAttribute = _eventAttributeRepository.GetByEventDetailId(eventDetail.FirstOrDefault().Id);
var EventTicketDetailTicketCategoryTypeMappingDataModel = _eventTicketDetailTicketCategoryTypeMappingRepository.GetByEventTicketDetails(eventTicketDetils.Select(s => s.Id).ToList()).Where(s => s.IsEnabled == true);
var EventTicketDetailTicketCategoryTypeMappingModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventTicketDetailTicketCategoryTypeMapping> >(EventTicketDetailTicketCategoryTypeMappingDataModel);
var ticketCategories = _ticketCategoryRepository.GetByTicketCategoryIds(eventTicketDetils.Select(s => s.TicketCategoryId)).Where(s => s.IsEnabled == true);
var placeCustomerDocumentTypes = _placeCustomerDocumentTypeMappingRepository.GetAllByEventId(eventData.Id);
var placeCustomerDocumentTypeModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.PlaceCustomerDocumentTypeMapping> >(placeCustomerDocumentTypes);
var placeTicketRedemptionDetails = _placeTicketRedemptionDetailRepository.GetAllByEventDetailIds(eventDetail.Select(s => s.Id));
var placeTicketRedemptionDetailModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.PlaceTicketRedemptionDetail> >(placeTicketRedemptionDetails);
var placeDeliveryTypes = _eventDeliveryTypeDetailRepository.GetByEventDetailId(eventDetail.ElementAt(0).Id);
var placeDeliveryTypesModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventDeliveryTypeDetail> >(placeDeliveryTypes);
var customerDoumentType = _customerDocumentTypeRepository.GetAll();
var customerDoumentTypeModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.CustomerDocumentType> >(customerDoumentType);
var placeHolidayDates = _placeHolidydates.GetAllByEventId(eventData.Id);
var placeHolidayDatesModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.PlaceHolidayDate> >(placeHolidayDates);
var placeWeekOffs = _placeWeekOffRepository.GetAllByEventId(eventData.Id);
var placeWeekOffsModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.PlaceWeekOff> >(placeWeekOffs);
var customerInformationMapping = _customerInformationRepository.GetAll();
var customerInformationMappingModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.CustomerInformation> >(customerInformationMapping);
var eventCustomerInformationMapping = _eventCustomerInformationMappingRepository.GetAllByEventID(eventModel.Id).ToList();
List <FIL.Contracts.Models.EventCustomerInformationMapping> eventCustomerInformationMappingModel = new List <Contracts.Models.EventCustomerInformationMapping>();;
if (eventCustomerInformationMapping.Count() > 0)
{
eventCustomerInformationMappingModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.EventCustomerInformationMapping> >(eventCustomerInformationMapping);
}
List <FIL.Contracts.DataModels.EventTicketDetail> etdList = new List <FIL.Contracts.DataModels.EventTicketDetail>();
foreach (FIL.Contracts.DataModels.EventTicketDetail currentTicketCat in eventTicketDetils.ToList())
{ /*--------------- Add those ETD whose eventticketdetail and ETA exists */
var etaData = _eventTicketAttribute.GetByEventTicketDetailIdFeelAdmin(currentTicketCat.Id);
if (etaData != null)
{
etdList.Add(currentTicketCat);
}
}
var ticketCategoryContainer = etdList.Select(td =>
{
try
{
var ticketDetailModel = AutoMapper.Mapper.Map <FIL.Contracts.Models.EventTicketDetail>(td);
var ticketCategory = _ticketCategoryRepository.Get((int)td.TicketCategoryId);
var ticketCategoryModel = AutoMapper.Mapper.Map <FIL.Contracts.Models.TicketCategory>(ticketCategory);
var eventTicketAttributes = _eventTicketAttribute.GetByEventTicketDetailIdFeelAdmin(td.Id);
var eventTicketAttributeModel = AutoMapper.Mapper.Map <FIL.Contracts.Models.EventTicketAttribute>(eventTicketAttributes);
var TicketCategoryTypeTypeMapping = _eventTicketDetailTicketCategoryTypeMappingRepository.GetByEventTicketDetail(td.Id);
var ticketFeeDetail = _ticketFeeDetailRepository.GetAllByEventTicketAttributeId(eventTicketAttributeModel.Id);
var ticketFeeDetailModel = AutoMapper.Mapper.Map <List <FIL.Contracts.Models.TicketFeeDetail> >(ticketFeeDetail);
return(new TicketCategoryInfo
{
TicketCategory = ticketCategoryModel,
EventTicketAttribute = eventTicketAttributeModel,
EventTicketDetail = ticketDetailModel,
TicketCategorySubTypeId = (TicketCategoryTypeTypeMapping != null ? TicketCategoryTypeTypeMapping.TicketCategorySubTypeId : 1),
TicketCategoryTypeId = (TicketCategoryTypeTypeMapping != null ? TicketCategoryTypeTypeMapping.TicketCategoryTypeId : 1),
TicketFeeDetails = ticketFeeDetailModel
});
}
catch (Exception e)
{
return(new TicketCategoryInfo
{
});
}
}).ToList();
var data = _calendarProvider.GetCalendarData(eventData.Id);
return(new GetPlaceInventoryQueryResult
{
Event = eventModel,
EventDetails = eventDetailModel,
TicketCategoryContainer = ticketCategoryContainer,
PlaceCustomerDocumentTypeMappings = placeCustomerDocumentTypeModel,
DeliveryTypes = DeliveryTypes,
eventDeliveryTypeDetails = placeDeliveryTypesModel,
EventTicketDetailTicketCategoryTypeMappings = EventTicketDetailTicketCategoryTypeMappingModel,
PlaceTicketRedemptionDetails = placeTicketRedemptionDetailModel,
TicketValidityTypes = TicketValidityTypes,
CustomerDocumentTypes = customerDoumentTypeModel,
PlaceHolidayDates = placeHolidayDatesModel,
PlaceWeekOffs = placeWeekOffsModel,
CustomerInformations = customerInformationMappingModel,
EventCustomerInformationMappings = eventCustomerInformationMappingModel,
RegularTimeModel = data.RegularTimeModel,
SeasonTimeModel = data.SeasonTimeModel,
SpecialDayModel = data.SpecialDayModel,
EventAttribute = eventAttribute
});
}
catch (Exception e)
{
return(new GetPlaceInventoryQueryResult
{
});
}
}
protected override async Task <ICommandResult> Handle(ZoomValidateUserCommand command)
{
ZoomValidateUserCommandResult zoomValidateUserCommandResult = new ZoomValidateUserCommandResult();
try
{
var zoomUserModel = _zoomUserRepository.GetByAltId(command.AltId);
var getTimeStamp = GetTimeStamp(zoomUserModel);
zoomValidateUserCommandResult.timeStamp = getTimeStamp;
//var checkTimeStamp = CheckValidTimeStamp(zoomUserModel);
//if (!checkTimeStamp.IsValid)
//{
// zoomValidateUserCommandResult.message = checkTimeStamp.Message;
// zoomValidateUserCommandResult.success = false;
// return zoomValidateUserCommandResult;
//}
if (zoomUserModel == null)
{
if (zoomUserModel == null)
{
zoomValidateUserCommandResult.message = Constant.Zoom.Message.Invalid;
}
else
{
zoomValidateUserCommandResult.message = Constant.Zoom.Message.Active;
}
zoomValidateUserCommandResult.success = false;
return(zoomValidateUserCommandResult);
}
else
{
string apikey = _settings.GetConfigSetting <string>(SettingKeys.Integration.Zoom.API_Key);
string apiSecret = _settings.GetConfigSetting <string>(SettingKeys.Integration.Zoom.Secret_key);
var zoomMeetingModel = _zoomMeetingRepository.GetByEventId(zoomUserModel.EventId);
//Interactivity levels available
zoomValidateUserCommandResult.isAudioAvailable = true;
zoomValidateUserCommandResult.isVideoAvailable = true;
zoomValidateUserCommandResult.isChatAvailable = true;
bool isHost = false;
var access = Access.None;
var eventHostModel = new EventHostMapping();
if (zoomUserModel.RoleId != 21 && zoomUserModel.RoleId != 26) // If the user is attendee
{
var userModel = _userRepository.Get(zoomUserModel.UserId);
zoomValidateUserCommandResult.email = userModel.Email;
zoomValidateUserCommandResult.userName = userModel.FirstName + " " + userModel.LastName;
zoomValidateUserCommandResult.UserAltId = userModel.AltId;
var transactionDetailsModel = _transactionRepository.GetFeelOnlineDetails(zoomUserModel.TransactionId).Where(s => s.TransactionType == Contracts.Enums.TransactionType.LiveOnline).FirstOrDefault();
if (transactionDetailsModel == null)
{
return(zoomValidateUserCommandResult);
}
//interactivity levels available based on ticket cat.
if (transactionDetailsModel.TicketCategoryId == 1360)
{
access = Access.GA;
zoomValidateUserCommandResult.isAudioAvailable = false;
zoomValidateUserCommandResult.isVideoAvailable = false;
zoomValidateUserCommandResult.isChatAvailable = false;
}
if (transactionDetailsModel.TicketCategoryId == 606)
{
access = Access.VIP;
zoomValidateUserCommandResult.isAudioAvailable = false;
zoomValidateUserCommandResult.isVideoAvailable = false;
}
if (transactionDetailsModel.TicketCategoryId == 12080 || transactionDetailsModel.TicketCategoryId == 19352)
{
zoomValidateUserCommandResult.isVideoAvailable = false;
}
}
else // Host user
{
eventHostModel = _eventHostMappingRepository.Get(zoomUserModel.EventHostUserId);
zoomValidateUserCommandResult.email = eventHostModel.Email;
zoomValidateUserCommandResult.userName = eventHostModel.FirstName + " " + eventHostModel.LastName;
isHost = true;
}
zoomValidateUserCommandResult.meetingNumber = zoomMeetingModel.MeetingNumber.ToString();
zoomValidateUserCommandResult.apikey = apikey;
zoomValidateUserCommandResult.secretkey = apiSecret;
zoomValidateUserCommandResult.success = true;
zoomValidateUserCommandResult.roleId = (zoomUserModel.RoleId == 21 || zoomUserModel.RoleId == 26) ? "1" : "0";
if (!zoomUserModel.IsActive && command.IsZoomLandingPage)
{
zoomUserModel.UniqueId = command.UniqueId;
zoomUserModel.IsActive = true;
_zoomUserRepository.Save(zoomUserModel);
}
var eventDetail = _eventDetailRepository.GetAllByEventId(zoomUserModel.EventId).FirstOrDefault();
zoomValidateUserCommandResult.eventName = eventDetail.Name;
if (!command.IsZoomLandingPage)
{
zoomValidateUserCommandResult.EventAttribute = _eventAttributeRepository.GetByEventDetailId(eventDetail.Id);
zoomValidateUserCommandResult.EventHostMappings = _eventHostMappingRepository.GetAllByEventId(eventDetail.EventId).OrderBy(s => s.StartDateTime).ToList();
foreach (var currentEHM in zoomValidateUserCommandResult.EventHostMappings)
{
currentEHM.StartDateTime = currentEHM.StartDateTime != null?_localTimeZoneConvertProvider.ConvertToLocal((DateTime)currentEHM.StartDateTime, zoomValidateUserCommandResult.EventAttribute.TimeZone) : currentEHM.StartDateTime;
currentEHM.EndDateTime = currentEHM.EndDateTime != null?_localTimeZoneConvertProvider.ConvertToLocal((DateTime)currentEHM.EndDateTime, zoomValidateUserCommandResult.EventAttribute.TimeZone) : currentEHM.EndDateTime;
}
zoomValidateUserCommandResult.EventDetail = _eventDetailRepository.Get(eventDetail.Id);
zoomValidateUserCommandResult.LiveEventDetail = _liveEventDetailRepository.GetByEventId(eventDetail.EventId);
if (isHost && eventHostModel.StartDateTime != null && zoomValidateUserCommandResult.LiveEventDetail != null)
{
zoomValidateUserCommandResult.LiveEventDetail.EventStartDateTime = eventHostModel.StartDateTime;
}
zoomValidateUserCommandResult.Event = _eventRepository.Get(eventDetail.EventId);
var eventTicketDetails = _eventTicketDetailRepository.GetByEventDetailId(eventDetail.Id).Where(s => s.IsEnabled).ToList();
var eventTicketAttributes = _eventTicketAttributeRepository.GetByEventTicketDetailIds(eventTicketDetails.Select(s => s.Id)).Where(s => s.IsEnabled).ToList();
if (eventTicketDetails.Select(s => s.TicketCategoryId).Contains(19452) || eventTicketDetails.Select(s => s.TicketCategoryId).Contains(12259)) // if donate
{
zoomValidateUserCommandResult.IsDonate = true;
}
if ((access == Access.GA || access == Access.VIP) && eventTicketDetails.Select(s => s.TicketCategoryId).Contains(19350) || eventTicketDetails.Select(s => s.TicketCategoryId).Contains(12079)) // if BSP Exists
{
var price = getBSPPrice(eventTicketDetails, eventTicketAttributes) - (access == Access.GA ? getGAPrice(eventTicketDetails, eventTicketAttributes) : getVIP(eventTicketDetails, eventTicketAttributes));
var transacions = _transactionRepository.GetAllSuccessfulTransactionByReferralId(zoomUserModel.TransactionId.ToString());
if (price >= 0 && !transacions.Any())
{
zoomValidateUserCommandResult.IsUpgradeToBSP = true;
zoomValidateUserCommandResult.Price = price;
}
}
if (zoomUserModel.RoleId != 21 && zoomUserModel.RoleId != 26) // If the user is attendee
{
var transactionDetail = _transactionDetailRepository.GetByTransactionId(zoomUserModel.TransactionId);
var eta = _eventTicketAttributeRepository.Get(transactionDetail.Count() > 1 ? transactionDetail.Where(s => s.TransactionType == Contracts.Enums.TransactionType.LiveOnline).FirstOrDefault().EventTicketAttributeId : transactionDetail.FirstOrDefault().EventTicketAttributeId);
zoomValidateUserCommandResult.ImportantInformation = eta.TicketCategoryNotes;
/* If Recurring then update Event Start & Interactivity start time */
if (eventDetail.EventFrequencyType == Contracts.Enums.EventFrequencyType.Recurring)
{
UpdateEventSchedule(zoomValidateUserCommandResult, transactionDetail.ToList());
}
}
else
{
zoomValidateUserCommandResult.ImportantInformation = zoomValidateUserCommandResult.EventHostMappings.Where(s => s.Id == zoomUserModel.EventHostUserId).FirstOrDefault().ImportantInformation;
}
}
}
zoomValidateUserCommandResult.success = true;
zoomValidateUserCommandResult.TransactionId = zoomUserModel.TransactionId;
return(zoomValidateUserCommandResult);
}
catch (Exception e)
{
_logger.Log(LogCategory.Error, new Exception("Failed to validate zoom details " + e.Message, e));
return(zoomValidateUserCommandResult);
}
}
protected override async Task <ICommandResult> Handle(PlaceCalendarCommand command)
{
try
{
var StartDateTime = DateTime.UtcNow;
var EndDateTime = DateTime.UtcNow.AddYears(2);
List <EventDetail> createdEventDetailList = new List <EventDetail>();
if (command.PlaceType == FIL.Contracts.Enums.EventType.Regular)
{
StartDateTime = command.PlaceStartDate;
EndDateTime = command.PlaceEndDate;
}
var place = _eventRepository.GetByAltId(command.PlaceAltId);
var placeDetail = _eventDetailRepository.GetSubEventByEventId(place.Id).ToList();
var currentPlaceDetail = _eventDetailRepository.GetByEvent(place.Id).ToList();
if (!currentPlaceDetail.Any())
{
try
{
foreach (FIL.Contracts.DataModels.EventDetail currentEventDetail in currentPlaceDetail)
{
currentEventDetail.IsEnabled = false;
currentEventDetail.EventId = 2384;
_eventDetailRepository.Save(currentEventDetail);
}
}
catch (Exception e)
{
}
EventDetail eventDetail = new EventDetail();
eventDetail.AltId = Guid.NewGuid();
eventDetail.EventId = place.Id;
eventDetail.Description = "";
eventDetail.IsEnabled = true;
eventDetail.Name = place.Name;
eventDetail.VenueId = 9893;
eventDetail.IsEnabled = true;
eventDetail.CreatedBy = command.ModifiedBy;
eventDetail.CreatedUtc = DateTime.Now;
eventDetail.UpdatedBy = command.ModifiedBy;
eventDetail.ModifiedBy = command.ModifiedBy;
eventDetail.UpdatedUtc = DateTime.Now;
eventDetail.StartDateTime = StartDateTime;
eventDetail.EndDateTime = EndDateTime;
eventDetail.GroupId = 1;
_eventDetailRepository.Save(eventDetail);
}
var index = -1;
int venueId = 1;
//DateTime From = new DateTime(StartDateTime.Year, StartDateTime.Month, StartDateTime.Day, StartDateTime.Hour, StartDateTime.Minute, 0).ToUniversalTime();
var From = StartDateTime;
var To = EndDateTime;
//DateTime To = new DateTime(EndDateTime.Year, EndDateTime.Month, EndDateTime.Day, EndDateTime.Hour, EndDateTime.Minute, 0).ToUniversalTime();
if (!command.IsEdit) // if new creation
{
place.EventTypeId = command.PlaceType;
_eventRepository.Save(place);
index = index + 1;
Guid guid = Guid.NewGuid();
venueId = placeDetail.ElementAt(0).VenueId;
placeDetail.ElementAt(0).Name = place.Name;
placeDetail.ElementAt(0).AltId = guid;
placeDetail.ElementAt(0).StartDateTime = From;
placeDetail.ElementAt(0).EndDateTime = To;
placeDetail.ElementAt(0).UpdatedUtc = DateTime.UtcNow;
_eventDetailRepository.Save(placeDetail.ElementAt(0));
deleteCalendar(place);
addCalendar(command, place);
var eventDetail = _eventDetailRepository.GetByAltId(guid);
createdEventDetailList.Add(eventDetail);
CreateNewHolidyCalendar(command.HolidayDates, eventDetail.Id, place.Id);
var weeklyOffDaysCount = command.WeekOffDays.Where(s => s).Count();
CreatePlaceWeekOffs(weeklyOffDaysCount, eventDetail.Id, command.WeekOffDays, place.Id);
}
else // if edit
{
if (place.EventTypeId != command.PlaceType)
{
place.EventTypeId = command.PlaceType;
_eventRepository.Save(place);
}
index = 0;
var eventDetails = _eventDetailRepository.GetAllByEventId(place.Id).ToList();
Guid guid = Guid.NewGuid();
var eventDetail = _eventDetailRepository.GetAllByEventId(place.Id).ElementAt(index);
eventDetail.Name = place.Name;
eventDetail.StartDateTime = From;
eventDetail.EndDateTime = To;
eventDetail.IsEnabled = true;
_eventDetailRepository.Save(eventDetail);
deleteCalendar(place);
addCalendar(command, place);
var weeklyOffDaysCount = command.WeekOffDays.Where(s => s).Count();
UpdatePlaceWeekOff(weeklyOffDaysCount, eventDetail.Id, command.WeekOffDays, place.Id);
if (command.HolidayDates.Count() > 0)
{
UpdatePlaceHoliday(command.HolidayDates, eventDetail.Id, place.Id);
}
updateEventStatus(place.Id, false);
}
return(new PlaceCalendarCommandResult
{
Success = true,
});
}
catch (Exception e)
{
return(new PlaceCalendarCommandResult {
});
}
}