Commit 4856846a authored by Eric Dieckman's avatar Eric Dieckman
Browse files

feat: add Infoblox API controllers for domains, networks, roles, and role access

parent bbe48933

src/api/Controllers/InfobloxDomainsController.cs

0 → 100644
+78 −0
Original line number Diff line number Diff line 
using Cals.Visor.Api.Authorization;

using Cals.Visor.Infrastructure.Contexts;

using Cals.Visor.Models;

using Microsoft.AspNetCore.Authorization;

using Microsoft.AspNetCore.Mvc;

using Microsoft.EntityFrameworkCore;



namespace Cals.Visor.Api.Controllers;



[Route("infoblox/domains")]

[ApiController]

public class InfobloxDomainsController : ControllerBase

{

    private readonly ApplicationDbContext _context;



    public InfobloxDomainsController(ApplicationDbContext context) => _context = context;



    // GET: /infoblox/domains

    [ProducesResponseType<IList<InfobloxDomain>>(StatusCodes.Status200OK)]

    [HttpGet(Name = "GetAllInfobloxDomains")]

    public async Task<IActionResult> GetAllAsync()

    {

        List<InfobloxDomain> result = await _context.InfobloxDomains

            .ToListAsync();



        return Ok(result);

    }



    // GET: /infoblox/domains/1

    [ProducesResponseType<InfobloxDomain>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpGet("{domainId:long}", Name = "GetInfobloxDomainById")]

    public async Task<IActionResult> GetByIdAsync(long domainId)

    {

        InfobloxDomain? result = await _context.InfobloxDomains

            .Where(e => e.InfobloxDomainId == domainId)

            .FirstOrDefaultAsync();



        if (result == null)

            return NotFound();



        return Ok(result);

    }



    // POST: /infoblox/domains

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxDomain>(StatusCodes.Status201Created)]

    [HttpPost(Name = "CreateNewInfobloxDomain")]

    public async Task<IActionResult> CreateNewAsync(InfobloxDomain data)

    {

        _context.Add(data);

        await _context.SaveChangesAsync();



        return CreatedAtRoute("GetInfobloxDomainById", new { domainId = data.InfobloxDomainId }, data);

    }



    // PUT: /infoblox/domains/2

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxDomain>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpPut("{domainId:long}", Name = "UpdateInfobloxDomain")]

    public async Task<IActionResult> UpdateAsync(long domainId, InfobloxDomain data)

    {

        InfobloxDomain? entity = await _context.InfobloxDomains

            .Where(e => e.InfobloxDomainId == domainId)

            .FirstOrDefaultAsync();



        if (entity == null)

            return NotFound();



        entity.Name = data.Name;

        entity.Description = data.Description;



        await _context.SaveChangesAsync();



        return Ok(entity);

    }

}

src/api/Controllers/InfobloxNetworksController.cs

0 → 100644
+79 −0
Original line number Diff line number Diff line 
using Cals.Visor.Api.Authorization;

using Cals.Visor.Infrastructure.Contexts;

using Cals.Visor.Models;

using Microsoft.AspNetCore.Authorization;

using Microsoft.AspNetCore.Http;

using Microsoft.AspNetCore.Mvc;

using Microsoft.EntityFrameworkCore;



namespace Cals.Visor.Api.Controllers;



[Route("infoblox/networks")]

[ApiController]

public class InfobloxNetworksController : ControllerBase

{

    private readonly ApplicationDbContext _context;



    public InfobloxNetworksController(ApplicationDbContext context) => _context = context;



    // GET: /infoblox/networks

    [ProducesResponseType<IList<InfobloxNetwork>>(StatusCodes.Status200OK)]

    [HttpGet(Name = "GetAllInfobloxNetworks")]

    public async Task<IActionResult> GetAllAsync()

    {

        List<InfobloxNetwork> result = await _context.InfobloxNetworks

            .ToListAsync();



        return Ok(result);

    }



    // GET: /infoblox/networks/1

    [ProducesResponseType<InfobloxNetwork>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpGet("{networkId:long}", Name = "GetInfobloxNetworkById")]

    public async Task<IActionResult> GetByIdAsync(long networkId)

    {

        InfobloxNetwork? result = await _context.InfobloxNetworks

            .Where(e => e.InfobloxNetworkId == networkId)

            .FirstOrDefaultAsync();



        if (result == null)

            return NotFound();



        return Ok(result);

    }



    // POST: /infoblox/networks

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxNetwork>(StatusCodes.Status201Created)]

    [HttpPost(Name = "CreateNewInfobloxNetwork")]

    public async Task<IActionResult> CreateNewAsync(InfobloxNetwork data)

    {

        _context.Add(data);

        await _context.SaveChangesAsync();



        return CreatedAtRoute("GetInfobloxNetworkById", new { networkId = data.InfobloxNetworkId }, data);

    }



    // PUT: /infoblox/networks/2

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxNetwork>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpPut("{networkId:long}", Name = "UpdateInfobloxNetwork")]

    public async Task<IActionResult> UpdateAsync(long networkId, InfobloxNetwork data)

    {

        InfobloxNetwork? entity = await _context.InfobloxNetworks

            .Where(e => e.InfobloxNetworkId == networkId)

            .FirstOrDefaultAsync();



        if (entity == null)

            return NotFound();



        entity.Description = data.Description;

        entity.SubnetId = data.SubnetId;



        await _context.SaveChangesAsync();



        return Ok(entity);

    }

}

src/api/Controllers/InfobloxRoleAccessController.cs

0 → 100644
+77 −0
Original line number Diff line number Diff line 
using Cals.Visor.Api.Authorization;

using Cals.Visor.Infrastructure.Contexts;

using Cals.Visor.Models;

using Microsoft.AspNetCore.Authorization;

using Microsoft.AspNetCore.Http;

using Microsoft.AspNetCore.Mvc;

using Microsoft.EntityFrameworkCore;



namespace Cals.Visor.Api.Controllers;



[Route("infoblox/role_access")]

[ApiController]

public class InfobloxRoleAccessController : ControllerBase

{

    private readonly ApplicationDbContext _context;



    public InfobloxRoleAccessController(ApplicationDbContext context) => _context = context;



    // GET: /infoblox/role_access

    [ProducesResponseType<IList<InfobloxRoleAccess>>(StatusCodes.Status200OK)]

    [HttpGet(Name = "GetAllInfobloxRoleAccess")]

    public async Task<IActionResult> GetAllAsync()

    {

        List<InfobloxRoleAccess> result = await _context.InfobloxRoleAccess

            .ToListAsync();



        return Ok(result);

    }



    // GET: /infoblox/role_access/1

    [ProducesResponseType<InfobloxRoleAccess>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpGet("{roleAccessId:long}", Name = "GetInfobloxRoleAccessById")]

    public async Task<IActionResult> GetByIdAsync(long roleAccessId)

    {

        InfobloxRoleAccess? result = await _context.InfobloxRoleAccess

            .Where(e => e.InfobloxRoleAccessId == roleAccessId)

            .FirstOrDefaultAsync();



        if (result == null)

            return NotFound();



        return Ok(result);

    }



    // POST: /infoblox/role_access

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxRoleAccess>(StatusCodes.Status201Created)]

    [HttpPost(Name = "CreateNewInfobloxRoleAccess")]

    public async Task<IActionResult> CreateNewAsync(InfobloxRoleAccess data)

    {

        _context.Add(data);

        await _context.SaveChangesAsync();



        return CreatedAtRoute("GetInfobloxRoleAccessById", new { roleAccessId = data.InfobloxRoleAccessId }, data);

    }



    // DELETE: /infoblox/role_access/1

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType(StatusCodes.Status204NoContent)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpDelete("{roleAccessId:long}", Name = "DeleteInfobloxRoleAccess")]

    public async Task<IActionResult> DeleteAsync(long roleAccessId)

    {

        InfobloxRoleAccess? entity = await _context.InfobloxRoleAccess

            .Where(e => e.InfobloxRoleAccessId == roleAccessId)

            .FirstOrDefaultAsync();



        if (entity == null)

            return NotFound();



        _context.InfobloxRoleAccess.Remove(entity);

        await _context.SaveChangesAsync();



        return NoContent();

    }

}

src/api/Controllers/InfobloxRolesController.cs

0 → 100644
+81 −0
Original line number Diff line number Diff line 
using Cals.Visor.Api.Authorization;

using Cals.Visor.Infrastructure.Contexts;

using Cals.Visor.Models;

using Microsoft.AspNetCore.Authorization;

using Microsoft.AspNetCore.Http;

using Microsoft.AspNetCore.Mvc;

using Microsoft.EntityFrameworkCore;



namespace Cals.Visor.Api.Controllers;



[Route("infoblox/roles")]

[ApiController]

public class InfobloxRolesController : ControllerBase

{

    private readonly ApplicationDbContext _context;



    public InfobloxRolesController(ApplicationDbContext context) => _context = context;



    // GET: /infoblox/roles

    [ProducesResponseType<IList<InfobloxRole>>(StatusCodes.Status200OK)]

    [HttpGet(Name = "GetAllInfobloxRoles")]

    public async Task<IActionResult> GetAllAsync()

    {

        List<InfobloxRole> result = await _context.InfobloxRoles

            .Where(e => e.IsActive == true)

            .ToListAsync();



        return Ok(result);

    }



    // GET: /infoblox/roles/1

    [ProducesResponseType<InfobloxRole>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpGet("{roleId:long}", Name = "GetInfobloxRoleById")]

    public async Task<IActionResult> GetByIdAsync(long roleId)

    {

        InfobloxRole? result = await _context.InfobloxRoles

            .Where(e => e.InfobloxRoleId == roleId)

            .FirstOrDefaultAsync();



        if (result == null)

            return NotFound();



        return Ok(result);

    }



    // POST: /infoblox/roles

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxRole>(StatusCodes.Status201Created)]

    [HttpPost(Name = "CreateNewInfobloxRole")]

    public async Task<IActionResult> CreateNewAsync(InfobloxRole data)

    {

        _context.Add(data);

        await _context.SaveChangesAsync();



        return CreatedAtRoute("GetInfobloxRoleById", new { roleId = data.InfobloxRoleId }, data);

    }



    // PUT: /infoblox/roles/2

    [Authorize(Policy = Policies.CanEdit)]

    [ProducesResponseType<InfobloxRole>(StatusCodes.Status200OK)]

    [ProducesResponseType(StatusCodes.Status404NotFound)]

    [HttpPut("{roleId:long}", Name = "UpdateInfobloxRole")]

    public async Task<IActionResult> UpdateAsync(long roleId, InfobloxRole data)

    {

        InfobloxRole? entity = await _context.InfobloxRoles

            .Where(e => e.InfobloxRoleId == roleId)

            .FirstOrDefaultAsync();



        if (entity == null)

            return NotFound();



        entity.Name = data.Name;

        entity.Description = data.Description;

        entity.IsActive = data.IsActive;



        await _context.SaveChangesAsync();



        return Ok(entity);

    }

}