public async Task <IActionResult> UploadAvatar(UserAvatarModel model, IFormFile uploadedFile)
{
if (!_workContext.CurrentUser.IsRegistered())
{
return(Challenge());
}
if (!_userSettings.AllowUsersToUploadAvatars)
{
return(RedirectToRoute("UserInfo"));
}
var user = _workContext.CurrentUser;
if (ModelState.IsValid)
{
try
{
var userAvatar = await _pictureService.GetPictureById(await _genericAttributeService.GetAttributeAsync <int>(user,
UserDefaults.AvatarPictureIdAttribute));
if (!string.IsNullOrEmpty(uploadedFile?.FileName))
{
var avatarMaxSize = _userSettings.AvatarMaximumSizeBytes;
if (uploadedFile.Length > avatarMaxSize)
{
throw new DefaultException($"Maximum avatar size is {avatarMaxSize} bytes.");
}
var userPictureBinary = await _pictureService.GetDownloadBits(uploadedFile);
userAvatar = userAvatar != null
? await _pictureService.UpdatePicture(userAvatar.Id, userPictureBinary, uploadedFile.ContentType, null)
: await _pictureService.InsertPicture(userPictureBinary, uploadedFile.ContentType, null);
}
var userAvatarId = 0;
if (userAvatar != null)
{
userAvatarId = userAvatar.Id;
}
await _genericAttributeService.SaveAttributeAsync(user, UserDefaults.AvatarPictureIdAttribute, userAvatarId);
model.AvatarUrl = _pictureService.GetPictureUrl(
await _genericAttributeService.GetAttributeAsync <int>(user,
UserDefaults.AvatarPictureIdAttribute), _mediaSettings.AvatarPictureSize, false);
return(View(model));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
model = await _userAccountModelFactory.PrepareUserAvatarModel(model);
return(View(model));
}
public async Task <IActionResult> RemoveAvatar(UserAvatarModel model)
{
if (!_workContext.CurrentUser.IsRegistered())
{
return(Challenge());
}
if (!_userSettings.AllowUsersToUploadAvatars)
{
return(RedirectToRoute("UserInfo"));
}
var user = _workContext.CurrentUser;
var userAvatar = await _pictureService.GetPictureById(await _genericAttributeService.GetAttributeAsync <int>(user,
UserDefaults.AvatarPictureIdAttribute));
if (userAvatar != null)
{
await _pictureService.DeletePicture(userAvatar);
}
await _genericAttributeService.SaveAttributeAsync(user, UserDefaults.AvatarPictureIdAttribute, 0);
return(RedirectToRoute("UserAvatar"));
}
public PostModel getPostModel(string postId, string loginedUserId)
{
Post post = postDao.getPostById(postId);
User user = userDao.getUserByPostId(post.id);
UserAvatarModel userOfPost = new UserAvatarModel()
{
Id = user.id, Username = user.username, Avatar = user.avatar
};
List <CommentModel> top3CommentModels = commentDao.getAllCommentModelsOfPost(post.id);
int numberOfLikes = favoriteDao.getNumberOfLikesInPost(post.id);
string timeAgo = DateTimeUtils.getTimeAgo(post.time.GetValueOrDefault());
bool isLike = favoriteDao.isLikeByUser(loginedUserId, post.id);
PostModel postModel = new PostModel()
{
UserOfPost = userOfPost,
PostId = post.id,
PostContent = post.content,
PostImage = post.image,
Top3CommentModels = top3CommentModels,
NumberLikes = numberOfLikes,
Time = post.time,
TimeAgo = timeAgo,
IsLikeByLoginedUser = isLike
};
return(postModel);
}
public async Task <UserAvatarModel> PrepareUserAvatarModel(UserAvatarModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model.AvatarUrl = _pictureService.GetPictureUrl(await _genericAttributeService.GetAttributeAsync <int>(_workContext.CurrentUser,
UserDefaults.AvatarPictureIdAttribute), _mediaSettings.AvatarPictureSize, false);
return(model);
}
public async Task <IActionResult> UpdatePersonAvatar([FromForm] UserAvatarModel model)
{
try {
if (ModelState.IsValid)
{
var requestHeaders = HttpContext.Request.Headers;
int userId = 0;
if (requestHeaders.TryGetValue("Authorization", out StringValues token))
{
userId = JwtService.GetUserIdFromToken(JwtService.DecodeToken(token.ToString()));
if (userId < 1)
{
return(Unauthorized());
}
}
else
{
return(Unauthorized());
}
byte[] avatarImage;
using (var memoryStream = new MemoryStream()) {
await model.AvatarImage.CopyToAsync(memoryStream);
avatarImage = memoryStream.ToArray();
}
string guid = Guid.NewGuid().ToString();
string mime = model.AvatarImage.ContentType.Contains("/") ?
model.AvatarImage.ContentType.Split("/")[1] :
model.AvatarImage.ContentType;
string fileName = $"{guid}.{mime}";
string realPath;
try {
realPath = _personLogic.SavePersonsAvatar(fileName, avatarImage, userId);
} catch (Exception e) {
return(StatusCode(500, e));
}
if (string.IsNullOrWhiteSpace(realPath))
{
return(BadRequest());
}
return(Ok(realPath));
}
else
{
return(BadRequest(ModelState));
}
} catch (Exception e) {
return(BadRequest(e));
}
}
private void SetText(UserAvatarModel context, IUserIdentity userIdentity)
{
if (TeamCodingPackage.Current.Settings.UserSettings.UserTabDisplay == UserSettings.UserDisplaySetting.Colour)
{
context.Letter = null;
}
else
{
var firstLetter = (userIdentity.Id)[0];
context.Letter = firstLetter;
context.LetterBrush = VisuallyDistinctColours.GetTextBrushFromBackgroundColour(UserColours.GetUserColour(userIdentity));
}
}
private void SetImageSource(UserAvatarModel context, IUserIdentity userIdentity)
{
if (TeamCodingPackage.Current.Settings.UserSettings.UserTabDisplay == UserSettings.UserDisplaySetting.Avatar)
{
if (userIdentity.ImageBytes != null)
{
using (var MS = new MemoryStream(userIdentity.ImageBytes))
{
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.StreamSource = MS;
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.EndInit();
context.AvatarImageSource = UrlImages[userIdentity.ImageUrl] = bitmap;
}
}
else if (userIdentity.ImageUrl != null)
{
if (UrlImages.ContainsKey(userIdentity.ImageUrl))
{
context.AvatarImageSource = UrlImages[userIdentity.ImageUrl];
}
else
{
ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
try
{
var request = await TeamCodingPackage.Current.HttpClient.GetAsync(userIdentity.ImageUrl);
if (!request.IsSuccessStatusCode)
{
return;
}
var imageStream = await request.Content.ReadAsStreamAsync();
context.AvatarImageSource = UrlImages[userIdentity.ImageUrl] = BitmapFrame.Create(imageStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
catch (Exception ex) when(!System.Diagnostics.Debugger.IsAttached)
{
TeamCodingPackage.Current.Logger.WriteError(ex);
}
});
}
}
}
else
{
context.AvatarImageSource = null;
}
}
public ActionResult Index()
{
LoginedUser loginedUser = getUserInSession();
UserAvatarModel userAvatarModel = new UserAvatarModel()
{
Id = loginedUser.Id, Avatar = loginedUser.Avatar, Username = loginedUser.UserName
};
NewFeedModel model = newFeedService.getNewFeedModel(loginedUser.Id);
model.UserAvatar = userAvatarModel;
return(View(model));
}
public virtual IActionResult Avatar()
{
if (!_workContext.CurrentUser.IsRegistered())
{
return(Challenge());
}
if (!_userSettings.AllowUsersToUploadAvatars)
{
return(RedirectToRoute("UserInfo"));
}
var model = new UserAvatarModel();
model = _userModelFactory.PrepareUserAvatarModel(model);
return(View(model));
}
public List <UserAvatarModel> getAllUnFollowUser(string userId)
{
List <UserAvatarModel> userAvatars = new List <UserAvatarModel>();
List <User> users = userDao.getAllUnFollowUsers(userId);
foreach (User user in users)
{
string relationshipStatus = getRelationship(userId, user.id);
UserAvatarModel userAvatar = new UserAvatarModel()
{
Id = user.id, Avatar = user.avatar,
Username = user.username, RelationshipStatus = relationshipStatus
};
userAvatars.Add(userAvatar);
}
return(userAvatars);
}
public UserAvatarModel CreateUserAvatarModel(IUserIdentity userIdentity)
{
if (UserModels.TryGetValue(userIdentity.Id, out var context))
{
return(context);
}
context = new UserAvatarModel()
{
ToolTip = (userIdentity.DisplayName ?? userIdentity.Id),
Tag = userIdentity.Id
};
context.BorderBrush = context.BackgroundBrush = UserColours.GetUserBrush(userIdentity);
SetContextAccordingToDisplaySettings(context, userIdentity);
UserModels.Add(userIdentity.Id, context);
return(context);
}
private void SetImageSource(UserAvatarModel context, IUserIdentity userIdentity)
{
if (TeamCodingPackage.Current.Settings.UserSettings.UserTabDisplay == UserSettings.UserDisplaySetting.Avatar)
{
if (userIdentity.ImageBytes != null)
{
using (var MS = new MemoryStream(userIdentity.ImageBytes))
{
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.StreamSource = MS;
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.EndInit();
context.AvatarImageSource = UrlImages[userIdentity.ImageUrl] = bitmap;
}
}
else if (userIdentity.ImageUrl != null)
{
if (UrlImages.ContainsKey(userIdentity.ImageUrl))
{
context.AvatarImageSource = UrlImages[userIdentity.ImageUrl];
}
else
{
ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
try
{
context.AvatarImageSource = await GetImageFromUrl(userIdentity.ImageUrl);
}
catch (Exception ex) when(!System.Diagnostics.Debugger.IsAttached)
{
TeamCodingPackage.Current.Logger.WriteError(ex);
}
});
}
}
}
else
{
context.AvatarImageSource = null;
}
}
public List <PostModel> getPostModelsForNewFeed(string id)
{
List <PostModel> postModelList = new List <PostModel>();
List <User> friends = userDao.getAllFriends(id);
//loop each friend to get their posts
foreach (User friend in friends)
{
UserAvatarModel userOfPost = new UserAvatarModel()
{
Id = friend.id, Username = friend.username, Avatar = friend.avatar
};
Post latestPost = postDao.getLatestPostOfUser(friend.id);
if (latestPost != null)
{
List <CommentModel> top3CommentModels = commentDao.getTop3CommentModels(latestPost.id);
int numberOfLikes = favoriteDao.getNumberOfLikesInPost(latestPost.id);
string timeAgo = DateTimeUtils.getTimeAgo(latestPost.time.GetValueOrDefault());
bool isLike = favoriteDao.isLikeByUser(id, latestPost.id);
PostModel postModel = new PostModel()
{
UserOfPost = userOfPost,
PostId = latestPost.id,
PostContent = latestPost.content,
PostImage = latestPost.image,
Top3CommentModels = top3CommentModels,
NumberLikes = numberOfLikes,
Time = latestPost.time,
TimeAgo = timeAgo,
IsLikeByLoginedUser = isLike
};
postModelList.Add(postModel);
}
}
postModelList.Sort();
return(postModelList);
}
protected override void OnActionExecuting(ActionExecutingContext filterContext)
{
LoginedUser user = (LoginedUser)Session[CommonConstant.USER_SESSION];
if (user == null || (user.Role != CommonConstant.ROLE_USER && user.Role != CommonConstant.ROLE_ADMIN))
{
filterContext.Result = new RedirectToRouteResult(new System.Web.Routing.RouteValueDictionary(
new { controller = "Login", action = "Index" }));
}
else
{
this.UserAvatar = new UserAvatarModel()
{
Id = user.Id, Avatar = user.Avatar, Username = user.UserName
};
this.ViewBag.UserAvatar = this.UserAvatar;
}
base.OnActionExecuting(filterContext);
}
private void SetContextAccordingToDisplaySettings(UserAvatarModel context, IUserIdentity userIdentity)
{
SetText(context, userIdentity);
SetImageSource(context, userIdentity);
}
public virtual IActionResult UploadAvatar(UserAvatarModel model, IFormFile uploadedFile)
{
if (!_workContext.CurrentUser.IsRegistered())
{
return(Challenge());
}
if (!_userSettings.AllowUsersToUploadAvatars)
{
return(RedirectToRoute("UserInfo"));
}
var user = _workContext.CurrentUser;
if (ModelState.IsValid)
{
try
{
var userAvatar = _pictureService.GetPictureById(_genericAttributeService.GetAttribute <int>(user, NopUserDefaults.AvatarPictureIdAttribute));
if (uploadedFile != null && !string.IsNullOrEmpty(uploadedFile.FileName))
{
var avatarMaxSize = _userSettings.AvatarMaximumSizeBytes;
if (uploadedFile.Length > avatarMaxSize)
{
throw new NopException(string.Format(_localizationService.GetResource("Account.Avatar.MaximumUploadedFileSize"), avatarMaxSize));
}
var userPictureBinary = _downloadService.GetDownloadBits(uploadedFile);
if (userAvatar != null)
{
userAvatar = _pictureService.UpdatePicture(userAvatar.Id, userPictureBinary, uploadedFile.ContentType, null);
}
else
{
userAvatar = _pictureService.InsertPicture(userPictureBinary, uploadedFile.ContentType, null);
}
}
var userAvatarId = 0;
if (userAvatar != null)
{
userAvatarId = userAvatar.Id;
}
_genericAttributeService.SaveAttribute(user, NopUserDefaults.AvatarPictureIdAttribute, userAvatarId);
model.AvatarUrl = _pictureService.GetPictureUrl(
_genericAttributeService.GetAttribute <int>(user, NopUserDefaults.AvatarPictureIdAttribute),
_mediaSettings.AvatarPictureSize,
false);
return(View(model));
}
catch (Exception exc)
{
ModelState.AddModelError("", exc.Message);
}
}
//If we got this far, something failed, redisplay form
model = _userModelFactory.PrepareUserAvatarModel(model);
return(View(model));
}
