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