public record StoreWithOffersCount( Guid Guid, string Name, DateTime?CloseDate, string?Url, User?Manager, int OffersCount);
public BuildBuilder WithOwner(Action <UserBuilder>?configure = null) { _owner = null; _ownerBuilder = new UserBuilder(); configure?.Invoke(_ownerBuilder); return(this); }
private IList <IAuthenticationProvider> GetAuthenticationProviders(User?user) { var authenticationProviderId = user?.AuthenticationProviderId; var providers = _authenticationProviders.Where(i => i.IsEnabled).ToList(); if (!string.IsNullOrEmpty(authenticationProviderId)) { providers = providers.Where(i => string.Equals(authenticationProviderId, i.GetType().FullName, StringComparison.OrdinalIgnoreCase)).ToList(); } if (providers.Count == 0) { // Assign the user to the InvalidAuthProvider since no configured auth provider was valid/found _logger.LogWarning( "User {Username} was found with invalid/missing Authentication Provider {AuthenticationProviderId}. Assigning user to InvalidAuthProvider until this is corrected", user?.Username, user?.AuthenticationProviderId); providers = new List <IAuthenticationProvider> { _invalidAuthProvider }; } return(providers); }
public async Task OnGetAsync() { GraphServiceClient graphClient = GetGraphServiceClient(new[] { "user.read", "calendars.read" }); User?me = await graphClient.Me.Request().GetAsync(); ViewData["Me"] = me; ICalendarEventsCollectionPage?cal = await graphClient.Me.Calendar.Events.Request().GetAsync(); foreach (Event?evnt in cal) { Console.WriteLine(evnt.Subject); } try { // Get user photo using Stream? photoStream = await graphClient.Me.Photo.Content.Request().GetAsync(); byte[] photoByte = ((MemoryStream)photoStream).ToArray(); ViewData["Photo"] = Convert.ToBase64String(photoByte); } catch (Exception) { ViewData["Photo"] = null; } }
public async Task <long> CreateUser(CreateUser createUser) { bool emailIsTaken = await IsEmailAddressTaken(createUser.EmailAddress); if (emailIsTaken) { throw new DomainException(DomainExceptions.User_with_given_email_address_already_exists); } User?createdUser = null; using (var transaction = await context.Database.BeginTransactionAsync()) { createdUser = new User(EmailAddress.Create(createUser.EmailAddress), Password.Create(createUser.Password)); createdUser.Name = createUser.Name; context.Users.Add(createdUser); await context.SaveChangesAsync(); context.AddEvent(createdUser.CreateEvent(), correlationIdProvider.TraceId); await context.SaveChangesAsync(); await transaction.CommitAsync(); } return(createdUser !.UserId); }
public ActionResult Login(LoginPageModel model) //TODO: Move all of this to a UserService class { if (model is null) { throw new ArgumentNullException(nameof(model)); } //We want to wait a specified amount of time for the response regardless of the results, to avoid //Exposing any information to the client StaticLogger.Log($"{model.Login}: Login attempt", StaticLogger.LoggingLevel.Call); DateTime startLogin = DateTime.Now; void WaitForRedirect() { const double LoginTime = 3000; double toWait = LoginTime - (DateTime.Now - startLogin).TotalMilliseconds; StaticLogger.Log($"{model.Login}: Waiting for {toWait}", StaticLogger.LoggingLevel.Call); if (toWait > 0) { System.Threading.Thread.Sleep((int)toWait); } } StaticLogger.Log($"{model.Login}: Calling user service...", StaticLogger.LoggingLevel.Call); User?user = this.UserService.Login(model.Login, model.Password); if (user != null) { StaticLogger.Log($"{model.Login}: User not null", StaticLogger.LoggingLevel.Call); if (this.ConfigurationService.GetBool(ConfigurationNames.REQUIRE_EMAIL_VALIDATION)) { if (!this.EmailValidationRepository.IsValidated(user)) { return(this.RedirectToAction(nameof(EmailValidationRequired), new { Id = user.Guid.ToString(), area = "" })); } } if (!string.IsNullOrWhiteSpace(model.ReturnUrl) && model.ReturnUrl != this.Request.Path.Value) { WaitForRedirect(); StaticLogger.Log($"{model.Login}: Returning to {model.ReturnUrl}", StaticLogger.LoggingLevel.Call); return(this.Redirect(model.ReturnUrl)); } else { WaitForRedirect(); StaticLogger.Log($"{model.Login}: Returning Home", StaticLogger.LoggingLevel.Call); return(this.Redirect("/Home/Index")); } } else { StaticLogger.Log($"{model.Login}: User is null", StaticLogger.LoggingLevel.Call); this.ModelState.AddModelError(string.Empty, "Invalid Login or Password" + System.Environment.NewLine); WaitForRedirect(); return(this.View(model)); } }
public async Task <CommentReadView?> FindById(int id, User?user = null) { var comments = await Connection.QueryAsync <CommentRecord>( @"WITH RECURSIVE commenttree AS ( SELECT r.* FROM comment r WHERE id = @Id AND was_deleted = FALSE UNION ALL SELECT c.* FROM comment c INNER JOIN commenttree ct ON ct.id = c.parent_id WHERE c.was_deleted = FALSE ) SELECT * FROM commenttree ORDER BY parent_id, creation_date ASC;", new { Id = id } ); IUserReader userReader = GetReader <IUserReader>(); IVoteReader voteReader = GetReader <IVoteReader>(); List <CommentReadView> views = new List <CommentReadView>(); foreach (CommentRecord comment in comments) { CommentReadView view = Map(comment); view.User = (await userReader.FindById(comment.UserId)) !; if (user != null) { view.Vote = await voteReader.FindByCommentAndUser(comment.Id, user.Id); } views.Add(view); } // We're assuming there will always be one top level comment. return(BuildCommentTree(views)[0]); }
public Task <User> Update(User update) { this.Update_InputUser = update; this.Update_Output = update; return(Task.FromResult(this.Update_Output)); }
public async override Task <ServiceView> Execute(UpdateServiceCommand input, User?user) { var service = await this.service.GetById(input.Id); if (!service.IsOwner(user !)) { throw new AuthorizationException(); } await this.service.Update( service, new ServiceUpdate( input.Name, input.Description, input.PricingMethod, input.Configurations.Select(c => new ServiceConfigurationUpdate( c.VehicleCategoryId, c.Price, c.Duration )).ToList() ) ); throw new NotImplementedException(); // return mapper.Map<Service, ServiceView>(service); }
public async Task <IActionResult> ProcessSendActivationUserMailTopic([FromBody] TopicData <User> topicData) { User?user = topicData.Data; if (!string.IsNullOrWhiteSpace(user?.Id)) { _logger.LogInformation($"Receive send activation user mail topic, user id: {user.Id}"); // TODO Add api key ADMIN from global tenant and add tenant Id to header await _daprClient.InvokeMethodAsync("userapi", $"UserMail/activation", data : user, httpExtension : new HTTPExtension() { Verb = HTTPVerb.Post, Headers = new Dictionary <string, string>() { { "tenantId", topicData.TenantId } } } ); } else { _logger.LogWarning($"Receive user topic without id"); } return(Ok()); }
public Task <User> Create(User create) { this.Create_InputUser = create; this.Create_Output = create; return(Task.FromResult(this.Create_Output)); }
protected override async Task <UserLogin> HandleInput(UserRegisterParams input) { using (var connection = database.GetConnection()) { using (var transaction = connection.BeginTransaction()) { IUserRepo userRepo = database.GetRepo <IUserRepo>(connection); ISpaceRepo spaceRepo = database.GetRepo <ISpaceRepo>(connection); ISubscriptionRepo subRepo = database.GetRepo <ISubscriptionRepo>(connection); // Check that the email is free first. if (!String.IsNullOrWhiteSpace(input.Email)) { User?emailInUse = await userRepo.FindByEmail(input.Email); if (emailInUse != null) { throw new CollisionException("Email is already in use"); } } User?usernameInUse = await userRepo.FindByUsername(input.Username); if (usernameInUse != null) { throw new CollisionException("Username is unavailable"); } User user = new User() { Username = input.Username, PasswordHash = passwordHasher.Hash(input.Password), Email = StringUtils.NullifyWhiteSpace(input.Email), JoinedDate = System.DateTime.UtcNow }; await userRepo.Add(user); // Subscribe the user to the default spaces. IEnumerable <Space> defaultSpaces = await spaceRepo.FindDefault(); IEnumerable <Subscription> defaultSubscriptions = defaultSpaces.Select(space => new Subscription() { User = user, Space = space }); foreach (Subscription s in defaultSubscriptions) { await subRepo.Add(s); s.Space.SubscriptionCount++; await spaceRepo.Update(s.Space); } UserView userView = userMapper.Map(user); string authToken = tokenHandler.IssueToken(user); transaction.Commit(); return(new UserLogin(userView, authToken)); } } }
/// <summary> /// ログインする。 /// </summary> /// <param name="mailAddress">メールアドレス</param> /// <param name="password">パスワード</param> /// <returns>ログインに成功したかどうか</returns> public static bool LogIn(string mailAddress, string password) { bool ret; var userDAO = new UserDAO(); // メールアドレスが一致するユーザ取得 var dt = userDAO.Select(mailAddress); var users = User.ConvertFrom(dt); if (users.Count == 0) { return(false); } // 認証 var user = Authenticate(users, mailAddress, password); ret = (user != null); // オンラインフラグ更新 ret = ret && user !.LogIn(); if (ret) { // 認証成功した場合はログイン中ユーザを保持 CurrentUser = user; } return(ret); }
public async Task <User?> AuthenticateUser(string name, string password) { User?user = null; byte[] hash = pool.Rent(64); try /// Arraypool example from https://adamsitnik.com/Array-Pool/ { user = await _context.Users.Where(u => u.Name == name).AsNoTracking().SingleOrDefaultAsync(); if (user == null) { return(null); } Hash(password, user.PasswordSalt, hash); if (!user.PasswordSha512Hash.SequenceEqual(hash)) { return(null); } } catch { } finally { pool.Return(hash); } return(user); }
/// <summary> /// Creates a character in the database with the given settings. /// </summary> /// <param name="owner">The owner. Defaults to <see cref="DefaultOwner"/>.</param> /// <param name="server">The server. Defaults <see cref="DefaultServer"/>.</param> /// <param name="name">The name.</param> /// <param name="avatarUrl">The avatar.</param> /// <param name="nickname">The nickname.</param> /// <param name="summary">The summary.</param> /// <param name="description">The description.</param> /// <param name="pronouns">The pronouns.</param> /// <param name="isNSFW">Whether the character is NSFW.</param> /// <returns>The character.</returns> protected Character CreateCharacter ( User?owner = null, Server?server = null, string?name = null, string?avatarUrl = null, string?nickname = null, string?summary = null, string?description = null, string?pronouns = null, bool?isNSFW = null ) { var character = this.Database.CreateProxy <Character> ( owner ?? this.DefaultOwner, server ?? this.DefaultServer, name ?? string.Empty, avatarUrl ?? string.Empty, nickname ?? string.Empty, summary ?? string.Empty, description ?? string.Empty, pronouns ?? "They" // a real value is used here to avoid having to set it in the majority of cases ); if (isNSFW is not null) { character.IsNSFW = isNSFW.Value; } this.Database.Characters.Update(character); this.Database.SaveChanges(); return(character); }
protected override async Task <UserLogin?> HandleInput(UserCredentials input) { using (var connection = database.GetConnection()) { IUserRepo userRepo = database.GetRepo <IUserRepo>(connection); User?user = await userRepo.FindByUsername(input.Username); if (user == null) { return(null); } if (passwordHasher.Verify(input.Password, user.PasswordHash)) { UserView userView = userMapper.Map(user); string authToken = tokenHandler.IssueToken(user); return(new UserLogin(userView, authToken)); } else { return(null); } } }
public override Task Login(User user, AuthenticationProperties properties) { this.Login_InputUser = user; this.Login_InputProperties = properties; return(base.Login(user, properties)); }
public async Task CreateUserOfUserNotInSystemShouldWork(string userName, string userRole, string userEmail) { User?enteredUser = null; User?returnedUser = null; await using (var ctx = new TestKitchenRpContext(_options)) { ctx.Database.EnsureCreated(); var users = new UserRepository(ctx, new RolesRepository(ctx)); enteredUser = await users.CreateNewUser(userName, userRole, userEmail); } await using (var ctx = new TestKitchenRpContext(_options)) { var users = new UserRepository(ctx, new RolesRepository(ctx)); Assert.NotNull(enteredUser.Id); returnedUser = await users.FindById(enteredUser.Id.Value); } Assert.NotNull(returnedUser); Assert.Equal(returnedUser.Id, enteredUser.Id); Assert.Equal(returnedUser.Email, enteredUser.Email); Assert.Equal(returnedUser.Sub, enteredUser.Sub); Assert.Equal(returnedUser.AllowNotifications, enteredUser.AllowNotifications); Assert.Equal(returnedUser.Role?.Id, enteredUser.Role?.Id); Assert.Equal(returnedUser.Email, userEmail); Assert.Equal(returnedUser.Sub, userName); Assert.Equal(returnedUser.Role?.RoleName, userRole); }
/// <inheritdoc /> public async Task <RetrieveEntityResult <Character> > GetBestMatchingCharacterAsync ( Server server, User?user, string?name, CancellationToken ct = default ) { server = _database.NormalizeReference(server); if (!(user is null)) { user = _database.NormalizeReference(user); } if (user is null && name is null) { return(RetrieveEntityResult <Character> .FromError("No user and no name specified.")); } if (user is null) { return(await GetCharacterByNameAsync(server, name !, ct)); } if (name.IsNullOrWhitespace()) { return(await GetCurrentCharacterAsync(user, server, ct)); } return(await GetUserCharacterByNameAsync(user, server, name, ct)); }
/// <summary> /// Get user by email without Discrminator /// </summary> /// <param name="email"></param> /// <returns>User as its found</returns> public async Task <User?> GetUserByEmail(string email) { User?user = null; FullAPIUri = new Uri(BaseAPIUri, $"{nameof(GetUserByEmail)}/{email}"); string stringResult = string.Empty; await Policy.Handle <Exception>() .WaitAndRetryAsync( retryCount: 5, sleepDurationProvider: retryAttemp => TimeSpan.FromSeconds(Math.Pow(1.5, retryAttemp)), onRetry: (exception, timeSpan, retryCount, context) => { // Add logic to be executed before each retry, such as logging System.Diagnostics.Debug.WriteLine($"Retry #{retryCount} due to exception '{(exception.InnerException ?? exception).Message}'"); HttpClient.CancelPendingRequests(); } ).ExecuteAsync(async() => { var response = await HttpClient.GetStringAsync(FullAPIUri); user = JsonConvert.DeserializeObject <User>(response, new JsonSerializerSettings { ContractResolver = new JsonPrivateResolver(), ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor });; }); return(user); }
public async Task <IEnumerable <CommentReadView> > FindByPost(int postId, User?user = null) { var comments = (await Connection.QueryAsync <CommentRecord>( @"WITH RECURSIVE commenttree AS ( SELECT r.* FROM comment r WHERE post_id = @PostId AND parent_id = 0 AND was_deleted = FALSE UNION ALL SELECT c.* FROM comment c INNER JOIN commenttree ct ON ct.id = c.parent_id WHERE c.was_deleted = FALSE ) SELECT * FROM commenttree ORDER BY parent_id, creation_date DESC;", new { PostId = postId } )); IUserReader userReader = GetReader <IUserReader>(); IVoteReader voteReader = GetReader <IVoteReader>(); List <CommentReadView> views = new List <CommentReadView>(); foreach (CommentRecord comment in comments) { CommentReadView view = Map(comment); view.User = (await userReader.FindById(comment.UserId)) !; if (user != null) { view.Vote = await voteReader.FindByCommentAndUser(comment.Id, user.Id); } views.Add(view); } return(BuildCommentTree(views)); }
public async Task <int> Handle(CreatePersistedURLCommand request, CancellationToken cancellationToken) { User?user = null; if (request?.UserId != null) { user = await _ctx.Users.FindAsync(request.UserId); if (user == null) { throw new BadRequestException("The specified user is unknown."); } } var shortURL = await GetShortURL(request?.DesiredShortURL); var persistedURL = new PersistedURL { URL = request.URL, // request cannot be null, but I still get a warning for that it might be :( ShortURL = shortURL, User = user }; await _ctx.PersistedURLs.AddAsync(persistedURL); await _ctx.SaveChangesAsync(cancellationToken); return(persistedURL.Id); }
private static void InitializeUser() { Console.WriteLine("Username:"******""; user = users.FirstOrDefault(u => u.UserName.Equals(userName, StringComparison.OrdinalIgnoreCase)); if (user == null) { Console.WriteLine("Ip:"); var ip = Console.ReadLine() ?? ""; int port; do { Console.WriteLine("Your port:"); } while (!int.TryParse(Console.ReadLine(), out port)); Console.WriteLine("Recipient ip"); var recipientIp = Console.ReadLine() ?? ""; int recipientPort; do { Console.WriteLine("Recipient port:"); } while (!int.TryParse(Console.ReadLine(), out recipientPort)); user = new User(userName, ip, port, recipientPort, recipientIp); configHelper.WriteUsers(users.Concat(new User[] { user })); } Console.Clear(); }
public async Task ReceiveSyncMessage(int roomId, string authToken, VideoSyncMessage videoSyncMessage) { AuthUser?authUser = await _authService.GetUser(authToken); if (authUser == null) { return; } User?user = await _userService.CreateOrGetByAuthUser(authUser); if (user == null) { return; } Room?room = await _roomService.Get(roomId); if (room == null || room.CreatedByUserId != user.UserId) { return; } await Clients.OthersInGroup(roomId.ToString()).SendAsync("VideoSyncMessage", videoSyncMessage); }
public async void OnSaveButtonClick(object sender, RoutedEventArgs args) { this.FindControl <TextBlock>("ErrorTextBlock").IsVisible = false; this.FindControl <TextBlock>("SavedTextBlock").IsVisible = false; this.FindControl <TextBlock>("WaitTextBlock").IsVisible = true; UserID = this.FindControl <TextBox>("UserID").Text; ClientID = this.FindControl <TextBox>("ClientID").Text; ClientSecret = this.FindControl <TextBox>("ClientSecret").Text; User?user = await RunAPIRequest(UserID, ClientID, ClientSecret); if (user != null) { StartUser = user; SaveConfig(); this.FindControl <TabItem>("TabUser").Header = StartUser.Username; this.FindControl <TextBlock>("SavedTextBlock").IsVisible = true; this.FindControl <TabItem>("TabCustomization").IsVisible = true; UpdateValues(StartUser); UpdateDiffValues(StartUser); InitTimer(); } else { this.FindControl <TextBlock>("ErrorTextBlock").IsVisible = true; } this.FindControl <TextBlock>("WaitTextBlock").IsVisible = false; }
public ActionResult <QueryResult <BaseItemDto> > GetMusicGenres( [FromQuery] int?startIndex, [FromQuery] int?limit, [FromQuery] string?searchTerm, [FromQuery] string?parentId, [FromQuery] string?fields, [FromQuery] string?excludeItemTypes, [FromQuery] string?includeItemTypes, [FromQuery] bool?isFavorite, [FromQuery] int?imageTypeLimit, [FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] ImageType[] enableImageTypes, [FromQuery] Guid?userId, [FromQuery] string?nameStartsWithOrGreater, [FromQuery] string?nameStartsWith, [FromQuery] string?nameLessThan, [FromQuery] bool?enableImages = true, [FromQuery] bool enableTotalRecordCount = true) { var dtoOptions = new DtoOptions() .AddItemFields(fields) .AddClientFields(Request) .AddAdditionalDtoOptions(enableImages, false, imageTypeLimit, enableImageTypes); User?user = userId.HasValue && userId != Guid.Empty ? _userManager.GetUserById(userId.Value) : null; var parentItem = _libraryManager.GetParentItem(parentId, userId); var query = new InternalItemsQuery(user) { ExcludeItemTypes = RequestHelpers.Split(excludeItemTypes, ',', true), IncludeItemTypes = RequestHelpers.Split(includeItemTypes, ',', true), StartIndex = startIndex, Limit = limit, IsFavorite = isFavorite, NameLessThan = nameLessThan, NameStartsWith = nameStartsWith, NameStartsWithOrGreater = nameStartsWithOrGreater, DtoOptions = dtoOptions, SearchTerm = searchTerm, EnableTotalRecordCount = enableTotalRecordCount }; if (!string.IsNullOrWhiteSpace(parentId)) { if (parentItem is Folder) { query.AncestorIds = new[] { new Guid(parentId) }; } else { query.ItemIds = new[] { new Guid(parentId) }; } } var result = _libraryManager.GetMusicGenres(query); var shouldIncludeItemTypes = !string.IsNullOrWhiteSpace(includeItemTypes); return(RequestHelpers.CreateQueryResult(result, dtoOptions, _dtoService, shouldIncludeItemTypes, user)); }
public async Task <UserLogin> Register(UserRegistration registration) { // If registration provided an email, check to see if it's available. if (!String.IsNullOrWhiteSpace(registration.Email)) { User?emailInUse = await userRepo.FindByEmail(registration.Email !); if (emailInUse != null) { throw new EmailAlreadyInUseException(); } } // Check to see if the username is unique. User?usernameInUse = await userRepo.FindByUsername(registration.Username); if (usernameInUse != null) { throw new UsernameAlreadyInUseException(); } User user = factory.CreateFromRegistration(registration); await userRepo.Add(user); UserLogin login = new UserLogin(user.Id); await loginRepo.Add(login); await bus.Dispatch(new UserRegisterEvent(user, login)); return(login); }
public static AccessReason GetProfileAccess([NotNull] this User user, [CanBeNull] User?currentUser) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (currentUser == null) { return(AccessReason.NoAccess); } if (user.UserId == currentUser.UserId) { return(AccessReason.ItsMe); } if (user.Claims.Any(claim => claim.HasAccess(currentUser.UserId) && claim.ClaimStatus != Claim.Status.AddedByMaster)) { return(AccessReason.Master); } if (user.ProjectAcls.Any(acl => acl.Project.HasMasterAccess(currentUser.UserId))) { return(AccessReason.CoMaster); } if (currentUser.Auth.IsAdmin == true) { return(AccessReason.Administrator); } return(AccessReason.NoAccess); }
private async Task <(string username, bool success)> AuthenticateWithProvider( IAuthenticationProvider provider, string username, string password, User?resolvedUser) { try { var authenticationResult = provider is IRequiresResolvedUser requiresResolvedUser ? await requiresResolvedUser.Authenticate(username, password, resolvedUser).ConfigureAwait(false) : await provider.Authenticate(username, password).ConfigureAwait(false); if (authenticationResult.Username != username) { _logger.LogDebug("Authentication provider provided updated username {1}", authenticationResult.Username); username = authenticationResult.Username; } return(username, true); } catch (AuthenticationException ex) { _logger.LogError(ex, "Error authenticating with provider {Provider}", provider.Name); return(username, false); } }
public async Task <TokenAuthorizationResult?> RefreshToken() { var cookies = _httpContextAccessor.HttpContext?.Request.Cookies; if (cookies == null || !cookies.TryGetValue(RefreshTokenCookieKey, out var value) || string.IsNullOrEmpty(value)) { return(null); } var model = JsonSerializer.Deserialize <RefreshTokenModel>(value); if (model == null || string.IsNullOrEmpty(model.Username) || string.IsNullOrEmpty(model.RefreshToken)) { return(null); } User?user = await _userService.FindByNameAsync(model.Username); if (user == null || !_userService.IsValidRefreshToken(user, model.RefreshToken)) { return(null); } await _userService.RemoveRefreshToken(user, model.RefreshToken); user = (await _userService.FindByNameAsync(model.Username)) !; await SetRefreshTokenCookie(user); return(GetAccessToken(user.UserName)); }