public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto) { //validate var repo = new TableStorageRepository(); userForRegisterDto.Email = userForRegisterDto.Email.ToLower(); if (await _repo.UserExists(userForRegisterDto.Email)) { return(BadRequest("Email already exists!")); } var userToCreate = _mapper.Map <User>(userForRegisterDto); var pass = userForRegisterDto.Password.ToString(); ////sendgrid var CurrentUserId = (User.FindFirst(ClaimTypes.NameIdentifier).Value); var userLogged = await repo.GetUser(CurrentUserId); Execute(userLogged, userToCreate, pass).Wait(); //// end var createdUser = await _repo.Register(userToCreate, userForRegisterDto.Password); var userToReturn = _mapper.Map <UserDto>(createdUser); return(CreatedAtRoute("GetUser", new { controller = "User", id = createdUser.Id }, userToReturn)); }
public async Task <IActionResult> GetAllUsers([FromQuery] UserParams userParams) { var repo = new TableStorageRepository(); var users = await repo.GetUsersWithoutParams(); var CurrentUserId = (User.FindFirst(ClaimTypes.NameIdentifier).Value); var userLogged = await repo.GetUser(CurrentUserId); if (userLogged.Role == "admin") { var usersAdmin = await repo.GetUsersWithoutParamsForAdmin(); var usersForAdmin = _mapper.Map <IEnumerable <UserDto> >(usersAdmin); return(Ok(usersForAdmin)); } if (!string.IsNullOrEmpty(userParams.UserId)) { users = users.Where(x => x.RowKey != userParams.UserId).OrderBy(x => x.Name); } users = users.OrderBy(x => x.Name); var usersToReturn = _mapper.Map <IEnumerable <UserDto> >(users); if (!usersToReturn.Any()) { return(NotFound()); } return(Ok(usersToReturn)); }
public virtual void Add_ValidProjectionView_ProjectionViewCanBeRetreived() { // Arrange var correlationIdHelper = new CorrelationIdHelper(new ThreadedContextItemCollectionFactory()); correlationIdHelper.SetCorrelationId(Guid.NewGuid()); var logger = new ConsoleLogger(new LoggerSettingsConfigurationSection(), correlationIdHelper); TableStorageDataStore <TestEvent> dataStore = CreateDataStore <TestEvent>(logger, new ConfigurationManager()); var event1 = new TestEvent { Rsn = Guid.NewGuid(), Id = Guid.NewGuid(), CorrelationId = correlationIdHelper.GetCorrelationId(), Frameworks = new List <string> { "Test 1" }, TimeStamp = DateTimeOffset.UtcNow }; // Act dataStore.Add(event1); // Assert var timer = new Stopwatch(); var repository = new TableStorageRepository <TestQueryStrategy, TestQueryBuilder <TestEvent>, TestEvent>(() => dataStore, null); timer.Start(); TestEvent view = repository.Load(event1.Rsn); timer.Stop(); Console.WriteLine("Load operation took {0}", timer.Elapsed); Assert.IsNotNull(view); Assert.AreEqual(event1.Id, view.Id); }
public async Task CanQueryWithSingleIntGreaterThan() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ 8 }, Comparison = Comparisons.GreaterThan }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Level"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(2); results.Any(x => x.Id == "7").ShouldBeTrue(); results.Any(x => x.Id == "8").ShouldBeTrue(); }
public static async Task <ITableStorageRepository <NotifiedSessionEntity> > GetRepositoryAsync(this NewSessionNotificationConfig config) { var repo = new TableStorageRepository <NotifiedSessionEntity>(CloudStorageAccount.Parse(config.ConnectionString), config.Table); await repo.InitializeAsync(); return(repo); }
public async Task CanQueryWithSingleGuidEquals() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ Guid.Parse("9B522321-B689-43EC-A3DC-DC17EE2A42DD") }, Comparison = Comparisons.Equal }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "TypeId"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(2); results.Any(x => x.Id == "2").ShouldBe(true); results.Any(x => x.Id == "5").ShouldBe(true); }
public async Task CanQueryWithSingleDateLessEqualThan() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ new DateTime(2016, 1, 1).ToUtc() }, Comparison = Comparisons.LessThan }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Effective"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(2); results.Any(x => x.Id == "4").ShouldBe(true); results.Any(x => x.Id == "5").ShouldBe(true); }
public async Task CanQueryWithMultipleValueStringsEquals() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ "6", "7", "8" }, Comparison = Comparisons.Equal }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Id"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(3); results.Any(x => x.Id == "6").ShouldBeTrue(); results.Any(x => x.Id == "7").ShouldBeTrue(); results.Any(x => x.Id == "8").ShouldBeTrue(); }
public async Task CanQueryWithMultipleValueGuidsEquals() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object> { Guid.Parse("DE6EFD89-2D62-4E63-98D2-AEA9E622B223"), Guid.Parse("DC742320-F3A4-4DE1-9239-6A9EC68BD430"), Guid.Parse("CC562BC9-C2E5-46D8-B701-E5D57F5800B8") }, Comparison = Comparisons.Equal }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "TypeId"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(3); results.Any(x => x.Id == "8").ShouldBeTrue(); results.Any(x => x.Id == "6").ShouldBeTrue(); results.Any(x => x.Id == "3").ShouldBeTrue(); }
public async Task CanHandleEntityTypeWithStringBasedPartition() { Expression <Func <DocumentDbFoo1, string> > expression = x => x.MyStringCategory; var configurations = GetBaseConfigurations <DocumentDbFoo1>((MemberExpression)expression.Body); TableStorageRepository.Configure(typeof(DocumentDbFoo1), configurations); const string id = "3"; await TableStorageRepository.AddAsync(new DocumentDbFoo1 { Id = id, Name = "Foo 1", MyStringCategory = "cat 1" }, null); await TableStorageRepository.UpdateAsync(new DocumentDbFoo1 { Id = id, Name = "Foo 1 v2", MyStringCategory = "cat 1" }, null); try { var item = (await GetByIdAsync <DocumentDbFoo1>(id)).Single(); item.Name.ShouldBe("Foo 1 v2"); } finally { TableStorageRepository.DeleteAllAsync <DocumentDbFoo1>(null).GetAwaiter().GetResult(); } }
public virtual void Add_ValidProjectionEntityView_ProjectionEntityViewCanBeRetreived() { // Arrange var correlationIdHelper = new CorrelationIdHelper(new ThreadedContextItemCollectionFactory()); correlationIdHelper.SetCorrelationId(Guid.NewGuid()); var logger = new ConsoleLogger(new LoggerSettingsConfigurationSection(), correlationIdHelper); TableStorageDataStore <TestEntity> dataStore = CreateDataStore <TestEntity>(logger, new ConfigurationManager()); var event1 = new TestEntity { Rsn = Guid.NewGuid(), Name = "Name" }; // Act dataStore.Add(event1); // Assert var timer = new Stopwatch(); var repository = new TableStorageRepository <TestQueryStrategy, TestQueryBuilder <TestEntity>, TestEntity>(() => dataStore, null); timer.Start(); TestEntity view = repository.Load(event1.Rsn); timer.Stop(); Console.WriteLine("Load operation took {0}", timer.Elapsed); Assert.IsNotNull(view); Assert.AreEqual(event1.Rsn, view.Rsn); Assert.AreEqual(event1.Name, view.Name); }
private static async void SaveUser() { var r = new TableStorageRepository<User>(new DevelopmentStorageContext(), "Users"); var user = new User { PartitionKey = "user", RowKey = "steve", Name = "Steve Hobbs", }; r.BatchCommitted += (s, a) => { Console.WriteLine("Committed.."); }; r.Insert(user); await r.CommitAsync(); var user2 = await r.SingleAsync(new TableStorageKey("steve", "user")); if (user2 != null) { Console.WriteLine(user2.Name); } var users = await r.QueryAsync(); users.ToList().ForEach(u => Console.WriteLine(u.RowKey)); }
public async Task CanQueryWithSingleDateEquals() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ new DateTime(2017, 1, 1).ToUtc() }, Comparison = Comparisons.Equal }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Effective"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(1); results[0].Id.ShouldBe("1"); await RemoveAll(); }
public static async Task <ITableStorageRepository <Vote> > GetRepositoryAsync(this VotingConfig config) { var repo = new TableStorageRepository <Vote>(CloudStorageAccount.Parse(config.ConnectionString), config.Table); await repo.InitializeAsync(); return(repo); }
public async Task <IActionResult> GetUsers([FromQuery] UserParams userParams) { var repo = new TableStorageRepository(); var CurrentUserId = (User.FindFirst(ClaimTypes.NameIdentifier).Value); userParams.UserId = CurrentUserId; var userLogged = await repo.GetUser(CurrentUserId); if (!string.IsNullOrEmpty(userLogged.Role) && userParams.Team) { userParams.Role = userLogged.Role; if (!string.IsNullOrEmpty(userLogged.Manager_ID)) { userParams.Manager = userLogged.Manager_ID; } } var users = await repo.GetUsers(userParams); var usersToReturn = _mapper.Map <IEnumerable <UserDto> >(users); Response.AddPagination(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages); if (!usersToReturn.Any()) { return(NotFound()); } return(Ok(usersToReturn)); }
static IRepository <CloudTable> GetRepository(string connectionString) { var options = new TableStorageOptions(); var repository = new TableStorageRepository(connectionString, options); return(repository); }
public async Task CanQueryWithSingleIntLessEqualThanWithStringEqual() { await Seed(); QueryParameter[] args = { new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ 2 }, Comparison = Comparisons.LessEqualThan }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Level"), false) }, new QueryParameter { ContextValue = new ContextValue{ Values = new List <object>{ "Foo 4" }, Comparison = Comparisons.Equal }, MemberModel = new ModelMember(_type, _accessor, _members.Single(x => x.Name == "Name"), false) } }; var results = (await TableStorageRepository.QueryAsync <DocumentDbFoo3>("test", args, null, null)).ToList(); results.Count.ShouldBe(1); results[0].Id.ShouldBe("4"); }
public async Task <IActionResult> GiveFeedback(GiveFeedbackDto giveFeedbackDto) { var repo = new TableStorageRepository(); var userToCreate = _mapper.Map <Feedbacks>(giveFeedbackDto); var createdUser = await repo.GiveFeedback(userToCreate); return(Ok(createdUser)); }
public void TableStorageRepository_FindByPartition() { string tablePrefix = "TEST" + Guid.NewGuid().ToString("N"); var data = new TableStorageRepository(ConnectionString, tablePrefix); string tableName = data.GetTable <EsoSale>().Name; var salesByPartition = new Dictionary <int, List <EsoSale> >(); const int saleCount = 100; try { for (int i = 0; i < saleCount; i++) { // Arrange var sale = CreateRandomSale(); data.InsertOrReplace(sale); List <EsoSale> partition; if (!salesByPartition.TryGetValue(sale.TimestampId, out partition)) { partition = new List <EsoSale>(); salesByPartition.Add(sale.TimestampId, partition); } // Act partition.Add(sale); } foreach (int timestampId in salesByPartition.Keys) { // Arrange List <EsoSale> expectedSales = salesByPartition[timestampId]; // Act EsoSale[] partitionSales = data.Find <EsoSale>(timestampId.ToString(CultureInfo.InvariantCulture)).ToArray(); // Assert EsoSale missingSale = partitionSales.FirstOrDefault(x => expectedSales.All(y => y.RowKey != x.RowKey)); if (missingSale != null) { Assert.Fail("Table {0} Partition {1} missing expected entity with row key {2}", tableName, missingSale.PartitionKey, missingSale.RowKey); } EsoSale extraSale = expectedSales.FirstOrDefault(x => partitionSales.All(y => y.RowKey != x.RowKey)); if (extraSale != null) { Assert.Fail("Table {0} Partition {1} contains unexpected entity with row key {2}", tableName, extraSale.PartitionKey, extraSale.RowKey); } } } finally { // Clean up data.RemoveTable <EsoSale>(); } }
public void InitializeNewQuery_Should_CreateNewTableQuery() { var mockContext = new StorageContextMockFactory().CreateStorageContextMock(); var provider = new TableStorageUnitOfWorkProvider(uowRegistry, () => mockContext.Object); var repository = new TableStorageRepository <Musician>(provider, new LocalDateTimeProvider()); var query = repository.InitializeNewQuery(); Assert.NotNull(query); }
public async Task <IActionResult> SoftDeleteAdmin(UserDto userDto) { var repo = new TableStorageRepository(); var cards = await repo.GetUser(userDto.ID); _mapper.Map(userDto, cards); await repo.PostEntityUser(cards); return(Ok()); }
public void InitializeNew_Should_SetPartitionKeyAndRowKey() { var mockContext = new StorageContextMockFactory().CreateStorageContextMock(); var provider = new TableStorageUnitOfWorkProvider(uowRegistry, () => mockContext.Object); var repository = new TableStorageRepository <Musician>(provider, new LocalDateTimeProvider()); var employee = repository.InitializeNew("Doe", "*****@*****.**"); Assert.Equal("Doe", employee.PartitionKey); Assert.Equal("*****@*****.**", employee.RowKey); }
public async Task <IActionResult> UpdateUser(string id, UpdateUserDto requestUpdate) { var repo = new TableStorageRepository(); var cards = await repo.GetUser(id); _mapper.Map(requestUpdate, cards); await repo.PostEntityUser(cards); return(Ok()); }
public CustomControllerCache() { UnitOfWork = new UnitOfWorkCQRS(new EscarGoContext()); QueueRepositoryAsync = new QueueRepositoryAsync(); ITableStorageRepository tablestorageRepository = new TableStorageRepository(); IRedisRepository redisRepository = new RedisRepository(tablestorageRepository); Builder = new ViewModelBuilderQueue(UnitOfWork, redisRepository); TicketModelBuilder = new TicketModelBuilderCache(UnitOfWork, QueueRepositoryAsync); }
public TableStorageRepositoryQueryTests() { Expression <Func <DocumentDbFoo3, string> > expression = x => x.Category; var configurations = GetBaseConfigurations <DocumentDbFoo3>((MemberExpression)expression.Body); TableStorageRepository.Configure(typeof(DocumentDbFoo3), configurations); _accessor = TypeAccessor.Create(_type); _members = _accessor.GetMembers(); }
public override void Given() { this.TableStorageContext = new Mock<ITableStorageContext> { DefaultValue = DefaultValue.Mock }; var userConfiguration = new UserConfiguration { UserId = TestValues.USER_ID }; this.TableStorageContext .Setup(x => x.UserConfigurations.GetByNameIdentifier()) .Returns(userConfiguration); this.TableStorageRepository = new TableStorageRepository<Card>(this.TableStorageContext.Object); }
protected TableStorageRepositoryTestsBase() { TableStorageRepository = new TableStorageRepository(Extensions.GetLogger <TableStorageRepository>(), new List <ITableStorageComparison> { new TableStorageComparisonBool(), new TableStorageComparisonInt(), new TableStorageComparisonString(), new TableStorageComparisonDate(), new TableStorageComparisonGuid() }); }
public async Task <IActionResult> RequestFeedback(RequestFeedbackDto requestFeedbackDto, string id) { //validate var repo = new TableStorageRepository(); var requestToCreate = _mapper.Map <Feedbacks>(requestFeedbackDto); var createdRequest = await repo.RequestFeedback(requestToCreate, id); return(Ok(createdRequest)); }
private static async Task <(ITableStorageRepository <SessionEntity>, ITableStorageRepository <PresenterEntity>)> GetSessionRepositoryAsync(string connectionString, string sessionsTable, string presentersTable) { var storageAccount = CloudStorageAccount.Parse(connectionString); var sessionsRepo = new TableStorageRepository <SessionEntity>(storageAccount, sessionsTable); var presentersRepo = new TableStorageRepository <PresenterEntity>(storageAccount, presentersTable); await sessionsRepo.InitializeAsync(); await presentersRepo.InitializeAsync(); return(sessionsRepo, presentersRepo); }
public static async Task <(ITableStorageRepository <ConferenceFeedbackEntity>, ITableStorageRepository <SessionFeedbackEntity>)> GetRepositoryAsync(this FeedbackConfig feedback) { var storageAccount = CloudStorageAccount.Parse(feedback.ConnectionString); var conferenceFeedbackRepository = new TableStorageRepository <ConferenceFeedbackEntity>(storageAccount, feedback.ConferenceFeedbackTable); var sessionFeedbackRepository = new TableStorageRepository <SessionFeedbackEntity>(storageAccount, feedback.SessionFeedbackTable); await conferenceFeedbackRepository.InitializeAsync(); await sessionFeedbackRepository.InitializeAsync(); return(conferenceFeedbackRepository, sessionFeedbackRepository); }
protected TableStorageRepositoryTestsBase() { TableStorageRepository = new TableStorageRepository(Substitute.For <ILogger>(), new List <ITableStorageComparison> { new TableStorageComparisonBool(), new TableStorageComparisonInt(), new TableStorageComparisonString(), new TableStorageComparisonDate(), new TableStorageComparisonGuid() }); }
public static async void Run([QueueTrigger("delete-posts-from-track", Connection = "QUEUESTORAGE_CONNECTION")] CloudQueueMessage trackId, TraceWriter log) { List <string> listOfPostsToDelete = await PostRepository.GetPostIdsInTrack(trackId.AsString); foreach (var postId in listOfPostsToDelete) { TableStorageRepository.AddMessageToQueue("process-delete-post", $"{trackId.AsString}.{postId}"); } log.Info($"Added all posts in track to delete queue: {trackId.AsString}"); }
public static void Main() { ITableStorageRepository<Person> personRespository = new TableStorageRepository<Person>(); Person userToStore = new Person { Id = 1, Name = "Chetan", PartitionKey = "Person", RowKey = string.Format("{0}-{1}", 1, "Chetan"), }; personRespository.CreateTable(); personRespository.Put(userToStore); var retrievedUser = personRespository.Get(userToStore.RowKey); }
public override void Given() { this.TableStorageContext = new Mock<ITableStorageContext> { DefaultValue = DefaultValue.Mock }; this.TableStorageRepository = new TableStorageRepository<UserConfiguration>(this.TableStorageContext.Object); }