//Workaround the timeout issue
//Has to be fixed in the future
private PartyTable GetSelectedJoined(long partyId)
{
using (var db = new EntitiesChooseEm())
{
return(db.PartyTables.FirstOrDefault(arg => arg.ID == partyId));
}
}
/// <summary>
/// Update the party details
/// </summary>
/// <param name="updatedParty"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public PartyTable UpdateParty(PartyTable updatedParty)
{
using (var context = new EntitiesChooseEm())
{ //check for party being null?
PartyTable party = context.PartyTables.FirstOrDefault(p => p.ID == updatedParty.ID);
party.startDate = updatedParty.startDate;
party.endDate = updatedParty.endDate;
party.locationLatitude = updatedParty.locationLatitude;
party.locationLongitude = updatedParty.locationLongitude;
party.privacy = updatedParty.privacy;
party.Name = updatedParty.Name;
party.RowVersion = updatedParty.RowVersion;
party.AvailablePlaces = updatedParty.AvailablePlaces;
context.PartyTables.Attach(party);
context.Entry(party).State = System.Data.Entity.EntityState.Modified;
var num = context.SaveChanges();
if (num != 1)
{
throw new Exception("Concurrency Error");
}
}
return(updatedParty);
}
public UsersAtParty CreateUserAtParty(UsersAtParty userAtParty, byte[] RowVersion)
{
PartyRepository pr = new PartyRepository();
using (var db = new EntitiesChooseEm())
{
using (var dbContextTransaction = db.Database.BeginTransaction())
{
var selectedParty = db.PartyTables.First(p => p.ID == userAtParty.partyID);
if (selectedParty.AvailablePlaces > 0)
{
db.UsersAtParties.Add(userAtParty);
db.SaveChanges();
selectedParty.AvailablePlaces -= 1;
selectedParty.RowVersion = RowVersion;
}
else
{
throw new Exception("No places left, refresh the page");
}
try { pr.UpdateParty(selectedParty);
dbContextTransaction.Commit(); }
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw ex;
}
}
}
return(userAtParty);
}
private bool GetSelectedNotJoined(long partyId, long userId)
{
using (var db = new EntitiesChooseEm())
{
return(db.UsersAtParties.Any(arg => arg.partyID == partyId && arg.userID == userId));
}
}
public void RevertRating(SongRatingFromPartyTable rating, int previousType)
{
using (var db = new EntitiesChooseEm())
{
var aux = db.SongRatingFromPartyTables.First(p => p.userID == rating.userID && p.songURL == rating.songURL && p.partyID == rating.partyID);
aux.voteType = previousType;
db.SaveChanges();
}
}
public bool AddSongInPartyPlaylist(SongsForPartyTable playlist)
{
using (var db = new EntitiesChooseEm())
{
db.SongsForPartyTables.Add(playlist);
db.SaveChanges();
}
return(true);
}
public PartyTable CreateParty(PartyTable party)
{
using (var db = new EntitiesChooseEm())
{
db.PartyTables.Add(party);
db.SaveChanges();
}
return(party);
}
/// <summary>
/// Get all parties of the specific user
/// </summary>
/// <param name="ownerId"></param>
/// <returns></returns>
public List <PartyTable> GetAllParties(long ownerId)
{
List <PartyTable> parties;
using (var db = new EntitiesChooseEm())
{
parties = db.PartyTables.Where(p => p.ownerID == ownerId).ToList();
}
return(parties);
}
/// <summary>
/// Gets all users at a certain party specified by the party id
/// </summary>
/// <param name="partyId"></param>
/// <returns></returns>
public List <UsersAtParty> GetAllUsers(long partyId)
{
List <UsersAtParty> users = new List <UsersAtParty>();
using (var db = new EntitiesChooseEm())
{
users = db.UsersAtParties.Where(uP => uP.partyID == partyId).ToList();
}
return(users);
}
/// <summary>
/// Gets a certain user from the usersAtParty table by id
///
/// what is this good for? todo: something with this
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public UsersAtParty GetUserForID(long userId)
{
UsersAtParty userAtParty;
using (var db = new EntitiesChooseEm())
{
userAtParty = db.UsersAtParties.FirstOrDefault(uP => uP.userID == userId);
}
return(userAtParty);
}
public SongsForPartyTable UpdateSongRating(SongsForPartyTable songWithUpdatedRating)
{
using (var context = new EntitiesChooseEm())
{
SongsForPartyTable song = context.SongsForPartyTables.FirstOrDefault(p => p.songURL == songWithUpdatedRating.songURL && p.partyID == songWithUpdatedRating.partyID);
song.rating = songWithUpdatedRating.rating;
context.SaveChanges();
}
return(songWithUpdatedRating);
}
/// <summary>
/// Get a party specified by id
/// </summary>
/// <param name="partyId"></param>
/// <returns></returns>
public PartyTable GetParty(long partyId)
{
PartyTable party;
using (var db = new EntitiesChooseEm())
{
party = db.PartyTables.FirstOrDefault(p => p.ID == partyId);
}
return(party);
}
public SongsForPartyTable GetSongFromPartyPlaylist(long partyID, string songURL)
{
SongsForPartyTable song = null;
using (var db = new EntitiesChooseEm())
{
song = db.SongsForPartyTables.FirstOrDefault(p => p.partyID == partyID && p.songURL == songURL);
}
return(song);
}
/// <summary>
/// True if the two users are friends, false otherwise
/// </summary>
/// <param name="firstUserId"></param>
/// <param name="secondUserId"></param>
/// <returns></returns>
public bool AreFriends(long firstUserId, long secondUserId)
{
bool areFriends;
using (var db = new EntitiesChooseEm())
{
areFriends = db.FriendTables.Any(f => f.idOne == firstUserId && f.idTwo == secondUserId);
}
return(areFriends);
}
/// <summary>
/// Get every friend of a user specified by id
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public List <FriendTable> GetAllUserFriends(long userId)
{
List <FriendTable> allFriends;
using (var db = new EntitiesChooseEm())
{
allFriends = db.FriendTables.Where(uP => uP.idOne == userId || uP.idTwo == userId).ToList();
}
return(allFriends);
}
/// <summary>
/// Returns true if the selected user is at the selected party, false otherwise
/// </summary>
/// <param name="userId"></param>
/// <param name="partyId"></param>
/// <returns></returns>
public bool IsAtParty(long userId, long partyId)
{
bool isAtParty;
using (var context = new EntitiesChooseEm())
{
isAtParty = context.UsersAtParties.Any(u => u.partyID == partyId && u.userID == userId);
}
return(isAtParty);
}
/// <summary>
/// Get user data of the party owner
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public UserTable GetOwner(long userId)
{
UserTable user;
using (var db = new EntitiesChooseEm())
{
user = db.UserTables.FirstOrDefault(u => u.ID == userId);
}
return(user);
}
public bool RemoveSongRating(long partyID, long userID, string songURL)
{
SongRatingFromPartyTable rating = null;
using (var db = new EntitiesChooseEm())
{
rating = db.SongRatingFromPartyTables.FirstOrDefault(r => r.partyID == partyID && r.userID == userID && r.songURL == songURL);
db.SongRatingFromPartyTables.Remove(rating);
}
return(true);
}
public UsersAtParty UpdateUserAtParty(UsersAtParty updatedUsers)
{
using (var context = new EntitiesChooseEm())
{ //check for user being null?
UsersAtParty user = context.UsersAtParties.FirstOrDefault(u => u.userID == updatedUsers.userID);
user.status = updatedUsers.status;
user.adminPrivileges = updatedUsers.adminPrivileges;
context.SaveChanges();
}
return(updatedUsers);
}
public UsersAtParty GetUserAfterFK(long partyId, long userId)
{
/// you always give back null, how was this even working? todo: delete/make this work
UsersAtParty usersAtParty = null;
using (var db = new EntitiesChooseEm())
{
var uap = db.UsersAtParties.Select(t => t.userID == userId && t.partyID == partyId);
}
return(usersAtParty);
}
public bool RemoveSongFromPartyPlaylist(long partyID, string songURL)
{
using (var db = new EntitiesChooseEm())
{
db.SongRatingFromPartyTables.RemoveRange(db.SongRatingFromPartyTables.Where(p => ((p.partyID == partyID) && (p.songURL == songURL))));
db.SongsForPartyTables.RemoveRange(db.SongsForPartyTables.Where(p => ((p.partyID == partyID) && (p.songURL == songURL))));
db.SaveChanges();
}
return(true);
}
public SongRatingFromPartyTable VoteSong(SongRatingFromPartyTable songWithUpdatedRating)
{
using (var db = new EntitiesChooseEm())
{
SongRatingFromPartyTable ratingfromDB = db.SongRatingFromPartyTables.FirstOrDefault(r => r.partyID == songWithUpdatedRating.partyID && r.userID == songWithUpdatedRating.userID && r.songURL == songWithUpdatedRating.songURL);
ratingfromDB.voteType = songWithUpdatedRating.voteType;
songWithUpdatedRating = ratingfromDB;
db.SaveChanges();
}
return(songWithUpdatedRating);
}
/// <summary>
/// Rollback method
/// </summary>
/// <param name="userId"></param>
/// <param name="partyId"></param>
/// <returns></returns>
public bool RollBackUserAtParty(long userId, long partyId)
{
using (var context = new EntitiesChooseEm())
{
context.UsersAtParties.Remove(context.UsersAtParties.FirstOrDefault
(u => u.userID == userId && u.partyID == partyId));
context.SaveChanges();
}
return(true);
}
public bool RemoveUser(long ID)
{
UserTable user = null;
using (var db = new EntitiesChooseEm())
{
user = db.UserTables.FirstOrDefault(p => p.ID == ID);
db.UserTables.Remove(user);
db.SaveChanges();
}
return(true);
}
public static long AddLoginAccount(UserLoginTable userLogin)
{
var hash = SecurePasswordHasher.Hash(userLogin.password);
userLogin.password = hash;
System.Diagnostics.Debug.WriteLine(" addloginaccount: " + hash + " - " + userLogin.password);
using (var db = new EntitiesChooseEm())
{
db.UserLoginTables.Add(userLogin);
db.SaveChanges();
}
return(userLogin.userID);
}
public List <PartyTable> GetAllJoinedParties(long userId)
{
var parties = new List <PartyTable>();
using (var db = new EntitiesChooseEm())
{
var uap = db.UsersAtParties.Where(i => i.userID == userId).ToList();
foreach (var foundParties in uap)
{
parties.Add(GetSelectedJoined(foundParties.partyID));
}
}
return(parties);
}
public UserTable UpdateUser(UserTable updatedUser)
{
using (var context = new EntitiesChooseEm())
{
UserTable user = context.UserTables.First(u => u.ID == updatedUser.ID);
user.firstName = updatedUser.firstName;
user.lastName = updatedUser.lastName;
user.accountType = updatedUser.accountType;
user.zip = updatedUser.zip;
user.currentPartyID = updatedUser.currentPartyID;
context.SaveChanges();
}
return(updatedUser);
}
public int CalculateTotalSongRating(long partyID, string songURL)
{
int aux = 0;
using (var db = new EntitiesChooseEm())
{
var rating = db.SongRatingFromPartyTables.Where(r => r.partyID == partyID && r.songURL == songURL);
foreach (var item in rating)
{
aux += item.voteType;
}
}
return(aux);
}
public bool RemoveUserAtParty(long userId, long partyId)
{
using (var context = new EntitiesChooseEm())
{ // check for user being null?
UsersAtParty user = context.UsersAtParties.FirstOrDefault(u => u.userID == userId && u.partyID == partyId);
context.UsersAtParties.Remove(user);
//change back the number of available spaces
var aux = context.PartyTables.First(p => p.ID == partyId);
aux.AvailablePlaces += 1;
context.SaveChanges();
}
return(true);
}
public static long CheckPassword(UserLoginTable userLogin)
{
using (var db = new EntitiesChooseEm())
{
//var hash = SecurePasswordHasher.Hash(userLogin.password);
//userLogin.password = hash;
//System.Diagnostics.Debug.WriteLine(" Checkpassword: "******" - " + userLogin.password);
UserLoginTable aux = db.UserLoginTables.First(o => o.email == userLogin.email);
if (SecurePasswordHasher.Verify(userLogin.password, aux.password))
{
return(aux.userID);
}
return(-1);
}
}
