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));
}
}
