Example #1
0
        public async void CreateUpdateDelete()
        {
            // Ensure there is no existing UserGroup called "Test"
            var existingUserGroup = (await PortalClient
                                     .GetAllAsync(new Filter <UserGroup> {
                FilterItems = new List <FilterItem <UserGroup> > {
                    new Eq <UserGroup>(nameof(UserGroup.Name), Value)
                }
            })
                                     .ConfigureAwait(false))
                                    .SingleOrDefault();

            if (existingUserGroup != null)
            {
                await PortalClient.DeleteAsync(existingUserGroup).ConfigureAwait(false);
            }

            var userGroup = await PortalClient.CreateAsync(new UserGroupCreationDto
            {
                Name        = Value,
                Description = "Desc",
            }).ConfigureAwait(false);

            // Refetch
            var refetch = await PortalClient.GetAsync <UserGroup>(userGroup.Id).ConfigureAwait(false);

            Assert.NotNull(refetch);

            // Delete
            await PortalClient.DeleteAsync(userGroup).ConfigureAwait(false);
        }
        public async void CanCreateAndDeleteNetscanGroups()
        {
            var allNetscanGroups = await PortalClient.GetAllAsync <NetscanGroup>().ConfigureAwait(false);

            const string name        = "API Unit Test CanCreateAndDeleteNetscanGroups";
            const string description = "API Unit Test CanCreateAndDeleteNetscanGroups Description";

            var existingTestNetscanGroup = allNetscanGroups.SingleOrDefault(group => group.Name == name);

            if (existingTestNetscanGroup != null)
            {
                await PortalClient.DeleteAsync <NetscanGroup>(existingTestNetscanGroup.Id).ConfigureAwait(false);
            }
            Assert.DoesNotContain(await PortalClient.GetAllAsync <NetscanGroup>().ConfigureAwait(false), group => group.Name == name);
            // Definitely not there now

            // Create one
            var netscanGroupCreationDto = new NetscanGroupCreationDto
            {
                Name        = name,
                Description = description
            };
            var newNetscanGroup = await PortalClient.CreateAsync(netscanGroupCreationDto).ConfigureAwait(false);

            Assert.Contains(await PortalClient.GetAllAsync <NetscanGroup>().ConfigureAwait(false), group => group.Name == name);

            await PortalClient.DeleteAsync(newNetscanGroup).ConfigureAwait(false);

            Assert.DoesNotContain(await PortalClient.GetAllAsync <NetscanGroup>().ConfigureAwait(false), group => group.Name == name);
        }
Example #3
0
        public async void CreateUser()
        {
            // Delete it if it already exists
            foreach (var existingUser in await PortalClient.GetAllAsync(new Filter <User>
            {
                FilterItems = new List <FilterItem <User> >
                {
                    new Eq <User>(nameof(User.UserName), "test")
                }
            }).ConfigureAwait(false))
            {
                await PortalClient.DeleteAsync(existingUser).ConfigureAwait(false);
            }

            var userCreationDto = new UserCreationDto
            {
                ViewPermission = new ViewPermission
                {
                    Alerts     = true,
                    Dashboards = true,
                    Devices    = true,
                    Reports    = true,
                    Websites   = true,
                    Settings   = true
                },
                Username  = "******",
                FirstName = "first",
                LastName  = "last",
                Email     = "*****@*****.**",
#pragma warning disable SCS0015 // Hardcoded password
                Password = "******",
#pragma warning restore SCS0015 // Hardcoded password
                Password1           = "Abc123!!!",
                ForcePasswordChange = true,
                TwoFAEnabled        = false,
                SmsEmail            = "",
                SmsEmailFormat      = "sms",
                Timezone            = "",
                ViewPermissions     = new List <bool> {
                    true, true, true, true, true, true
                },
                Status = "active",
                Note   = "note",
                Roles  = new List <Role>
                {
                    new Role {
                        Id = 1
                    }
                },
                ApiTokens = new List <object>(),
                Phone     = "+447761503941",
                ApiOnly   = false
            };

            var user = await PortalClient.CreateAsync(userCreationDto).ConfigureAwait(false);

            // Delete again
            await PortalClient.DeleteAsync(user).ConfigureAwait(false);
        }
Example #4
0
        public async void CrudCollectorGroup()
        {
            // Try to get this item
            var collectorGroups = await PortalClient.GetAllAsync(new Filter <CollectorGroup>
            {
                FilterItems = new List <FilterItem <CollectorGroup> >
                {
                    new Eq <CollectorGroup>(nameof(CollectorGroup.Name), TestName)
                }
            }).ConfigureAwait(false);

            foreach (var priorCollectorGroup in collectorGroups)
            {
                await PortalClient.DeleteAsync(priorCollectorGroup).ConfigureAwait(false);
            }
            // There are now none with this name

            // Create one
            var newCollectorGroup = await PortalClient.CreateAsync(new CollectorGroupCreationDto
            {
                Name             = TestName,
                Description      = TestDescription,
                CustomProperties = new List <Property>
                {
                    new Property {
                        Name = "a", Value = "b"
                    }
                }
            }).ConfigureAwait(false);

            Assert.NotNull(newCollectorGroup);
            Assert.NotEqual(0, newCollectorGroup.Id);

            var newCollectorGroupRefetch = await PortalClient.GetAsync <CollectorGroup>(newCollectorGroup.Id).ConfigureAwait(false);

            Assert.NotNull(newCollectorGroupRefetch);
            Assert.NotNull(newCollectorGroupRefetch.Name);
            Assert.NotNull(newCollectorGroupRefetch.Description);
            Assert.NotNull(newCollectorGroupRefetch.CustomProperties);
            Assert.NotEmpty(newCollectorGroupRefetch.CustomProperties);
            Assert.Single(newCollectorGroupRefetch.CustomProperties);
            Assert.Equal("a", newCollectorGroupRefetch.CustomProperties[0].Name);
            Assert.Equal("b", newCollectorGroupRefetch.CustomProperties[0].Value);

            // Put
            await PortalClient.PutAsync(newCollectorGroupRefetch).ConfigureAwait(false);

            // Delete
            await PortalClient.DeleteAsync(newCollectorGroupRefetch).ConfigureAwait(false);
        }
        public async void CreateUpdateAndDelete()
        {
            const string testAppliesToFunctionName        = "XxxUnitTest";
            var          testAppliesToFunctionDescription = $"{testAppliesToFunctionName} - Description";
            var          testAppliesToFunctionCode        = $"displayname == \"{testAppliesToFunctionName}\"";

            // Delete if already present
            var existingAppliesToFunction = await PortalClient.GetByNameAsync <AppliesToFunction>(testAppliesToFunctionName).ConfigureAwait(false);

            if (existingAppliesToFunction != null)
            {
                await PortalClient.DeleteAsync(existingAppliesToFunction).ConfigureAwait(false);
            }

            // Create
            var createdAppliesToFunction = await PortalClient.CreateAsync(new AppliesToFunctionCreationDto
            {
                Name        = testAppliesToFunctionName,
                Description = testAppliesToFunctionDescription,
                Code        = testAppliesToFunctionCode
            }).ConfigureAwait(false);

            // Refetch and check
            existingAppliesToFunction = await PortalClient.GetByNameAsync <AppliesToFunction>(testAppliesToFunctionName).ConfigureAwait(false);

            Assert.NotNull(existingAppliesToFunction);
            Assert.Equal(createdAppliesToFunction.Id, existingAppliesToFunction.Id);

            // Update
            var newDescription = testAppliesToFunctionDescription + "2";

            existingAppliesToFunction.Description = newDescription;
            await PortalClient.PutAsync(existingAppliesToFunction).ConfigureAwait(false);

            // Refetch and check
            existingAppliesToFunction = await PortalClient.GetByNameAsync <AppliesToFunction>(testAppliesToFunctionName).ConfigureAwait(false);

            Assert.Equal(newDescription, existingAppliesToFunction.Description);

            // Delete
            await PortalClient.DeleteAsync(existingAppliesToFunction).ConfigureAwait(false);

            // Refetch and check
            existingAppliesToFunction = await PortalClient.GetByNameAsync <AppliesToFunction>(testAppliesToFunctionName).ConfigureAwait(false);

            Assert.Null(existingAppliesToFunction);
        }
Example #6
0
        public async void CreateCollectorDownloadAndDelete()
        {
            // Determine the latest supported version
            var collectorVersionInts = (await PortalClient.GetAllCollectorVersionsAsync(
                                            new Filter <CollectorVersion>
            {
                FilterItems = new List <FilterItem <CollectorVersion> >
                {
                    new Eq <CollectorVersion>(nameof(CollectorVersion.IsStable), true),
                }
            }
                                            ).ConfigureAwait(false))
                                       .Select(cv => (cv.MajorVersion * 1000) + cv.MinorVersion)
                                       .OrderByDescending(v => v)
                                       .ToList();

            Assert.NotNull(collectorVersionInts);
            Assert.NotEmpty(collectorVersionInts);

            var collectorVersionInt = collectorVersionInts[0];

            // Create the collector
            var collector = await PortalClient.CreateAsync(new CollectorCreationDto { Description = "UNIT TEST" }).ConfigureAwait(false);

            var tempFileInfo = new FileInfo(Path.GetTempPath() + Guid.NewGuid().ToString());

            try
            {
                await PortalClient.DownloadCollector(
                    collector.Id,
                    tempFileInfo,
                    CollectorPlatformAndArchitecture.Win64,
                    CollectorDownloadType.Bootstrap,
                    CollectorSize.Medium,
                    collectorVersionInt).ConfigureAwait(false);
            }
            finally
            {
                // No need to do this as the collector has not been registered
                // await DefaultPortalClient.DeleteAsync(collector).ConfigureAwait(false);
                tempFileInfo.Delete();

                // Remove the collector from the API
                await PortalClient.DeleteAsync(collector).ConfigureAwait(false);
            }
        }
Example #7
0
        public async void GetOpsNotes()
        {
            // Create an ops note
            var newOpsNote = await PortalClient.CreateAsync(new OpsNoteCreationDto
            {
                DateTimeUtcSeconds = DateTime.UtcNow.SecondsSinceTheEpoch(),
                Note = $"LogicMonitor.Api.Test run on {DateTime.UtcNow}",
                Tags = new List <OpsNoteTagCreationDto> {
                    new OpsNoteTagCreationDto {
                        Name = "LogicMonitor.Api"
                    }
                }
            })
                             .ConfigureAwait(false);

            await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);

            var allOpsNotes = await PortalClient.GetAllAsync <OpsNote>().ConfigureAwait(false);

            // Make sure that some are returned
            Assert.True(allOpsNotes.Count > 0);
            Assert.Contains(newOpsNote.Id, allOpsNotes.Select(o => o.Id));
        }
Example #8
0
        public async void CrudReportGroups()
        {
            // Delete it if it already exists
            foreach (var existingReportGroup in await PortalClient.GetAllAsync(new Filter <ReportGroup>
            {
                FilterItems = new List <FilterItem <ReportGroup> >
                {
                    new Eq <ReportGroup>(nameof(ReportGroup.Name), "Test Name")
                }
            }).ConfigureAwait(false))
            {
                await PortalClient.DeleteAsync(existingReportGroup).ConfigureAwait(false);
            }

            // Create it
            var reportGroup = await PortalClient.CreateAsync(new ReportGroupCreationDto
            {
                Name        = "Test Name",
                Description = "Test Description"
            }).ConfigureAwait(false);

            // Delete it again
            await PortalClient.DeleteAsync(reportGroup).ConfigureAwait(false);
        }
        public async void CreatePingDataSourceSdtOnEmptyDeviceGroup()
        {
            const string deviceGroupName = "CreatePingDataSourceSdtOnEmptyDeviceGroupUnitTest";

            // Ensure DeviceGroup is NOT present
            var deviceGroup = await PortalClient
                              .GetDeviceGroupByFullPathAsync(deviceGroupName)
                              .ConfigureAwait(false);

            if (deviceGroup != null)
            {
                await PortalClient
                .DeleteAsync(deviceGroup)
                .ConfigureAwait(false);
            }

            // Create DeviceGroup
            deviceGroup = await PortalClient
                          .CreateAsync(new DeviceGroupCreationDto
            {
                ParentId = "1",
                Name     = deviceGroupName
            })
                          .ConfigureAwait(false);

            // Get ping DataSource
            var dataSource = (await PortalClient
                              .GetAllAsync(new Filter <DataSource>
            {
                FilterItems = new List <FilterItem <DataSource> >
                {
                    new Eq <DataSource>(nameof(DataSource.Name), "Ping")
                }
            })
                              .ConfigureAwait(false))
                             .SingleOrDefault();

            // Create Scheduled Downtime
            var sdtCreationDto = new DeviceGroupScheduledDownTimeCreationDto(deviceGroup.Id)
            {
                Comment = "Created by Unit Test",
                StartDateTimeEpochMs = DateTime.UtcNow.MillisecondsSinceTheEpoch(),
                EndDateTimeEpochMs   = DateTime.UtcNow.AddDays(7).MillisecondsSinceTheEpoch(),
                RecurrenceType       = ScheduledDownTimeRecurrenceType.OneTime,
                DataSourceId         = dataSource.Id,
                DataSourceName       = dataSource.Name
            };

            // Check the created SDT looks right
            var createdSdt = await PortalClient
                             .CreateAsync(sdtCreationDto)
                             .ConfigureAwait(false);

            Assert.NotNull(createdSdt);

            // Clean up
            await PortalClient
            .DeleteAsync <ScheduledDownTime>(createdSdt.Id)
            .ConfigureAwait(false);

            // Remove the device group
            await PortalClient
            .DeleteAsync(deviceGroup)
            .ConfigureAwait(false);
        }
Example #10
0
        public async void CreateUpdateDelete()
        {
            // Ensure there is no existing role called "Test"
            var existingRole = (await PortalClient
                                .GetAllAsync(new Filter <Role> {
                FilterItems = new List <FilterItem <Role> > {
                    new Eq <Role>(nameof(Role.Name), Value)
                }
            })
                                .ConfigureAwait(false))
                               .SingleOrDefault();

            if (existingRole != null)
            {
                await PortalClient.DeleteAsync(existingRole).ConfigureAwait(false);
            }

            var dashboardGroup = (await PortalClient.GetAllAsync(new Filter <DashboardGroup> {
                Take = 1
            }).ConfigureAwait(false)).SingleOrDefault();
            var deviceGroup    = (await PortalClient.GetAllAsync(new Filter <DeviceGroup> {
                Take = 1
            }).ConfigureAwait(false)).SingleOrDefault();
            var websiteGroup   = (await PortalClient.GetAllAsync(new Filter <WebsiteGroup> {
                Take = 1
            }).ConfigureAwait(false)).SingleOrDefault();
            var reportGroup    = (await PortalClient.GetAllAsync(new Filter <ReportGroup> {
                Take = 1
            }).ConfigureAwait(false)).SingleOrDefault();
            var role           = await PortalClient.CreateAsync(new RoleCreationDto
            {
                CustomHelpLabel = "",
                CustomHelpUrl   = "",
                Description     = "Desc",
                Name            = Value,
                RequireEULA     = false,
                TwoFactorAuthenticationRequired = false,
                Privileges = new List <RolePrivilege>
                {
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.DashboardGroup,
                        ObjectId   = dashboardGroup.Id.ToString(),
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.DeviceGroup,
                        ObjectId   = deviceGroup.Id.ToString(),
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.WebsiteGroup,
                        ObjectId   = websiteGroup.Id.ToString(),
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.ReportGroup,
                        ObjectId   = reportGroup.Id.ToString(),
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.Help,
                        ObjectId   = "*",
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.DeviceDashboard,
                        Operation  = RolePrivilegeOperation.Read
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.ConfigNeedDeviceManagePermission,
                        ObjectId   = "",
                        Operation  = RolePrivilegeOperation.Write
                    },
                    new RolePrivilege
                    {
                        ObjectType = PrivilegeObjectType.ReportGroup,
                        ObjectId   = reportGroup.Id.ToString(),
                        Operation  = RolePrivilegeOperation.Read
                    },
                }
            }).ConfigureAwait(false);

            // Refetch
            var refetch = await PortalClient.GetAsync <Role>(role.Id).ConfigureAwait(false);

            Assert.NotNull(refetch);

            // Delete
            await PortalClient.DeleteAsync(role).ConfigureAwait(false);
        }
Example #11
0
        public async void SetDeviceGroupCustomProperty()
        {
            // Create a device group for testing purposes
            const string testDeviceGroupName = "Property Test Device Group";
            var          existingDeviceGroup = await PortalClient
                                               .GetDeviceGroupByFullPathAsync(testDeviceGroupName)
                                               .ConfigureAwait(false);

            if (existingDeviceGroup != null)
            {
                await PortalClient
                .DeleteAsync(existingDeviceGroup)
                .ConfigureAwait(false);
            }
            var deviceGroup = await PortalClient.CreateAsync(new DeviceGroupCreationDto
            {
                ParentId = "1",
                Name     = testDeviceGroupName
            }).ConfigureAwait(false);

            const string propertyName = "blah";
            const string value1       = "test1";
            const string value2       = "test2";

            // Set it to an expected value
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, value1).ConfigureAwait(false);

            var deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            var actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value1);

            Assert.Equal(1, actual);

            // Set it to a different value
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, value2).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value2);
            Assert.Equal(1, actual);

            // Set it to null (delete it)
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, null).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName);
            Assert.Equal(0, actual);

            // This should fail as there is nothing to delete
            var deletionException = await Record.ExceptionAsync(async() => await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, null, SetPropertyMode.Delete).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <LogicMonitorApiException>(deletionException);

            var updateException = await Record.ExceptionAsync(async() => await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, null, SetPropertyMode.Update).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <InvalidOperationException>(updateException);

            var createNullException = await Record.ExceptionAsync(async() => await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, null, SetPropertyMode.Create).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <InvalidOperationException>(createNullException);

            // Create one without checking
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, value1, SetPropertyMode.Create).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value1);
            Assert.Equal(1, actual);

            // Update one without checking
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, value2, SetPropertyMode.Update).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value2);
            Assert.Equal(1, actual);

            // Delete one without checking
            await PortalClient.SetDeviceGroupCustomPropertyAsync(deviceGroup.Id, propertyName, null, SetPropertyMode.Delete).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetDeviceGroupPropertiesAsync(deviceGroup.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName);
            Assert.Equal(0, actual);
        }
Example #12
0
        public async void SetWebsiteCustomProperty()
        {
            var website =
                await PortalClient.GetByNameAsync <Website>(nameof(SetWebsiteCustomProperty)).ConfigureAwait(false)
                ?? await PortalClient.CreateAsync(GetWebsiteCreationDto(1, nameof(SetWebsiteCustomProperty))).ConfigureAwait(false);

            const string propertyName = "blah";
            const string value1       = "test1";
            const string value2       = "test2";

            // Set it to an expected value
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, value1).ConfigureAwait(false);

            var deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            var actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value1);

            Assert.Equal(1, actual);

            // Set it to a different value
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, value2).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value2);
            Assert.Equal(1, actual);

            // Set it to null (delete it)
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, null).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName);
            Assert.Equal(0, actual);

            // This should fail as there is nothing to delete
            var deletionException = await Record.ExceptionAsync(async() => await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, null, SetPropertyMode.Delete).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <LogicMonitorApiException>(deletionException);

            var updateException = await Record.ExceptionAsync(async() => await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, null, SetPropertyMode.Update).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <InvalidOperationException>(updateException);

            var createNullException = await Record.ExceptionAsync(async() => await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, null, SetPropertyMode.Create).ConfigureAwait(false)).ConfigureAwait(false);

            Assert.IsType <InvalidOperationException>(createNullException);

            // Create one without checking
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, value1, SetPropertyMode.Create).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value1);
            Assert.Equal(1, actual);

            // Update one without checking
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, value2, SetPropertyMode.Update).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName && dp.Value == value2);
            Assert.Equal(1, actual);

            // Delete one without checking
            await PortalClient.SetWebsiteCustomPropertyAsync(website.Id, propertyName, null, SetPropertyMode.Delete).ConfigureAwait(false);

            deviceProperties = await PortalClient.GetWebsitePropertiesAsync(website.Id).ConfigureAwait(false);

            actual = deviceProperties.Count(dp => dp.Name == propertyName);
            Assert.Equal(0, actual);

            await PortalClient.DeleteAsync(website).ConfigureAwait(false);
        }
Example #13
0
        public async void CrudWebsiteGroupsAndWebsites()
        {
            // Ensure the website group doesn't exist
            var oldWebsiteGroup = await PortalClient.GetWebsiteGroupByFullPathAsync("Test Name").ConfigureAwait(false);

            if (oldWebsiteGroup != null)
            {
                await PortalClient.DeleteAsync <WebsiteGroup>(oldWebsiteGroup.Id).ConfigureAwait(false);
            }

            // Ensure the website doesn't exist
            var oldWebsites = await PortalClient.GetAllAsync(new Filter <Website>
            {
                FilterItems = new List <FilterItem <Website> >
                {
                    new Eq <Website>(nameof(Website.Name), nameof(CrudWebsiteGroupsAndWebsites))
                }
            }).ConfigureAwait(false);

            foreach (var oldWebsite in oldWebsites)
            {
                await PortalClient.DeleteAsync <Website>(oldWebsite.Id).ConfigureAwait(false);
            }

            // Create it
            var websiteGroup = await PortalClient.CreateAsync(new WebsiteGroupCreationDto
            {
                Name                 = "Test Name",
                Description          = "Test Description",
                IsAlertingDisabled   = false,
                IsMonitoringDisabled = false,
                ParentGroupFullPath  = "",
                ParentId             = "1",
                Properties           = new List <Property>
                {
                    new Property {
                        Name = "name", Value = "value"
                    }
                },
                TestLocation = new TestLocation {
                    All = true, SmgIds = new List <int> {
                        1, 2, 4, 3, 5, 6
                    }
                }
            }).ConfigureAwait(false);

            try
            {
                // Create the website
                var website = await PortalClient
                              .CreateAsync(GetWebsiteCreationDto(websiteGroup.Id, nameof(CrudWebsiteGroupsAndWebsites)))
                              .ConfigureAwait(false);

                Assert.NotNull(website);
                Assert.Equal(websiteGroup.Id, website.WebsiteGroupId);
                Assert.True(website.TriggerSslExpirationAlerts);
                Assert.Equal(ExpectedAlertExpression, website.AlertExpression);

                // Wait to ensure that it was created
                await Task.Delay(1000)
                .ConfigureAwait(false);

                // Delete it
                await PortalClient
                .DeleteAsync <Website>(website.Id)
                .ConfigureAwait(false);
            }
            finally
            {
                // Delete it again
                await PortalClient.DeleteAsync(websiteGroup).ConfigureAwait(false);
            }
        }
        private static async Task <TGroup> CreateGroupAsync <TGroup, TItem>(
            PortalClient portalClient,
            TGroup parentGroup,
            Structure <TGroup, TItem> structure,
            List <Property> variables,
            List <Property> originalProperties)
            where TGroup : IdentifiedItem, IHasEndpoint, new()
            where TItem : IdentifiedItem, IHasEndpoint, new()
        {
            var name       = Substitute(structure.Name, variables);
            var properties = structure.ApplyProperties
                                ? originalProperties
                             .Select(p => new Property
            {
                Name  = p.Name,
                Value = Substitute(p.Value, variables)
            })
                             .ToList()
                                : null;
            var groupTypeName = typeof(TGroup).Name;
            CreationDto <TGroup> creationDto;

            switch (groupTypeName)
            {
            case nameof(CollectorGroup):
                creationDto = new CollectorGroupCreationDto
                {
                    Name = name
                } as CreationDto <TGroup>;
                break;

            case nameof(DashboardGroup):
                creationDto = new DashboardGroupCreationDto
                {
                    ParentId = parentGroup?.Id.ToString() ?? "1",
                    Name     = name
                } as CreationDto <TGroup>;
                break;

            case nameof(DeviceGroup):
                creationDto = new DeviceGroupCreationDto
                {
                    ParentId         = parentGroup?.Id.ToString() ?? "1",
                    Name             = name,
                    AppliesTo        = Substitute(structure.AppliesTo, variables),
                    CustomProperties = properties
                } as CreationDto <TGroup>;
                break;

            case nameof(NetscanGroup):
                creationDto = new NetscanGroupCreationDto
                {
                    Name = name
                } as CreationDto <TGroup>;
                break;

            case nameof(ReportGroup):
                creationDto = new ReportGroupCreationDto
                {
                    Name = name
                } as CreationDto <TGroup>;
                break;

            case nameof(WebsiteGroup):
                creationDto = new WebsiteGroupCreationDto
                {
                    ParentId   = parentGroup?.Id.ToString() ?? "1",
                    Name       = name,
                    Properties = properties
                } as CreationDto <TGroup>;
                break;

            default:
                throw new NotSupportedException($"Creating {groupTypeName}s not supported.");
            }
            return(await portalClient
                   .CreateAsync(creationDto)
                   .ConfigureAwait(false));
        }