public async Task <TenantDTO> UpdateTenantAsync(TenantDTO tenantDto)
{
Tenant?fromDB = await _context.Tenants.FindAsync(tenantDto.Id);
if (fromDB == null)
{
throw new ItemNotFoundExcepton("Tenant");
}
tenantDto.CopyTo(fromDB);
_context.Entry(fromDB).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
_logger.LogInformation(ex, "Concurrency exception saving changes to {TenatnID}, {TenantName}", fromDB.Id, fromDB.Name);
throw;
}
TenantDTO returnValue = new TenantDTO(fromDB);
return(returnValue);
}
public async Task <IActionResult> PutTenant(Guid tenantId, TenantDTO tenantDTO)
{
_logger.LogDebug("Updating tenant {TenantID} by {User}", tenantId, User?.Identity?.Name);
if (tenantId != tenantDTO.Id)
{
_logger.LogInformation("Requested Id {TenantID} did not match request data {DTOTenantID}", tenantId, tenantDTO.Id);
return(BadRequest());
}
try
{
await _tenantService.UpdateTenantAsync(tenantDTO);
_logger.LogInformation("Updated tenant {TenantName} with id {TenantID}", tenantDTO.Name, tenantDTO.Id);
}
catch (ItemNotFoundExcepton ex)
{
_logger.LogWarning(ex, "Unable to find tenant {TenantID}", tenantId);
return(NotFound());
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Problem updating tenant {TenantID}", tenantId);
throw;
}
return(NoContent());
}
public async Task <ActionResult> PutTenant(string tenantId, [FromBody] TenantDTO tenantDTO)
{
if (tenantId == null)
{
return(BadRequest("Tenant id is invalid"));
}
if (_tenantRepository.GetById(Guid.Parse(tenantId)) == null)
{
return(BadRequest("Tenant id is not valid"));
}
if (ModelState.IsValid)
{
Tenant tenantToUpdate = await _tenantRepository.FirstOrDefault(tenant => tenant.Id == Guid.Parse(tenantId));
tenantToUpdate.CompanyName = tenantDTO.CompanyName;
tenantToUpdate.CompanyStrength = tenantDTO.CompanyStrength;
await _tenantRepository.Update(tenantToUpdate);
return(Ok("Tenant Updated successfully"));
}
else
{
return(BadRequest("Please provide all fields"));
}
}
public void Version_Is_Transferred_Correctly(TenantDTO dto, byte[] versionBytes)
{
//Version needs to be a valid base 64 string
dto.Version = Convert.ToBase64String(versionBytes);
Tenant tenant = dto.ToTenant();
Assert.Equal(versionBytes, tenant.ConcurrencyToken);
}
public void All_Values_Are_Copied_To_Tenant(TenantDTO dto, byte[] versionBytes)
{
//Version needs to be a valid base 64 string
dto.Version = Convert.ToBase64String(versionBytes);
Tenant tenant = dto.ToTenant();
AssertAdditions.AllPropertiesAreEqual(tenant, dto, nameof(tenant.ConcurrencyToken), nameof(tenant.CreatedTime));
}
public void Add(TenantDTO tenantDTO)
{
var tenant = TenantFactory.Create(tenantDTO.Descricao);
ValideTenant(tenant);
_repositoryFactory.TenantRepository.Add(tenant);
_repositoryFactory.Commit();
}
public void Round_Trip_Concurrency_Token(Tenant tenant)
{
TenantDTO dto = new TenantDTO(tenant);
Tenant converted = dto.ToTenant();
Assert.NotSame(tenant, converted);
Assert.NotSame(tenant.ConcurrencyToken, converted.ConcurrencyToken);
Assert.Equal(tenant.ConcurrencyToken, converted.ConcurrencyToken);
}
public async void PutTenant_NullIdPassed_ReturnsBadRequest()
{
TenantDTO tenantToPut = new TenantDTO {
CompanyName = "MQU Corps", CompanyStrength = 1500
};
var resultOnTenantUpdate = await _tenantController.PutTenant(null, tenantToPut);
Assert.IsType <BadRequestObjectResult>(resultOnTenantUpdate);
}
public async Task <IActionResult> Create([FromBody] TenantDTO tenant)
{
var createdTenant = await _tenantManager.Add(Mapper.Map <Tenant>(tenant));
if (createdTenant.Item1 == null)
{
return(BadRequest(new BadRequestResponse(ModelState, ExceptionKeyHelper.GetString(createdTenant.Item2.Value))));
}
return(CreatedAtAction("GetById", new { id = createdTenant.Item1.Id }, new CreatedResponse(Mapper.Map <TenantDTO>(createdTenant.Item1), 1)));
}
public async void AddTenant_OnModelError_ReturnsBadRequest()
{
_tenantController.ModelState.AddModelError("CompanyName", "Company name is required");
TenantDTO tenantToAdd = new TenantDTO {
CompanyStrength = 1500
};
var resultOnTenantAdd = await _tenantController.AddTenant(tenantToAdd);
Assert.IsType <BadRequestObjectResult>(resultOnTenantAdd);
}
public async void PutTenant_ModelError_ReturnsBadRequest()
{
_tenantController.ModelState.AddModelError("CompanyName", "Company name is required");
TenantDTO tenantToPut = new TenantDTO {
CompanyStrength = 1500
};
var resultOnTenantUpdate = await _tenantController.PutTenant(new Guid().ToString(), tenantToPut);
Assert.IsType <BadRequestObjectResult>(resultOnTenantUpdate);
}
public void Over_Rides_Correct_Values_On_Copy(Tenant fromDb, TenantDTO fromUser)
{
fromUser.Id = fromDb.Id;
fromUser.Version = fromUser.Version != null?Convert.ToBase64String(Encoding.UTF8.GetBytes(fromUser.Version)) : null;
Assert.NotEqual(fromDb.Name, fromUser.Name);
fromUser.CopyTo(fromDb);
AssertAdditions.AllPropertiesAreEqual(fromDb, fromUser, nameof(fromDb.ConcurrencyToken), nameof(fromDb.CreatedTime));
}
public void All_Values_Are_Copied_To_DTO(Tenant tenant)
{
TenantDTO dto = new TenantDTO(tenant);
AssertAdditions.AllPropertiesAreEqual(dto, tenant, nameof(dto.Version), nameof(dto.CreatedTime));
Assert.NotNull(tenant.CreatedTime);
if (tenant.CreatedTime != null)
{
Assert.Equal(tenant.CreatedTime.Value, dto.CreatedTime);
}
}
public async Task <TenantDTO> GetTenantAsync(Guid tenantId)
{
Tenant?tenant = await _context.Tenants.FindAsync(tenantId);
if (tenant == null)
{
throw new ItemNotFoundExcepton("Tenant");
}
TenantDTO returnValue = new TenantDTO(tenant);
return(returnValue);
}
public async Task <ActionResult> PostTenant([FromBody] TenantDTO tenantDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Tenant not added properly"));
}
Tenant tenant = new Tenant {
TenantName = tenantDto.TenantName, CompanyStrength = tenantDto.CompanyStrength
};
await _repository.Add(tenant);
return(Ok(tenant));
}
public ActionResult Index(TenantDTO tenantDTO)
{
try
{
AppServiceFactory.TenantAppService.Add(tenantDTO);
}
catch (Exception ex)
{
ControllerError.Processing(this, ex, false);
}
return(RedirectToAction("index"));
}
public TenantViewModel(TenantDTO tenantDTO, IEnumerable <IdNameReferenceItem> categories, IEnumerable <IdNameReferenceItem> products)
{
Id = tenantDTO.Id;
CreatedTime = tenantDTO.CreatedTime.LocalDateTime;
Name = tenantDTO.Name;
Route = tenantDTO.Route;
CreatorEmail = tenantDTO.CreatorEmail;
ProductTierId = tenantDTO.ProductTierId;
ProductName = products.ElementAtOrDefault(tenantDTO.ProductTierId - 1)?.Name ?? "Free";
CategoryId = tenantDTO.CategoryId;
CategoryName = categories.ElementAtOrDefault(tenantDTO.CategoryId - 1)?.Name ?? "Unknown";
Version = tenantDTO.Version;
}
public async Task <ActionResult> AddTenant([FromBody] TenantDTO tenantDTO)
{
if (ModelState.IsValid)
{
await _tenantRepository.Add(new Tenant { CompanyName = tenantDTO.CompanyName, CompanyStrength = tenantDTO.CompanyStrength });
return(Ok("Tenant added successfully"));
}
else
{
return(BadRequest("Please check if all the field values are provided"));
}
}
/// <summary>
/// Saves a new tenant or updates an already existing tenant.
/// </summary>
/// <param name="tenant">Tenant to be saved or updated.</param>
/// <param name="tenantId">TenantId of the tenant creating or updating</param>
/// <returns>tenantId</returns>
public long SaveTenant(TenantDTO tenantDTO, string userId)
{
long tenantId = 0;
if (tenantDTO.TenantId == 0)
{
var tenant = new Tenant()
{
FirstName = tenantDTO.FirstName,
LastName = tenantDTO.LastName,
Email = tenantDTO.Email,
MobileNumber = tenantDTO.MobileNumber,
HouseId = tenantDTO.HouseId,
CreatedOn = DateTime.Now,
Timestamp = DateTime.Now,
CreatedBy = userId,
Deleted = false,
};
this.UnitOfWork.Get <Tenant>().AddNew(tenant);
this.UnitOfWork.SaveChanges();
tenantId = tenant.TenantId;
return(tenantId);
}
else
{
var result = this.UnitOfWork.Get <Tenant>().AsQueryable()
.FirstOrDefault(e => e.TenantId == tenantDTO.TenantId);
if (result != null)
{
result.FirstName = tenantDTO.FirstName;
result.LastName = tenantDTO.LastName;
result.Email = tenantDTO.Email;
result.MobileNumber = tenantDTO.MobileNumber;
result.HouseId = tenantDTO.HouseId;
result.Timestamp = DateTime.Now;
result.Deleted = tenantDTO.Deleted;
result.DeletedBy = tenantDTO.DeletedBy;
result.DeletedOn = tenantDTO.DeletedOn;
this.UnitOfWork.Get <Tenant>().Update(result);
this.UnitOfWork.SaveChanges();
}
return(tenantDTO.TenantId);
}
return(tenantId);
}
public TenantDTO GetCreatedLimit(UserInfo MyUserInfo)
{
TenantDTO TenantsInfo = null;
try
{
TenantsInfo = this._db.Query <TenantDTO>("SELECT * from tenants WHERE Id = @Id", new { Id = MyUserInfo.TenantId }).FirstOrDefault();
}
catch (Exception ex)
{
//TODO
var MessageError = ex.ToString();
}
return(TenantsInfo);
}
public void User_Cant_Override_Created_Date(Tenant tenant, DateTime original, DateTime updated)
{
Assert.NotEqual(original, updated);
tenant.CreatedTime = original;
TenantDTO dto = new TenantDTO(tenant)
{
CreatedTime = updated
};
Assert.NotEqual(tenant.CreatedTime, dto.CreatedTime);
dto.CopyTo(tenant);
Assert.Equal(original, tenant.CreatedTime);
}
public async Task <ActionResult> PutTenant([FromBody] TenantDTO tenantDto, Guid tenantId)
{
if (await _repository.GetById(tenantId) == null)
{
return(BadRequest("Invalid tenant id"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Tenant not updated properly"));
}
Tenant tenant = await _repository.GetById(tenantId);
tenant.TenantName = tenantDto.TenantName;
tenant.CompanyStrength = tenantDto.CompanyStrength;
await _repository.Update(tenant);
return(Ok("Tenant Updated Successfully.."));
}
public async Task <ActionResult <TenantDTO> > PostTenant(NewTenantRequest tenantRequest)
{
try
{
_logger.LogInformation("Creating a new tenant: {NewTenantName} for {OwnerID}, requested by {User}", tenantRequest.Name, tenantRequest.CreatorEmail, User?.Identity?.Name);
TenantDTO tenant = await _tenantService.AddTenantAsync(tenantRequest, User?.GetNameIdentifierId() !);
_logger.LogInformation("Created a new tenant {NewTenantName} with URL {NewTenantRoute}, and ID {NewTenantID}", tenant.Name, tenant.Route, tenant.Id);
return(CreatedAtAction(nameof(GetTenant), new { tenantId = tenant.Id }, tenant));
}
catch (DbUpdateException ex)
{
return(BadRequest((ex.InnerException ?? ex).Message));
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Problem creating tenant with ID {TenantName}", tenantRequest.Name);
throw;
}
}
public async Task <ActionResult <TenantDTO> > GetTenant(Guid tenantId)
{
_logger.LogDebug("{User} requested tenant with ID {TeanntID}", User?.Identity?.Name, tenantId);
try
{
TenantDTO tenant = await _tenantService.GetTenantAsync(tenantId);
_logger.LogDebug("Found {TenantName} with {TenantID}", tenant.Name, tenantId);
return(Ok(tenant));
}
catch (ItemNotFoundExcepton)
{
_logger.LogDebug("Was not able to find tenant with ID {TeantntID}", tenantId);
return(NotFound());
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Problem retrieving tenant with ID {TeantntID}", tenantId);
throw;
}
}
public async Task <IActionResult> Edit(string id, [Bind("Id,Name,Route,ProductTierId,CategoryId,CreatorEmail")] TenantDTO tenant)
{
Guid guid = new Guid();
if (!Guid.TryParse(id, out guid) || guid != tenant.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _adminServiceClient.TenantsPUTAsync(guid, tenant);
}
catch (ApiException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(tenant));
}
public async Task <Tenant> GetTenantAsync(string identifier)
{
// Get tenant from cache
TenantDTO data = cache.Get <TenantDTO>(identifier);
// Check if exists in cache
if (data is null)
{
// Get tentant from repository if it is null
data = await repository.GetTenantAsync(identifier);
// Throw an error if it not exists in the database
if (data is null)
{
throw new ArgumentException($"The tenant with identifier {identifier} were not found.");
}
// Persist in cache
await cache.Add(identifier, data).ConfigureAwait(false);
}
// Return a new instance of tenant
return(new Tenant(data));
}
public async Task <TenantDTO> AddTenantAsync(NewTenantRequest newTenantRequest, string adminId)
{
Tenant tenant = newTenantRequest.ToTenant();
_context.Tenants.Add(tenant);
await _context.SaveChangesAsync();
try
{
await _permissionService.AddUserPermissionsToTenantAsync(tenant.Id.ToString(), adminId, AppConstants.Roles.TenantAdmin);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error setting permission for tenant {tenantName}", newTenantRequest.Name);
_context.Tenants.Remove(tenant);
await _context.SaveChangesAsync();
throw;
}
TenantDTO?returnValue = new TenantDTO(tenant);
return(returnValue);
}
public void ConcurrencyToken_Is_Transfereed_Correctly(Tenant tenant)
{
TenantDTO dto = new TenantDTO(tenant);
Assert.Equal(Convert.ToBase64String(tenant.ConcurrencyToken ?? Array.Empty <byte>()), dto.Version);
}
public UserDTO creatingUsers(string Firstname, string lastname, string useremail, string password, string tenantname,
int subscriptionid, SubscriptionDTO MySubscriptionInfo)
{
UserDTO userDTO = null;
TenantDTO tenantDTO = null;
DateTime SubscriptionEnd = DateTime.Now;
string TenantsQuery = "";
DateTime FirstDay = DateTime.Now;
DateTime LastDay = DateTime.Now;
try
{
int year = DateTime.Now.Year;
FirstDay = new DateTime(year, 1, 1);
LastDay = new DateTime(year, 12, 31);
if (MySubscriptionInfo.SubscriptionDays > 0)
{
SubscriptionEnd = DateTime.Now.AddDays(MySubscriptionInfo.SubscriptionDays);
}
TenantsQuery = @"INSERT tenants(tenantName,subscriptionId,subscriptionEnd,noOfUsers,creditLimit)
values(@tenantName,@subscriptionId,@subscriptionEnd,@noOfUsers,@creditLimit)";
int rowsAffected = this._db.Execute(TenantsQuery,
new
{
tenantName = tenantname,
subscriptionId = subscriptionid,
subscriptionEnd = SubscriptionEnd,
noOfUsers = MySubscriptionInfo.noOfUser,
creditLimit = MySubscriptionInfo.creditLimit
}
);
if (rowsAffected != 0)
{
tenantDTO = this._db.Query <TenantDTO>("SELECT * FROM tenants order by Id desc limit 1").FirstOrDefault();
int rowsAffected1 = _db.Execute(@"INSERT users(userTypeId,firstName,lastName,userName,userEmail,userPassword,tenantId,roleId,isFirstTime,isCustom,fromDate,toDate)
values (@userTypeId,@firstName,@lastName,@userName,@userEmail,@userPassword,@tenantId,@roleId,@isFirstTime,@isCustom,@fromDate,@toDate)",
new
{
userTypeId = 1,
firstName = Firstname,
lastname = lastname,
userName = Firstname + " " + lastname,
userEmail = useremail,
userPassword = password,
tenantId = tenantDTO.ID,
roleId = 1,
isFirstTime = 1,
isCustom = 1,
fromDate = FirstDay,
toDate = LastDay
});
if (rowsAffected1 != 0)
{
userDTO = this._db.Query <UserDTO>("SELECT * FROM users order by Id desc limit 1").FirstOrDefault();
}
}
}
catch (Exception exp)
{
var ErrorMessage = exp.ToString();
}
return(userDTO);
}
