public async Task<JsonResult> GetTweetsForDashboard(string userId)
{
var result = new JsonServiceResult<List<TweetVM>>();
try
{
var tweets = new List<TweetVM>();
var user = await GetCurrentUserAsync();
var userObjectId = user.Id.ToObjectId();
var allUserIds = new List<ObjectId>() { userObjectId };
var followingUserIds = await _userRelationshipManager.GetFollowingUsers(userObjectId);
if (followingUserIds.Count > 0)
allUserIds.AddRange(followingUserIds);
var allTweets = await _tweetManager.GetTweetsByUserIds(allUserIds);
if (allTweets.Count() > 0)
{
foreach (var t in allTweets)
{
var tweetUser = await _userManager.FindByIdAsync(t.UserId.ToString());
tweets.Add(TweetMapper.MapTweetToViewModel(t, tweetUser));
}
var currentUserLikedTweets = await _tweetManager.GetUserLikedTweets(userObjectId);
foreach (var tweet in tweets)
{
tweet.CanRetweet = tweet.TweetedByUserId != user.Id;
tweet.CurrentUserAlreadyLiked = currentUserLikedTweets.Any(t => t.Id == tweet.TweetId.ToObjectId());
}
}
result.Value = tweets;
result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> StartNewConversation(string username, string message)
{
var result = new JsonServiceResult<ConversationVM>();
try
{
var user = await _userManager.FindByIdAsync(User.GetUserId());
var recipientUser = await _userManager.FindByNameAsync(username.ToUpper());
if (recipientUser == null)
{
result.Message = "User with the specified username was not found!";
return Json(result);
}
List<Tuple<ObjectId, string>> participants = new List<Tuple<ObjectId, string>>();
participants.Add(new Tuple<ObjectId, string>(user.Id.ToObjectId(), user.UserName));
participants.Add(new Tuple<ObjectId, string>(recipientUser.Id.ToObjectId(), recipientUser.UserName));
var conversation = await _conversationManager.StartNewConversation(user.Id.ToObjectId(), participants, message);
result.Value = new ConversationVM()
{
ConversationId = conversation.Id.ToString(),
Name = conversation.Name,
Messages = new List<MessageVM>() { MessageMapper.MapMessageToViewModel(conversation.Messages[0], User.GetUserName()) }
};
result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> FollowUser(string userId)
{
var result = new JsonServiceResult<bool>();
try
{
var currentUserId = User.GetUserId();
await _userRelationshipManager.AddFollowingUser(currentUserId.ToObjectId(), userId.ToObjectId());
await _notificationManager.CreateNewNotification(userId.ToObjectId(), NotificationType.Follow, currentUserId.ToObjectId(), null);
result.IsValid = true;
result.Value = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> SearchUsers(string searchParam)
{
var result = new JsonServiceResult<List<UserVM>>();
if (string.IsNullOrEmpty(searchParam))
return Json(result);
try
{
var user = await _userManager.FindByNameAsync(searchParam.ToUpper());
if (user != null)
{
var vm = UserMapper.MapUserToViewModel(user);
result.Value = new List<UserVM>() { vm };
result.IsValid = true;
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> PostTweet(PostTweetVM tweet)
{
var result = new JsonServiceResult<TweetVM>();
try
{
var user = await GetCurrentUserAsync();
var now = DateTime.Now;
var file = tweet.File;
var newTweet = new Tweet()
{
Content = tweet.Content,
UserId = user.Id.ToObjectId(),
CreatedOn = now
};
if (tweet.LocationEnabled)
{
double latitude;
double longitude;
if (Double.TryParse(tweet.Latitude, NumberStyles.AllowDecimalPoint, NumberFormatInfo.InvariantInfo, out latitude)
&& Double.TryParse(tweet.Longitude, NumberStyles.AllowDecimalPoint, NumberFormatInfo.InvariantInfo, out longitude))
{
newTweet.Latitude = latitude;
newTweet.Longitude = longitude;
}
}
if (file != null)
{
var allowedExtensions = new string[] { ".jpg", ".png", ".gif" };
if (file.Length > 0)
{
var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
var fileName = parsedContentDisposition.FileName.Trim('"');
string ext = Path.GetExtension(fileName).ToLower();
if (allowedExtensions.Contains(ext))
{
var userAsciiName = user.NormalizedUserName.ToAsciiString();
var fileNameHash = fileName.GetHashCode();
if (fileNameHash < 0)
fileNameHash = fileNameHash * -1;
var mediaDir = Path.Combine(_environment.WebRootPath, "media");
var userDir = Path.Combine(mediaDir, userAsciiName);
Directory.CreateDirectory(userDir);
var filePath = Path.Combine(userDir, fileNameHash.ToString());
await file.SaveAsAsync(string.Format("{0}{1}", filePath, ext));
newTweet.FileMimeType = file.ContentType;
newTweet.FilePath = string.Format("/media/{0}/{1}{2}", userAsciiName, fileNameHash, ext);
}
}
}
await _tweetManager.CreateTweet(newTweet);
var mentionedUserNames = TweetUtils.ExtractUserMentions(tweet.Content);
foreach (var mentionedUserName in mentionedUserNames)
{
var mentionedUser = await _userManager.FindByNameAsync(mentionedUserName.ToUpper());
if (mentionedUser != null)
{
await _notificationManager.CreateNewNotification(mentionedUser.Id.ToObjectId(), NotificationType.Mention, user.Id.ToObjectId(), newTweet.Id);
}
}
var viewModel = new TweetVM();
viewModel.Content = tweet.Content;
viewModel.TweetedByFullName = user.FullName;
viewModel.TweetedByUserName = user.UserName;
viewModel.TweetedOn = now;
result.Value = viewModel;
result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> Retweet(string tweetId)
{
var result = new JsonServiceResult<bool>();
try
{
var currentUserObjectId = User.GetUserId().ToObjectId();
var tweetObjectId = tweetId.ToObjectId();
var originalTweet = await _tweetManager.GetTweetById(tweetObjectId);
var originalTweetUser = await _userManager.FindByIdAsync(originalTweet.UserId.ToString());
await _tweetManager.CreateTweet(new Tweet() {
Content = originalTweet.Content,
UserId = currentUserObjectId,
FileMimeType = originalTweet.FileMimeType,
FilePath = originalTweet.FilePath,
CreatedOn = DateTime.Now,
RetweetedFromId = originalTweet.Id,
RetweetedFromUserName = originalTweetUser.UserName
});
await _notificationManager.CreateNewNotification(originalTweet.UserId, NotificationType.Retweet, currentUserObjectId, tweetObjectId);
result.Value = result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> LikeTweet(string tweetId)
{
var result = new JsonServiceResult<bool>();
try
{
var currentUserObjectId = User.GetUserId().ToObjectId();
var tweetObjectId = tweetId.ToObjectId();
var tweet = await _tweetManager.GetTweetById(tweetObjectId);
await _tweetManager.LikeTweet(currentUserObjectId, tweetObjectId);
await _notificationManager.CreateNewNotification(tweet.UserId, NotificationType.Like, currentUserObjectId, tweetObjectId);
result.Value = result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> OpenConversation(string conversationId)
{
var result = new JsonServiceResult<ConversationVM>();
try
{
var conversation = await _conversationManager.GetConversationById(conversationId);
var conversationVM = new ConversationVM();
conversationVM.ConversationId = conversation.Id.ToString();
conversationVM.Name = conversation.Name;
foreach (var message in conversation.Messages)
{
var messageUser = await _userManager.FindByIdAsync(message.UserIdFrom.ToString());
conversationVM.Messages.Add(MessageMapper.MapMessageToViewModel(message, messageUser.UserName));
}
result.Value = conversationVM;
result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
public async Task<JsonResult> SendNewMessage(string conversationId, string message)
{
var result = new JsonServiceResult<MessageVM>();
try
{
var newMessage = await _conversationManager.SendNewMessage(conversationId, User.GetUserId(), message);
result.Value = MessageMapper.MapMessageToViewModel(newMessage, User.GetUserName());
result.IsValid = true;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return Json(result);
}
