public async Task <ActionResult> Register(RegisterViewModel model) { if (this.ModelState.IsValid) { if (string.IsNullOrEmpty(model.AvatarUrl) && !string.IsNullOrEmpty(model.Email)) { model.AvatarUrl = GravatarHelper.CreateGravatarUrl(model.Email, 200, GravatarHelper.DefaultImageIdenticon, GravatarRating.G, false, false); } var user = this.Mapper.Map <User>(model); var result = await this.UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await this.SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(this.RedirectToAction("Index", "Home")); } this.AddErrors(result); } // If we got this far, something failed, redisplay form return(this.View(model)); }
public bool ChangeEmail(int userId, ChangeEmailRequest request) { var user = Fetch(userId); if (user == null) { return(false); } //verify its not already being used var exists = _context.Users .Where(u => u.Email == request.email) .FirstOrDefault(e => e.Id != userId); if (exists != null) { return(false); } var helper = new GravatarHelper(); user.Email = request.email; user.EmailMd5 = helper.CalculateMD5Hash(request.email); _context.Users.Update(user); _context.SaveChanges(); return(true); }
public async Task <ActionResult <JwtTokenModel> > Register([FromBody] RegisterModel model) { if (ModelState.IsValid) { var gravatarUrl = GravatarHelper.GetAvatarUrl(model.Email); var user = new ApplicationUser { UserName = model.Name, Email = model.Email, AvatarUrl = gravatarUrl }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); var jwtToken = await _tokenService.GetJwtToken(user); return(jwtToken); } var errors = AuthHelper.GetErrors(result); return(BadRequest(errors)); } return(BadRequest(ModelState)); }
public ActionResult Index() { var viewModel = new IndexViewModel { Rooms = this.Db.ChatRooms.Select(m => new RoomViewModel { Id = m.Id, RoomName = m.Name, Description = m.Description, RoomUsersCount = m.ChatRoomUsers.Count }).ToList(), Users = this.Db.Users.Select(m => new UserViewModel { Id = m.Id, DisplayName = m.DisplayName, EMail = m.Email }).ToList() }; // refine data viewModel.Users.ForEach( u => { u.ProfilePictureUrl = GravatarHelper.GetGravatarUrl(GravatarHelper.GetGravatarHash(u.EMail), GravatarHelper.Size.S16); }); return(this.View(viewModel)); }
/// <summary> /// Joins the chat /// </summary> public ActionResult JoinChat(string userName, string email) { // try to find an existing user with the same e-mail var user = ChatHub.FindUserByEmail(email); if (user == null) { user = new ChatUser() { Name = userName, Email = email, ProfilePictureUrl = GravatarHelper.GetGravatarUrl(GravatarHelper.GetGravatarHash(email), GravatarHelper.Size.s32), Id = new Random().Next(100000), Status = ChatUser.StatusType.Online, RoomId = ChatController.ROOM_ID_STUB }; // for signalr { ChatHub.RegisterNewUser(user); } // for long-polling { ChatServer.SetupRoomIfNonexisting(ChatController.ROOM_ID_STUB); ChatServer.Rooms[ChatController.ROOM_ID_STUB].RegisterNewUser(user); } } // Normally it wouldn't be necessary to create this cookie because the // FormsAuthentication cookie does this ChatHelper.CreateNewUserCookie(this.Response, user); return(this.RedirectToAction("Index")); }
protected override void OnActionExecuted(ActionExecutedContext filterContext) { base.OnActionExecuted(filterContext); var id = this.User.Identity.GetUserId(); if (id != null) { var currentUser = this.UserManager.FindById(int.Parse(id)); if (currentUser == null) { this.AuthenticationManager.SignOut(); return; } this.ViewBag.User = new UserViewModel { Id = currentUser.Id, UserName = currentUser.UserName, DisplayName = currentUser.DisplayName, EMail = currentUser.DisplayName, ProfilePictureUrl = GravatarHelper.GetGravatarUrl(GravatarHelper.GetGravatarHash(currentUser.Email), GravatarHelper.Size.S32) }; } }
private Task <bool> AddClaimsAsync(UserWithClaims user, ExternalLoginInfo externalLogin, string email, bool isFirst = false) { var newClaims = new List <Claim>(); void AddClaim(Claim claim) { newClaims.Add(claim); user.Claims.Add(claim); } foreach (var squidexClaim in externalLogin.Principal.GetSquidexClaims()) { AddClaim(squidexClaim); } if (!user.HasPictureUrl()) { AddClaim(new Claim(SquidexClaimTypes.PictureUrl, GravatarHelper.CreatePictureUrl(email))); } if (!user.HasDisplayName()) { AddClaim(new Claim(SquidexClaimTypes.DisplayName, email)); } if (isFirst) { AddClaim(new Claim(SquidexClaimTypes.Permissions, Permissions.Admin)); } return(MakeIdentityOperation(() => userManager.SyncClaimsAsync(user.Identity, newClaims))); }
/// <summary> /// Default constructor. /// </summary> /// <param name="html"></param> public PiranhaHelper(WebPage parent, HtmlHelper html) { Parent = parent ; Html = html ; Gravatar = new GravatarHelper() ; Culture = new CultureHelper() ; }
public ActionResult Index() { var existingUser = ChatCookieHelperStub.GetDbUserFromCookie(this.Request); ChatViewModel chatViewModel = null; if (existingUser != null) { if (!ChatHub.IsUserRegisteredInDbUsersStub(existingUser)) { // cookie is invalid ChatCookieHelperStub.RemoveCookie(this.Response); return(this.RedirectToAction("Index")); } // in this case the authentication cookie is valid and we must render the chat chatViewModel = new ChatViewModel() { IsUserAuthenticated = true, UserId = existingUser.Id, UserName = existingUser.FullName, UserProfilePictureUrl = GravatarHelper.GetGravatarUrl(GravatarHelper.GetGravatarHash(existingUser.Email), GravatarHelper.Size.s32) }; } return(this.View(chatViewModel)); }
public async Task check_if_gravatar_helper_creates_correct_url() { var userUrl = GravatarHelper.CreateGravatarUrl("Test"); var content = await _httpService.GetByteArrayAsync(userUrl); Assert.NotNull(content); }
/// <summary> /// Gets the model for the blog post page /// </summary> /// <param name="currentPage">The current page</param> /// <param name="currentMember">The current member</param> /// <returns>The page model</returns> public BlogPostViewModel GetBlogPostPageModel(IPublishedContent currentPage, IMember currentMember) { var model = GetPageModel <BlogPostViewModel>(currentPage, currentMember); model.ImageUrl = GravatarHelper.CreateGravatarUrl(model.Author.Email, 200, string.Empty, null, null, null); return(model); }
internal async Task ReLoadGravatar() { if (!String.IsNullOrEmpty(this.Email)) { this.FeedbackMessage.GravatarHash = GravatarHelper.CreateHash(this.Email); this.Gravatar = await GravatarHelper.LoadGravatar(this.FeedbackMessage.GravatarHash); } }
protected string GetAvatar(object CustomerId, object EmailAddress) { var email = EmailAddress == null ? string.Empty : EmailAddress.ToString(); var avatar = GravatarHelper.GetGravatarUrlForEmailWithSize(email, 40); return(string.Format(AVATAR_FORMAT, GetEditUrl(CustomerId.ToString()), avatar, email)); }
public OrganizationMemberViewModel(Membership membership) { var member = membership?.Member ?? throw new ArgumentNullException(nameof(membership)); Username = member.Username; EmailAddress = member.EmailAddress; IsAdmin = membership.IsAdmin; GravatarUrl = GravatarHelper.Url(EmailAddress, Constants.GravatarElementSize); }
public async override Task <ClaimsPrincipal> CreateAsync(AppUser user) { var principal = await base.CreateAsync(user); ((ClaimsIdentity)principal.Identity).AddClaims(new [] { new Claim(OpenIdConnectConstants.Claims.Picture, GravatarHelper.CreateHash(user.Email)) }); return(principal); }
public PackageOwnersResultViewModel(User user, User currentUser, UrlHelper url, bool isPending, bool isNamespaceOwner) { Name = user.Username; EmailAddress = user.EmailAddress; ProfileUrl = url.User(user, relativeUrl: false); ImageUrl = GravatarHelper.Url(user.EmailAddress, size: Constants.GravatarImageSize); GrantsCurrentUserAccess = PermissionsService.IsActionAllowed(user, currentUser, AccountActions.ManagePackageOwnershipOnBehalfOf); IsCurrentUserMemberOfOrganization = PermissionsService.IsActionAllowed(user, currentUser, AccountActions.DisplayPrivateOrganization); Pending = isPending; IsNamespaceOwner = isNamespaceOwner; }
private OrganizationMemberViewModel(User member) { if (member == null) { throw new ArgumentNullException(nameof(member)); } Username = member.Username; EmailAddress = member.EmailAddress; GravatarUrl = GravatarHelper.Url(EmailAddress, Constants.GravatarElementSize); }
public PackageOwnersResultViewModel(User user, User currentUser, PackageRegistration packageRegistration, UrlHelper url, bool isPending, bool isNamespaceOwner) { Name = user.Username; EmailAddress = user.EmailAddress; ProfileUrl = url.User(user, relativeUrl: false); ImageUrl = GravatarHelper.Url(user.EmailAddress, size: GalleryConstants.GravatarImageSize); GrantsCurrentUserAccess = ActionsRequiringPermissions.ManagePackageOwnership.CheckPermissions(currentUser, user, packageRegistration) == PermissionsCheckResult.Allowed; IsCurrentUserAdminOfOrganization = (user as Organization)?.GetMembershipOfUser(currentUser)?.IsAdmin ?? false; Pending = isPending; IsNamespaceOwner = isNamespaceOwner; }
public void GetAvatarUrl_ManyEmailFormats_Url() { var expected = GravatarHelper.GetAvatarUrl("*****@*****.**"); Assert.AreEqual("http://www.gravatar.com/avatar/c5c70a93a2b605756df1af5da0dd413f.jpg", expected); expected = GravatarHelper.GetAvatarUrl("*****@*****.**"); Assert.AreEqual("http://www.gravatar.com/avatar/c5c70a93a2b605756df1af5da0dd413f.jpg", expected); expected = GravatarHelper.GetAvatarUrl(" [email protected] "); Assert.AreEqual("http://www.gravatar.com/avatar/c5c70a93a2b605756df1af5da0dd413f.jpg", expected); }
public static List <DoctorViewModel> GetDoctorViewModelsFromPractice(CerebelloEntitiesAccessFilterWrapper db, Practice practice, DateTime localNow) { var usersThatAreDoctors = db.Users .Where(u => u.PracticeId == practice.Id) .Where(u => u.Doctor != null); var dataCollection = usersThatAreDoctors .Select(u => new { ViewModel = new DoctorViewModel() { Id = u.Id, Name = u.Person.FullName, UrlIdentifier = u.Doctor.UrlIdentifier, CRM = u.Doctor.CRM, MedicalSpecialty = u.Doctor.MedicalSpecialtyName, }, u.Doctor.MedicalEntityCode, u.Doctor.MedicalEntityJurisdiction, u.Doctor, u.Person.EmailGravatarHash, }) .ToList(); // Getting more doctor's informations: // Todo: this is going to become a problem in the future, because this info has no cache. // - next free time slot of each doctor; // - gravatar image. foreach (var eachItem in dataCollection) { if (!string.IsNullOrEmpty(eachItem.EmailGravatarHash)) { eachItem.ViewModel.ImageUrl = GravatarHelper.GetGravatarUrl(eachItem.EmailGravatarHash, GravatarHelper.Size.s16); } eachItem.ViewModel.MedicalEntity = string.Format( string.IsNullOrEmpty(eachItem.MedicalEntityJurisdiction) ? "{0}" : "{0}-{1}", eachItem.MedicalEntityCode, eachItem.MedicalEntityJurisdiction); // It is only possible to determine the next available time if the schedule of the doctor is already configured. if (eachItem.Doctor.CFG_Schedule != null) { var nextSlotInLocalTime = ScheduleController.FindNextFreeTimeInPracticeLocalTime(db, eachItem.Doctor, localNow); eachItem.ViewModel.NextAvailableTime = nextSlotInLocalTime.Item1; } } var doctors = dataCollection.Select(item => item.ViewModel).ToList(); return(doctors); }
public async Task <IResult> RegisterUserAsync([FromBody] UserRegisterWriteModel userRegister) { if (!ModelState.IsValid) { var errors = ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage).ToArray(); return(CreateResult(ResultStateEnum.Failed, errors)); } var gravatarUrl = GravatarHelper.CreateGravatarUrl(userRegister.UserName); userRegister.Gravatar = await _httpService.GetByteArrayAsync(gravatarUrl); return(await _userAuthDomainServiceProxy.CreateUserAsync(userRegister)); }
private static void AddTranslator(SetLocaleDbContext context, string name, string email) { var user = new User { Email = email, Name = name, RoleId = SetLocaleRole.Translator.Value, RoleName = SetLocaleRole.Translator.ToString(), ImageUrl = GravatarHelper.GetGravatarURL(email, 35), PasswordHash = BCrypt.Net.BCrypt.HashPassword("password"), LastLoginAt = DateTime.Now, IsActive = true }; context.Users.Add(user); }
private ChatUserInfo GetUserInfo(User user, ChatUserInfo.StatusType status) { if (user == null) { throw new ArgumentNullException("user"); } return(new ChatUserInfo { Id = user.Id, Name = user.DisplayName, Status = status, ProfilePictureUrl = GravatarHelper.GetGravatarUrl(GravatarHelper.GetGravatarHash(user.Email), GravatarHelper.Size.S32) }); }
/// <summary> /// /// </summary> /// <param name="model"></param> /// <param name="roleId">default is 3 - SetLocaleRole.Developer.Value </param> /// <returns></returns> public async Task <int?> Create(UserModel model, int roleId = 3) { var img = GravatarHelper.GetGravatarURL(model.Email, 55, "mm"); var user = new User { Email = model.Email, Name = model.Name, PasswordHash = BCrypt.Net.BCrypt.HashPassword(model.Password), ImageUrl = img, RoleId = roleId, RoleName = SetLocaleRole.GetString(roleId), IsActive = true, Language = model.Language }; _userRepo.Create(user); if (roleId == SetLocaleRole.Developer.Value) { var app = new App { UserEmail = model.Email, Name = model.Name, Url = "example.com", IsActive = true, Tokens = new List <Token> { new Token { Key = Guid.NewGuid().ToString().Replace("-", string.Empty), UsageCount = 0, IsAppActive = true } } }; _appRepository.Create(app); _appRepository.SaveChanges(); } if (!_userRepo.SaveChanges()) { return(null); } return(await Task.FromResult(user.Id)); }
public virtual ActionResult GetPackageOwners(string id, string version) { var package = _packageService.FindPackageByIdAndVersion(id, version); if (package == null) { return(Json(new { message = Strings.AddOwner_PackageNotFound })); } if (!package.IsOwner(HttpContext.User)) { return(new HttpUnauthorizedResult()); } var owners = from u in package.PackageRegistration.Owners select new { Name = u.Username, EmailAddress = u.EmailAddress, Current = u.Username == HttpContext.User.Identity.Name, Pending = false }; var pending = _packageOwnerRequestService.GetPackageOwnershipRequests(package: package.PackageRegistration) .Select(r => new { Name = r.NewOwner.Username, EmailAddress = r.NewOwner.EmailAddress, Current = false, Pending = true }); var result = owners.Union(pending).Select(o => new { name = o.Name, profileUrl = Url.User(o.Name, relativeUrl: false), imageUrl = GravatarHelper.Url(o.EmailAddress, size: Constants.GravatarImageSize), current = o.Current, pending = o.Pending, }); return(Json(result, JsonRequestBehavior.AllowGet)); }
public async Task <GravatarProxyResult> GetAvatarOrNullAsync(string username, int imageSize) { if (!_features.IsGravatarProxyEnabled()) { return(null); } var user = _users.GetAll().FirstOrDefault(u => u.Username == username); if (user == null) { _logger.LogWarning("Could not find an account with username {Username}", username); return(null); } try { var emailAddress = user.EmailAddress ?? user.UnconfirmedEmailAddress; var useEnSubdomain = _features.ProxyGravatarEnSubdomain(); var url = GravatarHelper.RawUrl(emailAddress, imageSize, useEnSubdomain); // The response will be disposed when the caller disposes the content stream. var client = _httpClientFactory.CreateClient(GravatarHttpClientName); var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead); response.EnsureSuccessStatusCode(); string contentType = null; if (response.Content.Headers.TryGetValues(HttpContentTypeHeaderName, out var contentTypes)) { contentType = contentTypes.FirstOrDefault(); } return(new GravatarProxyResult( await response.Content.ReadAsStreamAsync(), contentType ?? HttpContentTypeDefaultValue)); } catch (Exception e) { _logger.LogError(0, e, "Unable to fetch profile picture for user {Username}", username); return(null); } }
/// <summary> /// Method to get the model for the main navigation /// </summary> /// <param name="currentPage">The current page</param> /// <param name="currentMember">The current member</param> /// <returns>Navigation model</returns> public MainNavigationViewModel GetMainNavigation(IPublishedContent currentPage, IMember currentMember) { var login = Root.Descendant(ContentTypeAliases.Login); var model = new MainNavigationViewModel { Items = GetMenuItems(currentPage, Root, 0, 3), Login = login != null?MapItem(currentPage, login) : null }; if (currentMember == null) { return(model); } model.IsLoggedIn = true; model.Name = currentMember.Name; model.ImageUrl = GravatarHelper.CreateGravatarUrl(currentMember.Email, 30, string.Empty, null, null, null); return(model); }
private static UserValues CreateUserValues(ExternalLoginInfo externalLogin, string email, IUser?user = null) { var values = new UserValues { CustomClaims = externalLogin.Principal.Claims.GetSquidexClaims().ToList() }; if (user != null && !user.Claims.HasPictureUrl()) { values.PictureUrl = GravatarHelper.CreatePictureUrl(email); } if (user != null && !user.Claims.HasDisplayName()) { values.DisplayName = email; } return(values); }
/** * Create a new account. */ public User Register(string email, string password, string username) { var gravatar = new GravatarHelper(); var user = new User { Email = email, Username = username, Password = password, EmailMd5 = gravatar.CalculateMD5Hash(email), CreatedAt = DateTime.Now, UpdatedAt = DateTime.Now, }; _context.Users.Add(user); _context.SaveChanges(); return(AppendToken(user)); }
public OrganizationMemberViewModel(MembershipRequest request) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var member = request.NewMember; if (member == null) { throw new ArgumentNullException(nameof(request.NewMember)); } Username = member.Username; IsAdmin = request.IsAdmin; Pending = true; GravatarUrl = GravatarHelper.Url(member.EmailAddress, Constants.GravatarElementSize); }
public async Task <JsonResult> AddPackageOwner(string id, string username, string message) { ManagePackageOwnerModel model; if (TryGetManagePackageOwnerModel(id, username, out model)) { var encodedMessage = HttpUtility.HtmlEncode(message); var ownerRequest = await _packageOwnerRequestService.AddPackageOwnershipRequest( model.Package, model.CurrentUser, model.User); var confirmationUrl = Url.ConfirmPendingOwnershipRequest( model.Package.Id, model.User.Username, ownerRequest.ConfirmationCode, relativeUrl: false); var rejectionUrl = Url.RejectPendingOwnershipRequest( model.Package.Id, model.User.Username, ownerRequest.ConfirmationCode, relativeUrl: false); var packageUrl = Url.Package(model.Package.Id, version: null, relativeUrl: false); var policyMessage = GetNoticeOfPoliciesRequiredMessage(model.Package, model.User, model.CurrentUser); _messageService.SendPackageOwnerRequest(model.CurrentUser, model.User, model.Package, packageUrl, confirmationUrl, rejectionUrl, encodedMessage, policyMessage); return(Json(new { success = true, name = model.User.Username, profileUrl = Url.User(model.User.Username, relativeUrl: false), imageUrl = GravatarHelper.Url(model.User.EmailAddress, size: Constants.GravatarImageSize), pending = true })); } else { return(Json(new { success = false, message = model.Error }, JsonRequestBehavior.AllowGet)); } }