public async Task <IHttpActionResult> PutUser(int id, Models.Users.User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != user.IdUser)
{
return(BadRequest());
}
db.Entry(user).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public string SaveUser(Models.Users.User user)
{
user.Validate();
var result = context.SaveUser(user);
return(result);
}
public async Task <Models.Users.User> FindByEmailAsync(string normalizedEmail)
{
var createResponse = await CosmosClient.CreateDatabaseIfNotExistsAsync(_DatabaseName, _DatabaseThroughput);
var database = createResponse.Database;
var containerProperties = new ContainerProperties(_UserContainerName, _UserContainerPartitionKeyPath);
var containerResponse = await database.CreateContainerIfNotExistsAsync(
containerProperties,
_UserContainerThroughput);
var container = containerResponse.Container;
var query = new QueryDefinition($"SELECT * FROM {_UserContainerName} c WHERE UPPER(c.NormalizedEmail) = @NormalizedEmail")
.WithParameter("@NormalizedEmail", normalizedEmail);
var queryIterator = container.GetItemQueryIterator <Models.Users.User>(query, requestOptions: new QueryRequestOptions()
{
MaxConcurrency = 1
});
Models.Users.User user = null;
while (queryIterator.HasMoreResults)
{
var response = await queryIterator.ReadNextAsync();
user = response.FirstOrDefault();
}
return(user);
}
public async Task <bool> HasPasswordAsync(Models.Users.User user)
{
var createResponse = await CosmosClient.CreateDatabaseIfNotExistsAsync(_DatabaseName, _DatabaseThroughput);
var database = createResponse.Database;
var containerProperties = new ContainerProperties(_UserContainerName, _UserContainerPartitionKeyPath);
var containerResponse = await database.CreateContainerIfNotExistsAsync(
containerProperties,
_UserContainerThroughput);
var container = containerResponse.Container;
var query = new QueryDefinition($"SELECT * FROM {_UserContainerName} c WHERE c.UserId = @UserId")
.WithParameter("@UserId", user.UserId);
var queryIterator = container.GetItemQueryIterator <Models.Users.User>(query, requestOptions: new QueryRequestOptions()
{
MaxConcurrency = 1
});
Models.Users.User userDb = null;
while (queryIterator.HasMoreResults)
{
var response = await queryIterator.ReadNextAsync();
userDb = response.FirstOrDefault();
}
return(!string.IsNullOrEmpty(userDb.PasswordHash));
}
public CostumerCart Edit(Models.Users.User user, CostumerCart model, CancellationToken cancellationToken = default)
{
var toEdit = Cache.Get <CostumerCart>(user.UserId);
Cache.Set(user.UserId, Map(toEdit, model));
return(model);
}
private static Persistence.EntityFramework.Entities.User Map(Models.Users.User model)
{
return(new Persistence.EntityFramework.Entities.User()
{
UserId = model.UserId,
Username = model.Username,
Email = model.Email,
Registered = model.Registered,
});
}
public async Task Delete(Models.Users.User model, CancellationToken cancellationToken = default)
{
var userDb = await DbContext.Users
.Where(x => x.UserId == model.UserId)
.FirstOrDefaultAsync(cancellationToken);
DbContext.Users.Remove(userDb);
await DbContext.SaveChangesAsync(cancellationToken);
}
public async Task <IHttpActionResult> GetUser(int id)
{
Models.Users.User user = await db.Users.FindAsync(id);
if (user == null)
{
return(NotFound());
}
return(Ok(user));
}
public async Task <Models.Users.User> Edit(Models.Users.User model, CancellationToken cancellationToken = default)
{
var userDb = await DbContext.Users
.FirstOrDefaultAsync(x => x.UserId == model.UserId, cancellationToken);
userDb = DbContext.Users.Update(Map(userDb, model)).Entity;
await DbContext.SaveChangesAsync(cancellationToken);
return(Map(userDb));
}
public async Task <IHttpActionResult> PostUser(Models.Users.User user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Users.Add(user);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = user.IdUser }, user));
}
public async Task <IHttpActionResult> DeleteUser(int id)
{
Models.Users.User user = await db.Users.FindAsync(id);
if (user == null)
{
return(NotFound());
}
db.Users.Remove(user);
await db.SaveChangesAsync();
return(Ok(user));
}
public void User_ShouldBeSetAndGottenCorrectly()
{
//Arrange
var user = new Models.Users.User();
//Act
var regularUser = new Models.Users.RegularUser()
{
User = user
};
//Assert
Assert.AreSame(user, regularUser.User);
Assert.AreEqual(user.Id, regularUser.User.Id);
}
public void User_ShouldBeSetAndGottenCorrectly()
{
//Arrange
var user = new Models.Users.User();
//Act
var admin = new Models.Users.Admin()
{
User = user
};
//Assert
Assert.AreSame(user, admin.User);
Assert.AreEqual(user.Id, admin.User.Id);
}
public async Task <bool> UpdateUserAsync(Models.Users.User user)
{
var createResponse = await CosmosClient.CreateDatabaseIfNotExistsAsync(_DatabaseName, _DatabaseThroughput);
var database = createResponse.Database;
var containerProperties = new ContainerProperties(_UserContainerName, _UserContainerPartitionKeyPath);
var containerResponse = await database.CreateContainerIfNotExistsAsync(
containerProperties,
_UserContainerThroughput);
var container = containerResponse.Container;
var query = new QueryDefinition($"SELECT * FROM {_UserContainerName} c WHERE c.UserId = @UserId")
.WithParameter("@UserId", user.UserId);
var queryIterator = container.GetItemQueryIterator <Models.Users.User>(query, requestOptions: new QueryRequestOptions()
{
MaxConcurrency = 1
});
Models.Users.User userDb = null;
while (queryIterator.HasMoreResults)
{
var response = await queryIterator.ReadNextAsync();
user = response.FirstOrDefault();
}
if (userDb == null)
{
return(false);
}
else
{
userDb = user;
var upsertItemResponse = await container.UpsertItemAsync(userDb, new PartitionKey(user.UserId));
if (upsertItemResponse.StatusCode == HttpStatusCode.Created || upsertItemResponse.StatusCode == HttpStatusCode.OK)
{
return(true);
}
return(false);
}
}
public async Task CreateUserAsync(string realm)
{
var user = new Models.Users.User()
{
UserName = "******",
Enabled = true,
EmailVerified = true,
FirstName = "testfirstname1",
LastName = "testlastname1",
Email = "*****@*****.**"
};
var result = await _client.CreateUserAsync(realm, user);
Assert.False(string.IsNullOrWhiteSpace(result), "Created user ID not returned");
}
public string SaveUser(Models.Users.User user)
{
logger.LogInformation($"User - userId - {user.Id}");
logger.LogTrace($"User - userId - {user.Id}", user.Id);
if (string.IsNullOrEmpty(user.Id))
{
user.Id = Guid.NewGuid().ToString();
//context.Users.Add(user);
}
else
{
//context.Users.Update(user);
}
//context.SaveChanges();
return(user.Id);
}
public async Task SetNormalizedUserNameAsync(Models.Users.User user, string normalizedName)
{
var createResponse = await CosmosClient.CreateDatabaseIfNotExistsAsync(_DatabaseName, _DatabaseThroughput);
var database = createResponse.Database;
var containerProperties = new ContainerProperties(_UserContainerName, _UserContainerPartitionKeyPath);
var containerResponse = await database.CreateContainerIfNotExistsAsync(
containerProperties,
_UserContainerThroughput);
var container = containerResponse.Container;
var query = new QueryDefinition($"SELECT * FROM {_UserContainerName} c WHERE c.UserId = @UserId")
.WithParameter("@UserId", user.UserId);
var queryIterator = container.GetItemQueryIterator <Models.Users.User>(query, requestOptions: new QueryRequestOptions()
{
MaxConcurrency = 1
});
Models.Users.User userDb = null;
while (queryIterator.HasMoreResults)
{
var response = await queryIterator.ReadNextAsync();
user = response.FirstOrDefault();
}
if (userDb == null)
{
return;
}
else
{
user.NormalizedUserName = normalizedName;
await container.UpsertItemAsync(user, new PartitionKey(user.UserId));
}
}
public CostumerCart EditProductQuantity(Models.Users.User user, Models.Products.Product product, int quantity, CancellationToken cancellationToken = default)
{
var toEdit = Cache.Get <CostumerCart>(user.UserId);
var foundProduct = toEdit.CartProducts.FirstOrDefault(x => x.Product.ProductId == product.ProductId);
if (foundProduct != null)
{
if (quantity > 0)
{
foundProduct.Quantity = quantity;
}
else
{
toEdit.CartProducts.Remove(foundProduct);
}
}
Cache.Set(user.UserId, toEdit);
return(toEdit);
}
public CostumerCart AddProduct(Models.Users.User user, Models.Products.Product product, CancellationToken cancellationToken = default)
{
var toEdit = Cache.Get <CostumerCart>(user.UserId);
var foundProduct = toEdit.CartProducts.FirstOrDefault(x => x.Product.ProductId == product.ProductId);
if (foundProduct != null)
{
++foundProduct.Quantity;
}
else
{
toEdit.CartProducts.Add(new OrderProduct()
{
Product = product, Quantity = 1
});
}
Cache.Set(user.UserId, toEdit);
return(toEdit);
}
public async Task <bool> CreateUserAsync(Models.Users.User user)
{
var createResponse = await CosmosClient.CreateDatabaseIfNotExistsAsync(_DatabaseName, _DatabaseThroughput);
var database = createResponse.Database;
var containerProperties = new ContainerProperties(_UserContainerName, _UserContainerPartitionKeyPath);
var containerResponse = await database.CreateContainerIfNotExistsAsync(
containerProperties,
_UserContainerThroughput);
var container = containerResponse.Container;
var createItemResponse = await container.CreateItemAsync(user, new PartitionKey(user.UserId));
if (createItemResponse.StatusCode == HttpStatusCode.Created || createItemResponse.StatusCode == HttpStatusCode.OK)
{
return(true);
}
return(false);
}
public ActionResult <string> Post([FromBody] Models.Users.User user)
{
var result = context.SaveUser(user);
return(Ok(result));
}
public bool Exists(Models.Users.User user, CancellationToken cancellationToken = default)
{
return(Cache.TryGetValue <CostumerCart>(user.UserId, out _));
}
public void Delete(Models.Users.User user, CancellationToken cancellationToken = default)
{
var toEdit = Cache.Get <CostumerCart>(user.UserId);
Cache.Remove(toEdit);
}
public Task InsertAsync(Models.Users.User user)
{
return(GetUserCollection().InsertOneAsync(user));
}
public Task UpdateAsync(string id, Models.Users.User user)
{
return(GetUserCollection().FindOneAndReplaceAsync(i => string.Equals(i.Id, id), user));
}
public async Task <Models.Users.User> Update(Models.Users.User user)
{
return(await _userRepository.Update(user));
}
public string SaveUser(Models.Users.User user)
{
return(MockData.Users.UserData.FirstUser.Id);
}
public Permissions(Models.Users.User user)
{
}
private static Persistence.EntityFramework.Entities.User Map(Persistence.EntityFramework.Entities.User userDb, Models.Users.User model)
{
userDb.Username = model.Username;
userDb.Email = model.Email;
userDb.Registered = userDb.Registered;
return(userDb);
}
public async Task <Models.Users.User> Create(Models.Users.User model, CancellationToken cancellationToken = default)
{
var userEntry = await DbContext.Users.AddAsync(Map(model), cancellationToken);
return(Map(userEntry.Entity));
}
