static void SetupSeq() { PrintTitle("Setting up Seq"); var connection = new SeqConnection(SeqUrl); var entity = new ApiKeyEntity { Title = AppName, AssignedPermissions = new HashSet <Permission> { Permission.Ingest }, InputSettings = new InputSettingsPart { MinimumLevel = LogEventLevel.Debug, AppliedProperties = new List <InputAppliedPropertyPart> { new InputAppliedPropertyPart { Name = "app", Value = AppName } } } }; Task("Add API key", () => { var result = connection.ApiKeys.AddAsync(entity).Result; GeneratedOutput.Add("SeqConfiguration::ApiKey", result.Token); }); }
public async Task <AddApiKeyResponse> Handle(AddApiKeyRequest request, CancellationToken cancellationToken) { var existing = await _storeDbContext .ApiKeys .Where(ak => ak.Name == request.Name) .SingleOrDefaultAsync(); if (existing == null) { var apiKey = new ApiKeyEntity( request.Name, ApiKeyGenerator.CreateApiKey(), request.ValidTo ?? DateTime.UtcNow.AddYears(1)); _storeDbContext.Add(apiKey); await _storeDbContext.SaveChangesAsync(cancellationToken); return(new AddApiKeyResponse() { ApiKeyId = apiKey.Id, ApiKey = apiKey.Key }); } Log.ApiKeyAlreadyExist(_logger, request.Name); throw new InvalidOperationException($"A ApiKey with name {request.Name} already exist."); }
public static ApiKeyEntity Map(Character source, ApiKeyEntity target) { target.EntityId = (int)source.CharacterId; target.Name = source.CharacterName; target.Type = "Character"; return(target); }
public async Task <IndustryJobs> GetIndustryJobs(ApiKey key, ApiKeyEntity entity) { var character = new Character(key.ApiKeyId, key.VCode, entity.EntityId); var result = (await character.GetIndustryJobsAsync().ConfigureAwait(false)).Result; return(result); }
/// <summary> /// Retrieve a detailed metric for the API key. /// </summary> /// <param name="entity">The API key to retrieve metrics for.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param> /// <param name="measurement">The measurement to get.</param> /// <returns></returns> public async Task <MeasurementTimeseriesPart> GetMeasurementTimeseriesAsync(ApiKeyEntity entity, string measurement, CancellationToken cancellationToken = default) { var parameters = new Dictionary <string, object> { ["id"] = entity.Id, ["measurement"] = measurement }; return(await GroupGetAsync <MeasurementTimeseriesPart>("Metric", parameters, cancellationToken)); }
static ApplicationHelper() { Instance = new ApplicationHelper(); TaxRate = 0.75; BrokerFeeRate = 0.73; ActiveEntity = new ApiKeyEntity(); ActiveEntity.Name = "No Active Entity"; StationId = 60003760; }
public CharacterData GetCharacterData(ApiKey key, ApiKeyEntity entity) { var data = new CharacterData(); var ckey = new CharacterKey(key.ApiKeyId, key.VCode); Character character = ckey.Characters.Single(c => c.CharacterId == entity.EntityId); EveApiResponse <CharacterInfo> info = character.GetCharacterInfo(); return(data); }
public async Task <AssetList> GetAssetsAsync(ApiKey key, ApiKeyEntity entity) { var data = new CharacterData(); var ckey = await new CharacterKey(key.ApiKeyId, key.VCode).InitAsync().ConfigureAwait(false); Character character = ckey.Characters.Single(c => c.CharacterId == entity.EntityId); var assets = await character.GetAssetListAsync().ConfigureAwait(false); return(assets.Result); }
public async Task <string> Get() { TableOperation retrieveOperation = TableOperation.Retrieve <ApiKeyEntity>("apikey", "apikey"); TableResult result = await _table.ExecuteAsync(retrieveOperation); ApiKeyEntity apiKeyEntity = (ApiKeyEntity)result.Result; return(apiKeyEntity.ApiKey); }
public async Task CreateAsync(CreateApiKeyRequest request) { var entity = new ApiKeyEntity { Owner = request.Owner, Permissions = request.Permissions }; await(await _container).CreateItemAsync(await _entityMutator.CreateMetadataAsync(entity, request.SharedWith)); }
public async Task UpdateAsync(string key, UpdateApiKeyRequest request) { var entity = await _readRepository.GetByKeyAsync(key); var updatedEntity = new ApiKeyEntity { Owner = request.Owner ?? entity.Owner, Permissions = request.Permissions ?? entity.Permissions }; await(await _container).ReplaceItemAsync( await _entityMutator.UpdateMetadataAsync(updatedEntity, entity, request.SharedWith), key ); }
public static async Task CreateApiKey(string keyName, string env) { ApiKeyEntity templateKey = await _seqConnection.ApiKeys.TemplateAsync(); templateKey.Title = keyName; InputAppliedPropertyPart _property = new InputAppliedPropertyPart(); _property.Name = "Environment"; _property.Value = _envKV.GetValueOrDefault(env); templateKey.AppliedProperties.Add(_property); if (applyChanges) { await _seqConnection.ApiKeys.AddAsync(templateKey); } }
public async Task <AddApiKeyResponse> Handle(AddApiKeyRequest request, CancellationToken cancellationToken) { var existing = await _storeDbContext .ApiKeys .Where(ak => ak.Name == request.Name) .SingleOrDefaultAsync(); if (existing == null) { var key = ApiKeyGenerator.CreateApiKey(); var apiKey = new ApiKeyEntity( name: request.Name, key: key, validTo: request.ValidTo ?? DateTime.UtcNow.AddYears(1)); var apiKeyPermissions = new PermissionEntity() { SubjectId = key, Kind = SubjectType.Application, ApplicationRole = Enum.Parse <ApplicationRole>(request.ActAs, ignoreCase: true) }; _storeDbContext .Add(apiKeyPermissions); _storeDbContext .Add(apiKey); await _storeDbContext.SaveChangesAsync(cancellationToken); return(new AddApiKeyResponse() { Name = apiKey.Name, Key = key }); } Log.ApiKeyAlreadyExist(_logger, request.Name); throw new InvalidOperationException($"A ApiKey with name {request.Name} already exist."); }
public void FirstRun(ApiKeyEntity apiKeyEntity) { // Create the table client CloudTableClient tableClient = _storageAccount.CreateCloudTableClient(); // Create the table if it doesn't exist const string tableName = "keys"; tableClient.CreateTableIfNotExist(tableName); // Get the data service context TableServiceContext serviceContext = tableClient.GetDataServiceContext(); // Add the new customer to the people table serviceContext.AddObject("keys", apiKeyEntity); // Submit the operation to the table service serviceContext.SaveChangesWithRetries(); ApiKeyEntity retrieveApiKey = RetrieveApiKey(apiKeyEntity.ApiKey); }
private async Task InitializeAsync() { IEnumerable <ApiKeyEntity> entities = await _shellService.GetAllActiveEntities(); Entities = new BindableCollection <ApiKeyEntity>(entities); int activeEntityId = Settings.Default.ActiveEntity; if (activeEntityId != 0) { ApiKeyEntity entity = Entities.Single(e => e.Id == activeEntityId); if (entity != null) { ApplicationHelper.ActiveEntity = entity; } } StatusMessage = "Initializing data..."; await IoC.Get <EveStaticDataRepository>().Initialize; StatusMessage = "Initializing modules..."; await _moduleService.InitialiseAsync(); StatusMessage = "Ready"; }
public async Task <int> Handle(AddApiKeyRequest request, CancellationToken cancellationToken) { var existing = await _storeDbContext .ApiKeys .Where(ak => ak.Name == request.Name) .SingleOrDefaultAsync(); if (existing == null) { var apiKey = new ApiKeyEntity( request.Name, request.Description, ApiKeyGenerator.CreateApiKey()); _storeDbContext.Add(apiKey); await _storeDbContext.SaveChangesAsync(cancellationToken); return(apiKey.Id); } Log.ApiKeyAlreadyExist(_logger, request.Name); throw new InvalidOperationException($"A ApiKey with name {request.Name} already exist."); }
/// <summary> /// Update an existing API key. /// </summary> /// <param name="entity">The API key to update.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param> /// <returns>A task indicating completion.</returns> /// <remarks>The API key token itself cannot be updated using this method.</remarks> public async Task UpdateAsync(ApiKeyEntity entity, CancellationToken cancellationToken = default) { await Client.PutAsync(entity, "Self", entity, cancellationToken : cancellationToken).ConfigureAwait(false); }
/// <summary> /// Add a new API key. /// </summary> /// <param name="entity">The API key to add.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param> /// <returns>The API key, with server-allocated properties, such as <see cref="ApiKeyEntity.Token"/> (if server-allocated), /// and <see cref="Entity.Id"/>, initialized.</returns> /// <remarks>Leaving the token blank will cause the server to generate a cryptographically random API key token. After creation, the first /// few characters of the token will be readable from <see cref="ApiKeyEntity.TokenPrefix"/>, but because only a cryptographically-secure /// hash of the token is stored internally, the token itself cannot be retrieved.</remarks> public async Task <ApiKeyEntity> AddAsync(ApiKeyEntity entity, CancellationToken cancellationToken = default) { return(await GroupCreateAsync <ApiKeyEntity, ApiKeyEntity>(entity, cancellationToken : cancellationToken).ConfigureAwait(false)); }
public ActiveEntityChangedEvent(ApiKeyEntity newEntity) { NewEntity = newEntity; }
private static async Task <IList <JournalEntry> > getJournalEntriesAsync(ApiKey key, ApiKeyEntity apiKeyEntity, int rowLimit, long limitId = 0) { var list = new List <JournalEntry>(); var ckey = await new CharacterKey(key.ApiKeyId, key.VCode).InitAsync().ConfigureAwait(false); Character entity = ckey.Characters.Single(c => c.CharacterId == apiKeyEntity.EntityId); var res = await entity.GetWalletJournalAsync(rowLimit).ConfigureAwait(false); while (res.Result.Journal.Count > 0) { var sortedList = res.Result.Journal.OrderByDescending(f => f.RefId); foreach (var entry in sortedList) { if (entry.RefId == limitId) { return(list); } var newEntry = new JournalEntry(); newEntry.ApiKeyEntity_Id = apiKeyEntity.Id; list.Add(ApiEntityMapper.Map(entry, newEntry)); } try { res = await entity.GetWalletJournalAsync(rowLimit, sortedList.Last().RefId).ConfigureAwait(false); } catch (Exception) { return(list); } } return(list); }
public async Task <ApiKeyEntity> AddAsync(ApiKeyEntity entity) { return(await Client.PostAsync <ApiKeyEntity, ApiKeyEntity>(entity, "Create", entity).ConfigureAwait(false)); }
public Task <IList <JournalEntry> > GetAllJournalEntriesAsync(ApiKey key, ApiKeyEntity entity, Func <JournalEntry> transactionFactory) { return(getJournalEntriesAsync(key, entity, 2560)); }
public async Task RemoveAsync(ApiKeyEntity entity) { await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false); }
public Task <IList <Transaction> > GetAllTransactionsAsync(ApiKey key, ApiKeyEntity entity, Func <Transaction> transactionFactory) { return(getTransactionsAsync(key, entity, 2560)); }
public Task <IList <JournalEntry> > GetNewJournalEntriesAsync(ApiKey key, ApiKeyEntity entity, long latestId) { return(getJournalEntriesAsync(key, entity, 2560, latestId)); }
public Task <IList <Transaction> > GetNewTransactionsAsync(ApiKey key, ApiKeyEntity entity, long latestId) { return(getTransactionsAsync(key, entity, 2560, latestId)); }
public string GetPortraint(ApiKeyEntity entity) { return(new Image().GetCharacterPortrait(entity.EntityId, Image.CharacterPortraitSize.X256, @"c:\Temp")); }
public async Task <MarketOrders> GetMarketOrdersAsync(ApiKey activeKey, ApiKeyEntity apiKeyEntity) { var entity = new Character(activeKey.ApiKeyId, activeKey.VCode, apiKeyEntity.EntityId); return((await entity.GetMarketOrdersAsync()).Result); }
public async Task UpdateAsync(ApiKeyEntity entity) { await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false); }
private static async Task <IList <Transaction> > getTransactionsAsync(ApiKey key, ApiKeyEntity apiKeyEntity, int rowLimit, long limitId = 0) { var transactions = new List <Transaction>(); var ckey = await new CharacterKey(key.ApiKeyId, key.VCode).InitAsync().ConfigureAwait(false); Character entity = ckey.Characters.Single(c => c.CharacterId == apiKeyEntity.EntityId); EveApiResponse <WalletTransactions> res = await entity.GetWalletTransactionsAsync(rowLimit).ConfigureAwait(false); while (res.Result.Transactions.Count > 0) { IOrderedEnumerable <WalletTransactions.Transaction> sortedList = res.Result.Transactions.OrderByDescending(f => f.TransactionId); foreach (WalletTransactions.Transaction transaction in sortedList) { if (transaction.TransactionId == limitId) { return(transactions); } var newTransaction = new Transaction(); newTransaction.ApiKeyEntity_Id = apiKeyEntity.Id; transactions.Add(ApiEntityMapper.Map(transaction, newTransaction)); } res = entity.GetWalletTransactions(rowLimit, sortedList.Last().TransactionId); } return(transactions); }