// GET: api/Login
public IHttpActionResult Get()
{
var headers = Request.Headers;
if (headers.Contains("token-jwt"))
{
string token = headers.GetValues("token-jwt").First();
TokenValidation validation = new TokenValidation();
string userValidated = validation.ValidateToken(token);
if (userValidated != null)
{
TokenData data = JsonConvert.DeserializeObject <TokenData>(userValidated);
Player g2 = null;
try
{
g2 = db.Gamers.FirstOrDefault(g => g.ID == data.ID);
}
catch
{
}
return(Ok(g2));
}
else
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
public IActionResult SaveNotificationSettings(TokenDto tokenDto)
{
var token = tokenDto.Token;
Dictionary <string, string> validatedTokenClaims;
try
{
validatedTokenClaims = TokenValidation.ValidateToken(token);
}
catch (ArgumentException)
{
return(BadRequest(new { text = "Validation failed" }));
}
var userId = int.Parse(validatedTokenClaims["userId"]);
var sound = bool.Parse(validatedTokenClaims["sound"]);
var connection = bool.Parse(validatedTokenClaims["connection"]);
var newChat = bool.Parse(validatedTokenClaims["newchat"]);
var newMessage = bool.Parse(validatedTokenClaims["newmessage"]);
var notificationId = _context.Users.Single(user => user.UserId == userId).NotificationSettingsId;
var notificationEntity = _context.NotificationSettings.SingleOrDefault(settings => settings.NotificationSettingsId == notificationId);
if (notificationEntity != null)
{
notificationEntity.Sound = sound;
notificationEntity.ConnectionChanged = connection;
notificationEntity.NewChatReceived = newChat;
notificationEntity.NewMessageReceived = newMessage;
_context.NotificationSettings.Update(notificationEntity);
_context.SaveChanges();
}
return(Ok("success"));
}
public async Task <ResultWrapper <InviteOutDto> > CreateInvite(InviteDto newInvite, TokenDto token)
{
if (!TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> errors = new List <ErrorResult>();
errors.Add(new ErrorResult(401, "Invalid token."));
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(tk => tk.token.Equals(token.AccessToken)).FirstOrDefault());
return(new ResultWrapper <InviteOutDto>(null, errors));
}
var invite = GetInvite(newInvite);
if (invite != null)
{
invite.State = newInvite.State;
}
else
{
invite = Mapper.Map <Invite>(newInvite);
_unitOfWork.InviteRepo.AddAsync(invite);
}
await _unitOfWork.InviteRepo.SaveAsync();
var eventI = await _unitOfWork.EventRepo.GetAsync(invite.EventId);
var user = await _unitOfWork.UserRepo.GetAsync(invite.UserId);
return(new ResultWrapper <InviteOutDto>(ConvertInviteToOutInvite(user, eventI, invite.State), null));
}
public IActionResult AddChat(TokenDto tokenDto)
{
var token = tokenDto.Token;
Dictionary <string, string> validatedTokenClaims;
try
{
validatedTokenClaims = TokenValidation.ValidateToken(token);
}
catch (ArgumentException)
{
return(BadRequest(new { text = "Validation failed" }));
}
var curUserId = int.Parse(validatedTokenClaims["userId"]);
var emailToAdd = validatedTokenClaims["emailToAdd"];
var match = _context.Users.SingleOrDefault(u => u.Login.Email.Equals(emailToAdd));
if (match == null)
{
return(BadRequest(new { text = "No one with such email exists bro..." }));
}
//Checking if user is not adding himself
if (match.UserId == curUserId)
{
return(BadRequest(new { text = "You cannot add yourself,pls.." }));
}
var curUser = _context.Users.Find(curUserId);
var chatsCurrentUserHas = _context.ChatUsers.Where(user => user.UserId == curUserId).ToList();
// Loop looking for occurrences, when we already have a same chat ID with the user that we are about to add
foreach (var t in chatsCurrentUserHas)
{
var userListPerChat = ChatUserForASpecificChatFinder(t.ChatId);
if (userListPerChat.Any(user => user.UserId == match.UserId))
{
return(BadRequest(new { text = "You already have this guy..." }));
}
}
if (curUser != null)
{
var chatUser = _chatWorker.AddChat(new List <User>()
{
curUser, match
});
var newChatDto = new AddChatDto
{
ChatId = chatUser.ChatId, UserName = chatUser.User.UserName, FriendImageUrl = chatUser.User.ImageUrl
};
return(Ok(newChatDto));
}
return(BadRequest(new{ text = "Email not found" }));
}
public async Task <IActionResult> GetAllChatsWithLastMessage(TokenDto tokenDto)
{
var token = tokenDto.Token;
Dictionary <string, string> validatedTokenClaims;
try
{
validatedTokenClaims = TokenValidation.ValidateToken(token);
}
catch (ArgumentException)
{
return(BadRequest(new { text = "Validation failed" }));
}
var userId = int.Parse(validatedTokenClaims["userId"]);
var chatsOfUser = _context.ChatUsers.Where(user => user.UserId == userId).ToList();
var userChatsToReturn = new List <UserChatDTO>();
for (var i = 0; i < chatsOfUser.Count; i++)
{
var friendId = _context.ChatUsers
.Single(user => user.ChatId == chatsOfUser[i].ChatId && user.UserId != userId).UserId;
var friend = _context.Users.Find(friendId);
//Trying to use LastOrDefault resulted in a crash, using this workaround for now
var msgList = await _context.Messages.Where(message => message.ChatId == chatsOfUser[i].ChatId).ToListAsync();
Message?lastMsg = msgList.Count > 0 ? msgList[^ 1] : null;
public async Task <ResultWrapper <CompletedEvent> > CreateEvent(CompletedEvent newEvent, TokenDto token)
{
if (!TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> error = new List <ErrorResult>();
error.Add(new ErrorResult(401, "Invalid token."));
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(tk => tk.token.Equals(token.AccessToken)).FirstOrDefault());
return(new ResultWrapper <CompletedEvent>(null, error));
}
var errors = eventValid.ValidateEventCreation(newEvent);
if (errors.Count() > 0)
{
return(new ResultWrapper <CompletedEvent>(null, errors));
}
CompletedEvent existEvent = null;
if (newEvent.EventId.HasValue)
{
existEvent = await GetEvent(newEvent.EventId.Value);
}
if (existEvent != null)
{
return(await UpdateEvent(existEvent, newEvent, token));
}
Event ev = Mapper.Map <Event>(newEvent);
Location location = Mapper.Map <Location>(newEvent.Location);
// Insert a new location in DB
_unitOfWork.LocationRepo.AddAsync(location);
await _unitOfWork.LocationRepo.SaveAsync();
// Get user from token
var userId = TokenValidation.GetUserIdFromToken(token, _unitOfWork);
ev.Author = userId;
ev.Location = location.LocationId;
_unitOfWork.EventRepo.AddAsync(ev);
await _unitOfWork.EventRepo.SaveAsync();
Category c = _unitOfWork.categoriesRepo.Find(e => e.Category1.Equals(newEvent.Category)).FirstOrDefault();
EventHasCategories ehc = new EventHasCategories();
ehc.EventId = ev.EventId;
ehc.CategoryId = c.CategoryId;
_unitOfWork.eventHasCategories.Add(ehc);
await _unitOfWork.eventHasCategories.SaveAsync();
return(new ResultWrapper <CompletedEvent>(newEvent, null));
}
public IHttpActionResult GetRequestedMatchForLogg()
{
Player gamerlogado = null;
var headers = Request.Headers;
if (headers.Contains("token-jwt"))
{
string token = headers.GetValues("token-jwt").First();
TokenValidation validation = new TokenValidation();
string userValidated = validation.ValidateToken(token);
if (userValidated != null)
{
TokenData data = JsonConvert.DeserializeObject <TokenData>(userValidated);
gamerlogado = db.Gamers.FirstOrDefault(g => g.ID == data.ID);
}
}
if (gamerlogado == null)
{
return(BadRequest());
}
List <RequestedMatch> reqMatches = db.RequestedMatchs
.Where(x => x.IdPlayer2 == gamerlogado.ID)
.AsEnumerable().ToList();
List <Player> gamersReq = new List <Player>();
foreach (RequestedMatch reqMatch in reqMatches)
{
if (reqMatch.Status != "A")
{
continue;
}
Player findMe = db.Gamers.Find(reqMatch.IdPlayer1);
if (findMe != null)
{
gamersReq.Add(new Player()
{
ID = findMe.ID,
Nickname = findMe.Nickname,
Bio = findMe.Bio,
LastName = findMe.LastName,
Name = findMe.Name,
Sex = findMe.Sex,
ImagePath = findMe.ImagePath
});
}
}
return(Ok(gamersReq));
}
public IHttpActionResult ValidateToken()
{
var headers = Request.Headers;
if (headers.Contains("token-jwt"))
{
string token = headers.GetValues("token-jwt").First();
TokenValidation validation = new TokenValidation();
string userValidated = validation.ValidateToken(token);
if (userValidated != null)
{
return(Ok());
}
}
return(BadRequest());
}
public async Task <bool> DeleteInvite(InviteDto inviteToDelete, TokenDto token)
{
if (!TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> error = new List <ErrorResult>();
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(tk => tk.token.Equals(token.AccessToken)).FirstOrDefault());
error.Add(new ErrorResult(401, "Invalid token."));
return(false);
}
Invite deleteInvite = _unitOfWork.InviteRepo.Find(i => i.UserId == inviteToDelete.UserId && i.EventId == inviteToDelete.EventId).FirstOrDefault();
_unitOfWork.InviteRepo.Remove(deleteInvite);
return(await _unitOfWork.InviteRepo.SaveAsync() > 0);
}
public async Task <ResultWrapper <PagedResult <CompletedEvent> > > GetUserEvents(TokenDto token, int?currentPage)
{
int currIndexPage = currentPage == null ? 0 : currentPage.Value;
if (token == null || !TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> errors = new List <ErrorResult>();
errors.Add(new ErrorResult(401, "Invalid token."));
return(new ResultWrapper <PagedResult <CompletedEvent> >(null, errors));
}
int userId = TokenValidation.GetUserIdFromToken(token, _unitOfWork);
var events = await _unitOfWork.EventRepo.GetEventsByUserAsync(userId);
PagedResult <CompletedEvent> pg = new PagedResult <CompletedEvent>(currIndexPage, events.Count(), 25, Mapper.Map <IEnumerable <CompletedEvent> >(events));
return(new ResultWrapper <PagedResult <CompletedEvent> >(pg, null));
}
private Player GetPlayerFromToken(string token)
{
Player gamerL = null;
TokenValidation validation = new TokenValidation();
string userValidated = validation.ValidateToken(token);
if (userValidated != null)
{
TokenData data = JsonConvert.DeserializeObject <TokenData>(userValidated);
try
{
gamerL = db.Gamers.FirstOrDefault(g => g.ID == data.ID);
}
catch (Exception e)
{
}
}
return(gamerL);
}
public async Task <ResultWrapper <IEnumerable <InviteOutDto> > > GetInvites(TokenDto token, int?eventId, int?state)
{
if (token == null || !TokenValidation.ValidateToken(token, _unitOfWork))
{
List <ErrorResult> errors = new List <ErrorResult>();
errors.Add(new ErrorResult(401, "Invalid token."));
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(tk => tk.token.Equals(token.AccessToken)).FirstOrDefault());
return(new ResultWrapper <IEnumerable <InviteOutDto> >(null, errors));
}
int?userId = null;
if (eventId == null)
{
userId = TokenValidation.GetUserIdFromToken(token, _unitOfWork);
}
var invites = _unitOfWork.InviteRepo.GetInvites(userId, eventId, state);
return(new ResultWrapper <IEnumerable <InviteOutDto> >(Mapper.Map <IEnumerable <InviteOutDto> >(invites), null));
}
public async Task <bool> DeleteEvent(int eventId, TokenDto tk)
{
if (!TokenValidation.ValidateToken(tk, _unitOfWork))
{
List <ErrorResult> error = new List <ErrorResult>();
error.Add(new ErrorResult(401, "Invalid token."));
_unitOfWork.tokenRepo.Remove(_unitOfWork.tokenRepo.Find(token => token.token.Equals(tk.AccessToken)).FirstOrDefault());
return(false);
}
Event deleteEvent = await _unitOfWork.EventRepo.GetAsync(eventId);
var tokenAuthor = TokenValidation.GetUserIdFromToken(tk, _unitOfWork);
if (deleteEvent.Author != tokenAuthor)
{
List <ErrorResult> error = new List <ErrorResult>();
return(false);
}
// Remove
EventHasCategories evCategories = _unitOfWork.eventHasCategories.Find(evt => evt.EventId == deleteEvent.EventId).FirstOrDefault();
_unitOfWork.eventHasCategories.Remove(evCategories);
await _unitOfWork.eventHasCategories.SaveAsync();
_unitOfWork.InviteRepo.RemoveRange(_unitOfWork.InviteRepo.Find((iv) => iv.EventId == deleteEvent.EventId));
await _unitOfWork.InviteRepo.SaveAsync();
_unitOfWork.LocationRepo.Remove(_unitOfWork.LocationRepo.Get(deleteEvent.Location.Value));
await _unitOfWork.LocationRepo.SaveAsync();
_unitOfWork.EventRepo.Remove(deleteEvent);
await _unitOfWork.EventRepo.SaveAsync();
return(true);
}
public async Task <IActionResult> HandleGoogleLogin(TokenDto tokenDto)
{
if (!ModelState.IsValid || string.IsNullOrEmpty(tokenDto.Token))
{
return(BadRequest(new { text = "Invalid data." }));
}
var token = tokenDto.Token;
Dictionary <string, string> validatedTokenClaims;
try
{
validatedTokenClaims = TokenValidation.ValidateToken(token);
}
catch (ArgumentException)
{
return(BadRequest(new { text = "Validation failed" }));
}
var email = validatedTokenClaims["http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress"];
var name = validatedTokenClaims["name"];
var picture = validatedTokenClaims["imageUrl"];
//user exists -> login
if (_context.Users.Any(u => u.Login.Email.Equals(email)))
{
var user = _context.Users.Single(u => u.Login.Email.Equals(email));
//we dont put our users as verified in the DB
//This can still get broken if normal email is registered, but not verified yet
if (user.EmailVerified)
{
return(BadRequest(new { text = "Email already taken." }));
}
var notificationSetting = _context.NotificationSettings.Find(user.NotificationSettingsId);
var userData = new UserDTO
{
UserId = user.UserId,
UserName = user.UserName,
IsOnline = user.IsOnline,
ImageUrl = user.ImageUrl,
NotificationSettings = notificationSetting
};
var userToken = await TokenValidation.CreateJwtAsync(userData);
return(Ok(new { userToken }));
}
else
{
var loginData = new Login()
{
Email = email, Password = "******"
};
var notificationSetting = new NotificationSettings();
_context.NotificationSettings.Add(notificationSetting);
await _context.SaveChangesAsync();
var user = new User()
{
Login = loginData,
UserName = name,
ImageUrl = picture,
NotificationSettingsId = notificationSetting.NotificationSettingsId
};
_context.Users.Add(user);
await _context.SaveChangesAsync();
var userData = new UserDTO
{
UserId = user.UserId,
UserName = user.UserName,
IsOnline = user.IsOnline,
ImageUrl = user.ImageUrl,
NotificationSettings = notificationSetting
};
var userToken = await TokenValidation.CreateJwtAsync(userData);
return(Ok(new { userToken }));
}
}
