public override void OnActionExecuting(ActionExecutingContext filterContext)
{
Room currentRoom = (Room)filterContext.HttpContext.Items["currentRoom"];
User currentUser = (User)filterContext.HttpContext.Items["currentUser"];
if (currentRoom != null)
{
int currentRoomID = currentRoom.RoomID;
int currentUserID = currentUser.UserID;
using (var db = new RealtimeChatDB())
{
RoomMember currentRoomMember = db.RoomMembers.Where(m => m.RoomID == currentRoomID && m.UserID == currentUserID).FirstOrDefault();
if (currentRoomMember.MemberLevel < 2)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { action = "Index", controller = "Rooms" })
);
}
}
}
else
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { action = "Index", controller = "Rooms" })
);
}
}
public async Task <IHttpActionResult> PostRoom(PostRoomMemberClass postroom)
{
if (!TokenRepositor.checkToken(postroom.idUser, postroom.token))
{
return(NotFound());
}
Room room = new Room();
room.RoomName = postroom.RoomName;
room.Private = postroom.Private;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Rooms.Add(room);
await db.SaveChangesAsync();
RoomMember roomm = new RoomMember();
roomm.IdRoom = room.Id;
roomm.IdUser = postroom.idUser;
db.RoomMembers.Add(roomm);
await db.SaveChangesAsync();
return(Ok("Chatroom Created"));
}
// ADD MEMBER
public async Task AddMemberAsync(string groupName, User user)
{
var room = await this.GetByNameAsync(groupName);
if (room == null)
{
throw new ArgumentException("Invalid room name: " + groupName);
}
if (user == null)
{
throw new ArgumentException("Invalid user");
}
var members = await this.GetMembersAsync(groupName);
if (members.Contains(user))
{
return;
}
var roomMember = new RoomMember {
Room = room, Member = user
};
room.RoomMembers.Add(roomMember);
await this.db.SaveChangesAsync();
}
private async Task <FullTrack> GetSongFromQueue(RoomMember member, string playlist)
{
try
{
var api = await _spotifyAccessService.TryGetMemberApi(member.UserName);
var queueList = await api.GetPlaylistTracksAsync(playlist);
queueList.ThrowOnError(nameof(api.GetPlaylistTracks));
if (!queueList.Items.Any())
{
return(null);
}
var track = queueList.Items.First().Track;
var remove = await api.RemovePlaylistTrackAsync(playlist, new DeleteTrackUri(track.Uri, 0));
remove.ThrowOnError(nameof(api.RemovePlaylistTrackAsync));
return(track);
}
catch (Exception e)
{
_logger.Log(LogLevel.Warning, "Failed to get song from {Username}'s queue because {@Exception}", member.UserName, e);
Debug.WriteLine(e);
return(null);
}
}
public void VoteSkipSong(RoomMember member)
{
var oldVal = member.VotedSkipSong;
member.VotedSkipSong = true;
if (oldVal == false)
{
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} voted to skip song"
});
}
if (_members.Count / 2 > _members.Count(x => x.VotedSkipSong))
{
return;
}
_roomEvents.Add(new SongSkippedEvent());
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Success,
Message = $"Skipping song with {_members.Count(x => x.VotedSkipSong)} votes"
});
_handledUntil = DateTimeOffset.Now;
foreach (var roomMember in _members)
{
roomMember.VotedSkipSong = false;
}
}
public async Task <IActionResult> Create(JoinClassInfor joinClassInfor)
{
if (ModelState.IsValid)
{
AppUser currentUser = await userManager.FindByNameAsync(HttpContext.User.Identity.Name);
joinClassInfor.NewClass.User = currentUser;
joinClassInfor.NewClass.isActive = true;
//joinClassInfor.NewClass.HOC = hoc;
_context.Classes.Add(joinClassInfor.NewClass);
RoomDocument roomD = new RoomDocument
{
ClassInfoID = joinClassInfor.NewClass.ClassID
};
_context.RoomDocuments.Add(roomD);
RoomMember roomM = new RoomMember
{
ClassID = joinClassInfor.NewClass.ClassID
};
_context.RoomMembers.Add(roomM);
await _context.SaveChangesAsync();
return(RedirectToAction("Room", "Room", joinClassInfor.NewClass));
}
return(View());
}
// PUT api/RoomMember/5
public async Task <IHttpActionResult> PutRoomMember(int id, RoomMember roommember)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != roommember.Id)
{
return(BadRequest());
}
db.Entry(roommember).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomMemberExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> DeleteRoomMember(DeleteRoomMemberClass deleteRoomMember)
{
if (!TokenRepositor.checkToken(deleteRoomMember.idUser, deleteRoomMember.token))
{
return(NotFound());
}
RoomMember roommember = db.RoomMembers.Where(x => x.IdUser == deleteRoomMember.idUser && x.IdRoom == deleteRoomMember.IdRoom).FirstOrDefault();
if (roommember == null)
{
return(NotFound());
}
db.RoomMembers.Remove(roommember);
await db.SaveChangesAsync();
string delete = "";
if (db.RoomMembers.Where(x => x.IdRoom == deleteRoomMember.IdRoom).Count() == 0)
{
Room r = await db.Rooms.FindAsync(deleteRoomMember.IdRoom);
db.Rooms.Remove(r);
delete = ",room deleted";
}
await db.SaveChangesAsync();
return(Ok("User left Room" + delete));
}
public void MemberJoin(RoomMember member)
{
if (_members.Any(x => x.UserName == member.UserName))
{
return;
}
_members.Add(member);
OnRoomMembersChanged?.Invoke(this, member.UserName);
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, UserEventType.JoinedRoom));
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} joined room"
});
ToggleDj(member, false);
if (_currentTrack != null)
{
StartSongForMemberUgly(member);
}
_timeSinceEmpty = CustomFutureDateTimeOffset;
}
public void VoteSkipSong(RoomMember member)
{
var oldVal = member.VotedSkipSong;
member.VotedSkipSong = true;
var requiredVotes = _members.Count / 2;
var totalVotes = _members.Count(x => x.VotedSkipSong);
var changedCount = oldVal == false;
if (requiredVotes > totalVotes)
{
if (changedCount)
{
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} voted to skip song, {requiredVotes-totalVotes} more vote(s) until skipping..."
});
}
return;
}
_logger.Log(LogLevel.Information, "Skipping current song in {Room} with group vote", RoomId);
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Success,
Message = $"Skipping song with {_members.Count(x => x.VotedSkipSong)} vote(s)"
});
SkipSongActual();
}
// CREATE ASYNC
public async Task CreateAsync(string roomName, User owner = null)
{
if (this.Exists(roomName))
{
throw new ArgumentException("This room already exists.");
}
var room = new Room
{
Name = roomName,
Owner = owner,
OwnerId = owner?.Id,
ReceivedMessages = new List <Message>(),
RoomMembers = new List <RoomMember>()
};
this.db.Add(room);
if (owner != null)
{
var roomMember = new RoomMember()
{
Room = room,
Member = owner
};
this.db.Add(roomMember);
room.RoomMembers.Add(roomMember);
owner.RoomMembers.Add(roomMember);
owner.RoomsOwned.Add(room);
}
await this.db.SaveChangesAsync();
}
private async Task PlaySong(RoomMember member, FullTrack song, int positionMs = 0)
{
try
{
var api = await _spotifyAccessService.TryGetMemberApi(member.UserName);
var devices = await api.GetDevicesAsync();
devices.ThrowOnError(nameof(api.GetDevices));
if (!devices.Devices.Any())
{
throw new Exception("No devices available to play on!");
}
var device = devices.Devices.FirstOrDefault(x => x.IsActive) ?? devices.Devices.First();
var resume = await api.ResumePlaybackAsync(deviceId : device.Id, uris : new List <string> {
song.Uri
}, offset : 0, positionMs : positionMs);
resume.ThrowOnError(nameof(api.ResumePlaybackAsync));
// we don't care if this one fails
await api.SetRepeatModeAsync(RepeatState.Off, device.Id);
}
catch (Exception e)
{
_logger.Log(LogLevel.Warning, "Failed to play song for {Username} because {@Exception}", member.UserName, e);
// oh well
Debug.WriteLine(e);
}
}
public void MemberJoin(RoomMember member)
{
if (_members.Any(x => x.UserName == member.UserName))
{
return;
}
_statisticsService.IncrementUserCount();
_members.Add(member);
OnRoomMembersChanged?.Invoke(this, member.UserName);
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, UserEventType.JoinedRoom));
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} joined room"
});
ToggleDj(member, false);
if (_currentTrack != null)
{
StartSongForMemberUgly(member);
}
}
public bool UserReaction(RoomMember member, string reaction)
{
// no awarding your own song
if (member.UserName == CurrentRoomState.CurrentDjUsername)
{
return(false);
}
try
{
var actualReaction = Enum.Parse <Reaction>(reaction, true);
var currentReactions = member.ReactionFlagsForCurrentTrack;
member.ReactionFlagsForCurrentTrack |= actualReaction;
if (currentReactions == member.ReactionFlagsForCurrentTrack)
{
return(false);
}
UpdateReactionTotals();
return(true);
}
catch (Exception e)
{
_logger.Log(LogLevel.Warning, "{Username} failed to react to track with {Reaction} because {@Exception}", member.UserName, reaction, e);
Debug.WriteLine(e);
return(false);
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
Room currentRoom;
User currentUser = (User)filterContext.HttpContext.Items["currentUser"];
int currentRoomID = Convert.ToInt32(filterContext.RouteData.Values["id"]);
using (var db = new RealtimeChatDB())
{
currentRoom = db.Rooms.Where(r => r.RoomID == currentRoomID).FirstOrDefault();
if (currentRoom != null)
{
RoomMember existingMember = db.RoomMembers.Where(m => m.UserID == currentUser.UserID && m.RoomID == currentRoom.RoomID).FirstOrDefault();
if (existingMember == null)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { action = "Index", controller = "Rooms" })
);
}
else
{
filterContext.HttpContext.Items["currentRoom"] = currentRoom;
}
}
else
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { action = "Index", controller = "Rooms" })
);
}
}
}
public async Task AddToLiked(RoomMember member)
{
try
{
var api = await _spotifyAccessService.TryGetMemberApi(member.UserName);
var track = _currentTrack;
var result = await api.SaveTrackAsync(track.Id);
result.ThrowOnError(nameof(api.SaveTrackAsync));
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Success,
Message = $"Successfully added {string.Join(", ", track.Artists.Select(x => x.Name).ToArray())} - {track.Name} to your Liked Songs",
TargetId = member.ConnectionId
});
}
catch (Exception e)
{
_logger.Log(LogLevel.Warning, "Failed to add song to {Username}'s liked songs because {@Exception}", member.UserName, e);
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Error,
Message = $"Failed to add song to your Liked Songs",
TargetId = member.ConnectionId
});
Debug.WriteLine(e);
}
}
public void MemberLeave(RoomMember member)
{
var didRemove = _members.Remove(member);
if (!didRemove)
{
return;
}
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, UserEventType.LeftRoom));
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} left the room"
});
OnRoomMembersChanged?.Invoke(this, member.UserName);
UpdateReactionTotals();
// this was the last member to leave
if (!_members.Any())
{
_timeSinceEmpty = DateTimeOffset.Now;
}
}
private async Task PlaySong(RoomMember member, FullTrack song, int positionMs = 0, bool canRetry = true)
{
try
{
var api = await _spotifyAccessService.TryGetMemberApi(member.UserName);
var devices = await api.GetDevicesAsync();
devices.ThrowOnError(nameof(api.GetDevices));
if (!devices.Devices.Any())
{
throw new Exception("No devices available to play on!");
}
var device = devices.Devices.FirstOrDefault(x => x.IsActive) ?? devices.Devices.First();
var resume = await api.ResumePlaybackAsync(deviceId : device.Id, uris : new List <string> {
song.Uri
}, offset : 0, positionMs : positionMs);
resume.ThrowOnError(nameof(api.ResumePlaybackAsync));
}
catch (Exception e)
{
_logger.Log(LogLevel.Warning, "Failed to play song for {Username} because {@Exception}", member.UserName, e);
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Error,
Message = $"Failed to play song",
TargetId = member.ConnectionId
});
if (e.Message.Contains("HTTP 5") && canRetry)
{
// if it's a server side error let's add it to the retry queue
async Task RetryTask()
{
// make sure user hasn't left in the last room-cycle
if (!_members.Contains(member))
{
return;
}
// try starting song again
var left = _handledUntil.ToUnixTimeMilliseconds() - DateTimeOffset.Now.ToUnixTimeMilliseconds();
await PlaySong(member, _currentTrack, (int)(_currentTrack.DurationMs - left), false);
}
_logger.Log(LogLevel.Information, "Added retry task for {UserName}", member.UserName);
_roomRetries.Add(RetryTask);
}
// else oh well
Debug.WriteLine(e);
}
}
public void TryFixPlaybackForMember(RoomMember member)
{
if (_currentTrack == null)
{
return;
}
_logger.LogInformation("Trying to fix playback for {Username} in {Room}", member.UserName, RoomId);
StartSongForMemberUgly(member);
}
public void ToggleDj(RoomMember member, bool isDj)
{
member.IsDj = isDj;
member.DjOrderNumber = isDj ? _members.Where(x => x.IsDj).Max(y => y.DjOrderNumber) + 1 : -1;
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, isDj ? UserEventType.BecameDj : UserEventType.BecameListener));
OnRoomMembersChanged?.Invoke(this, null);
}
public async UnaryResult <ChatRoomResponse> Join(string roomId, string nickName)
{
var room = RoomRepository.Default.GetRoom(roomId);
var newMember = new RoomMember(Guid.NewGuid().ToString(), nickName);
room.AddMember(newMember, GetStreamingContextRepository());
await room.BroadcastJoinAsync(newMember);
return(room.ToChatRoomResponse());
}
internal void Init(Room room, RoomMember playerData)
{
Room = room;
UserId = playerData.Pid;
ActorId = playerData.ActorId;
IsActive = !playerData.Inactive;
if (playerData.Attr != null)
{
CustomProperties = CodecUtils.DeserializePlayObject(playerData.Attr);
}
}
public async Task <IHttpActionResult> GetRoomMember(int id)
{
RoomMember roommember = await db.RoomMembers.FindAsync(id);
if (roommember == null)
{
return(NotFound());
}
return(Ok(roommember));
}
public GameObject FindRoomMember(string uid)
{
foreach (Transform r in roomMemberList)
{
RoomMember roomMember = r.GetComponent <RoomMember>();
if (roomMember.UID.Equals(uid))
{
return(roomMember.gameObject);
}
}
return(null);
}
public async Task AddRoomMemberToUI(string uid)
{
string usernamePath = "users/" + uid;
DataSnapshot usernameSnapshot = await FirebaseData.Instance.reference.Child(usernamePath).GetValueAsync();
string username = usernameSnapshot.Child("username").Value.ToString();
GameObject r = Instantiate(roomMemberPrefab, roomMemberList, false);
RoomMember roomMember = r.GetComponent <RoomMember>();
roomMember.UID = uid;
roomMember.usernameText.text = username;
roomMember.readyText.text = "Not Ready";
}
public void ToggleDj(RoomMember member, bool isDj)
{
member.IsDj = isDj;
member.DjOrderNumber = isDj ? _members.Where(x => x.IsDj).Max(y => y.DjOrderNumber) + 1 : -1;
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, isDj ? UserEventType.BecameDj : UserEventType.BecameListener));
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Information,
Message = $"{member.FriendlyName} became a {(isDj ? "DJ" : "listener")}"
});
OnRoomMembersChanged?.Invoke(this, null);
}
public void TryForceSkipAsDj(RoomMember member)
{
if (CurrentRoomState.CurrentDjUsername != member.UserName)
{
return;
}
_logger.Log(LogLevel.Information, "Skipping current song in {Room} per request of the DJ", RoomId);
OnRoomNotification?.Invoke(this, new RoomNotification
{
Category = RoomNotificationCategory.Success,
Message = $"Skipping song per DJ's request"
});
SkipSongActual();
}
public void VoteSkipSong(RoomMember member)
{
member.VotedSkipSong = true;
if (_members.Count / 2 > _members.Count(x => x.VotedSkipSong))
{
return;
}
_roomEvents.Add(new SongSkippedEvent());
_handledUntil = DateTimeOffset.Now;
foreach (var roomMember in _members)
{
roomMember.VotedSkipSong = false;
}
}
public IActionResult Room(IndexModel room)
{
var username = HttpContext.User.Claims.GetSpotifyUsername();
// prev room?
var alreadyInRoom = _roomService.TryGetRoomForUsername(username, out var prevRoom);
if (alreadyInRoom && room.RoomName != prevRoom.RoomId)
{
// if it doesn't match leave the prev one
prevRoom.MemberLeave(prevRoom.Members.First(x => x.UserName == username));
}
// sanitize room name
var rgx = new Regex("[^a-zA-Z-]");
if (string.IsNullOrWhiteSpace(room.RoomName))
{
room.RoomName = NaughtyRoomName;
}
var sanitizedRoomName = rgx.Replace(room.RoomName.Replace(" ", "-"), string.Empty);
if (string.IsNullOrWhiteSpace(sanitizedRoomName) || sanitizedRoomName.Length < 3)
{
// hehe
sanitizedRoomName = NaughtyRoomName;
}
room.RoomName = sanitizedRoomName;
var party = _roomService.EnsureRoom(room.RoomName);
_logger.Log(LogLevel.Information, "{Page} loaded for {Username}", "Room", username);
var member = new RoomMember(username, HttpContext.User.Claims.GetSpotifyFriendlyName(), room.PlaylistId);
party.MemberJoin(member);
return(View(new RoomModel
{
RoomName = room.RoomName,
UserName = username,
QueuePlaylistLink = $"spotify:playlist:{room.PlaylistId}"
}));
}
public void MemberLeave(RoomMember member)
{
var didRemove = _members.Remove(member);
if (!didRemove)
{
return;
}
_roomEvents.Add(new UserEvent(member.UserName, member.FriendlyName, UserEventType.LeftRoom));
OnRoomMembersChanged?.Invoke(this, member.UserName);
// this was the last member to leave
if (!_members.Any())
{
_timeSinceEmpty = DateTimeOffset.Now;
}
}
