public AssetManager(
AssetRepository assetRepository,
AssetHierarchyRepository assetHierarchyRepository,
IRepository<AssetType, long> assetTypeRepository
)
{
_assetRepository = assetRepository;
_assetHierarchyRepository = assetHierarchyRepository;
_assetTypeRepository = assetTypeRepository;
}
public void Setup()
{
var connString = new ConnectionString();
_productRepo = new ProductRepository(connString);
_sut = new AssetRepository(connString, _productRepo);
var product = InsertProduct();
_expected = new List <AssetDto>
{
new AssetDto
{
CreatedBy = "user1",
Tag = "CRD-X-00001",
Product = product,
PaidBy = "user1",
Owner = "user1",
TeamAsset = true
},
new AssetDto
{
CreatedBy = "user2",
Tag = "CRD-X-00002",
Serial = "xx0123456789",
Product = product,
Description = "Asset Description",
InvoiceDate = DateTime.Now.AddDays(-7),
InvoiceNumber = "ii0123456789",
Price = 50.14M,
PaidBy = "user2",
Owner = "user2",
InstallDate = DateTime.Now.AddDays(2),
InstalledBy = "user2",
Remark = "To be installed within 2 days",
TeamAsset = false
}
};
_expected.ForEach(x => x.Id = _sut.Insert(x));
}
private void ConfigureRepositories(ContainerBuilder builder, bool isRelease)
{
// Client Logs Repository
builder.Register <ILogRepository>(ctx =>
new LogRepository(AzureTableStorage <LogEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage), "ClientEventLogs", _log)));
// BoxConfig Repository
builder.Register <IBoxConfigRepository>(ctx =>
new BoxConfigRepository(AzureTableStorage <BoxSizeEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage),
isRelease ? "BoxConfig" : "DEVBoxConfig",
_log)));
// Activities Repository
builder.Register <IActivityRepository>(ctx =>
new ActivityRepository(AzureTableStorage <ActivityEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage),
"Activities",
_log)));
// Asset Database Interface
// and dependecy repositories
var assetrepo = new AssetRepository(AzureTableStorage <BestBidAskEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage), "BestBidAskHistory", _log));
builder.RegisterInstance <IAssetDatabase>(new Processors.AzureQuoteDatabase(assetrepo));
// Game Database Interface
// and dependecy repositories
var userRepo = new UserRepository(
AzureTableStorage <UserEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage), "UserRepo", _log),
AzureTableStorage <UserHistoryEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage), "UserHistory", _log));
var gameRepo = new GameRepository(AzureTableStorage <GameBetEntity> .Create(
_settings.Nested(s => s.ConnectionStrings.BoxOptionsApiStorage), "GameRepo", _log));
builder.RegisterInstance <IGameDatabase>(new Processors.AzureGameDatabase(userRepo, gameRepo));
}
private async Task <DeploymentExtended> GetDeploymentAsync(AssetRepository assetRepo, IManagementClientProvider managementClientProvider)
{
using (var resourceClient = await managementClientProvider.CreateResourceManagementClient(assetRepo.SubscriptionId))
{
try
{
return(await resourceClient.Deployments.GetAsync(
assetRepo.ResourceGroupName,
assetRepo.DeploymentName));
}
catch (CloudException e)
{
if (ResourceNotFound(e))
{
return(null);
}
throw;
}
}
}
public async Task <AssetOwners> GetAssetOwners(string id)
{
AssetOwners assetOwner;
try
{
var lastBlock = await BlockchainDataProvider.GetLastBlock();
assetOwner = await AssetRepository.GetAssetOwners(id);
assetOwner.BlockHeight = lastBlock.Height;
}
catch (Exception ex)
{
await Log.WriteError(this.GetType().ToString(), "GetAssetOwners", $"asset_id{id}", ex, DateTime.Now);
return(null);
}
return(assetOwner);
}
public OrdersController(CategoryRepository categoryRepository,
UserRepository userRepository, SubcategoryRepository subcategoryRepository,
OrdersRepository ordersRepository, AssetRepository assetRepository, TaskRepository taskRepository,
ReviewRepository reviewRepository, UserService userService,
UserResponseHistoryRepository userResponseHistoryRepository,
ViewCounterService viewCounterService,
BillingService billingService, GigbucketDbContext dbContext)
{
_categoryRepository = categoryRepository;
_userRepository = userRepository;
_subcategoryRepository = subcategoryRepository;
_ordersRepository = ordersRepository;
_assetRepository = assetRepository;
_taskRepository = taskRepository;
_reviewRepository = reviewRepository;
_userService = userService;
_userResponseHistoryRepository = userResponseHistoryRepository;
_viewCounterService = viewCounterService;
_billingService = billingService;
_dbContext = dbContext;
}
/// <summary>
/// Define new assets
/// </summary>
/// <param name="allSymbols"></param>
/// <returns></returns>
private List <Asset> DefineNewAssets(IReadOnlyCollection <string> allSymbols)
{
var allAssets = AssetRepository.GetAssets();
var primaryAssets = allAssets
.Where(i => i.IsMain == true)
.ToDictionary(i => i, i => allSymbols
.Where(t => t.EndsWith(i.Name))
.Select(s => s).ToList());
return(primaryAssets
.ToDictionary(i => i.Key, i => i.Value
.Where(v => primaryAssets
.All(i2 => i2.Value
.Any(v2 => v2.Replace(i2.Key.Name, "") == v.Replace(i.Key.Name, ""))))
.Where(v => allAssets.All(a => a.Name == v.Replace(i.Key.Name, "")))
.Select(s => new Asset()
{
Name = s.Replace(i.Key.Name, ""), IsMain = false, IsStable = false
}).ToList())
.FirstOrDefault().Value);
}
//
// Deployment operations
//
public async Task BeginRepositoryDeploymentAsync(AssetRepository repository, IManagementClientProvider managementClientProvider, IAzureResourceProvider azureResourceProvider)
{
using (var client = await managementClientProvider.CreateResourceManagementClient(repository.SubscriptionId))
{
await client.ResourceGroups.CreateOrUpdateAsync(
repository.ResourceGroupName,
new ResourceGroup(
repository.Subnet.Location, // The subnet location pins us to a region
tags : AzureResourceProvider.GetEnvironmentTags(repository.EnvironmentName)));
await azureResourceProvider.AssignManagementIdentityAsync(
repository.SubscriptionId,
repository.ResourceGroupResourceId,
AzureResourceProvider.ContributorRole,
_identityProvider.GetPortalManagedServiceIdentity());
repository.DeploymentName = "FileServerDeployment";
await UpdateRepository(repository);
await DeployFileServer(repository as NfsFileServer, managementClientProvider);
}
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Accounts = new AccountRepository(_context);
Assets = new AssetRepository(_context);
Bonds = new BondRepository(_context);
Contacts = new ContactRepository(_context);
Partners = new PartnerRepository(_context);
Institutions = new InstitutionRepository(_context);
Banks = new InstitutionRepository(_context);
Currencies = new CurrencyRepository(_context);
Countries = new CountryRepository(_context);
Messages = new MessageRepository(_context);
Portfolios = new PortfolioRepository(_context);
Tasks = new TaskRepository(_context);
Reports = new ReportRepository(_context);
ExchangeRates = new ExchangeRateRepository(_context);
Returns = new ReturnRepository(_context);
HoldingPeriodReturns = new ReturnRepository(_context);
TileWidgets = new TileWidgetRepository(_context);
}
public async Task <ProvisioningState> UpdateRepositoryFromDeploymentAsync(
AssetRepository repository,
IManagementClientProvider managementClientProvider)
{
var deployment = await GetDeploymentAsync(repository, managementClientProvider);
if (deployment == null)
{
return(ProvisioningState.Failed);
}
var fileServer = repository as NfsFileServer;
if (fileServer == null)
{
return(ProvisioningState.Failed);
}
string privateIp = null;
string publicIp = null;
Enum.TryParse <ProvisioningState>(deployment.Properties.ProvisioningState, out var deploymentState);
if (deploymentState == ProvisioningState.Succeeded)
{
(privateIp, publicIp) = await GetIpAddressesAsync(fileServer, managementClientProvider);
}
if (deploymentState == ProvisioningState.Succeeded || deploymentState == ProvisioningState.Failed)
{
fileServer.ProvisioningState = deploymentState;
fileServer.PrivateIp = privateIp;
fileServer.PublicIp = publicIp;
await UpdateRepository(fileServer);
}
return(deploymentState);
}
private void SetupComputeShader(ref RenderTexture renderTexture)
{
cs = Object.Instantiate(AssetRepository.LoadCalculateSelectAreaComputeShader());
addPointKernelId = cs.FindKernel("CSAddPoint");
addLineKernelId = cs.FindKernel("CSAddLine");
fillKernelId = cs.FindKernel("CSFill");
clearKernelId = cs.FindKernel("CSClear");
inverseFillKernelId = cs.FindKernel("CSInverseFill");
cs.SetTexture(addPointKernelId, CS_VARIABLE_SELECT_AREA_TEX, renderTexture);
cs.SetTexture(addLineKernelId, CS_VARIABLE_SELECT_AREA_TEX, renderTexture);
cs.SetTexture(fillKernelId, CS_VARIABLE_SELECT_AREA_TEX, renderTexture);
cs.SetTexture(clearKernelId, CS_VARIABLE_SELECT_AREA_TEX, renderTexture);
cs.SetTexture(inverseFillKernelId, CS_VARIABLE_SELECT_AREA_TEX, renderTexture);
buffer = new ComputeBuffer(renderTexture.width * renderTexture.height, sizeof(int));
cs.SetBuffer(addPointKernelId, CS_VARIABLE_SELECT_RESULT, buffer);
cs.SetBuffer(addLineKernelId, CS_VARIABLE_SELECT_RESULT, buffer);
cs.SetBuffer(fillKernelId, CS_VARIABLE_SELECT_RESULT, buffer);
cs.SetBuffer(clearKernelId, CS_VARIABLE_SELECT_RESULT, buffer);
cs.SetBuffer(inverseFillKernelId, CS_VARIABLE_SELECT_RESULT, buffer);
cs.SetInt(CS_VARIABLE_WIDTH, renderTexture.width);
}
public void Add_WhenAssetProvided_AddEntityToDbContext_Test()
{
// Arrange
_fakeDbContext = new FinancialDbContext();
_repository = new AssetRepository(_fakeDbContext);
var expectedAsset = new Asset { /*Id = 1,*/
AssetTypeId = 2, Name = "b", IsActive = true
};
// Act
_repository.Add(expectedAsset);
var actualAsset = _fakeDbContext.Assets.Local.ToList()[0];
// Assert
Assert.Multiple(() =>
{
Assert.That(actualAsset.Id, Is.EqualTo(0), "Asset Id");
Assert.That(actualAsset.Name, Is.EqualTo(expectedAsset.Name), "Asset Name");
Assert.That(actualAsset.AssetTypeId, Is.EqualTo(expectedAsset.AssetTypeId), "AssetType Id");
Assert.That(actualAsset.IsActive, Is.EqualTo(expectedAsset.IsActive), "IsActive");
});
}
/// <summary>
/// Define new markets
/// </summary>
/// <param name="allSymbols"></param>
/// <returns></returns>
private List <Market> DefineNewMarkets(IReadOnlyCollection <string> allSymbols)
{
var allMarkets = MarketRepository.GetMarkets().ToList();
var allAssets = AssetRepository.GetAssets();
var newMarkets = new List <Market>();
foreach (var a in allAssets)
{
foreach (var a2 in allAssets.Where(i => i.IsMain || (!i.IsMain && !a.IsMain)))
{
if (allSymbols.Any(i => i == a.Name + a2.Name) && !allMarkets.Any(i => i.AssetId1 == a.Id && i.AssetId2 == a2.Id) &&
!allMarkets.Any(i => i.AssetId1 == a.Id && i.AssetId2 == a2.Id) &&
!newMarkets.Any(i => i.AssetId1 == a.Id && i.AssetId2 == a2.Id))
{
newMarkets.Add(new Market()
{
AssetId1 = a.Id, AssetId2 = a2.Id, IsActive = true
});
}
}
}
return(newMarkets);
}
public async Task <Asset> GetAsset(string id)
{
Asset asset;
try
{
asset = await AssetRepository.GetById(id);
if (asset == null)
{
asset = await BlockchainDataProvider.GetAsset(id);
await AssetRepository.Save(asset);
}
}
catch (Exception ex)
{
await Log.WriteError(this.GetType().ToString(), "GetAsset", $"asset_id:{id}", ex, DateTime.Now);
return(null);
}
return(asset);
}
public async Task UpdateRepositoryFromDeploymentAsync(AssetRepository repository)
{
if (repository.Deployment == null)
{
return;
}
var deployment = await GetDeploymentAndUpdateState(repository);
if (repository is NfsFileServer fileServer)
{
await UpdateFileServerFromDeploymentAsync(deployment, fileServer);
}
else if (repository is AvereCluster avere)
{
await UpdateAvereFromDeploymentAsync(deployment, avere);
}
else
{
throw new NotSupportedException("Unknown type of repository");
}
await UpdateRepository(repository);
}
public AssetsController()
{
_context = new Data.Contexts.AssetContext();
_repo = new CoreAutoCrudApp.Data.Repositories.AssetRepository();
}
public AssetService(AssetRepository assetRepository)
{
_assetRepository = assetRepository;
}
private async Task prepareTestData()
{
MapperConfiguration config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <AssetEntity, AssetDTO>();
cfg.CreateMap <AssetDTO, AssetEntity>();
cfg.CreateMap <AssetCategoryEntity, AssetCategoryDTO>();
cfg.CreateMap <AssetCategoryDTO, AssetCategoryEntity>();
cfg.CreateMap <AssetExtendedInfosEntity, AssetExtendedInfoDTO>();
cfg.CreateMap <AssetExtendedInfoDTO, AssetExtendedInfosEntity>();
cfg.CreateMap <AssetGroupDTO, AssetGroupEntity>();
cfg.CreateMap <AssetGroupEntity, AssetGroupDTO>();
cfg.CreateMap <AssetPairDTO, AssetPairEntity>();
cfg.CreateMap <AssetPairEntity, AssetPairDTO>();
cfg.CreateMap <AssetIssuerDTO, AssetIssuersEntity>();
cfg.CreateMap <AssetIssuersEntity, AssetIssuerDTO>();
cfg.CreateMap <MarginAssetPairDTO, MarginAssetPairsEntity>();
cfg.CreateMap <MarginAssetPairsEntity, MarginAssetPairDTO>();
cfg.CreateMap <MarginAssetDTO, MarginAssetEntity>();
cfg.CreateMap <MarginAssetEntity, MarginAssetDTO>();
cfg.CreateMap <MarginIssuerDTO, MarginIssuerEntity>();
cfg.CreateMap <MarginIssuerEntity, MarginIssuerDTO>();
cfg.CreateMap <WatchListDTO, WatchListEntity>();
cfg.CreateMap <WatchListEntity, WatchListDTO>();
cfg.CreateMap <AssetSettingsDTO, AssetSettingsEntity>();
cfg.CreateMap <AssetSettingsEntity, AssetSettingsDTO>();
cfg.CreateMap <AssetSettingsDTO, AssetSettingsCreateDTO>();
cfg.CreateMap <AssetSettingsCreateDTO, AssetSettingsDTO>();
cfg.CreateMap <Erc20TokenEntity, Erc20TokenDto>().ReverseMap();
});
this.mapper = config.CreateMapper();
var assetsFromDB = AssetRepository.GetAllAsync(
a => a.PartitionKey == AssetEntity.GeneratePartitionKey() &&
a.Type != "Erc20Token");
var AssetExtInfoFromDB = AssetExtendedInfosManager.GetAllAsync();
var assetsAttrFromDB = AssetAttributesManager.GetAllAsync();
var assetsCatsFromDB = AssetCategoryManager.GetAllAsync();
var assetsGroupsFromDB = AssetGroupsManager.GetAllAsync();
var assetPairsFromDB = AssetPairManager.GetAllAsync();
var assetSettingsFromDB = AssetSettingsManager.GetAllAsync();
var assetIssuersFromDB = AssetIssuersManager.GetAllAsync();
var marginAssetPairsFromDB = MarginAssetPairManager.GetAllAsync();
var marginAssetsFromDB = MarginAssetManager.GetAllAsync();
var marginIssuersFromDB = MarginIssuerManager.GetAllAsync();
var watchListsFromDB = WatchListRepository.GetAllAsync();
this.AllAssetsFromDB = (await assetsFromDB).Cast <AssetEntity>().ToList();
this.TestAsset = EnumerableUtils.PickRandom(AllAssetsFromDB);
this.AllAssetExtendedInfosFromDB = (await AssetExtInfoFromDB).Cast <AssetExtendedInfosEntity>().ToList();
this.TestAssetExtendedInfo = EnumerableUtils.PickRandom(AllAssetExtendedInfosFromDB);
this.AllAssetAttributesFromDB = (await assetsAttrFromDB).Cast <AssetAttributesEntity>().ToList();
this.TestAssetAttribute = EnumerableUtils.PickRandom(AllAssetAttributesFromDB);
this.AllAssetCategoriesFromDB = (await assetsCatsFromDB).Cast <AssetCategoryEntity>().ToList();
this.TestAssetCategory = EnumerableUtils.PickRandom(AllAssetCategoriesFromDB);
this.AllAssetGroupsFromDB = (await assetsGroupsFromDB).Cast <AssetGroupEntity>().ToList();
this.TestAssetGroup = EnumerableUtils.PickRandom(AllAssetGroupsFromDB);
this.AllAssetPairsFromDB = (await assetPairsFromDB).Cast <AssetPairEntity>().ToList();
this.TestAssetPair = EnumerableUtils.PickRandom(AllAssetPairsFromDB);
ConfigBuilder apiv2Config = new ConfigBuilder("ApiV2");
ApiConsumer registerConsumer1 = new ApiConsumer(apiv2Config);
ApiConsumer registerConsumer2 = new ApiConsumer(apiv2Config);
var registeredAccount1 = registerConsumer1.RegisterNewUser();
var registeredAccount2 = registerConsumer2.RegisterNewUser();
this.TestAccountId = (await registeredAccount1)?.Account.Id;
this.TestAccountIdForClientEndpoint = (await registeredAccount2)?.Account.Id;
this.TestGroupForClientEndpoint = await CreateTestAssetGroup();
this.TestAssetForClientEndpoint = await CreateTestAsset();
await AddClientToGroup(TestAccountIdForClientEndpoint, TestGroupForClientEndpoint.Name);
await AddAssetToGroup(TestAssetForClientEndpoint.Id, TestGroupForClientEndpoint.Name);
this.AllAssetSettingsFromDB = (await assetSettingsFromDB).Cast <AssetSettingsEntity>().ToList();
this.TestAssetSettings = EnumerableUtils.PickRandom(AllAssetSettingsFromDB);
this.AllAssetIssuersFromDB = (await assetIssuersFromDB).Cast <AssetIssuersEntity>().ToList();
this.TestAssetIssuer = EnumerableUtils.PickRandom(AllAssetIssuersFromDB);
this.AllMarginAssetPairsFromDB = (await marginAssetPairsFromDB).Cast <MarginAssetPairsEntity>().ToList();
this.TestMarginAssetPair = EnumerableUtils.PickRandom(AllMarginAssetPairsFromDB);
this.AllMarginAssetsFromDB = (await marginAssetsFromDB).Cast <MarginAssetEntity>().ToList();
this.TestMarginAsset = EnumerableUtils.PickRandom(AllMarginAssetsFromDB);
this.AllMarginIssuersFromDB = (await marginIssuersFromDB).Cast <MarginIssuerEntity>().ToList();
this.TestMarginIssuer = EnumerableUtils.PickRandom(AllMarginIssuersFromDB);
this.AllWatchListsFromDB = (await watchListsFromDB).Cast <WatchListEntity>().ToList();
this.AllWatchListsFromDBPredefined = AllWatchListsFromDB.Where(e => e.PartitionKey == "PublicWatchList").ToList();
this.TestWatchListPredefined = EnumerableUtils.PickRandom(AllWatchListsFromDBPredefined);
this.AllWatchListsFromDBCustom = AllWatchListsFromDB.Where(e => e.PartitionKey != "PublicWatchList").ToList();
this.TestWatchListCustom = EnumerableUtils.PickRandom(AllWatchListsFromDBCustom);
this.TestErcToken = await CreateTestErcToken();
}
public assetController()
{
_ourAssetRepository = new AssetRepository();
}
/// <summary>
/// UVマップを取得する
/// </summary>
/// <param name="mesh"></param>
/// <param name="subMeshIndex"></param>
/// <param name="texture"></param>
/// <returns></returns>
public Texture2D GenerateUVMap(Mesh mesh, MaterialInfo matInfo)
{
var texture = matInfo.Texture;
var triangles = new List <int>();
foreach (var slotIndex in matInfo.MaterialSlotIndices)
{
triangles.AddRange(mesh.GetTriangles(slotIndex));
}
var uvs = mesh.uv;
if (uvs.Count() <= 0 || triangles.Count() <= 0)
{
return(null);
}
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2(Mathf.Repeat(uvs[i].x, 1.0f), Mathf.Repeat(uvs[i].y, 1.0f));
}
ComputeShader cs = Object.Instantiate(AssetRepository.LoadCreateUVMapComputeShader());
int kernel = cs.FindKernel("CSMain");
var uvMapRT = new RenderTexture(texture.width, texture.height, 0, RenderTextureFormat.ARGB32)
{
enableRandomWrite = true,
anisoLevel = texture.anisoLevel,
mipMapBias = texture.mipMapBias,
filterMode = texture.filterMode,
wrapMode = texture.wrapMode,
wrapModeU = texture.wrapModeU,
wrapModeV = texture.wrapModeV,
wrapModeW = texture.wrapModeW
};
uvMapRT.Create();
var triangleBuffer = new ComputeBuffer(triangles.Count(), sizeof(int));
var uvBuffer = new ComputeBuffer(uvs.Count(), Marshal.SizeOf(typeof(Vector2)));
triangleBuffer.SetData(triangles);
uvBuffer.SetData(uvs);
cs.SetTexture(kernel, CS_VARIABLE_UVMAP, uvMapRT);
cs.SetInt(CS_VARIABLE_WIDTH, texture.width);
cs.SetInt(CS_VARIABLE_HEIGHT, texture.height);
cs.SetBuffer(kernel, CS_VARIABLE_TRIANGLES, triangleBuffer);
cs.SetBuffer(kernel, CS_VARIABLE_UVS, uvBuffer);
cs.Dispatch(kernel, triangles.Count() / 3, 1, 1);
triangleBuffer.Release();
uvBuffer.Release();
Texture2D uvMapTex = new Texture2D(texture.width, texture.height, TextureFormat.RGB24, false)
{
name = texture.name
};
var original = RenderTexture.active;
RenderTexture.active = uvMapRT;
uvMapTex.ReadPixels(new Rect(0, 0, uvMapRT.width, uvMapRT.height), 0, 0);
uvMapTex.Apply();
RenderTexture.active = original;
uvMapRT.Release();
uvMapTexture = uvMapTex;
return(uvMapTex);
}
public async Task <bool> RemoveRepository(AssetRepository repository)
{
return(await _configCoordinator.Remove(repository.Name));
}
public async Task UpdateRepository(AssetRepository repository, string originalName = null)
{
await _configCoordinator.Update(repository, repository.Name, originalName);
}
public AssetController(AssetRepository repository, BranchContext branchContext, ISessionContext sessionContext)
{
_repository = repository;
_branchContext = branchContext;
_sessionContext = sessionContext;
}
public async Task DeleteRepositoryResourcesAsync(AssetRepository repository, IManagementClientProvider managementClientProvider)
{
var fileServer = repository as NfsFileServer;
if (fileServer == null)
{
return;
}
using (var resourceClient = await managementClientProvider.CreateResourceManagementClient(repository.SubscriptionId))
using (var computeClient = await managementClientProvider.CreateComputeManagementClient(repository.SubscriptionId))
using (var networkClient = await managementClientProvider.CreateNetworkManagementClient(repository.SubscriptionId))
{
try
{
var virtualMachine = await computeClient.VirtualMachines.GetAsync(fileServer.ResourceGroupName, fileServer.VmName);
var nicName = virtualMachine.NetworkProfile.NetworkInterfaces[0].Id.Split("/").Last();;
var avSetName = virtualMachine.AvailabilitySet.Id?.Split("/").Last();
var osDisk = virtualMachine.StorageProfile.OsDisk.ManagedDisk.Id.Split("/").Last();
var dataDisks = virtualMachine.StorageProfile.DataDisks.Select(dd => dd.ManagedDisk.Id.Split("/").Last()).ToList();
string pip = null;
string nsg = null;
try
{
var nic = await networkClient.NetworkInterfaces.GetAsync(fileServer.ResourceGroupName, nicName);
pip = nic.IpConfigurations[0].PublicIPAddress?.Id.Split("/").Last();
nsg = nic.NetworkSecurityGroup?.Id.Split("/").Last();
}
catch (CloudException ex) when(ResourceNotFound(ex))
{
// NIC doesn't exist
}
await IgnoreNotFound(async() =>
{
await computeClient.VirtualMachines.GetAsync(fileServer.ResourceGroupName, fileServer.VmName);
await computeClient.VirtualMachines.DeleteAsync(fileServer.ResourceGroupName, fileServer.VmName);
});
if (nicName != null)
{
await IgnoreNotFound(() => networkClient.NetworkInterfaces.DeleteAsync(fileServer.ResourceGroupName, nicName));
}
var tasks = new List <Task>();
if (nsg == "nsg")
{
tasks.Add(IgnoreNotFound(() => networkClient.NetworkSecurityGroups.DeleteAsync(fileServer.ResourceGroupName, nsg)));
}
if (pip != null)
{
tasks.Add(IgnoreNotFound(() => networkClient.PublicIPAddresses.DeleteAsync(fileServer.ResourceGroupName, pip)));
}
tasks.Add(IgnoreNotFound(() => computeClient.Disks.DeleteAsync(fileServer.ResourceGroupName, osDisk)));
tasks.AddRange(dataDisks.Select(
dd => IgnoreNotFound(() => computeClient.Disks.DeleteAsync(fileServer.ResourceGroupName, dd))));
await Task.WhenAll(tasks);
if (avSetName != null)
{
await IgnoreNotFound(() => computeClient.AvailabilitySets.DeleteAsync(fileServer.ResourceGroupName, avSetName));
}
}
catch (CloudException ex) when(ResourceNotFound(ex))
{
// VM doesn't exist
}
try
{
await resourceClient.ResourceGroups.GetAsync(fileServer.ResourceGroupName);
var resources = await resourceClient.Resources.ListByResourceGroupAsync(fileServer.ResourceGroupName);
if (resources.Any())
{
_logger.LogDebug($"Skipping resource group deletion as it contains the following resources: {string.Join(", ", resources.Select(r => r.Id))}");
}
else
{
await resourceClient.ResourceGroups.DeleteAsync(fileServer.ResourceGroupName);
}
}
catch (CloudException ex) when(ResourceNotFound(ex))
{
// RG doesn't exist
}
await RemoveRepository(repository);
}
}
public DepositHandler(TimeSpan period, ILogFactory logFactory, DepositWalletRepository depositWallets, OperationRepository operations, AssetRepository assets,
StateRepository <TState> state, IBlockchainJob <TState> job, IChaosKitty chaosKitty = null) : base(period, logFactory, nameof(DepositHandler <TState>))
{
_depositWallets = depositWallets;
_operations = operations;
_assets = assets;
_state = state;
_job = job;
_chaosKitty = chaosKitty;
_log = logFactory.CreateLog(this);
}
public TestingController(IBlockchainApi api, AssetRepository assets)
{
_api = api;
_assets = assets;
}
public AssetAPIController(ILogger <AssetAPIController> logger)
{
_logger = logger;
_repo = new AssetRepository();
_context = new AssetContext();
}
public AssetsController(AssetRepository assets) => _assets = assets;
public FixtureBase()
{
var options = new DbContextOptionsBuilder <AssetContext>().UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
AssetContext = new AssetContext(options);
UnitOfWork = new UnitOfWork(AssetContext);
MemoryCache = new MemoryCache(new MemoryCacheOptions());
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(x => x.Map <Asset>(It.IsAny <AssetDto>())).Returns(new Asset()
{
ID = 1,
AssetName = "Test asset updated",
Department = Department.HQ,
Broken = false,
CountryOfDepartment = "LVA",
EMailAdressOfDepartment = "*****@*****.**",
PurchaseDate = DateTime.UtcNow
});
mapperMock.Setup(x => x.Map <AssetDto>(It.IsAny <Asset>())).Returns(new AssetDto()
{
AssetName = "Test asset",
Department = 1,
Broken = "false",
Country = "LVA",
Email = "*****@*****.**",
PurchaseDate = "01/01/2021"
});
mapperMock.Setup(x => x.Map <DepartmentDto>(It.IsAny <Department>())).Returns(new DepartmentDto());
mapperMock.Setup(x => x.Map <CountryDto>(It.IsAny <ExpandoObject>())).Returns(new CountryDto());
Mapper = mapperMock.Object;
HttpClient = new HttpClient();
GenericLogger = new Mock <ILogger <ListOfValuesService> >().Object;
var settingsServiceMock = new Mock <ISettingsService>();
settingsServiceMock.Setup(x => x.GetRestCountriesUri()).Returns(new Uri("http://localhost/countries-test"));
settingsServiceMock.Setup(x => x.GetTopLevelDomainsUri()).Returns(new Uri("http://localhost/domains-test"));
settingsServiceMock.Setup(x => x.GetExcludeCountries()).Returns(new string[1] {
"GBR"
});
settingsServiceMock.Setup(x => x.GetCurrentCulture()).Returns(new CultureInfo("en-US"));
SettingsService = settingsServiceMock.Object;
var countryRepositoryMock = new Mock <CountryRepository>(MemoryCache, HttpClient, Mapper);
countryRepositoryMock.Protected().Setup <Task <HttpResponseMessage> >("Fetch", new Uri("http://localhost/countries-test"))
.Returns((Uri uri) =>
{
return(Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(String.Empty)
}));
});
countryRepositoryMock.Protected().As <IRawResponseParsing>().Setup <IList <CountryDto> >(x => x.ParseRawResponse <CountryDto>(String.Empty))
.Returns((String x) =>
{
return(new List <CountryDto>()
{
new CountryDto()
});
});
CountryRepository = countryRepositoryMock.Object;
var topLevelDomainRepositoryMock = new Mock <TopLevelDomainRepository>(MemoryCache, HttpClient, Mapper);
topLevelDomainRepositoryMock.Protected().Setup <Task <HttpResponseMessage> >("Fetch", new Uri("http://localhost/domains-test"))
.Returns((Uri uri) =>
{
return(Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(String.Empty)
}));
});
topLevelDomainRepositoryMock.Protected().As <IRawResponseParsing>().Setup <IList <string> >(x => x.ParseRawResponse <string>(String.Empty))
.Returns((String x) =>
{
return(new List <string>()
{
String.Empty
});
});
TopLevelDomainRepository = topLevelDomainRepositoryMock.Object;
AssetRepository = new AssetRepository(AssetContext);
}
public ImageManager()
{
AssetRepository = new AssetRepository();
}
// Tear the asset repository down after the test
private void AssetTestRepositoryDown()
{
_db.Database.EnsureDeleted();
_db = null;
AssetTestRepo = null;
}
public void AssetManager()
{
int create = 0;
int update = 0;
int error = 0;
int discard = 0;
new LineColorLine().Bold("\nCarregando lista de ativos...\n");
Asset assetsApi = GetAllAssets();
for (int x = 0; x < assetsApi.data.Count; x++)
{
bool isAvailable = new AssetRepository().AssetVerification(assetsApi.data[x].idt);
if (isAvailable)
{
try
{
bool isUpdated = new AssetRepository().AssetIsUpdated(assetsApi.data[x]);
if (isUpdated)
{
//Captura os dados antigos
AssetItem assetOld = new AssetRepository().AssetGetOld(assetsApi.data[x].idt);
//Salva os dados antigos na tabela de log (Historico do ativo)
new AssetRepository().AssetSaveLog(assetOld);
//Atualiza as novas informações na tabela de ativo
new AssetRepository().AssetUpdate(assetsApi.data[x]);
new LineColorLine().Green("Ativo atualizado com sucesso: ");
Console.WriteLine(assetsApi.data[x].code + " - " + assetsApi.data[x].companyName);
update++;
}
else
{
new LineColorLine().Yellow("Ativo sem Alteração: ");
Console.WriteLine(assetsApi.data[x].code + " - " + assetsApi.data[x].companyName);
discard++;
}
}
catch (Exception e)
{
new LineColorLine().Red("ERRO: ");
Console.WriteLine(assetsApi.data[x].code + " - " + assetsApi.data[x].companyName);
Console.WriteLine($" - Details: {e.Message}");
error++;
}
}
else
{
try
{
new AssetRepository().AssetSave(assetsApi.data[x]);
new LineColorLine().Green("Ativo cadastrado com sucesso: ");
Console.WriteLine(assetsApi.data[x].code + " - " + assetsApi.data[x].companyName);
create++;
}
catch (Exception e)
{
Console.WriteLine(assetsApi.data[x].code + " - " + assetsApi.data[x].companyName + ": ERRO --> " + e.Message);
error++;
}
}
}
Console.WriteLine("\n\n");
Console.WriteLine("Ativos Cadastrados Com Sucesso: " + create);
Console.WriteLine("Ativos Atualizados Com Sucesso: " + update);
Console.WriteLine("Ativos Sem Alteração: " + discard);
Console.WriteLine("Ativos Com Erro: " + error);
new MainMenu().GoBackMainMenu();
}
