private async Task <IActionResult> HandleVideoUpload(string ulToken, Stream fileStream, long streamLength)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (videoStore.GetUploadModel(ulToken, out Video video))
{
if (await this.User(db) is Admin)
{
video.Properties = await videoStore.StoreVideoAsync(fileStream, video.Properties, streamLength, HttpContext.RequestAborted);
if (video.Properties != null)
{
db.Videos.Add(video);
await db.SaveChangesAsync(); //Save and get Id
video.StreamUrl = $"{StreamBaseUrl}{video.Id}";
await db.SaveChangesAsync(); //Update URL with Id
return(Ok(video));
}
}
}
return(BadRequest());
}
public async Task <IActionResult> CreateComment(string message, long videoId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await this.User(db);
if (user != null)
{
var video = await db.Videos.FindAsync(videoId);
if (video != null)
{
var comment = new Comment
{
User = user,
CommentTime = DateTime.UtcNow,
Message = message,
Video = video
};
db.Comments.Add(comment);
await db.SaveChangesAsync();
await notificationService.PostUserMentions(comment);
return(Ok());
}
}
return(BadRequest());
}
public async Task PostUserMentions(Comment comment)
{
IEnumerable <string> userIds = GetUserIdsMentioned(comment);
IQueryable <Notification> notifications = db.Users.Where(u => userIds.Contains(u.UserName)).Select(user => new Notification
{
Dismissed = false,
NotificationTimeUtc = DateTime.UtcNow,
User = user,
RouterLink = RouterLink.Comment,
Message = string.Format(USER_MENTION_NOTIFICATION_TEXT, comment.User.FullName, comment.Video.Name),
RouterLinkParameters = new[]
{
new RouterLinkParam()
{
Param = LinkParam.VideoId,
Value = comment.Video.Id.ToString()
},
new RouterLinkParam()
{
Param = LinkParam.CommentId,
Value = comment.Id.ToString()
}
}
});
db.Notifications.AddRange(notifications);
await db.SaveChangesAsync();
}
public async Task <IActionResult> RegisterUser([FromBody] UserSignupModel userModel)
{
if (string.IsNullOrEmpty(userModel.Password) || string.IsNullOrEmpty(userModel.UserName))
{
return(BadRequest());
}
var user = new IdentityUser()
{
Email = userModel.Email,
UserName = userModel.UserName
};
var createUserResult = await userManager.CreateAsync(user, userModel.Password);
if (createUserResult.Succeeded)
{
await userManager.AddClaimsAsync(user, new[] { new Claim("UserId", user.Id), new Claim("UserName", user.UserName) });
//Decoupling domain users from Identity framework, by correlating a domain user with the identity.
modelDb.Users.Add(new Student
{
UserName = user.UserName, //correlation
Email = userModel.Email,
FullName = userModel.FullName,
isTeacher = false,
});
await modelDb.SaveChangesAsync();
}
return(Ok(createUserResult));
}
public async Task <IActionResult> AddRoom([FromBody] Room room)
{
if (!(await this.User(db) is Admin))
{
return(BadRequest());
}
var existingRoom = await db.Rooms.FirstOrDefaultAsync(r => r.WebuntisId == room.WebuntisId);
if (existingRoom != null)
{
return(Conflict(existingRoom));
}
db.Rooms.Add(room);
await db.SaveChangesAsync();
return(Ok(room));
}
public async Task <IActionResult> AddRange([FromBody] ICollection <Course> courses)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await this.User(db) is Admin)
{
var entitiesExist = await db.Courses.Where(c => courses.Select(c2 => c2.WebuntisCourseId).Contains(c.WebuntisCourseId)).ToDictionaryAsync(c => c.WebuntisCourseId, c => c);
var toAdd = courses.Where(c => !entitiesExist.TryGetValue(c.WebuntisCourseId, out Course _)).ToList();
db.Courses.AddRange(toAdd);
await db.SaveChangesAsync();
int added = toAdd.Count();
return(Ok(added));
}
return(Unauthorized());
}
public async Task <IActionResult> DismissNotification([FromRoute] long notificationId)
{
User user = await this.User(db);
if (user != null)
{
var notification = await db.Notifications.Where(n => n.UserId == user.Id && n.Id == notificationId).FirstOrDefaultAsync();
if (notification != null)
{
notification.Dismissed = true;
await db.SaveChangesAsync();
return(Ok(notification));
}
}
return(Forbid());
}
public async Task <IActionResult> EnrollUser([FromBody] EnrollUserModel enrollUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await this.User(db) is Admin)
{
if (db.Enrollments
.Where(enroll => enroll.User.Id == enrollUserModel.UserId && enroll.Course.Id == enrollUserModel.CourseId)
.Any())
{
return(Ok()); //User already enrolled in that course
}
var user = await db.Users.FindAsync(enrollUserModel.UserId);
if (user != null)
{
var course = await db.Courses.FindAsync(enrollUserModel.CourseId);
if (course != null)
{
db.Enrollments.Add(new Enrollment
{
Course = course,
User = user,
EnrollmentDateUtc = DateTime.UtcNow
});
await db.SaveChangesAsync();
return(Ok());
}
}
return(BadRequest());
}
return(Unauthorized());
}