public ActionResult CreateEventFormPopUp(string start, List <string> users)
{
var startTime = DateTime.Parse(start);
var first = true;
var list = new List <SelectListItem>();
var time = startTime.AddMinutes(30);
while (true)
{
list.Add(new SelectListItem
{
Selected = first,
Text = time.ToString("t"),
Value = time.ToString("o")
});
first = false;
if (time.Hour == 0)
{
break;
}
time = time.AddMinutes(30);
}
EventObject model = new EventObject {
start = startTime.ToString("o"), displayStart = startTime.ToString("t")
};
var viewModel = new CreateEventViewModel {
EndTimeList = list, Event = model, Users = users
};
return(PartialView("_CreateEventPartial", viewModel));
}
public async Task <ActionResult> CreateEvent(CreateEventViewModel eventObject)
{
var model = eventObject;
// Create EWS Appointment
var request = new CreateAppointmentRequest
{
Body = "Created From Web App",
End = DateTime.Parse(eventObject.Event.end).ToString(),
Start = DateTime.Parse(eventObject.Event.start).ToString(),
Location = "Web",
Subject = eventObject.Event.title,
Recipients = eventObject.Users
};
var resp = await _client.CreateAppointment(request);
// Send Emails
var emailRequest = new SendEmailRequest
{
Recipients = eventObject.Users,
Body = "Automated Email After Appointment Creation",
FileAttachments = new List <string>(),
Subject = "Automated Email After Appointment Creation"
};
var sendEmailResponse = await _client.SendEmail(emailRequest);
return(RedirectToAction("Index"));
}
public IActionResult Create(CreateEventViewModel model)
{
int sportId = int.Parse(model.SportId);
// Edit
if (model.Id > 0)
{
Events e = context.Events.Find(model.Id);
e.Title = model.Name;
e.StartsAt = model.StartsAt;
e.EndsAt = model.EndsAt;
e.SportId = int.Parse(model.SportId);
context.Events.Update(e);
context.SaveChanges();
}
else
{
Events e = new Events
{
CreatedAt = DateTime.UtcNow,
EndsAt = model.EndsAt,
StartsAt = model.StartsAt,
Title = model.Name,
SportId = sportId
};
context.Events.Add(e);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
public ActionResult Create(CreateEventViewModel model)
{
try
{
var creator = _user.Repository.GetCurrentId.ToString();
model.Invited.Add(creator);
if (!ModelState.IsValid || !model.IsValid)
{
_response.HasFailed("Entered information are not valid.");
return(PartialView("_EventResponse", _response as EventResponse));
}
var anEvent = model.GetEventFromViewModel;
var userEvent = _user.UserEvent(anEvent);
_atomicEventWork.Add(anEvent, userEvent);
return(JavaScript(RedirectTo.Action(Url, "Index", "Timeline")));
}
catch
{
_response.HasFailed("We apologize, an unexpected error has occured.");
return(PartialView("_EventResponse", _response as EventResponse));
}
}
public async Task <IActionResult> Post([FromBody] CreateEventViewModel createViewModel)
{
var result = await this.Mediator.Send(
createViewModel.ProjectedAs <PresenterCreateEventCommand>());
return(this.GetResult(result));
}
public async Task <ActionResult> Edit(CreateEventViewModel model, int?pageNumber)
{
if (ModelState.IsValid)
{
//var ev = this.Data.Events.GetById(model.Id);
var ev = this.Data.Events.All().Where(e => e.Id == model.Id && e.AuthorId == this.UserId).FirstOrDefault();
ev.EndDateTime = new DateTime(model.EndDate.Value.Year,
model.EndDate.Value.Month,
model.EndDate.Value.Day,
model.EndTime.Hour,
model.EndTime.Minute,
0);
ev.EventType = model.EventType;
ev.StartDateTime = new DateTime(model.StartDate.Value.Year,
model.StartDate.Value.Month,
model.StartDate.Value.Day,
model.StartTime.Hour,
model.StartTime.Minute,
0);
this.Data.Events.Update(ev);
await this.Data.SaveChangesAsync();
string url = Url.Action("UserCalendar", "Events", new { pageNumber = pageNumber });
return(Json(new { success = true, url = url }));
}
return(PartialView("_EditEvent", model));
}
public ActionResult CreateEvent(CreateEventViewModel model)
{
if (SessionManager.LoggedIn == false)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
EventManager eventManager = new EventManager();
Event containerEvent = new Event();
containerEvent.Category = "All";
containerEvent.Description = model.Description;
containerEvent.EndDate = Convert.ToDateTime(model.EndTime);
containerEvent.Location = model.Location;
containerEvent.Logo_Path = model.LogoPath;
containerEvent.Owner_ID = SessionManager.SessionID;
containerEvent.StartDate = Convert.ToDateTime(model.StartTime);
containerEvent.Status = "ON";
containerEvent.Title = model.Title;
containerEvent.Type = model.Type;
EventViewModels eventModel = eventManager.CreateEvent(containerEvent);
return(RedirectToAction("Events", "Home"));
}
return(View(model));
}
public ActionResult Create(CreateEventViewModel model)
{
try
{
//Project project = new Project { ProjectName = model.ProjectName, StartDate = model.StartDate, DueDate = model.DueDate, TotalTime = DateTime.Now, ClientID = model.ClientID, ProjectManagerID = 1 };
repo.Events.Add(new Event {
EventName = model.Event.EventName
, EventDescription = model.Event.EventDescription
, EventText = model.Event.EventText
, EventTriggered = model.Event.EventTriggered
, DirFwd = model.Event.DirFwd
, DirLeft = model.Event.DirLeft
, DirRight = model.Event.DirRight
, DirBack = model.Event.DirBack
, FightId = model.Event.FightId
, HealthId = model.Event.HealthId
, ItemId = model.Event.ItemId
, MudId = model.MUD
});
repo.SaveChanges();
//return RedirectToAction("Index","model.ClientID");
//return Index(model.ClientID);
return(RedirectToAction("Index", new { id = model.MUD }));
}
catch
{
return(View(model));
}
}
public ActionResult Create(Event one_event)
{
try
{
if (ModelState.IsValid)
{
db.Events.Add(one_event);
db.SaveChanges();
FlashMessageHelper.SetMessage(this, FlashMessageType.Success, "Zapisanie nowych danych przebiegło pomyślnie.");
return(RedirectToAction("Index"));
}
FlashMessageHelper.SetMessage(this, FlashMessageType.Info, "Nie można zapisać nowych danych. Należy poprawić zaistniałe błędy.");
}
catch (Exception)
{
FlashMessageHelper.SetMessage(this, FlashMessageType.Danger, "Wystąpił nieoczekiwany błąd związany z zapisem nowych danych.");
}
var query = from a in db.Locations
where a.ID == one_event.LocationId
select a;
var fail_event = query.FirstOrDefault();
CreateEventViewModel setItemViewModel = new CreateEventViewModel()
{
Location = fail_event,
Event = one_event
};
return(View(setItemViewModel));
}
public IActionResult Edit(Guid id)
{
var model = new CreateEventViewModel();
List <Artist> artists = artistService.GetAllArtists();
List <EventType> eventTypes = eventTypeService.GetAllTypes();
List <EventSubType> eventSubTypes = eventSubTypeService.GetAllSubTypes();
List <Location> locations = locationService.GetAllLocations();
if (id == null)
{
return(NotFound());
}
var iEvent = eventService.GetEventById(id);
if (iEvent == null)
{
return(NotFound());
}
model.Artists = artists;
model.EventSubTypes = eventSubTypes;
model.EventTypes = eventTypes;
model.Locations = locations;
model.Event = iEvent;
return(View(model));
}
public CreateEventViewModalName()
{
InitializeComponent();
vm = new CreateEventViewModel();
vm.Navigation = Navigation;
this.BindingContext = vm;
}
public IActionResult Post([FromBody] CreateEventViewModel createEventViewModel)
{
if ((createEventViewModel.StartDate < DateTime.Now) ||
(createEventViewModel.StartDate > createEventViewModel.EndDate))
{
return(BadRequest());
}
var eventDto = Mapper.Map <EventDto>(createEventViewModel);
var simpleUserDto = Mapper.Map <SimpleUserDto>(createEventViewModel);
var simpleUserDtoService = _eventService.CreateSimpleUser(simpleUserDto);
eventDto.OwnerId = simpleUserDtoService.Id;
var eventDtoService = _eventService.CreateEvent(eventDto);
createEventViewModel = Mapper.Map <CreateEventViewModel>(eventDtoService);
createEventViewModel = Mapper.Map <CreateEventViewModel>(simpleUserDtoService);
if (createEventViewModel == null)
{
return(BadRequest());
}
return(Ok(createEventViewModel));
}
public async Task CreateNewEvent(CreateEventViewModel @event)
{
var userName = UserHelpers.UserName();
var usr = await _db.Users.FirstOrDefaultAsync(u => u.Email == userName);
var evt = new Event
{
Address = @event.Address,
Date = @event.Date,
Title = @event.Title,
Description = @event.Description,
IsPrivate = @event.IsPrivate,
MaxSeats = @event.MaxParticipants,
MeetingDetails = @event.MeetingPoint,
Time = @event.Time
};
if (usr != null)
{
evt.Owner = usr;
}
_db.Events.Add(evt);
await AddParticipation(evt);
await _db.SaveChangesAsync();
}
public ActionResult Create(CreateEventViewModel eventToRegister)
{
if(!this.ModelState.IsValid)
{
return this.View(eventToRegister);
}
var userId = this.User.Identity.GetUserId();
var eventToCreate = new Event()
{
Name = eventToRegister.Name,
Description = eventToRegister.Description,
CreatedOn = DateTime.Now,
StartDate = eventToRegister.StartDate,
OrganiserId = userId,
Coordinates = eventToRegister.Coordinates,
LocationId = 1
};
var createdEvent = this.eventsServices.CreateEvent(eventToCreate);
IIdentifierProvider provider = new IdentifierProvider();
string encodedId = provider.EncodeId(createdEvent.Id);
return this.Redirect("~/Events/" + encodedId);
}
public ActionResult CreateEvent(CreateEventViewModel model)
{
string[] dateTime = model.date.Split('.');
int day = Int32.Parse(dateTime[0]);
int month = Int32.Parse(dateTime[1]);
int year = Int32.Parse(dateTime[2]);
DateTime start = new DateTime(year, month, day, model.hourStart, model.minStart, 0);
DateTime end = new DateTime(year, month, day, model.hourEnd, model.minEnd, 0);
//List<Snippet> snippets = _snippetService.GetAllSnippetsByID(model.Snippets);
Event ev = new Event {
Name = model.name, Description = model.description, Start = start, End = end /*, Snippets = snippets*/
};
bool res = _eventService.AddOrUpdateEvent(ev, model.Snippets);
if (!res)
{
return(Json("error", JsonRequestBehavior.AllowGet));
}
return(Json("Натпреварот е успешно креиран.", JsonRequestBehavior.AllowGet));
}
public async Task <IHttpActionResult> CreateEvent(CreateEventViewModel eventViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createEventDto = _mapper.Map <CreateEventDto>(eventViewModel);
var offices = eventViewModel.Offices.Select(p => p.ToString()).ToList();
createEventDto.Offices = new EventOfficesDto {
Value = JsonConvert.SerializeObject(offices)
};
SetOrganizationAndUser(createEventDto);
CreateEventDto createdEvent;
var userHubDto = GetUserAndOrganizationHub();
try
{
createdEvent = await _eventService.CreateEventAsync(createEventDto);
_asyncRunner.Run <NewEventNotifier>(async notifier => { await notifier.Notify(createdEvent, userHubDto); }, GetOrganizationName());
}
catch (EventException e)
{
return(BadRequest(e.Message));
}
return(Ok(new { createdEvent.Id }));
}
// GET: Events/Create
public async Task <IActionResult> Create()
{
//instantiaite view model
CreateEventViewModel vm = new CreateEventViewModel();
//set up drop down to display and select venue names
vm.Venues = _context.Venues.Select(v => new SelectListItem
{
Value = v.Id.ToString(),
Text = v.VenueName
}).ToList();
vm.Venues.Insert(0, new SelectListItem()
{
Value = "0",
Text = "Please choose a venue"
});
vm.Customers = _context.Customers.Select(c => new SelectListItem
{
Value = c.Id.ToString(),
Text = c.FirstName + " " + c.LastName
}).ToList();
vm.Customers.Insert(0, new SelectListItem()
{
Value = "0",
Text = "Please choose a customer"
});
return(View(vm));
}
public ActionResult CreateEvent(CreateEventViewModel model)
{
var db = new ApplicationDbContext();
db.Start();
var pub = (from p in db.Pubs where p.Name.Contains(model.BarName) select p).First();
if (pub != null)
{
if (User.Identity.IsAuthenticated)
{
//model.DateEvent.Hour = model.Hour;
var maneger = new ApplicationUserManager(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var MyUser = maneger.Users.Where(x => x.UserName == HttpContext.User.Identity.Name).FirstOrDefault();
var evento = new Event {
PubID = pub.ID, Hour = model.Hour, Date = model.DateEvent, Code = codigoale, AspNetUserID = MyUser.Id
};
db.Events.Add(evento);
db.SaveChanges(); //usuario
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public async Task <IActionResult> Create([FromBody] CreateEventViewModel createEventViewModel)
{
logger.LogInformation($"POST Request {HttpContext.Request.Headers[":path"]}. Body: {JsonConvert.SerializeObject(createEventViewModel)}");;
if (!accessChecker.IsConfirm(out var profileId))
{
throw new HttpStatusException(HttpStatusCode.Forbidden, CommonErrorMessages.Forbidden);
}
var config = new MapperConfiguration(cfg => cfg.CreateMap <CreateEventViewModel, Event>()
.ForMember("Teams", opt => opt.Ignore())
.ForMember("Owner", opt => opt.Ignore())
.ForMember("OwnerId", opt => opt.MapFrom(_ => profileId)));
var mapper = new Mapper(config);
var @event = mapper.Map <CreateEventViewModel, Event>(createEventViewModel);
try
{
await context.Events.AddAsync(@event);
await context.SaveChangesAsync();
}
catch (System.Exception)
{
throw new HttpStatusException(HttpStatusCode.InternalServerError, CommonErrorMessages.SaveChanges);
}
return(Json(@event));
}
public IActionResult CreateEvent(CreateEventViewModel input)
{
var context = new OnlineWebPortalDbContext();
Event myEvent = new Event();
if (ModelState.IsValid)
{
try
{
myEvent.EventDate = input.EventDate;
myEvent.EventName = input.EventName;
myEvent.Description = input.Description;
context.Add(myEvent);
context.SaveChanges();
TempData["successMessage"] = " Event has been created successfully";
return(RedirectToAction("EventList", "Event"));
}
catch (Exception ex)
{
TempData["failMessage"] = " Oops! Something went wrong" + ex.Message;
return(RedirectToAction("EventList", "Event"));
}
}
return(View());
}
public ActionResult Evento(CreateEventViewModel model)
{
if (User.Identity.IsAuthenticated)
{
var maneger = new ApplicationUserManager(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var MyUser = maneger.Users.Where(x => x.UserName == HttpContext.User.Identity.Name).FirstOrDefault();
ViewBag.ImageProfile = MyUser.Image;
var codigos = new List <int>();
Random random = new Random();
var codigoaleatorio = random.Next(0, 1000);
if (codigos.Contains(codigoaleatorio))
{
codigoaleatorio = random.Next(0, 1000);
ViewBag.CodigoEvento = codigoaleatorio;
codigoale = codigoaleatorio.ToString();
}
else
{
ViewBag.CodigoEvento = codigoaleatorio;
codigoale = codigoaleatorio.ToString();
}
return(View());
}
return(View());
}
public async Task CreateEvent(CreateEventViewModel eventViewModel)
{
var storeId = eventViewModel.StoreId;
var _event = _mapper.Map<Event>(eventViewModel);
await _mediator.Send(new CreateEventCommand()
{
Name = _event.Name,
Description = _event.Description,
EventDate = _event.EventDate,
LastBookingDate = _event.LastBookingDate,
EndEventDate = _event.EndEventDate,
Image = _event.Image,
Address = _event.Address,
Price = _event.Price,
PayOnline = _event.PayOnline,
MaxCustomerLimit = _event.MaxCustomerLimit,
MinCustomerAmount = _event.MinCustomerAmount,
Food = _event.Food,
Region = _event.Region,
City = _event.City,
Marker = _event.Marker,
Store = new Store { Id = storeId }
});
}
public async Task <ActionResult> CreateEvent(CreateEventViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// Converting
ClanEvent clanEvent = new ClanEvent
{
Title = model.EventName,
EventDateAndTime = model.EventDate,
Game = model.Game,
Description = model.Description,
Location = model.Location,
};
// This will choose if i want t osave the image also
if (model.Image == null)
{
// Adding the event to the database
await EventManager.CreateClanEventAsync(clanEvent);
}
else
{
// Adding the event to the database
await EventManager.CreateClanEventAsync(clanEvent, Bitmap.FromStream(model.Image.InputStream));
}
return(RedirectToAction("Events"));
}
public ActionResult Create(CreateEventViewModel model)
{
if (Session["LoggedIn"] == null)
{
return(RedirectToAction("LogIn", "User"));
}
if (!ModelState.IsValid)
{
return(View());
}
var u = utils.Utils.GetUser(Session);
DateTime dt = model.Date + model.Time;
try
{
var evnt = service.CreateEvent(model.Title, model.Description, model.NumOfParticipants, model.PriceFrom, model.PriceTo, model.Location, dt, model.IsPublic, u);
return(RedirectToAction("Details", new { id = evnt.Id }));
}
catch (FaultException err)
{
ViewBag.Message = err.Message;
return(View());
}
}
// GET: Event/Create
public ActionResult Create()
{
var model = new CreateEventViewModel();
this.loggerManager.LogInfo($"{User.Identity.Name} access Create(Get) page (Dashboard.EventController.Create)");
return(View(model));
}
public ActionResult Create(CreateEventViewModel model, HttpPostedFileBase imagefile = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var _event = Mapper.Map <CreateEventViewModel, Event>(model);
if (imagefile != null)
{
_event.FileName = imagefile.FileName;
_event.ContentType = imagefile.ContentType;
//movie.Image
_event.Image = new byte[imagefile.ContentLength];
imagefile.InputStream.Read(_event.Image, 0, imagefile.ContentLength);
}
_event.UserId = UserManager.Users.Where(u => u.UserName == User.Identity.Name).Select(x => x.Id).FirstOrDefault();
var result = new Event();
using (var eventRepo = new Repository <Event>())
{
result = eventRepo.InsertOrUpdate(_event);
}
return(RedirectToAction("Detail", new { id = result.Id }));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var oneEvent = db.Events.Find(id);
if (oneEvent == null)
{
return(HttpNotFound());
}
var query2 = from a in db.Monsters
from b in db.Images
where a.ImageId == b.ID
select new DetailsMonsterViewModel
{
Monster = a,
Image = b
};
var Location = db.Locations.Find(oneEvent.LocationId);
var monsters = query2.ToList();
CreateEventViewModel model = new CreateEventViewModel();
model.Location = Location;
model.Event = oneEvent;
model.Monsters = monsters;
return(View(model));
}
public AddEvent()
{
InitializeComponent();
// MVVM Implementation
createEventViewModel = new CreateEventViewModel(Navigation, this);
BindingContext = createEventViewModel;
}
public async Task <int> CreateEvent(CreateEventViewModel viewModel)
{
var ev = this._mapper.Map <CreateEventViewModel, Event>(viewModel);
await this._dbContext.Events.AddAsync(ev);
return(await this._dbContext.SaveChangesAsync());
}
public ViewResult DisplayEvent(int eventId)
{
var viewModel = new CreateEventViewModel
{
Event = context.Events.Include(i => i.Location).FirstOrDefault(x => x.EventID == eventId)
};
return(View("~/Views/GlobalDashboard/EventInfo.cshtml", viewModel));
}
public ActionResult CreateEvent()
{
CreateEventViewModel model = new CreateEventViewModel();
model.AllGroups = _groupService.GetAllGroups();
model.AllSnippets = _snippetService.GetAllSnippets(1, 20);
model.AllOperations = _snippetService.GetAllOperations();
return(View(model));
}
