Beispiel #1
0
        public async Task <IActionResult> SaveAndRemoveExistingNotificationTresholds(Guid serverId,
                                                                                     [FromBody] NotificationResourceThresholdDTO notificationResourceThresholdDto)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }

            var notificationResourceThresholdToDelete =
                await _unitOfWork.NotificationThresholds.GetAll(q => q.ServerId == server.Id
                                                                );

            _unitOfWork.NotificationThresholds.DeleteRange(notificationResourceThresholdToDelete);

            var notificationResourceThresholdToSave =
                _mapper.Map <NotificationResourceThreshold>(notificationResourceThresholdDto);

            notificationResourceThresholdToSave.ServerId = server.Id;

            await _unitOfWork.NotificationThresholds.Insert(notificationResourceThresholdToSave);

            return(NoContent());
        }
Beispiel #2
0
        public async Task <IList <PortServer> > GetServerPorts(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var portsOfServer = await _unitOfWork.PortsServer.GetAll(
                q => q.ServerId == server.Id
                );

            return(portsOfServer);
        }
Beispiel #3
0
        public async Task <IList <HardDiskServer> > GetHardDisksOfServer(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var hardDiskServers = await _unitOfWork.HardDisksServers.GetAll(
                q => q.ServerId == server.Id
                );

            return(hardDiskServers);
        }
        public async Task <IList <ServerEventDto> > GetEventsOfServer(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var serverEvents = await _unitOfWork.ServerEvents.GetAll(
                q => q.ServerId == server.Id,
                orderBy => orderBy.OrderByDescending(s => s.CreatedAt)

                );

            return(_mapper.Map <IList <ServerEventDto> >(serverEvents));
        }
Beispiel #5
0
        public async Task <IActionResult> GetNotificationTresholdSettings(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }

            var notificationResourceThreshold = await _unitOfWork.NotificationThresholds.Get(
                q => q.ServerId == server.Id
                );

            return(Ok(notificationResourceThreshold));
        }
Beispiel #6
0
        public async Task <IActionResult> GetNetworkServerAdapters(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }
            var networkAdapterServers = await _unitOfWork.NetworkAdaptersServer.GetAll(
                q => q.ServerId == server.Id
                );

            var networkAdaptersServersMapped = _mapper.Map <IList <NetworkAdapterServerDto> >(networkAdapterServers);

            return(Ok(networkAdaptersServersMapped));
        }
Beispiel #7
0
        public async Task <IList <NetworkUsageDTO> > GetNetworkUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var networkUsages = await _unitOfWork.NetworkUsages.GetAll(
                q => q.ServerId == server.Id &&
                createdBetween.From >= q.CreatedAt && createdBetween.To <= q.CreatedAt
                );

            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                networkUsages = await _unitOfWork.NetworkUsages.GetAll(
                    q =>
                    server.Id == q.ServerId
                    );
            }
            return(_mapper.Map <IList <NetworkUsageDTO> >(networkUsages));
        }
        public async Task <IList <CpuUsageDto> > GetCpuUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var cpusUsageServers = await _unitOfWork.CpuUsagesServers.GetAll(
                q => q.ServerId == server.Id
                );

            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                cpusUsageServers = await _unitOfWork.CpuUsagesServers.GetAll(
                    q =>
                    server.Id == q.ServerId &&
                    q.CreatedAt >= createdBetween.From && q.CreatedAt <= createdBetween.To
                    );
            }
            return(_mapper.Map <IList <CpuUsageDto> >(cpusUsageServers));
        }
        public async Task <IList <RamUsageDto> > GetRamUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var ramUsages = await _unitOfWork.RAMUsages.GetAll(
                q => q.ServerId == server.Id &&
                createdBetween.From >= q.CreatedAt && createdBetween.To <= q.CreatedAt
                );

            // TODO refactor (or on unit of work layer)
            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                ramUsages = await _unitOfWork.RAMUsages.GetAll(
                    q =>
                    server.Id == q.ServerId &&
                    q.CreatedAt >= createdBetween.From && q.CreatedAt <= createdBetween.To
                    );
            }
            return(_mapper.Map <IList <RamUsageDto> >(ramUsages));
        }