public int tblEvent_insert(EventDTO dt)
{
string sql = "INSERT INTO tblEvent(Subject, Voucher, Subscribe, Body, ConfigId, StartDate, EndDate, ResponeUrl, ConfirmContent, ConfirmFlag) " +
"VALUES(@Subject, @Voucher, @Subscribe, @Body, @ConfigId, @StartDate, @EndDate, @ResponeUrl, @ConfirmContent, @ConfirmFlag) SELECT SCOPE_IDENTITY()";
SqlCommand cmd = new SqlCommand(sql, ConnectionData._MyConnection);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("@Subject", SqlDbType.NVarChar).Value = dt.Subject;
cmd.Parameters.Add("@Voucher", SqlDbType.VarChar).Value = dt.Voucher;
cmd.Parameters.Add("@Subscribe", SqlDbType.VarChar).Value = dt.Subscribe;
cmd.Parameters.Add("@Body", SqlDbType.NVarChar).Value = dt.Body;
cmd.Parameters.Add("@ConfigId", SqlDbType.Int).Value = dt.ConfigId;
cmd.Parameters.Add("@StartDate", SqlDbType.DateTime).Value = dt.StartDate;
cmd.Parameters.Add("@EndDate", SqlDbType.DateTime).Value = dt.EndDate;
cmd.Parameters.Add("@ResponeUrl", SqlDbType.VarChar).Value = dt.ResponeUrl;
cmd.Parameters.Add("@ConfirmContent", SqlDbType.NVarChar).Value = dt.ConfirmContent;
cmd.Parameters.Add("@ConfirmFlag", SqlDbType.Char).Value = dt.ConfirmFlag;
if (ConnectionData._MyConnection.State == ConnectionState.Closed)
{
ConnectionData._MyConnection.Open();
}
var eventId = cmd.ExecuteScalar();
cmd.Dispose();
return int.Parse(eventId.ToString());
}
private static void CreateEvent()
{
Console.WriteLine("Name ?");
var name = Console.ReadLine();
Console.WriteLine("Address ?");
var address = Console.ReadLine();
Console.WriteLine("Description ?");
var description = Console.ReadLine();
Console.WriteLine("Date - dd/mm/yyyy ?");
var date_str = Console.ReadLine();
var date = Convert.ToDateTime(date_str);
ReadTypeEvent();
Console.WriteLine("ID Type Event ?");
var id_typeEvent = Convert.ToInt32(Console.ReadLine());
var typeEvent = service.GetTypeEvent(id_typeEvent);
var statusEvent = service.GetStatusEventByName("Pending");
ReadPerson();
Console.WriteLine("ID Person Creator ?");
var id_person = Convert.ToInt32(Console.ReadLine());
var person = service.GetPerson(id_person);
var events = new EventDTO { Name = name, Address = address, Description = description, Date = date, CreatorId = person.PersonId, TypeEventId = typeEvent.TypeEventId, StatusEventId = statusEvent.StatusEventId };
service.InsertEvent(events);
Console.WriteLine("Event created !");
}
private async Task CreateRegistrations(EventDTO eventData, CreateOrderDTO order, Order orderData)
{
var registrations = order.OrderItems.Select(i => new RegistrationDTO()
{
Id = Guid.NewGuid().ToString(),
FirstName = i.FirstName,
LastName = i.LastName,
Email = i.Email,
Sku = i.Sku,
SkuDescription = eventData.Prices.Single(p => p.Sku == i.Sku).Title,
OrderId = orderData.Id
});
await eventsApi.ApiRegistrationsByEventIdBatchPostAsync(eventData.Id, registrations);
}
private async Task <bool> Update(EventDTO ev)
{
HttpResponseMessage response = await _client.PutAsJsonAsync("api/event/", ev)
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
public bool Update(EventDTO eventDTO)
{
var eventFromId = eventRepo.GetById(eventDTO.Id);
if (eventFromId == null)
{
return(false);
}
eventFromId.InjectFrom(eventDTO);
eventRepo.Update(eventFromId);
unitOfWork.Commit();
return(true);
}
public async Task ApplyDiscount(EventDTO eventData, CalculateOrderDTO order, List <PriceDataDTO> orderItemPrices, bool invalidateDiscountCoupon)
{
// get discount code
var discountCode = await discountCodeCollection.FindByIdAsync(order.DiscountCode);
if (discountCode == null || discountCode.ExpirationDate < DateTime.UtcNow || discountCode.ClaimedDate != null)
{
throw new InvalidDiscountCodeException();
}
// apply to products
for (int i = 0; i < order.OrderItems.Count; i++)
{
var orderItem = order.OrderItems[i];
var orderItemPrice = orderItemPrices[i];
// try to find an applicable rule
var rule = discountCode.Rules.FirstOrDefault(r => r.ApplicableSku.Contains(orderItem.Sku));
if (rule != null)
{
// apply the rule
var applicableAmount = Math.Min(orderItem.Amount, rule.MaxAmount);
var discountPrice = CalculateDiscountPrice(rule, orderItemPrice);
// add the discount order line
order.OrderItems.Add(new CalculateOrderItemDTO()
{
Sku = Constants.DiscountSku,
Amount = applicableAmount
});
orderItemPrices.Add(new PriceDataDTO()
{
BasePrice = -discountPrice,
CurrencyCode = orderItemPrice.CurrencyCode,
Price = OrderPriceCalculationFacade.Round(-discountPrice * applicableAmount)
});
if (invalidateDiscountCoupon)
{
// claim discount code
await InvalidateDiscountCode(order);
}
return;
}
}
throw new InvalidDiscountCodeException();
}
public async Task SendEventResultsAsync(Message message, EventDTO eventDTO, CancellationToken cancellationToken = default)
{
if (eventDTO is null)
{
throw new ArgumentNullException(nameof(eventDTO));
}
var messageBuilder = new StringBuilder();
var buttons = new List <InlineKeyboardButton>();
AppendEventName(eventDTO, messageBuilder);
messageBuilder.Append(GetEventDateString(eventDTO));
messageBuilder.Append(" ");
messageBuilder.Append(eventDTO.Location);
messageBuilder.Append("\n");
messageBuilder.Append("\n");
if (eventDTO.FightCard != null)
{
foreach (var card in eventDTO.FightCard)
{
AppendCardName(messageBuilder, card);
foreach (var fight in card.Fights)
{
AppendFightFullInfo(messageBuilder, fight);
}
messageBuilder.Append("\n");
}
}
if (eventDTO.BonusAwards != null && eventDTO.BonusAwards.Any())
{
messageBuilder.Append("<u>Бонусные награды:</u>\n");
foreach (var award in eventDTO.BonusAwards)
{
messageBuilder.Append("- " + award + "\n");
}
}
var replyMarkup = message.ReplyMarkup.InlineKeyboard.SelectMany(e => e)
.Where(button => !button.CallbackData.StartsWith(GetEventResultsByIdCommand.Name));
await telegramBotClient.EditMessageTextAsync(
message.Chat.Id,
message.MessageId,
messageBuilder.ToString(),
parseMode : ParseMode.Html,
replyMarkup : new InlineKeyboardMarkup(replyMarkup),
cancellationToken : cancellationToken);
}
// ReSharper restore FunctionNeverReturns
#endregion
#region DATA PRINTING
public void UpdateGrid(EventDTO[] eventsToUpdate, GlobalFlags.CallbackTypes gridUpdateType)
{
foreach (var eventDTO in eventsToUpdate)
{
var found = _eventsCollection.FirstOrDefault(targetGuid => targetGuid.EventGuid == eventDTO.AdcEventId);
int index = _eventsCollection.IndexOf(found);
EventDTO dto = eventDTO;
if (index >= 0)
{
if (gridUpdateType == GlobalFlags.CallbackTypes.OnEvensUpdated)
{
Dispatcher.Invoke(new Action(() => _eventsCollection[index] = new EventData
{
EventGuid = dto.AdcEventId,
EventNumber = (index + 1).ToString(),
EventOnAirTime = TimeCodeDTOToStringConverter(dto.OnAirTime, false),
EventID = dto.ID,
EventTitle = dto.Title,
EventStatus = GetStatusString(dto.EventStatus, dto.DeviceIndex),
EventDuration = TimeCodeDTOToStringConverter(dto.Duration),
EventSOM = TimeCodeDTOToStringConverter(dto.Som),
EventProtectedDevice = GetDeviceByIndex(dto.BackupDeviceIndex)
}
));
}
MarkLine(GetGridLineType(dto.EventStatus, dto.DeviceIndex), index, false);
if (gridUpdateType == GlobalFlags.CallbackTypes.OnEventsDeleted)
{
Dispatcher.Invoke(new Action(() => _eventsCollection.Remove(found)));
}
}
if (gridUpdateType == GlobalFlags.CallbackTypes.OnEventsAdded)
{
Dispatcher.Invoke(new Action(() => _eventsCollection.Add(new EventData
{
EventGuid = dto.AdcEventId,
EventNumber = (_eventsCollection.Count + 1).ToString(),
EventOnAirTime = TimeCodeDTOToStringConverter(dto.OnAirTime, false),
EventID = dto.ID,
EventTitle = dto.Title,
EventStatus = GetStatusString(dto.EventStatus, dto.DeviceIndex),
EventDuration = TimeCodeDTOToStringConverter(dto.Duration),
EventSOM = TimeCodeDTOToStringConverter(dto.Som),
EventProtectedDevice = GetDeviceByIndex(dto.BackupDeviceIndex)
})));
MarkLine(GetGridLineType(dto.EventStatus, dto.DeviceIndex), _eventsCollection.Count, false);
}
}
}
private Task <EventDTO> CreateNewEventAsync(CancellationTokenSource cancellationTokenSource) =>
Task <EventDTO> .Run(async() => {
EventDTO createdEvent = null;
if (ValidateForm())
{
try {
createdEvent = await _schedulingService.CreateNewEventAsync(
new ManageEventDataModel()
{
ShortLabel = ShortLabel.Value?.Trim(),
RepeatsUntil = RepeatUntil.Value,
RepeatingType = (SelectedRepeating.Value == null) ? ActionRepeatsDataItem.NOT_REPEAT_VALUE : SelectedRepeating.Value.Value,
Assignments = Assignments.Select <AssignmentViewModel, AssignmentDataModel>(aVM => aVM.BuildDataModel()).ToArray(),
DurationInMinutes = (string.IsNullOrEmpty(Duration.Value) || string.IsNullOrWhiteSpace(Duration.Value)) ? default(long) : long.Parse(Duration.Value.Trim()),
Name = NameOfEvent.Value?.Trim(),
IsTimeTbd = TimeTBD,
LocationDetails = LocationDetails.Value?.Trim(),
LocationId = SelectedLocation.Value.Id,
Notes = Notes.Value?.Trim(),
NotifyTeam = ToNotifyYourTeam,
StartDate = Date.Value + Time.Value,
TeamId = _targetTeamMember.Team.Id,
}, cancellationTokenSource);
if (createdEvent != null)
{
Device.BeginInvokeOnMainThread(() => GlobalSettings.Instance.AppMessagingEvents.ScheduleEvents.InvokeEventCreated(this, new EventManagmentArgs()
{
Event = createdEvent, TeamMember = _targetTeamMember
}));
}
else
{
throw new InvalidOperationException(SchedulingService.CREATE_NEW_GAME_COMMON_ERROR_MESSAGE);
}
}
catch (OperationCanceledException) { }
catch (ObjectDisposedException) { }
catch (ServiceAuthenticationException) { }
catch (Exception exc) {
Crashes.TrackError(exc);
Device.BeginInvokeOnMainThread(async() => await DialogService.ToastAsync(exc.Message));
}
}
return(createdEvent);
});
public int Create(EventDTO eventDTO)
{
Event Event = EventMapper.EventDTO2Event(eventDTO);
string[] InviteList = eventDTO.Invites;
db.Events.Add(Event);
db.SaveChanges();
int EventID = Event.EventID;
InviteOperations.AddInvites(InviteList, EventID);
db.SaveChanges();
return(EventID);
}
private async Task <bool> Add(EventDTO ev)
{
HttpResponseMessage response =
await _client.PostAsJsonAsync <EventDTO>(string.Format("api/event/"), ev)
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
public static Event ToEvent(this EventDTO evnt)
{
return(new Event
{
Id = evnt.Id,
EventTypeId = evnt.EventTypeId,
PersonId = evnt.PersonId,
PlaceId = evnt.PlaceId,
Date = evnt.Date,
Description = evnt.Description,
CreatedDate = evnt.CreatedDate,
ModifiedDate = evnt.ModifiedDate,
});
}
public ActionResult AddEvent(EventInputModel inputModel)
{
var model = new EventDTO
{
EventName = inputModel.EventName,
OddsForFirstTeam = inputModel.OddsForFirstTeam,
OddsForDraw = inputModel.OddsForDraw,
OddsForSecondTeam = inputModel.OddsForSecondTeam,
EventStartDate = inputModel.EventStartDate
};
this.eventService.AddEvent(model);
return(this.RedirectToAction(Views.IndexView));
}
public static EventDTO GetEventByUserCode(int userCode)
{
Events__tbl getEvent = DAL.EventDAL.GetEventByUserCode(userCode);
if (getEvent == null)
{
return(null);
}
else
{
EventDTO eventDTOs = EventDTO.ObjectToDTO(getEvent);
return(eventDTOs);
}
}
public void AddEvent(EventModel newEvent)
{
var modeltransfer = new EventDTO()
{
Name = newEvent.Name,
Description = newEvent.Description,
EndTime = newEvent.EndTime,
Month = newEvent.Date,
Nrbar = newEvent.Nrbar,
Nrevent = newEvent.Nrevent,
Nriets = newEvent.Nriets
};
Context.AddEvent(modeltransfer);
}
public PartialEventViewModel EventDTO2PartialEventViewModel(EventDTO eventDTO)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <EventDTO, PartialEventViewModel>());
var mapper = config.CreateMapper();
PartialEventViewModel PartialEventViewModel = mapper.Map <PartialEventViewModel>(eventDTO);
PartialEventViewModel.StartDate = new DateTime(eventDTO.StartDateAndTime.Year, eventDTO.StartDateAndTime.Month, eventDTO.StartDateAndTime.Day);
TimeSpan timeSpan = eventDTO.StartDateAndTime.TimeOfDay;
PartialEventViewModel.StartTime += timeSpan;
return(PartialEventViewModel);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
EventDTO = await _context.EventDTO.FirstOrDefaultAsync(m => m.Id == id);
if (EventDTO == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> Create([FromBody] EventDTO eventDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = _identityService.GetUserIdByNameAsync(User.Identity.Name).ToString();
await _eventService.Create(eventDto, userId);
_logger.LogInformation($"{userId} add new event");
return(Ok());
}
public async Task <int> CreateAsync(EventDTO ev)
{
var eventEntity = new Event
{
DateTime = ev.DateTime,
Location = ev.Location,
WineType = ev.WineType
};
await _context.Events.AddAsync(eventEntity);
await _context.SaveChangesAsync();
return(eventEntity.Id);
}
public EventVM(EventDTO eventDto)
{
id = eventDto.Id;
title = eventDto.title;
description = eventDto.description;
location = eventDto.location;
host_id = eventDto.host_id;
createdOn = eventDto.createdOn;
begins_date = eventDto.begins.Date;
begins_time = new TimeSpan(eventDto.begins.Hour, eventDto.begins.Minute, eventDto.begins.Second);
ends_date = eventDto.ends.Date;
ends_time = new TimeSpan(eventDto.ends.Hour, eventDto.ends.Minute, eventDto.ends.Second);
participants = eventDto.participants;
likes = eventDto.likes;
}
public IActionResult Put([FromBody] EventDTO dto, [FromRoute] Guid id)
{
var existing = _context.Events.FirstOrDefault(s => s.Id == id);
if (existing == null)
{
return(NotFound($"Event with id {id} was not found"));
}
existing.RaceTime = dto.RaceTime;
existing.BroadcastLink = dto.BroadcastLink;
existing.EventState = dto.EventState;
existing.Order = dto.Order;
_context.SaveChanges();
return(Ok(new EventDTO(existing)));
}
/// <summary>
/// Business method to Add Events
/// </summary>
/// <param name="eventDTO"></param>
/// <returns></returns>
public EventDTO AddEventBAL(EventDTO eventDTO)
{
try
{
return(eventDAL.AddEvent(eventDTO));
}
catch (DALException dalEx)
{
throw new Exception(dalEx.Message);
}
catch (Exception)
{
throw new Exception(Resource.BALErrorMessage);
}
}
private Boolean ModifyEvent(String server, Int32 list, EventDTO ev, Guid position)
{
try
{
_listService.LockList(_loginSession, server, list, CLIENT_LOCKER_NAME);
_listService.ModifyEvent(_loginSession, server, list, ev, position);
_listService.UnlockList(_loginSession, server, list, CLIENT_LOCKER_NAME);
return(true);
}
catch (ListServiceEventProcessingException) { return(false); }
catch (ListServiceListNotEnabledException) { return(false); }
catch (ListServiceListLockedException) { return(false); }
catch (ADCEventException) { return(false); }
catch (ADCException) { return(false); }
}
public IActionResult Post([FromBody] EventDTO dto)
{
Event eventObj = new Event()
{
SeriesId = dto.SeriesId,
RaceTime = dto.RaceTime,
BroadcastLink = dto.BroadcastLink,
EventState = dto.EventState,
Order = dto.Order
};
_context.Events.Add(eventObj);
_context.SaveChanges();
return(Ok(new EventDTO(eventObj)));
}
public async Task <IActionResult> AddEvent()
{
EventDTO eventDTO = new EventDTO
{
MinistryArms = await StaticDataHandler.GetMinistryArmsAsync(BaseUrl),
OutputHandler = new OutputHandler
{
IsErrorOccured = false
}
};
eventDTO.DateOfEvent = DateTime.UtcNow.AddHours(2);
eventDTO.EventEndDate = DateTime.UtcNow.AddHours(2);
return(View(eventDTO));
}
public async Task <ActionResult <EventDTO> > Post([FromBody] EventDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (dto == null)
{
return(BadRequest());
}
var create = await _repo.CreateAsync(dto);
return(CreatedAtAction(nameof(Get), create));
}
public EventDTO Events(int id)
{
var ev = Db.EventRepository
.Get(e => e.Id == id, null, "Owner,City,EventCategory,Visitors")
.FirstOrDefault();
EventDTO eventDTO = _mapper.Map <Event, EventDTO>(ev);
eventDTO.CategoryNames = ev.EventCategory
.Select(x => Db.CategoryRepository.Get(x.CategoryId).Name).ToList();
eventDTO.Visitors = ev.Visitors
.Select(x => x.UserProfileId).ToList();
return(eventDTO);
}
public IActionResult PostEvent([FromBody] EventDTO eventDTO)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok(_eventBLL.AddNewEvent(eventDTO)));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
// GET: BpmsEvent
public object GetIndex(Guid ProcessId, string ElementId)
{
EventDTO eventDTO = null;
using (EventService eventService = new EventService())
{
eventDTO = new EventDTO(eventService.GetInfo(ElementId, ProcessId));
}
//Filling Default Message ViewBag
using (MessageTypeService messageTypeService = new MessageTypeService())
{
if (eventDTO.SubTypeMessageEventModel?.Type == (int)SubTypeMessageEventModel.e_Type.Message &&
eventDTO.MessageTypeID.HasValue)
{
//If messageType was changed, it adds or removes extra params.
List <MessageTypeParamsModel> listMTParams = messageTypeService.GetInfo(eventDTO.MessageTypeID.Value).ParamsXmlModel;
//update list of parameter
eventDTO.SubTypeMessageEventModel.MessageParams = listMTParams.Select(c =>
new SubTypeMessageParamEventModel(eventDTO.SubTypeMessageEventModel.MessageParams.FirstOrDefault(d => d.Name == c.Name)?.Variable, c.Name, c.IsRequired)).ToList();
}
using (EmailAccountService emailAccountService = new EmailAccountService())
{
List <QueryModel> list = new List <QueryModel>()
{
new QueryModel(((int)SubTypeEmailEventModel.e_FromType.CurrentUser).ToString(), "Current User"),
new QueryModel(((int)SubTypeEmailEventModel.e_FromType.CurrentThreadUser).ToString(), "Requested User")
};
return(new
{
SubTypeTimerEventModelIntervalTypes = EnumObjHelper.GetEnumList <SubTypeTimerEventModel.e_IntervalType>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeTimerEventModelSetTypes = EnumObjHelper.GetEnumList <SubTypeTimerEventModel.e_SetType>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeTimerEventModelTypes = EnumObjHelper.GetEnumList <SubTypeTimerEventModel.e_Type>().Where(c => eventDTO.TypeLU == (int)sysBpmsEvent.e_TypeLU.StartEvent || eventDTO.TypeLU == (int)sysBpmsEvent.e_TypeLU.boundary || c.Key != (int)SubTypeTimerEventModel.e_Type.Interval).Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeEmailEventModelToSystemicTypes = EnumObjHelper.GetEnumList <SubTypeEmailEventModel.e_ToSystemicType>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeEmailEventModelToTypes = EnumObjHelper.GetEnumList <SubTypeEmailEventModel.e_ToType>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeMessageEventModelKeyTypes = EnumObjHelper.GetEnumList <SubTypeMessageEventModel.e_KeyType>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
SubTypeMessageEventModelTypes = EnumObjHelper.GetEnumList <SubTypeMessageEventModel.e_Type>().Select(c => new QueryModel(c.Key.ToString(), c.Value)).ToList(),
//eventDTO.MessageTypeID
MessageTypes = messageTypeService.GetList("", true).Select(c => new QueryModel(c.ID.ToString(), c.Name)).ToList(),
//eventDTO.SubTypeMessageEventModel?.Email?.From
EmailAccounts = emailAccountService.GetList((int)sysBpmsEmailAccount.e_ObjectTypeLU.Systemic, null, null).
Select(c => new QueryModel(c.ID.ToString(), c.Email)).Union(list).ToList(),
Model = eventDTO,
});
}
}
}
public ActionResult <Event> PostEvent(EventDTO eventDTO)
{
try {
Event eventToCreate = new Event()
{
Name = eventDTO.Name,
Description = eventDTO.Description,
StartDate = eventDTO.StartDate,
EndDate = eventDTO.EndDate,
Country = eventDTO.Country,
Region = eventDTO.Region,
City = eventDTO.City,
Street = eventDTO.Street,
StreetNr = eventDTO.StreetNr,
ZipCode = eventDTO.ZipCode,
HeaderImageURL = eventDTO.HeaderImageURL
};
foreach (var genre in eventDTO.EventGenres)
{
Genre genreToAdd = _genreRepository.GetById(genre.GenreId);
eventToCreate.AddEventGenre(genreToAdd);
}
foreach (var price in eventDTO.Prices)
{
eventToCreate.AddPrice(new Price()
{
Name = price.Name, Description = price.Description, Cost = price.Cost
});
}
foreach (var resource in eventDTO.Links)
{
eventToCreate.AddLink(new Link()
{
Name = resource.Name, Url = resource.Url
});
}
_eventRepository.Add(eventToCreate);
_eventRepository.SaveChanges();
return(CreatedAtAction(nameof(GetEvent), new { id = eventToCreate.EventId }, eventToCreate));
}
catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Put(int id, EventDTO model)
{
try
{
var _event = await _eventRepository.GetByIdAsync(id);
if (_event == null)
{
return(NotFound());
}
var groupIds = new List <int>();
var socialMediaIds = new List <int>();
model.Groups.ForEach(item => groupIds.Add(item.Id));
model.SocialMedias.ForEach(item => socialMediaIds.Add(item.Id));
var groupsToRemove = _event.Groups.Where(group => !groupIds.Contains(group.Id))
.ToArray();
var socialMediaToRemove = _event.SocialMedias.Where(socialMedia => !socialMediaIds.Contains(socialMedia.Id))
.ToArray();
if (groupsToRemove.Length > 0)
{
_repository.DeleteRange(groupsToRemove);
}
if (socialMediaToRemove.Length > 0)
{
_repository.DeleteRange(socialMediaToRemove);
}
_mapper.Map(model, _event);
_repository.Update(_event);
if (await _repository.SaveChangesAsync())
{
return(Created($"/api/events/{ _event.Id }", _event));
}
return(BadRequest());
}
catch (System.Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <ActionResult <List <EventDTO> > > UpdateEvents()
{
string infernoAPIUrl = _configuration.GetValue <string>("InfernoAPIUrl");
string infernoAPIKey = _configuration.GetValue <string>("InfernoAPIKey");
List <EventDTO> eventList = new List <EventDTO>();
try
{
var allEventList = await _unitOfWork.EventRepository.FindAllAsync();
foreach (var curEvent in allEventList)
{
// Get InfernoEvent info from Inferno WebAPI
InfernoEventDTO infernoEvent = await GetInfernoEvent(infernoAPIUrl, infernoAPIKey, curEvent.InfernoEventId);
//If start or end times change
if (infernoEvent != null && !curEvent.Start.Equals(infernoEvent.startTime.DateTime))
{
Event updatedEvent = await UpdateEventAndSendEmail(curEvent, infernoEvent);
if (updatedEvent != null)
{
var eventDto = new EventDTO
{
Subject = updatedEvent.Subject,
Body = updatedEvent.Body.Content,
Start = updatedEvent.Start.DateTime,
End = updatedEvent.End.DateTime,
TimeZone = updatedEvent.Start.TimeZone
};
eventList.Add(eventDto);
}
}
}
}
catch (MsalUiRequiredException ex)
{
HttpContext.Response.ContentType = "text/plain";
HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
await HttpContext.Response.WriteAsync("An authentication error occurred while acquiring a token for downstream API\n" + ex.ErrorCode + "\n" + ex.Message);
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
return(Ok(eventList));
}
protected EventDTO getEvent()
{
string subject = txtAutoName.Text;
string subscribe = "";
string body = txtBody.Text;
int configId = int.Parse(drlMailConfig.SelectedValue.ToString());
string responeUrl = "";
if (chkDefaultPage.Checked == true)
{
responeUrl = "Default";
}
else
{
responeUrl = txtResponeUrl.Text;
if (responeUrl == null || responeUrl == "")
{
responeUrl = txtResponeUrl.Text;
}
}
int groupId = int.Parse(drlMailGroup.SelectedValue);
// Set some default value.
string confirmContent = "";
string confirmFlag = "t";
// Initial eventDto object.
EventDTO eventDto = new EventDTO(subject, "", subscribe, body, configId,
DateTime.Now, DateTime.Now, responeUrl, confirmContent, confirmFlag, getUserLogin().UserId, groupId);
return eventDto;
}
public void tblEvent_Update(EventDTO dt)
{
eDao.tblEvent_Update(dt);
}
public void tblEventCustomer_Insert(EventDTO eventDto)
{
eDao.tblEventCustomer_Insert(eventDto);
}
public int tblEvent_insert(EventDTO dt)
{
return eDao.tblEvent_insert(dt);
}
internal void tblEventCustomer_Insert(EventDTO eventDto)
{
string sql = @"insert into tblEventCustomer(customerid, eventid, countReceivedMail) select customerid, @eventid, 0 from tblDetailGroup where groupid=@groupid";
SqlCommand cmd = new SqlCommand(sql, ConnectionData._MyConnection);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("@EventId", SqlDbType.Int).Value = eventDto.EventId;
cmd.Parameters.Add("@GroupId", SqlDbType.Int).Value = eventDto.GroupId;
if (ConnectionData._MyConnection.State == ConnectionState.Closed)
{
ConnectionData._MyConnection.Open();
}
cmd.ExecuteNonQuery();
cmd.Dispose();
}
public void tblEvent_Update(EventDTO dt)
{
string sql = "UPDATE tblEvent SET "+
"Subject = @Subject, "+
"Voucher = @Voucher, "+
"Subscribe = @Subscribe, "+
"Body = @Body,"+
"ConfigId = @ConfigId, "+
"StartDate = @StartDate, "+
"EndDate = @EndDate, " +
"ResponeUrl = @ResponeUrl, " +
"ConfirmContent = @ConfirmContent, " +
"ConfirmFlag = @ConfirmFlag, " +
"UserId = @UserId, " +
"WHERE EventId = @EventId";
SqlCommand cmd = new SqlCommand(sql, ConnectionData._MyConnection);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("@EventId", SqlDbType.Int).Value = dt.EventId;
cmd.Parameters.Add("@Subject", SqlDbType.NVarChar).Value = dt.Subject;
cmd.Parameters.Add("@Voucher", SqlDbType.VarChar).Value = dt.Voucher;
cmd.Parameters.Add("@Subscribe", SqlDbType.VarChar).Value = dt.Subscribe;
cmd.Parameters.Add("@Body", SqlDbType.NVarChar).Value = dt.Body;
cmd.Parameters.Add("@ConfigId", SqlDbType.Int).Value = dt.ConfigId;
cmd.Parameters.Add("@StartDate", SqlDbType.DateTime).Value = dt.StartDate;
cmd.Parameters.Add("@EndDate", SqlDbType.DateTime).Value = dt.EndDate;
cmd.Parameters.Add("@ResponeUrl", SqlDbType.VarChar).Value = dt.ResponeUrl;
cmd.Parameters.Add("@ConfirmContent", SqlDbType.NVarChar).Value = dt.ConfirmContent;
cmd.Parameters.Add("@ConfirmFlag", SqlDbType.Char).Value = dt.ConfirmFlag;
cmd.Parameters.Add("@UserId", SqlDbType.Int).Value = dt.UserId;
if (ConnectionData._MyConnection.State == ConnectionState.Closed)
{
ConnectionData._MyConnection.Open();
}
cmd.ExecuteNonQuery();
cmd.Dispose();
}
