public bool ConfirmFriendRequest(FriendRequestModel friendRequestModel)
{
UserProfile requester = db.UserProfiles.Where(up => up.UserProfileId == friendRequestModel.AdderUserProfileId).FirstOrDefault();
UserProfile accepter = db.UserProfiles.Where(up => up.UserProfileId == friendRequestModel.AddedUserProfileId).FirstOrDefault();
if ((requester != null && accepter != null) && (requester != accepter))
{
if (!Utilities.AreFriends(requester, accepter))
{
Friendship friendship = new Friendship();
friendship.AddingParty = requester;
friendship.AddedParty = accepter;
db.AddToFriendships(friendship);
FriendRequest friendRequest = db.FriendRequests.Where(x => x.AdderId == friendRequestModel.AdderUserProfileId && x.AddedId == friendRequestModel.AddedUserProfileId).FirstOrDefault();
db.DeleteObject(friendRequest);
db.SaveChanges();
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
public override bool Execute()
{
int totalUsers = accountServices.GetAllUserProfiles().Count();
UserProfileModel accepter = accountServices.GetUserProfileByUserProfileId(random.Next(1, totalUsers));
GetFriendRequestsModel gfrm = new GetFriendRequestsModel();
gfrm.UserProfileId = accepter.UserProfileId;
IQueryable<UserProfileModel> friendRequests = accountServices.GetFriendRequests(gfrm);
UserProfileModel requester = friendRequests.FirstOrDefault();
if (requester != null)
{
FriendRequestModel m = new FriendRequestModel();
m.AddedUserProfileId = accepter.UserProfileId;
m.AdderUserProfileId = requester.UserProfileId;
Console.WriteLine("Making users " + m.AdderUserProfileId + " and " + m.AddedUserProfileId + " friends.");
return accountServices.ConfirmFriendRequest(m);
}
else
{
return false;
}
}
public async Task <IHttpActionResult> CancelFriendRequest(FriendRequestModel FriendRequest)
{
FriendRequest.UserID = CurrentUser.UserID;
FriendRequest.CreatedOn = DateTime.Now;
ModelState.Remove("FriendRequest.PageID");
ModelState.Remove("FriendRequest.CreatedOn");
FriendRequest.PostedByName = CurrentUser.FullName;
FriendRequest.PostedByAvatar = CurrentUser.ProfilePicture;
FriendRequest.PageRelationStatus = Enums.FriendshipStatus.FS;
if (ModelState.IsValid)
{
try
{
BroadcastFriendRequest model = _page.RejectUserFriendRequest(FriendRequest);
await _broadcaster.CancelFriendRequest(model, FriendRequest.broadCastType);
return(Ok(model.FriendRequest));
}
catch (Exception ex)
{
ExceptionService.LogError("Error cancel friend request to page", ex);
return(BadRequest(ex.Message));
}
}
else
{
return(BadRequest(ModelState.JsonValidation()));
}
}
/// <summary>
///
/// </summary>
/// <param name="FriendRequest"></param>
/// <returns></returns>
public async Task <IHttpActionResult> AddFriendRequest(FriendRequestModel FriendRequest)
{
FriendRequest.UserID = CurrentUser.UserID;
FriendRequest.CreatedOn = DateTime.Now;
ModelState.Remove("FriendRequest.UserID");
ModelState.Remove("FriendRequest.CreatedOn");
FriendRequest.PostedByName = CurrentUser.FullName;
FriendRequest.PostedByAvatar = CurrentUser.ProfilePicture;
FriendRequest.UserInfo = CurrentUser.Gender;
FriendRequest.PageRelationStatus = Enums.FriendshipStatus.FS;
if (ModelState.IsValid)
{
try
{
BroadcastFriendRequest model = _page.AddFriendRequest(FriendRequest);
await _broadcaster.AddFriendRequest(model, FriendRequest.broadCastType);
return(Ok((byte)model.FriendRequest.PageRelationStatus));
}
catch (Exception ex)
{
Logs.Error("Error adding friend request for page", ex);
return(BadRequest(ex.Message));
}
}
else
{
return(BadRequest(ModelState.JsonValidation()));
}
}
public async Task <bool> SendFriendRequest(FriendRequestModel model)
{
var toaster = new ToasterSettings("Friend request sending");
var settings = new HttpSettings($"{this._url}/request", null, null, toaster);
var body = new HttpBody <FriendRequestModel>(model);
return(await this._httpService.Create <FriendRequestModel>(settings, body));
}
public BroadcastFriendRequest RejectUserFriendRequest(FriendRequestModel FriendRequest)
{
switch (FriendRequest.PageType)
{
case Enums.PageType.Profile:
return(_dr.RejectUserFriendRequest(FriendRequest));
default:
return(null);
}
}
public async Task <object> Unfriend([FromBody] FriendRequestModel request)
{
var currUser = await GetLoginUserAsync();
if (currUser.Email != request.UserId && currUser.Email != request.FriendId)
{
return(Forbid());
}
await repository.UnfriendAsync(request.UserId, request.FriendId);
return(Ok());
}
public async Task <IActionResult> Add([FromBody] FriendRequestModel friendRequestModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var friendRequestDto = _mapper.Map <FriendRequestDto>(friendRequestModel);
var statuscode = await _friendRequestService.Create(friendRequestDto);
return(_friendRequestResponseCreator.ResponseForCreate(statuscode));
}
public ActionResult FriendRequest()
{
var model = new FriendRequestModel();
var userRep = new UserRepository();
using (var friendReqRepository = new FriendReqRepository())
{
model.FriendReqs =
friendReqRepository.returnAllPendingRequestsByUser(userRep.GetUserByUserName(User.Identity.Name));
}
return(View(model));
}
/// <summary>
/// Send friend request
/// Add notification rows
/// </summary>
/// <param name="model">Model of the request</param>
public void SendFriendRequest(FriendRequestModel model)
{
var user = this._utilsService.GetCurrentUser();
if (user.UserName == model.DestinationUserName)
{
throw this._loggerService.LogInvalidThings(user, nameof(FriendService), UserNameThing,
ThisNameIsYoursMessage);
}
var destination = this._context.AppUsers.FirstOrDefault(x => x.UserName == model.DestinationUserName);
if (destination == null)
{
throw this._loggerService.LogInvalidThings(user, nameof(FriendService), UserNameThing,
ThisUserDoesNotExistMessage);
}
if (this.HasFriendAlready(user, destination.Id))
{
throw this._loggerService.LogInvalidThings(user, nameof(FriendService), UserNameThing,
ThisUserIsYourFriendAlready);
}
if (this.HasOpenFriendRequestAlready(user, destination.Id))
{
throw this._loggerService.LogInvalidThings(user, nameof(FriendService), UserNameThing,
YouHasOpenFriendRequestWithThisUserMessage);
}
var request = new FriendRequest
{
Message = model.Message,
SenderId = user.Id,
DestinationId = destination.Id
};
this._context.FriendRequests.Add(request);
this._context.SaveChanges();
this._loggerService.LogInformation(user, nameof(FriendService), SendFriendRequestAction, request.Id);
this._notificationService.AddSystemNotificationByType(SystemNotificationType.FriendRequestSent, user,
destination.UserName);
this._notificationService.AddSystemNotificationByType(SystemNotificationType.FriendRequestReceived, destination,
user.UserName);
}
public HttpResponseMessage PostFriendRequest([FromBody] FriendRequestModel model)
{
try
{
LogRequest(model);
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (model.UId == model.FriendUId)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "UId and FriendUId cannot be same."));
}
FriendRequest request = NearByMeManager.GetInstance().IsFriendRequestExist(model.UId, model.FriendUId);
if (request != null && request.SenderId == model.UId)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
if (request != null && request.RecipientId == model.UId && request.Status != FriendRequestStatus.Pending)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "A request is already exist with " + request.Status.ToString() + "."));
}
var friendRequest = new FriendRequest()
{
SenderId = model.UId, RecipientId = model.FriendUId, Status = FriendRequestStatus.Pending
};
bool operationCompleted = NearByMeManager.GetInstance().UpsertFriendRequest(friendRequest);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (ApplicationException applicationException)
{
return(Request.CreateErrorResponse((HttpStatusCode)Convert.ToInt16(applicationException.Message), NeeoDictionaries.HttpStatusCodeDescriptionMapper[Convert.ToInt16(applicationException.Message)]));
}
catch (Exception exception)
{
Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().GetType(), exception.Message, exception);
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public async Task <FriendRequestModel> SendFriendRequest(string SourceId, string TargetId)
{
FriendRequestModel result = null;
if (!await AreUsersFriends(SourceId, TargetId) &&
!await _blockService.IsUserBlocked(SourceId, TargetId) &&
!await _friendRepository.HasPendingRequest(SourceId, TargetId))
{
result = await _friendRepository.SendFriendRequest(SourceId, TargetId);
}
else if (await _friendRepository.HasPendingRequest(TargetId, SourceId))
{
var request = await _friendRepository.FindRequest(TargetId, SourceId);
await AnswerFriendRequest(request.Id, true);
result = await _friendRepository.GetRequest(request.Id);
}
return(result);
}
//Accept Friend Request
public ActionResult Accept(int id)
{
FriendRequestModel request = db.FriendRequests.Find(id);
Profile requester = db.Profile.Find(request.Requester.ProfileId);
Profile requestee = db.Profile.Find(request.Requestee.ProfileId);
if (requester != null && requestee != null)
{
if (TryUpdateModel(requester) && TryUpdateModel(requestee))
{
requester.FriendRequests.Remove(request);
requester.Friends.Add(requestee);
requestee.FriendRequests.Remove(request);
requestee.Friends.Add(requester);
db.SaveChanges();
}
}
return(this.Delete(request));
}
//Create Friend Request
public ActionResult Create(int id)
{
var MyId = User.Identity.GetUserId();
var query = from pf in db.Profile
where pf.UserId == MyId
select pf;
Profile profile = query.FirstOrDefault <Profile>();
Profile friendProfile = db.Profile.Find(id);
var query1 = from fr in db.FriendRequests
where fr.Requester.ProfileId.Equals(profile.ProfileId) &&
fr.Requestee.ProfileId.Equals(friendProfile.ProfileId)
select fr;
FriendRequestModel friendRequest = query1.FirstOrDefault <FriendRequestModel>();
if (friendRequest == null || friendRequest.Equals(default(Profile)))
{
var NewFR = new FriendRequestModel();
NewFR.Requester = profile;
NewFR.Requestee = friendProfile;
NewFR.Accepted = false;
db.FriendRequests.Add(NewFR);
db.SaveChanges();
if (TryUpdateModel(profile))
{
profile.FriendRequests.Insert(0, NewFR);
db.SaveChanges();
}
if (TryUpdateModel(friendProfile))
{
friendProfile.FriendRequests.Insert(0, NewFR);
db.SaveChanges();
}
db.SaveChanges();
}
return(RedirectToAction("Show", "Profile", id));
}
public bool DenyFriendRequest(FriendRequestModel friendRequestModel)
{
FriendRequest friendRequest = db.FriendRequests.Where(x => x.AdderId == friendRequestModel.AdderUserProfileId && x.AddedId == friendRequestModel.AddedUserProfileId).FirstOrDefault();
if (friendRequest != null)
{
db.DeleteObject(friendRequest);
db.SaveChanges();
return true;
}
else
{
return false;
}
}
public async Task <FriendRequestModel> UpdateFriendRequest(FriendRequestModel friendRequest)
{
FriendRequest dbFriendRequest = Mapper.Map <FriendRequestModel, FriendRequest>(friendRequest);
return(Mapper.Map <FriendRequest, FriendRequestModel>(await _friendRequestsRepository.UpdateItemAsync(dbFriendRequest)));
}
public IActionResult SendFriendRequest(FriendRequestModel model)
{
this._friendService.SendFriendRequest(model);
return(this.Ok());
}
//Delete Friend Request
public ActionResult Delete(FriendRequestModel fr)
{
db.FriendRequests.Remove(fr);
db.SaveChanges();
return(RedirectToAction("Index", "FriendRequest"));
}
