public ActionResult PopupCreate(EventCreateModel model, SubmitType submit)
{
ModelState.Remove("EventSchedule.EventId");
if (ModelState.IsValid)
{
var response = _eventService.SaveEvent(model);
SetResponseMessage(response);
if (response.Success)
{
var id = (int)response.Data;
switch (submit)
{
case SubmitType.PopupSave:
return(View("CloseFancyBox",
new CloseFancyBoxViewModel
{
IsReload = true
}));
case SubmitType.SaveAndContinueEdit:
return(RedirectToAction("PopupEdit", new { id }));
}
}
}
return(View(model));
}
public IActionResult Post([FromBody] EventCreateModel request)
{
var api = Api.INSTANCE;
api.DemandModerator(Request);
using (var da = api.DAFactory.Get())
{
DbEventType type;
try
{
type = Enum.Parse <DbEventType>(request.type);
}
catch
{
return(BadRequest("Event type must be one of:" + string.Join(", ", Enum.GetNames(typeof(DbEventType)))));
}
var model = new DbEvent()
{
title = request.title,
description = request.description,
start_day = request.start_day,
end_day = request.end_day,
type = type,
value = request.value,
value2 = request.value2,
mail_subject = request.mail_subject,
mail_message = request.mail_message,
mail_sender = request.mail_sender,
mail_sender_name = request.mail_sender_name
};
return(new JsonResult(new { id = da.Events.Add(model) }));
}
}
public async Task <IHttpActionResult> Create(EventCreateModel createModel)
{
if (!await _eventsService.CanCreateAsync(createModel.GroupId))
{
return(StatusCode(System.Net.HttpStatusCode.Forbidden));
}
var @event = MapToEvent(createModel);
var activityId = _eventsService.Create(@event);
_reminderService.CreateIfNotExists(activityId, ReminderTypeEnum.OneDayBefore);
@event = _eventsService.Get(activityId);
if (createModel.GroupId.HasValue)
{
_groupActivityService.AddRelation(createModel.GroupId.Value, activityId);
@event.GroupId = createModel.GroupId;
}
_activityTagsHelper.ReplaceTags(activityId, createModel.TagIdsData);
ResolveMentions(createModel.Description, @event);
var redirectUrl = _activityLinkService.GetLinks(activityId).Details;
ReloadFeed();
return(Ok(redirectUrl));
}
private UIElement Add(IEnumerable <string> sports, IEnumerable <TournamentBaseModel> tournaments, IEnumerable <ParticipantTournamentModel> participants)
{
EventCreateViewModel viewModel = new EventCreateViewModel(sports, tournaments, participants);
EventCreateControl control = new EventCreateControl(viewModel);
viewModel.EventCreated += (s, e) =>
{
EventCreateModel eventCreateModel = e.Event;
EventCreateDTO eventCreateDTO = Mapper.Map <EventCreateModel, EventCreateDTO>(eventCreateModel);
using (IEventService service = factory.CreateEventService())
{
ServiceMessage serviceMessage = service.CreateWithParticipants(eventCreateDTO);
RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message);
if (serviceMessage.IsSuccessful)
{
viewModel.Notes = String.Empty;
Notify();
}
}
};
return(control);
}
public IActionResult Create(EventCreateModel model)
{
if (ModelState.IsValid)
{
this.eventService.Create(model);
return(Redirect("/"));
}
return(this.View(model));
}
private void Create(EventCreateModel eventCreateModel)
{
eventCreateModel.SportName = SelectedSport;
eventCreateModel.TournamentName = SelectedTournament.Name;
eventCreateModel.DateOfTournamentStart = SelectedTournament.DateOfStart;
eventCreateModel.Participants = new List <ParticipantBaseModel>(SelectedParticipants);
RaiseEventCreatedEvent(eventCreateModel);
}
public int Create(EventCreateModel model)
{
Guard.NotNull(model, nameof(model), Constants.NullExceptionGenerator);
_logger.LogInformation($"new event: {JsonConvert.SerializeObject(model)}");
var entity = Mapper.Map <Event>(model);
return(_repository.Create(entity));
}
public void Create([FromBody] EventCreateModel createModel)
{
var eventEntity = mapper.Map <Event>(createModel);
eventRepository.Add(eventEntity);
eventRepository.Commit();
// schedulerService.Schedule(mapper.Map<EventResource>(createModel));
}
private void RaiseEventCreatedEvent(EventCreateModel eventCreateModel)
{
var handler = EventCreated;
if (handler != null)
{
EventEventArgs e = new EventEventArgs(eventCreateModel);
handler(this, e);
}
}
protected override EventBase MapToEvent(EventCreateModel createModel)
{
var @event = (Event)base.MapToEvent(createModel);
var extendedCreateModel = (EventExtendedCreateModel)createModel;
@event.CanSubscribe = extendedCreateModel.CanSubscribe;
@event.SubscribeNotes = extendedCreateModel.SubscribeNotes;
return(@event);
}
public async Task <IActionResult> CreateAsync(EventCreateModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
await this.eventService.CreateFromAdminAsync(model.EventModel);
return(this.RedirectToAction(nameof(this.Index)));
}
public IActionResult Create()
{
var eventTypes = _eventsTypeService.GetAll();
var viewModels = eventTypes.Select(x => x.ToEventTypeModel()).ToList();
var viewModel = new EventCreateModel();
viewModel.EventTypes = viewModels;
return(View(viewModel));
}
public void CreateModelPassedToRepositoryTest()
{
var manager = GetManager();
var model = new EventCreateModel();
manager.Create(model);
_repositoryMock.Verify(
x => x.Create(It.Is <Event>(y => y != null)),
Times.Once);
}
public void CreateReturnsIdTest()
{
var id = 5;
_repositoryMock.Setup(x => x.Create(It.IsAny <Event>()))
.Returns(id);
var manager = GetManager();
var model = new EventCreateModel();
var idFromManager = manager.Create(model);
Assert.Equal(id, idFromManager);
}
protected virtual EventBase MapToEvent(EventCreateModel createModel)
{
var @event = createModel.Map <EventBase>();
@event.MediaIds = @event.MediaIds.Concat(_mediaHelper.CreateMedia(createModel));
@event.StartDate = createModel.StartDate.ToUniversalTime();
@event.PublishDate = createModel.PublishDate.ToUniversalTime();
@event.EndDate = createModel.EndDate.ToUniversalTime();
@event.EndPinDate = createModel.EndPinDate?.ToUniversalTime();
@event.CreatorId = _intranetMemberService.GetCurrentMemberId();
return(@event);
}
public static Event ToModel(this EventCreateModel viewModel)
{
return new Event
{
Name = viewModel.Name,
ImgUrl = viewModel.ImgUrl,
Location = viewModel.Location,
Date = viewModel.Date,
OrganizedBy = viewModel.OrganizedBy,
Description = viewModel.Description,
EventTypeId = viewModel.EventTypeId,
};
}
public IResponse Create(EventCreateModel model, int LoggedUser)
{
UOW.Events.Add(new ResourceEvent
{
CreatedById = LoggedUser,
Start = model.Start,
End = model.End,
Name = model.Name,
Location = model.Location,
});
UOW.Compelete();
return(response);
}
public void Create(EventCreateModel model)
{
var eventModel = new Event
{
End = model.End,
Name = model.Name,
PricePerTicket = model.PricePerTicket,
Place = model.Place,
Start = model.Start,
TotalTickets = model.TotalTickets
};
this.db.Events.Add(eventModel);
this.db.SaveChanges();
}
public IActionResult Create(EventCreateModel eventCreate)
{
var createEvent = new Event()
{
Id = Guid.NewGuid(),
Agenda = eventCreate.Agenda,
Title = eventCreate.Title,
Location = _context.Locations.Where(l => l.Id == eventCreate.LocationId).FirstOrDefault(),
Technologies = _context.Technologies.Where(t => eventCreate.TechnologiesIds.Any(technologyId => technologyId == t.Id)).ToList()
};
_context.Events.Add(createEvent);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(EventCreateModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (_eventService.Value.CreateEvent(model))
{
TempData["SaveResult"] = "Your event was created.";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Your event could not be created.");
return(View(model));
}
public IActionResult Create(EventCreateModel even)
{
if (ModelState.IsValid)
{
_service.CreateEvent(even.ToModel());
var userId = User.FindFirst("Id");
var logData = new LogData()
{
Type = LogType.Info, DateCreated = DateTime.Now, Message = $"User with id {userId} created recipe {even.Name}"
};
_logService.Log(logData);
return(RedirectToAction("ManageEvents", new { SuccessMessage = "Event created sucessfully" }));
}
return(View(even));
}
public IHttpActionResult Post(EventCreateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateEventService();
if (!service.CreateEvent(model))
{
return(InternalServerError());
}
return(Ok());
}
/// <summary>
/// Save new event from event create model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveEvent(EventCreateModel model)
{
// Save Event
var saveEventResponse = SaveEvent(model.Event);
// If save Event success, save EventSchedule
if (saveEventResponse.Success)
{
var eventId = (int)saveEventResponse.Data;
model.EventSchedule.EventId = eventId;
var saveEventScheduleResponse = _eventScheduleService.SaveEventSchedule(model.EventSchedule);
return(saveEventScheduleResponse.Success ? saveEventResponse : saveEventScheduleResponse);
}
return(saveEventResponse);
}
public virtual ActionResult Create(EventCreateModel createModel)
{
if (!ModelState.IsValid)
{
return(RedirectToCurrentUmbracoPage(Request.QueryString));
}
var @event = MapToEvent(createModel);
var activityId = _eventsService.Create(@event);
OnEventCreated(activityId, createModel);
var redirectUrl = _activityLinkService.GetLinks(activityId).Details;
return(Redirect(redirectUrl));
}
protected virtual EventCreateModel GetCreateModel(IActivityCreateLinks links)
{
var mediaSettings = _eventsService.GetMediaSettings();
var model = new EventCreateModel
{
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow.AddHours(8),
PublishDate = DateTime.UtcNow,
OwnerId = _intranetMemberService.GetCurrentMemberId(),
ActivityType = _activityTypeProvider[ActivityTypeId],
Links = links,
MediaRootId = mediaSettings.MediaRootId
};
return(model);
}
public EventCreateViewModel(IEnumerable <string> sports, IEnumerable <TournamentBaseModel> tournaments, IEnumerable <ParticipantTournamentModel> participants)
{
this.eventCreateModel = new EventCreateModel
{
DateOfEvent = DateTime.Now.AddMonths(2).Date
};
this.Sports = new ObservableCollection <string>(sports);
this.Tournaments = new ObservableCollection <TournamentBaseModel>(tournaments);
this.Participants = new ObservableCollection <ParticipantTournamentModel>(participants);
this.SelectedParticipants = new ObservableCollection <ParticipantTournamentModel>();
this.CreateEventCommand = new DelegateCommand(() => Create(eventCreateModel), CanCreate);
this.MoveToEventCommand = new DelegateCommand(
() => MoveToEvent(SelectedParticipant),
obj => SelectedParticipant != null);
this.MoveAllToEventCommand = new DelegateCommand(
() => MoveAllToEvent(),
obj => true);
this.MoveFromEventCommand = new DelegateCommand(
() => MoveFromEvent(SelectedEventsParticipant),
obj => SelectedEventsParticipant != null);
this.SortedTournaments.Filter = obj =>
{
TournamentBaseModel tournamentBaseModel = obj as TournamentBaseModel;
return(tournamentBaseModel.SportName == SelectedSport);
};
this.SortedParticipants.Filter = obj =>
{
bool isValid = SelectedTournament != null;
if (isValid)
{
ParticipantTournamentModel participantModel = obj as ParticipantTournamentModel;
isValid = participantModel
.Tournaments
.Select(t => t.Name)
.Contains(SelectedTournament.Name) &&
!SelectedParticipants
.Select(p => p.Name)
.Contains(participantModel.Name);
}
return(isValid);
};
}
public EventCreateModel GetCreateViewModel()
{
var dateNow = DateTime.Now;
var dateNowAfter30Min = dateNow.AddMinutes(30);
var model = new EventCreateModel
{
EventModel = new EventModel
{
StartDateTime = new DateTime(dateNow.Year, dateNow.Month, dateNow.Day, dateNow.Hour, dateNow.Minute, dateNow.Second, CultureInfo.CurrentUICulture.Calendar),
EndDateTime = new DateTime(dateNowAfter30Min.Year, dateNowAfter30Min.Month, dateNowAfter30Min.Day, dateNowAfter30Min.Hour, dateNowAfter30Min.Minute, dateNowAfter30Min.Second, CultureInfo.CurrentUICulture.Calendar),
},
Calendars = this.calendarService.GetAll(),
Colors = this.colorService.GetAllColors(),
};
return(model);
}
public ActionResult Create(EventCreateModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (!CreateEventService().CreateEvent(model))
{
ModelState.AddModelError("", "Unable to create event");
return(View(model));
}
TempData["SaveResult"] = "Your event was created";
return(RedirectToAction("Index"));
}
protected override void OnEventCreated(Guid activityId, EventCreateModel model)
{
_reminderService.CreateIfNotExists(activityId, ReminderTypeEnum.OneDayBefore);
var groupId = Request.QueryString.GetGroupId();
if (groupId.HasValue)
{
_groupActivityService.AddRelation(groupId.Value, activityId);
var @event = _eventsService.Get(activityId);
@event.GroupId = groupId;
}
if (model is EventExtendedCreateModel extendedModel)
{
_activityTagsHelper.ReplaceTags(activityId, extendedModel.TagIdsData);
}
}
public void EventCreateModelMapTest()
{
var eventModel = new EventCreateModel
{
StartDate = DateTime.Now,
EndDate = DateTime.Now,
Title = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
CanRegister = true
};
var eventEntity = Mapper.Map <Event>(eventModel);
Assert.Equal(eventModel.StartDate, eventEntity.StartDate);
Assert.Equal(eventModel.EndDate, eventEntity.EndDate);
Assert.Equal(eventModel.Title, eventEntity.Title);
Assert.Equal(eventModel.Description, eventEntity.Description);
Assert.Equal(eventModel.CanRegister, eventEntity.CanRegister);
}
