public async Task <Order> CreateAsync(Order model) { _context.Orders.Add(model); await _context.SaveChangesAsync(); return(model); }
public async Task <IActionResult> PutEventInfo(int id, EventInfo eventInfo) { if (id != eventInfo.Id) { return(BadRequest()); } _context.Entry(eventInfo).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EventInfoExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutEventConfirmation([FromRoute] int id, [FromBody] EventConfirmation eventConfirmation) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != eventConfirmation.Id) { return(BadRequest()); } _context.Entry(eventConfirmation).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EventConfirmationExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task CanselEvent(int id) { var res = context.Events.FirstOrDefault(p => p.Id == id); context.Events.Remove(res); await context.SaveChangesAsync(); }
public async Task <T> AddAsync(T item) { await entities.AddAsync(item); await dbContext.SaveChangesAsync(); return(item); }
/// <summary> /// Logs a Revoke Access event /// </summary> /// <param name="projectId">The Id of the project for which to revoke access.</param> /// <param name="remoteIpAddress">The IP address of the originating request</param> /// <param name="azureAdObjectIdentifier">The Azure AD Object Identifier</param> /// <param name="revokingUser">The ApplicationUser performing the event</param> /// <returns>A Task object</returns> public async Task LogRevokeAccessEventAsync( int projectId, string remoteIpAddress, int targetUserId, Role role, int revokingUserId, string customData) { var revokeAccess = new Models.Event(); revokeAccess.DateTime = DateTime.UtcNow; revokeAccess.Type = Enums.EventType.RevokeAccess.ToString(); revokeAccess.OldValue = role.ToString(); revokeAccess.RemoteIpAddress = remoteIpAddress; revokeAccess.ActedByUser = revokingUserId.ToString(); revokeAccess.TargetUserId = targetUserId; revokeAccess.ProjectId = projectId; revokeAccess.Data = "CustomData: " + customData; await _dbContext.Events.AddAsync(revokeAccess); var updatedRowCount = await _dbContext.SaveChangesAsync(); if (updatedRowCount > 1) { // we have a problem } }
public async Task RegisterEventAsync(string name, string subscriber) { var rawRabbitEvent = new RawRabbitEvent { Name = name, Subscriber = subscriber }; _context.Add(rawRabbitEvent); await _context.SaveChangesAsync(); }
public async Task <IActionResult> Create([Bind("TimeProposedId,StartTime,EndTime")] TimeProposed timeProposed) { if (ModelState.IsValid) { _context.Add(timeProposed); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(timeProposed)); }
public async Task <IActionResult> Create([Bind("UserId,Name,Password,CompanyId")] User user) { if (ModelState.IsValid) { _context.Add(user); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(user)); }
public async Task <IActionResult> Create([Bind("TaskId,TaskName,TaskDescription,done")] Models.Task task) { if (ModelState.IsValid) { _context.Add(task); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(task)); }
public async Task <IActionResult> ActivityCreate([Bind("ActivityId,Name,Description")] Activity activity) { if (ModelState.IsValid) { _context.Add(activity); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(ActivityEdit), "Activities", new { id = activity.ActivityId })); } return(View(activity)); }
public async Task <IActionResult> Create([Bind("EventId,EventName,EventDescription,EventType,ReleaseDate")] Event @event) { if (ModelState.IsValid) { _context.Add(@event); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(@event)); }
public async Task <IActionResult> PostEvent([FromBody] Event events) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.Events.Add(events); await _context.SaveChangesAsync(); return(CreatedAtAction("GetEvent", new { id = events.Id }, events)); }
public async Task <IActionResult> Create([Bind("CompanyId,Name,Description,UserId")] Company company) { if (ModelState.IsValid) { _context.Add(company); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["UserId"] = new SelectList(_context.users, "UserId", "UserId", company.UserId); return(View(company)); }
public async Task <User> Reqister(ReqisterDTO user) { var _user = new User() { FirstName = user.FirstName, LastName = user.LastName, Email = user.Email }; await context.User.AddAsync(_user); await context.SaveChangesAsync(); return(_user); }
public async Task <ActionResult <EventInfo> > AddEvent([FromBody] EventInfo eventInfo) { try { if (ModelState.IsValid) { var result = await db.Events.AddAsync(eventInfo); await db.SaveChangesAsync(); //return Created("", result.Entity); //returns the status code as 201 //If you want to use Action for redirection then give action name //return CreatedAtAction(nameof(GetEvent), new { id = result.Entity.Id }, result.Entity); //returns the status code as 201 //If you want to use route for redirection then give route name return(CreatedAtRoute("GetById", new { id = result.Entity.Id }, result.Entity)); //returns the status code as 201 } else { return(BadRequest(ModelState)); } } catch (Exception ex) { throw ex; } }
public async Task <Status> UpdatePerformanceDate(int artistId, int eventId, DateTime newPerformanceDate) { var @event = await _dbContext.Events.SingleOrDefaultAsync(x => x.IdEvent == eventId); if (@event is null) { return(Status.NotFound); } if (@event.StartDate < DateTime.UtcNow) { return(Status.BadRequest); } if (@event.StartDate > newPerformanceDate || @event.EndDate < newPerformanceDate) { return(Status.BadRequest); } var artistEvent = await _dbContext.ArtistEvents.SingleOrDefaultAsync(x => x.Artist.IdArtist == artistId && x.Event.IdEvent == eventId); if (artistEvent is null) { return(Status.NotFound); } artistEvent.PerformanceDate = newPerformanceDate; await _dbContext.SaveChangesAsync(); return(Status.NoContent); }
public async Task <ActionResult <EventData> > AddEventAsync(EventData item) { TryValidateModel(item); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } else { await db.Events.AddAsync(item); await db.SaveChangesAsync(); return(CreatedAtRoute("GetEventById", new { id = item.Id }, item)); } }
public async Task <IActionResult> OnPostAsync(int?id) { if (id == null) { return(NotFound()); } Event = await _context.Event.FirstOrDefaultAsync(m => m.Id == id); if (Event == null) { return(NotFound()); } var userId = _userManager.GetUserId(User); //När man är inloggad så joinar den inloggade usern ett event. var userJoin = await _context.MyUser .Where(e => e.Id == userId) .Include(a => a.JoinedEvents) .FirstOrDefaultAsync(); userJoin.JoinedEvents.Add(Event); await _context.SaveChangesAsync(); return(Page()); }
public async Task <IActionResult> OnPostAsync(int?id) { if (id == null) { return(NotFound()); } Event = await _context.Event.FirstOrDefaultAsync(m => m.EventId == id); if (Event == null) { return(NotFound()); } var attendee = await _context.Attendee.Where (a => a.AttendeeId == 1) .Include(e => e.Event) .FirstOrDefaultAsync(); var join = await _context.Event.Where (e => e.EventId == id) .FirstOrDefaultAsync(); join.SpotsAvailable = join.SpotsAvailable - 1; // Får lägga till en koll på att man inte redan är med i eventet attendee.Event.Add(join); await _context.SaveChangesAsync(); return(Page()); }
public void DeletById(int id) { var deletEvent = _context.Events.Find(id); _context.Events.Remove(deletEvent); _context.SaveChangesAsync(); }
public async Task AddEventAsync <TEvent>(TEvent @event) where TEvent : IEvent <TEventId, TAggregateId> { var persistedEvent = _eventDataFactory.Create(@event); await DbContext.Events.AddAsync(persistedEvent); await DbContext.SaveChangesAsync(); }
public IActionResult DeleteConfirmed(int id) { var confirmedEvent = _context.Events.Find(id); _context.Events.Remove(confirmedEvent); _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); }
public async Task <bool> SaveChangesAsync() { try { return(await context.SaveChangesAsync() > 0); } catch (Exception ex) { return(false); } }
public async Task OnPost(string?id) { var newrole = _context.MyUser.Where(a => a.Id == id).FirstOrDefault(); if (!_userManager.IsInRoleAsync(newrole, "organizer").Result) // Om man inte är orhganizer så blir man det när man checkar i boxen. { await _userManager.AddToRoleAsync(newrole, "organizer"); await _userManager.RemoveFromRoleAsync(newrole, "user"); await _context.SaveChangesAsync(); } else { await _userManager.AddToRoleAsync(newrole, "user"); await _userManager.RemoveFromRoleAsync(newrole, "organizer"); await _context.SaveChangesAsync(); } await OnGetAsync(); }
public static async Task SeedEventDbEntityAsync <T>(this EventDbContext context, IQueryable <EntityBase> entities, ILogger logger = null) where T : EntityBase { string seedFile = Path.Combine(AppContext.BaseDirectory, "Seed", "EventDB", $"{typeof(T).Name}.json"); if (File.Exists(seedFile) && !(await entities.ToListAsync()).Any()) { logger?.LogInformation($"Seeding {context.GetType().Name}::{typeof(T).Name} with {seedFile}"); List <T> seedEntities = JsonConvert.DeserializeObject <List <T> >(await File.ReadAllTextAsync(seedFile)); await context.AddRangeAsync(seedEntities); await context.SaveChangesAsync(); logger?.LogInformation($"Seeding of {context.GetType().Name}::{typeof(T).Name} has completed!"); } }
public async Task <IActionResult> ActivityCreate([Bind("InviteeId,Name,ActivityId")] ActivityCreateInviteeInputModel InputModel) { if (ModelState.IsValid) { _context.Invitees.Add(new Invitee { Name = InputModel.Name, ActivityTimeInvitees = //new List<ActivityTimeInvitee>() { new ActivityTimeInvitee() { ActivityId = InputModel.ActivityId } } }); //_context.ActivityTimeInvitees.Add(new ActivityTimeInvitee() //{ // ActivityId = InputModel.ActivityId, // InviteeId = InputModel.InviteeId //}); await _context.SaveChangesAsync(); return(RedirectToAction( nameof(ActivitiesController.ActivityEdit), "Activities", new { id = InputModel.ActivityId })); } return(View(new ActivityCreateInviteeViewModel() { ActivityId = InputModel.ActivityId })); }
public async Task <ActionResult <EventInfo> > AddEventAsync([FromBody] EventInfo eventInfo) { if (ModelState.IsValid) { var entity = await db.Events.AddAsync(eventInfo); await db.SaveChangesAsync(); return(CreatedAtRoute("GetByIdAsync", new { id = entity.Entity.Id }, entity.Entity)); } else { return(BadRequest(ModelState)); } }
public async Task <IActionResult> CreateAsync(EventInfo model) { if (!ModelState.IsValid) { return(View(model)); } else { await db.Events.AddAsync(model); await db.SaveChangesAsync(); return(Redirect("eventlist")); } }
public async Task <IActionResult> CreateAsync(EventInfo eventInfo) { if (!ModelState.IsValid) { return(View("Create", eventInfo)); } else { await eventDbContext.Events.AddAsync(eventInfo); await eventDbContext.SaveChangesAsync(); return(RedirectToRoute("ListEvents")); } }