public async Task<HttpResponseMessage> PostImage()
{
var context = new StorageContext();
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
// Get and create the container
var blobContainer = context.BlobClient.GetContainerReference(CONTAINER);
blobContainer.CreateIfNotExists();
string root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new MultipartFormDataStreamProvider(root);
try
{
// Read the form data and return an async task.
await Request.Content.ReadAsMultipartAsync(provider);
// This illustrates how to get the file names for uploaded files.
foreach (var fileData in provider.FileData)
{
var filename = fileData.Headers.ContentDisposition.Name.Replace("\"", "");
var blob = blobContainer.GetBlockBlobReference(filename);
blob.Properties.ContentType = fileData.Headers.ContentType.MediaType;
using (var filestream = File.OpenRead(fileData.LocalFileName))
{
blob.UploadFromStream(filestream);
}
File.Delete(fileData.LocalFileName);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
catch (System.Exception e)
{
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
}
public static bool SetDeal(StorageContext context, byte[] hashDeal, string key, object value)
{
Storage.Put(context, hashDeal.Concat(key.AsByteArray()), (byte[])value);
return(true);
}
public static bool SetAvailableForWithdrawalSTM(StorageContext context, BigInteger availableForWithdrawalSTM)
{
Storage.Put(context, AVAILABLE_FOR_WITHDRAWAL_STM_KEY, availableForWithdrawalSTM);
return(true);
}
public AgentRepository(StorageContext context, ILogger <Agent> logger, IHttpContextAccessor httpContextAccessor) : base(context, logger, httpContextAccessor)
{
}
public static void Put(StorageContext context, string key, string value)
{
Put(context, Op.String2Bytes(key), value);
}
public static void Put(StorageContext context, byte[] key, BigInteger value)
{
Put(context, key, Op.BigInt2Bytes(value));
}
public DbOwnersRepository(StorageContext context)
{
_dbContext = context;
}
public DBKittensRepository(StorageContext context)
{
_dbContext = context;
}
public VMObject InvokeScript(StorageContext storage, byte[] script)
{
return(InvokeScript(storage, script, Timestamp.Now));
}
public VMObject InvokeContract(StorageContext storage, string contractName, string methodName, params object[] args)
{
return(InvokeContract(storage, contractName, methodName, Timestamp.Now, args));
}
// NOTE this lists only nfts owned in this chain
public BigInteger[] GetOwnedTokens(StorageContext storage, string tokenSymbol, Address address)
{
var ownership = new OwnershipSheet(tokenSymbol);
return(ownership.Get(storage, address).ToArray());
}
public BigInteger GetTokenSupply(StorageContext storage, string symbol)
{
var supplies = new SupplySheet(symbol, this, Nexus);
return(supplies.GetTotal(storage));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <BlockcoreDataVaultSettings>(this.Configuration.GetSection("Blockcore"));
var camelCaseConventionPack = new ConventionPack {
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register("CamelCase", camelCaseConventionPack, type => true);
//BsonClassMap.RegisterClassMap<Entity>();
//BsonClassMap.RegisterClassMap<BsonDocument>(cm => {
// cm.AutoMap();
// cm.SetIdMember(cm.GetMemberMap("Id"));
// //cm.SetIdMember(cm.GetMemberMapForElement("Id"));
// cm.IdMemberMap.SetIdGenerator(GuidGenerator.Instance);
//});
var config = new ServerConfig();
Configuration.Bind(config);
services.AddResponseCompression();
services.AddMemoryCache();
var todoContext = new StorageContext(config.MongoDB);
var repo = new StorageRepository(todoContext);
services.AddSingleton <IStorageRepository>(repo);
// Add service and create Policy to allow Cross-Origin Requests
services.AddCors
(
options =>
{
options.AddPolicy
(
"CorsPolicy",
builder =>
{
var allowedDomains = new[] { "http://localhost", "http://localhost:4200", "http://localhost:8080" };
builder
.WithOrigins(allowedDomains)
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials();
}
);
});
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = ApiKeyAuthenticationOptions.DefaultScheme;
options.DefaultChallengeScheme = ApiKeyAuthenticationOptions.DefaultScheme;
})
.AddApiKeySupport(options => { });
services.AddSingleton <IAuthorizationHandler, OnlyUsersAuthorizationHandler>();
services.AddSingleton <IAuthorizationHandler, OnlyAdminsAuthorizationHandler>();
services.AddSingleton <IGetApiKeyQuery, AppSettingsGetApiKeyQuery>();
services.AddControllersWithViews(options =>
{
options.Filters.Add(typeof(LoggingActionFilter));
}).AddNewtonsoftJson(options =>
{
// Serializer.RegisterFrontConverters(options.SerializerSettings);
options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
});
services.AddSwaggerGen(
options =>
{
string assemblyVersion = typeof(Startup).Assembly.GetName().Version.ToString();
string description = "Access to the Blockcore Data Vault.";
description += " Authorization is enabled on this API. You must have API key to perform calls that are not public. Future versions will require DID, not API key.";
options.AddSecurityDefinition(ApiKeyConstants.HeaderName, new OpenApiSecurityScheme
{
Description = "API key needed to access the endpoints. Vault-Api-Key: YOUR_KEY",
In = ParameterLocation.Header,
Name = ApiKeyConstants.HeaderName,
Type = SecuritySchemeType.ApiKey
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Name = ApiKeyConstants.HeaderName,
Type = SecuritySchemeType.ApiKey,
In = ParameterLocation.Header,
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = ApiKeyConstants.HeaderName
},
},
new string[] {}
}
});
options.SwaggerDoc("dv", // "dv" = Data Vault, "edv" = Encrypted Data Vault
new OpenApiInfo
{
Title = "Blockcore Data Vault API",
Version = assemblyVersion,
Description = description,
Contact = new OpenApiContact
{
Name = "Blockcore",
Url = new Uri("https://www.blockcore.net/")
}
});
SwaggerApiDocumentationScaffolder.Scaffold(options);
options.DescribeAllEnumsAsStrings();
options.DescribeStringEnumsInCamelCase();
options.EnableAnnotations();
});
services.AddSwaggerGenNewtonsoftSupport(); // explicit opt-in - needs to be placed after AddSwaggerGen()
// services.AddControllersWithViews();
// In production, the Angular files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
}
public Bot(CommandService commandService, StorageContext prefixContext, ICustomLogger customLogger)
{
_commandService = commandService;
_prefixContext = prefixContext;
_customLogger = customLogger;
}
public DbPicturesRepository(StorageContext context)
{
_dbContext = context;
}
public List <Marker> GetAllMarkers(bool includeDeleted = false)
{
using (var ctx = new StorageContext()) {
return(ctx.Markers.Where(m => includeDeleted || m.Deleted.HasValue == false).ToList());
}
}
public DbOwnersRepository(StorageContext context)
{
_dbContext = context;
}
public bool IsContractDeployed(StorageContext storage, string name)
{
return(IsContractDeployed(storage, SmartContract.GetAddressForName(name)));
}
public UserAgreementRepository(StorageContext context, ILogger <UserAgreement> logger) : base(context, logger)
{
}
private StorageList GetSwapListForAddress(StorageContext storage, Address address)
{
var key = ByteArrayUtils.ConcatBytes(Encoding.UTF8.GetBytes(".swapaddr"), address.ToByteArray());
return(new StorageList(key, storage));
}
public static byte[] Get(StorageContext context, string key) => Get(context, Op.String2Bytes(key));
private StorageMap GetSwapMap(StorageContext storage)
{
var key = Encoding.UTF8.GetBytes(".swapmap");
return(new StorageMap(key, storage));
}
public static void Put(StorageContext context, byte[] key, string value)
{
Put(context, key, Op.String2Bytes(value));
}
public Hash[] GetSwapHashesForAddress(StorageContext storage, Address address)
{
var list = GetSwapListForAddress(storage, address);
return(list.All <Hash>());
}
public static void Delete(StorageContext context, string key)
{
Delete(context, Op.String2Bytes(key));
}
public void CloseBlock(Block block, StorageContext storage)
{
var rootStorage = this.IsRoot ? storage : Nexus.RootStorage;
if (block.Height > 1)
{
var prevBlock = GetBlockByHash(block.PreviousHash);
if (prevBlock.Validator != block.Validator)
{
block.Notify(new Event(EventKind.ValidatorSwitch, block.Validator, "block", Serialization.Serialize(prevBlock)));
}
}
var balance = new BalanceSheet(DomainSettings.FuelTokenSymbol);
var blockAddress = Address.FromHash("block");
var totalAvailable = balance.Get(storage, blockAddress);
var targets = new List <Address>();
if (Nexus.HasGenesis)
{
var validators = Nexus.GetValidators();
var totalValidators = Nexus.GetPrimaryValidatorCount();
for (int i = 0; i < totalValidators; i++)
{
var validator = validators[i];
if (validator.type != ValidatorType.Primary)
{
continue;
}
targets.Add(validator.address);
}
}
else
if (totalAvailable > 0)
{
targets.Add(Nexus.GetGenesisAddress(rootStorage));
}
if (targets.Count > 0)
{
if (!balance.Subtract(storage, blockAddress, totalAvailable))
{
throw new BlockGenerationException("could not subtract balance from block address");
}
var amountPerValidator = totalAvailable / targets.Count;
var leftOvers = totalAvailable - (amountPerValidator * targets.Count);
foreach (var address in targets)
{
BigInteger amount = amountPerValidator;
if (address == block.Validator)
{
amount += leftOvers;
}
// TODO this should use triggers when available...
if (!balance.Add(storage, address, amount))
{
throw new BlockGenerationException($"could not add balance to {address}");
}
var eventData = Serialization.Serialize(new TokenEventData(DomainSettings.FuelTokenSymbol, amount, this.Name));
block.Notify(new Event(EventKind.TokenClaim, address, "block", eventData));
}
}
}
public static BigInteger AvailableForWithdrawalSTM(StorageContext context)
{
return(Storage.Get(context, AVAILABLE_FOR_WITHDRAWAL_STM_KEY).AsBigInteger());
}
private void GetCharacterById(ICommunicationMessage e, Guid characterId)
{
using (var ctx = new StorageContext()) {
e.Reply(ctx.Characters.FirstOrDefault(c => c.Id == characterId));
}
}
public static int GetStatusDeal(StorageContext context, byte[] hashDeal)
{
return((int)GetDeal(context, hashDeal, "status"));
}
protected async void Save <T>(IRpcEvent e, T vehicle) where T : Vehicle
{
using (var context = new StorageContext())
using (var transaction = context.Database.BeginTransaction())
{
var dbVeh = context.Vehicles
.Include(v => v.Extras)
.Include(v => v.Wheels)
.Include(v => v.Doors)
.Include(v => v.Windows)
.Include(v => v.Seats)
.Include(v => v.Mods)
.FirstOrDefault(c => c.Id == vehicle.Id);
if (dbVeh == null ||
dbVeh.TrackingUserId != Guid.Empty && e.User.Id != dbVeh.TrackingUserId)
{
return;
}
vehicle.Created = dbVeh.Created;
context.Entry(dbVeh).CurrentValues.SetValues(vehicle);
// Wheels
foreach (var dbVehWheel in dbVeh.Wheels.ToList())
{
if (vehicle.Wheels.All(m => m.Position != dbVehWheel.Position))
{
context.VehicleWheels.Remove(dbVehWheel);
}
}
foreach (var vehWheel in vehicle.Wheels)
{
var dbVehWheel = dbVeh.Wheels.SingleOrDefault(s => s.Position == vehWheel.Position);
if (dbVehWheel != null)
{
vehWheel.Id = dbVehWheel.Id;
vehWheel.VehicleId = vehicle.Id;
context.Entry(dbVehWheel).CurrentValues.SetValues(vehWheel);
// We have to manually set enums for some reason...
context.Entry(dbVehWheel).Property("Position").CurrentValue = vehWheel.Position;
}
else
{
dbVeh.Wheels.Add(vehWheel);
}
}
// Doors
foreach (var dbVehDoor in dbVeh.Doors.ToList())
{
if (vehicle.Doors.All(m => m.Index != dbVehDoor.Index))
{
context.VehicleDoors.Remove(dbVehDoor);
}
}
foreach (var vehDoor in vehicle.Doors)
{
var dbVehDoor = dbVeh.Doors.SingleOrDefault(s => s.Index == vehDoor.Index);
if (dbVehDoor != null)
{
vehDoor.Id = dbVehDoor.Id;
vehDoor.VehicleId = vehicle.Id;
context.Entry(dbVehDoor).CurrentValues.SetValues(vehDoor);
}
else
{
dbVeh.Doors.Add(vehDoor);
}
}
// Extras
foreach (var dbVehExtra in dbVeh.Extras.ToList())
{
if (vehicle.Extras.All(m => m.Index != dbVehExtra.Index))
{
context.VehicleExtras.Remove(dbVehExtra);
}
}
foreach (var vehExtra in vehicle.Extras)
{
var dbVehExtra = dbVeh.Extras.SingleOrDefault(s => s.Index == vehExtra.Index);
if (dbVehExtra != null)
{
vehExtra.Id = dbVehExtra.Id;
vehExtra.VehicleId = vehicle.Id;
context.Entry(dbVehExtra).CurrentValues.SetValues(vehExtra);
}
else
{
dbVeh.Extras.Add(vehExtra);
}
}
// Windows
foreach (var dbVehWindow in dbVeh.Windows.ToList())
{
if (vehicle.Windows.All(m => m.Index != dbVehWindow.Index))
{
context.VehicleWindows.Remove(dbVehWindow);
}
}
foreach (var vehWindow in vehicle.Windows)
{
var dbVehWindow = dbVeh.Windows.SingleOrDefault(s => s.Index == vehWindow.Index);
if (dbVehWindow != null)
{
vehWindow.Id = dbVehWindow.Id;
vehWindow.VehicleId = vehicle.Id;
context.Entry(dbVehWindow).CurrentValues.SetValues(vehWindow);
}
else
{
dbVeh.Windows.Add(vehWindow);
}
}
// Seats
foreach (var dbVehSeat in dbVeh.Seats.ToList())
{
if (vehicle.Seats.All(m => m.Index != dbVehSeat.Index))
{
context.VehicleSeats.Remove(dbVehSeat);
}
}
foreach (var vehSeat in vehicle.Seats)
{
var dbVehSeat = dbVeh.Seats.SingleOrDefault(s => s.Index == vehSeat.Index);
if (dbVehSeat != null)
{
vehSeat.Id = dbVehSeat.Id;
vehSeat.VehicleId = vehicle.Id;
context.Entry(dbVehSeat).CurrentValues.SetValues(vehSeat);
}
else
{
dbVeh.Seats.Add(vehSeat);
}
}
// TODO: Mods
await context.SaveChangesAsync();
transaction.Commit();
}
}
public static Object HandleMethod(StorageContext context, string operation, params object[] args)
{
if (operation.Equals(METHOD_AVAILABLE_FOR_WITHDRAWAL))
{
return(AvailableForWithdrawal(context));
}
if (operation.Equals(METHOD_AVAILABLE_FOR_WITHDRAWAL_STM))
{
return(AvailableForWithdrawalSTM(context));
}
if (operation.Equals(METHOD_SET_AVAILABLE_FOR_WITHDRAWAL))
{
return(SetAvailableForWithdrawal(context, (BigInteger)args[0]));
}
if (operation.Equals(METHOD_SET_AVAILABLE_FOR_WITHDRAWAL_STM))
{
return(SetAvailableForWithdrawal(context, (BigInteger)args[0]));
}
if (operation.Equals(METHOD_PAY))
{
return(Pay(context, (byte[])args[0], (byte[])args[1], (byte[])args[2], (BigInteger)args[3], (BigInteger)args[4], (byte[])args[5]));
}
if (operation.Equals(METHOD_PAY_ALTCOIN))
{
return(PayAltCoin(context, (byte[])args[0], (byte[])args[1], (byte[])args[2], (BigInteger)args[3], (BigInteger)args[4], (byte[])args[5]));
}
if (operation.Equals(METHOD_GET_DEAL))
{
return(GetDeal(context, (byte[])args[0], (string)args[1]));
}
if (operation.Equals(METHOD_SET_DEAL))
{
return(SetDeal(context, (byte[])args[0], (string)args[1], args[2]));
}
if (operation.Equals(METHOD_VERIFY_DEAL))
{
return(VerifyDeal(context, (byte[])args[0], (byte[])args[1]));
}
if (operation.Equals(METHOD_START_DEAL_FOR_USER))
{
return(StartDealForUser(context, (byte[])args[0], (byte[])args[1], (byte[])args[2], (BigInteger)args[3], (BigInteger)args[4], (bool)args[5]));
}
if (operation.Equals(METHOD_WITHDRAW_COMMISSION_TO_ADDRESS))
{
return(WithdrawCommissionToAddress(context, (byte[])args[0], (BigInteger)args[1]));
}
if (operation.Equals(METHOD_WITHDRAW_COMMISSION_TO_ADDRESS_ALTCOIN))
{
return(WithdrawCommissionToAddressAltcoin(context, (byte[])args[0], (BigInteger)args[1]));
}
if (operation.Equals(METHOD_GET_STATUS_DEAL))
{
return(GetStatusDeal(context, (byte[])args[0]));
}
if (operation.Equals(METHOD_RELEASE_TOKENS))
{
return(ReleaseTokens(context, (byte[])args[0], (BigInteger)args[1]));
}
if (operation.Equals(METHOD_RELEASE_TOKENS_FORCE))
{
return(ReleaseTokensForce(context, (byte[])args[0]));
}
if (operation.Equals(METHOD_CANCEL_SELLER))
{
return(CancelSeller(context, (byte[])args[0], (BigInteger)args[1]));
}
if (operation.Equals(METHOD_APPROVE_DEAL))
{
return(ApproveDeal(context, (byte[])args[0]));
}
if (operation.Equals(METHOD_TRANSFER_MINUS_COMMISSION))
{
return(TransferMinusCommission(context, (byte[])args[0], (BigInteger)args[1], (BigInteger)args[2]));
}
if (operation.Equals(METHOD_TRANSFER_MINUS_COMMISSION_ALTCOIN))
{
return(TransferMinusCommissionAltCoin(context, (byte[])args[0], (BigInteger)args[1], (BigInteger)args[2]));
}
if (operation.Equals(METHOD_TRANSFER_TOKEN))
{
return(TransferToken(context, (byte[])args[0], (byte[])args[1], (BigInteger)args[2]));
}
if (operation.Equals(METHOD_TRANSFER_TOKEN_FROM))
{
return(TransferTokenFrom(context, (byte[])args[0], (byte[])args[1], (byte[])args[2], (BigInteger)args[3]));
}
if (operation.Equals(METHOD_APPROVE_TOKEN))
{
return(ApproveToken(context, (byte[])args[0], (byte[])args[1], (BigInteger)args[2]));
}
if (operation.Equals(METHOD_GET_CHECKPOINT))
{
return(Storage.Get(context, (byte[])args[0]));
}
return(false);
}
/// <summary>
/// Constructor for AuditLogRepository
/// </summary>
/// <param name="context"></param>
/// <param name="logger"></param>
public AuditLogRepository(StorageContext context, ILogger <AuditLog> logger, IHttpContextAccessor httpContextAccessor) : base(context, logger, httpContextAccessor)
{
}
public DbBreedsRepository(StorageContext context)
{
_dbContext = context;
}
public ProviderRepository(StorageContext context)
{
this.db = context;
}
public void TestStorage_Put()
{
var engine = GetEngine(false, true);
engine.CurrentContext.EvaluationStack.Push(1);
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//CheckStorageContext fail
var key = new byte[] { 0x01 };
var value = new byte[] { 0x02 };
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
var state = TestUtils.GetContract();
var storageContext = new StorageContext
{
ScriptHash = state.ScriptHash,
IsReadOnly = false
};
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//key.Length > MaxStorageKeySize
key = new byte[InteropService.Storage.MaxKeySize + 1];
value = new byte[] { 0x02 };
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//value.Length > MaxStorageValueSize
key = new byte[] { 0x01 };
value = new byte[ushort.MaxValue + 1];
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//context.IsReadOnly
key = new byte[] { 0x01 };
value = new byte[] { 0x02 };
storageContext.IsReadOnly = true;
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//storage value is constant
var snapshot = Blockchain.Singleton.GetSnapshot();
state.Manifest.Features = ContractFeatures.HasStorage;
var storageKey = new StorageKey
{
ScriptHash = state.ScriptHash,
Key = new byte[] { 0x01 }
};
var storageItem = new StorageItem
{
Value = new byte[] { 0x01, 0x02, 0x03, 0x04 },
IsConstant = true
};
snapshot.Contracts.Add(state.ScriptHash, state);
snapshot.Storages.Add(storageKey, storageItem);
engine = new ApplicationEngine(TriggerType.Application, null, snapshot, 0);
engine.LoadScript(new byte[] { 0x01 });
key = new byte[] { 0x01 };
value = new byte[] { 0x02 };
storageContext.IsReadOnly = false;
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeFalse();
//success
storageItem.IsConstant = false;
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeTrue();
//value length == 0
key = new byte[] { 0x01 };
value = new byte[0];
engine.CurrentContext.EvaluationStack.Push(value);
engine.CurrentContext.EvaluationStack.Push(key);
engine.CurrentContext.EvaluationStack.Push(new InteropInterface <StorageContext>(storageContext));
InteropService.Invoke(engine, InteropService.Storage.Put).Should().BeTrue();
}
public DbDisplayPlacesRepository(StorageContext context)
{
_dbContext = context;
}
