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(); }