public async Task <TenantDto> PutTenant(int id, TenantDto model) { var url = CRMApiUri + "/Tenant/" + id; var result = await PutRequestToApi(url, model); return(result); }
public async Task <TenantDto> PostTenant(TenantDto model) { var url = CRMApiUri + "/Tenant"; var result = await PostRequestToApi(url, model); return(result); }
public async Task <int> Create(TenantDto tenantDto) { int tenantId = await _tenantManager.Create(_mapper.Map <Tenant>(tenantDto)); _userSession.TenantId = tenantId; try { IdentityResult userCreationResult = await _userManager.CreateAsync(new User { UserName = "******" + "-" + _userSession.TenantId.ToString(), Email = tenantDto.Email, EmailConfirmed = true, }, "123@Qwe"); if (!userCreationResult.Succeeded) { throw new Exception("Error creating Tenant admin user. " + userCreationResult.Errors); } return(tenantId); } catch (Exception ex) { throw new Exception("Error creating Tenant admin user. " + ex.Message); } }
public async Task <TenantDto> GetById(int id) { try { if (id > 0) { var tenantObj = await _dbContext.TenantPersonnels.Where(s => s.Id == id).Include(s => s.GenderFk).FirstOrDefaultAsync(); var tenant = new TenantDto { FirstName = tenantObj.FirstName, LastName = tenantObj.LastName, MiddleName = tenantObj.MiddleName, Active = tenantObj.Active, DOB = tenantObj.DOB, GenderFk = tenantObj.GenderFk, PrefixId = tenantObj.PrefixId, NickName = tenantObj.NickName, TenantId = tenantObj.TenantId }; return(tenant); } else { return(null); } } catch (Exception ex) { throw ex; } }
public async Task <IActionResult> Put(Guid id, [FromBody] TenantDto tenantDto) { if (tenantDto == null) { return(InvalidRequestBodyJson(nameof(TenantDto))); } if (id.ToString() != tenantDto.Id) { return(BadRequest("Conflicting or missing tenant id in model data versus the URL")); } if (tenantDto.PrimaryContact == null) { AddErrors(new[] { "Model must have contact information defined" }); return(BadRequest()); } if (tenantDto.ServiceDetails == null) { AddErrors(new[] { "Model must have service information defined" }); return(BadRequest(ModelState)); } var tenant = await _tenantService.GetAsync(id); Mapper.Map(tenantDto, tenant, typeof(TenantDto), typeof(Tenant)); await _tenantService.UpdateAsync(tenant); return(NoContent()); }
//public void OnAuthorization(AuthorizationFilterContext context) //{ // var sub = context.HttpContext.User.Claims.FirstOrDefault(c => "sub".Equals(c.Type)); // var request = context.ActionDescriptor.Parameters; // if (sub is null) // { // context.Result = new ForbidResult(); // } //} public void OnActionExecuting(ActionExecutingContext context) { // do something before the action executes var sub = context.HttpContext.User.Claims.FirstOrDefault(c => "sub".Equals(c.Type)); var email = context.HttpContext.User.Claims.FirstOrDefault(c => "email".Equals(c.Type)).Value; context.ActionArguments.TryGetValue("tenantId", out object tenantId); context.ActionArguments.TryGetValue("officeId", out object officeId); context.HttpContext.Request.Headers.TryGetValue("User-Agent", out StringValues browser); var request = context.HttpContext.Request.Path; if (sub == null) { context.Result = new ForbidResult(); } if (email == null) { context.Result = new ForbidResult(); } UserDto currentUser = null; TenantDto currentTenant = null; OfficeDto currentOffice = null; RoleDto currentRole = null; var user = _userService.GetUserByEmail(email).Result; if (user == null) { currentUser = _userService.CreateInitialUser(new UserDto { Email = email, Name = email, LastSeenOn = DateTime.Now, LastBrowser = browser, LastIp = context.HttpContext.Connection.RemoteIpAddress.ToString() }).Result; } else { user.LastBrowser = browser; user.LastIp = context.HttpContext.Connection.RemoteIpAddress.ToString(); user.LastSeenOn = DateTime.Now; currentUser = _userService.UpdateContextUser(user).Result; } if (tenantId != null) { currentTenant = _userService.GetTenant(tenantId.ToString()).Result; } if (officeId != null) { currentOffice = currentUser.Offices.FirstOrDefault(o => o.Id == Guid.Parse(officeId.ToString())); } if (currentTenant == null && currentOffice != null) { currentTenant = _userService.GetTenant(currentOffice.TenantId.ToString()).Result; } if (currentOffice != null) { currentRole = currentUser.Roles.FirstOrDefault(r => r.OfficeId == currentOffice.Id); } _authContext.CurrentUser = currentUser; _authContext.CurrentTenant = currentTenant; _authContext.CurrentOffice = currentOffice; _authContext.CurrentRole = currentRole; }
/// <summary> /// Creates a tenant. /// </summary> /// <remarks> /// Client Credentials Flow required permissions: Administration or /// Administration.Write. /// /// Host only. Requires authentication. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='body'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <TenantDto> PostAsync(this ITenants operations, TenantDto body = default(TenantDto), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.PostWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public static void MappTenantDto(this Tenant tenant, TenantDto tenantDto) { //tenant.Id = tenantDto.Id; tenant.TenantCode = tenantDto.TenantCode; tenant.TenantName = tenantDto.TenantName; tenant.RegistrationDate = tenantDto.RegistrationDate; tenant.CurrencyCode = tenantDto.CurrencyCode; tenant.AddressLine1 = tenantDto.AddressLine1; tenant.AddressLine2 = tenantDto.AddressLine2; tenant.Street = tenantDto.Street; tenant.State = tenantDto.State; tenant.City = tenantDto.City; tenant.ZipCode = tenantDto.ZipCode; tenant.Country = tenantDto.Country; tenant.Phone = tenantDto.Phone; tenant.Fax = tenantDto.Fax; tenant.Email = tenantDto.Email; tenant.Url = tenantDto.Url; tenant.Logo = tenantDto.Logo; tenant.RegistrationNumber = tenantDto.RegistrationNumber; tenant.CreatedByUserId = tenantDto.CreatedByUserId; tenant.CreatedOn = tenantDto.CreatedOn; tenant.UpdatedByUserId = tenantDto.UpdatedByUserId; tenant.UpdatedOn = tenantDto.UpdatedOn; }
public async Task <TenantDto> UpdateTenant(TenantDto tenantDto) // in use { //https://github.com/aspnet/EntityFrameworkCore/issues/10954 //https://github.com/AutoMapper/AutoMapper/issues/1792 //https://github.com/AutoMapper/AutoMapper/issues/1695 var tenant = await _tenantRepository.List().Include(t => t.Offices).FirstOrDefaultAsync(t => t.Id == tenantDto.Id); var officeDtos = (tenantDto.Offices == null || !tenantDto.Offices.Any()) ? new List <OfficeDto>() : tenantDto.Offices; // var offices = tenant.Offices; // tenantDto.Offices = null; // unable to set the automapper to ignore this list; so it ends up added twice during the save. // a tenant should has at least one office if (!officeDtos.Any() && !tenant.Offices.Any()) { officeDtos.Add(new OfficeDto { TenantId = tenantDto.Id, OfficeCode = tenantDto.TenantCode, OfficeName = tenantDto.TenantName, NickName = tenantDto.TenantName }); } //_mapper.Map<TenantDto,Tenant>(tenantDto, tenant); tenant.MappTenantDto(tenantDto); _tenantRepository.Update(tenant); foreach (var officeDto in officeDtos) { officeDto.TenantId = tenant.Id; // ef addorupdate causes some kind of troubles var office = tenant.Offices.FirstOrDefault(o => o.Id == officeDto.Id); // _mapper.Map<Office>(officeDto); if (office == null) { office = _mapper.Map <Office>(officeDto); office = _officeRepository.Add(office); // the current user would be added to the office; so that the office at least has one user _officeUserRepository.Add(new OfficeUser { UserId = _authContext.CurrentUser.Id, OfficeId = office.Id }); var adminRole = new Role { RoleName = $"Admin of {officeDto.OfficeName}", IsAdministrator = true, OfficeId = office.Id }; adminRole = _roleRepository.Add(adminRole); // this user would be the admin of the office _roleUserRepository.Add(new RoleUser { UserId = _authContext.CurrentUser.Id, RoleId = adminRole.Id }); } else { //_mapper.Map<OfficeDto,Office>(officeDto,office); office.MappOfficeDto(officeDto); _officeRepository.Update(office); } } await _tenantRepository.SaveAsync(); return(await GetTenant(tenant.Id.ToString())); }
public async Task <ApiResponse> UpdateTenantAsync(TenantDto tenantDto) { var tenant = await _tenantStoreDbContext.TenantInfo.SingleOrDefaultAsync(i => i.Id == tenantDto.Id); if (tenant == null) { return(new ApiResponse(Status400BadRequest, L["The tenant {0} doesn't exist", tenantDto.Name])); } var response = new ApiResponse(Status200OK, L["Tenant {0} updated", tenantDto.Name], tenantDto); if (tenantDto.Identifier != tenant.Identifier && (tenantDto.Identifier == Constants.Settings.DefaultTenantId || tenant.Identifier == Constants.Settings.DefaultTenantId)) { response = new ApiResponse(Status403Forbidden, L["Default Tenant identifier cannot be changed and must be unique"]); } else { tenant = _autoMapper.Map(tenantDto, tenant); _tenantStoreDbContext.TenantInfo.Update(tenant); await _tenantStoreDbContext.SaveChangesAsync(); } return(response); }
public async Task UpdateTenant(TenantDto tenant) { var existingTenant = await this._tenantRep.GetAsync(tenant.Id); existingTenant.ChangeName(tenant.Name) .ChangeOrAddDesc(tenant.Description); }
public async Task <ActionResult <IEnumerable <TenantDto> > > Get() { return(await _context.Tenants .OrderBy(i => i.LastName) .Select(i => TenantDto.FromEntity(i)) .ToListAsync()); }
private void btnOK_Click(object sender, EventArgs e) { _tenantDto = new TenantDto { Name = txtTenantName.Text }; Close(); }
public void Update_ShouldFail_GivenTenantDoesntExist() { // Given // a random TenantDto var tenantDto = new TenantDto() { Id = Guid.NewGuid().ToString(), Name = "123 Name", Slug = "zbcdef_123", ServiceDetails = new ServiceDetailsDto { ServiceExpireDate = DateTime.Now + TimeSpan.FromDays(1000), ServiceMaxStorageMegabytes = 10000, ServiceMaxUsers = 1000 }, PrimaryContact = new ContactInfoDto { FullName = "John Doe", Email = "*****@*****.**", MobilePhoneNumber = "+79991234567" } }; // When var updateTenantResponse = _httpClient.PutAsJsonAsync(_url + tenantDto.Id, tenantDto).Result; // Then Assert.That(updateTenantResponse.StatusCode == HttpStatusCode.NotFound); }
public TenantDto Update(TenantDto tenant) { Tenant tenantToUpdate = Get(tenant.Id); _dbContext.Entry(tenantToUpdate).CurrentValues.SetValues(_mapper.Map <Tenant>(tenant)); _dbContext.SaveChanges(); return(_mapper.Map <TenantDto>(tenantToUpdate)); }
public async Task <Tenant> Create(TenantDto tenantDto) { throw new System.NotImplementedException(); //var tenant = _autoMapper.Map<TenantDto, Tenant>(tenantDto); //await _db.Tenants.AddAsync(tenant); //await _db.SaveChangesAsync(CancellationToken.None); //return tenant; }
public async Task <IActionResult> Post([FromBody] TenantDto tenantDto) { if (tenantDto.Id != 0) { return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted.")); } return(await SaveAndReturnEntityAsync(async() => await _tenantService.SaveAndReturnEntityAsync(tenantDto))); }
private void AddTenantNode(AuthTokenDto tokenDto, TenantDto tenant) { var node = new TenantNode(_serverDto, tenant.Name) { DisplayName = tenant.Name, Tag = tenant.Guid }; AddTenantNode(node); }
public TenantDto UpdateTenant(TenantDto tenantDto) { var tenant = this._tenantRepository.GetByKey(tenantDto.ID); tenant.UpdateTenant(tenantDto.DisplayName, tenantDto.Description, tenantDto.UpdatedBy); this._tenantRepository.Update(tenant); return(tenant.MapAs <TenantDto>()); }
public TenantDto CreateTenant(TenantDto tenantDto) { var tenant = new Tenant(tenantDto.TenantName, tenantDto.DisplayName, tenantDto.Description, tenantDto.CreatedBy); this._tenantRepository.Add(tenant); return(tenant.MapAs <TenantDto>()); }
public async Task <IActionResult> Put(int id, [FromBody] TenantDto tenantDto) { if (id == 0 || tenantDto.Id == 0) { return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0.")); } return(await SaveAndReturnEntityAsync(async() => await _tenantService.SaveAndReturnEntityAsync(tenantDto))); }
public ActionResult Edit(TenantDto model) { using (var service = ServiceLocator.Instance.Resolve <ITenantService>()) { model.UpdatedBy = this.LoginUser.Identity.Name; var tenant = service.UpdateTenant(model); return(Json(true, tenant)); } }
public TenantDto Add(TenantDto item) { Tenant tenant = _mapper.Map <Tenant>(item); _dbContext.Tenant.Add(tenant); _dbContext.SaveChanges(); return(GetDto(tenant.Id)); }
public IActionResult Create(int personId) { var person = _customerFacadeApiClient.GetPerson(personId).Result; var personAlert = new TenantDto { PersonId = personId, Person = person }; return(PartialView("Edit", personAlert)); }
public IActionResult Save(TenantDto model) { bool success; model = model.Id == 0 ? _customerFacadeApiClient.PostTenant(model).Result : _customerFacadeApiClient.PutTenant(model.Id, model).Result; success = string.IsNullOrWhiteSpace(model.ErrorMessage); return(Json(new { success, message = success ? model.SuccessMessage : model.ErrorMessage })); }
public async Task <ApiResponse> CreateTenantAsync(TenantDto tenantDto) { var tenant = _autoMapper.Map <TenantDto, TenantInfo>(tenantDto); await _tenantStoreDbContext.TenantInfo.AddAsync(tenant); await _tenantStoreDbContext.SaveChangesAsync(); return(new ApiResponse(Status200OK, L["Tenant {0} created", tenantDto.Name], tenantDto)); }
public TenantContainer(TenantDto tenant) { AdminName = NormalizeName(tenant.Name) + "Admin"; AdminPassword = "******"; TenantId = Guid.NewGuid(); Tenant = tenant; Department_1_1 = new TestDepartmentHolder(); Department_1_2 = new TestDepartmentHolder(); }
private TenantDto CreateTenantDto(OspTenant ospTenant) { var tenantDto = new TenantDto { TenantId = ospTenant.TenantId, Database = ospTenant.DatabaseName }; return(tenantDto); }
public async Task <IActionResult> Get(int id) { TenantDto tenant = await _tenantAppService.GetById(id); if (tenant == null) { return(NotFound("Tenant not found.")); } return(Ok(tenant)); }
private TenantDto AddTenant(TenantDto tenantDto) { var succcess = false; ActionHelper.Execute(delegate() { var auth = SnapInContext.Instance.AuthTokenManager.GetAuthToken(DisplayName); tenantDto = SnapInContext.Instance.ServiceGateway.Tenant.Create(auth.ServerDto, tenantDto, auth.Token); succcess = true; }); return(succcess ? tenantDto: null); }