/// <summary>
/// Enables working with smart search index from Kentico web application.
/// </summary>
/// <param name="kenticoRootPath">The absolute path to the folder with Kentico web application.</param>
private static void ConfigureSmartSearchStorageMapping(string kenticoRootPath)
{
var storageProvider = new StorageProvider
{
CustomRootPath = kenticoRootPath
};
StorageHelper.MapStoragePath("~/App_Data/CMSModules/SmartSearch", storageProvider);
}
public StorageProvider GetStorageProvider()
{
if (_storageProvider == null)
{
_storageProvider = StorageProviders.Resolve(StorageProviderName);
_storageProvider.Initialize();
}
return(_storageProvider);
}
public CheckContainerInfo GetCheckContainerInfo(string id)
{
var container = StorageProvider.GetWopiContainer(id);
return(new CheckContainerInfo
{
Name = container.Name
});
}
public async Task ListBlobs_Test()
{
var fileName = await CreateTestFile();
var result = await StorageProvider.ListBlobs(ContainerName);
result.ShouldNotBeNull();
result.Count.ShouldBeGreaterThan(0);
}
public static IStorage Get(StorageProvider provider)
{
switch (provider)
{
case StorageProvider.Azure: return new Azure();
case StorageProvider.OneDrive: return new OneDrive();
case StorageProvider.Local: return new LocalStorage();
default: throw new ArgumentNullException("Set StorageProvider in config");
}
}
public void Get_storage()
{
/* all testing will be touching just a single storage cell */
var storageCell = new StorageCell(TestItem.AddressA, 1);
/* to start with we need to create an account that we will be setting storage at */
_stateProvider.CreateAccount(storageCell.Address, UInt256.One);
_stateProvider.Commit(MuirGlacier.Instance);
_stateProvider.CommitTree();
/* at this stage we have an account with empty storage at the address that we want to test */
byte[] initialValue = new byte[] { 1, 2, 3 };
_storageProvider.Set(storageCell, initialValue);
_storageProvider.Commit();
_storageProvider.CommitTrees();
_stateProvider.Commit(MuirGlacier.Instance);
_stateProvider.CommitTree();
var retrieved =
_blockchainBridge.GetStorage(storageCell.Address, storageCell.Index, _stateProvider.StateRoot);
retrieved.Should().BeEquivalentTo(initialValue);
/* at this stage we set the value in storage to 1,2,3 at the tested storage cell */
/* Now we are testing scenario where the storage is being changed by the block processor.
* To do that we create some different storage / state access stack that represents the processor.
* It is a different stack of objects than the one that is used by the blockchain bridge. */
byte[] newValue = new byte[] { 1, 2, 3, 4, 5 };
StateProvider processorStateProvider =
new StateProvider(_dbProvider.StateDb, _dbProvider.CodeDb, LimboLogs.Instance);
processorStateProvider.StateRoot = _stateProvider.StateRoot;
StorageProvider processorStorageProvider =
new StorageProvider(_dbProvider.StateDb, processorStateProvider, LimboLogs.Instance);
processorStorageProvider.Set(storageCell, newValue);
processorStorageProvider.Commit();
processorStorageProvider.CommitTrees();
processorStateProvider.Commit(MuirGlacier.Instance);
processorStateProvider.CommitTree();
/* At this stage the DB should have the storage value updated to 5.
* We will try to retrieve the value by taking the state root from the processor.*/
retrieved =
_blockchainBridge.GetStorage(storageCell.Address, storageCell.Index, processorStateProvider.StateRoot);
retrieved.Should().BeEquivalentTo(newValue);
/* If it failed then it means that the blockchain bridge cached the previous call value */
}
public override void Initialize()
{
var deviceProvider = new DeviceProvider();
Mvx.RegisterSingleton <IDeviceProvider>(deviceProvider);
var notificationsProvider = new NotificationsProvider();
Mvx.RegisterSingleton <INotificationsProvider>(notificationsProvider);
Mvx.RegisterSingleton <IUserDialogs>(UserDialogs.Instance);
//db
string externalDirPath = deviceProvider.DataPath();
string dbPath = PortablePath.Combine(externalDirPath, FilesNames.databaseFile);
var dbConnectionFactory = new DbConnectionFactory(dbPath);
Mvx.RegisterSingleton <IDbConnectionFactory>(dbConnectionFactory);
var storageProvider = new StorageProvider(Mvx.Resolve <IDeviceProvider>(), Mvx.Resolve <IDbConnectionFactory>());
Mvx.RegisterSingleton <IStorageProvider>(storageProvider);
var sessionProvider = new SessionProvider(Mvx.Resolve <IStorageProvider>());
Mvx.RegisterSingleton <ISessionProvider>(sessionProvider);
//api interfaces
var carrierOrdersApi = RestService.For <ICarrierOrdersApi>(sessionProvider.HttpClient);
Mvx.RegisterSingleton <ICarrierOrdersApi>(carrierOrdersApi);
var routesApi = RestService.For <IRoutesApi>(sessionProvider.HttpClient);
Mvx.RegisterSingleton <IRoutesApi>(routesApi);
var salepointOrdersApi = RestService.For <ISalepointOrdersApi>(sessionProvider.HttpClient);
Mvx.RegisterSingleton <ISalepointOrdersApi>(salepointOrdersApi);
//services
var carrierOrdersService = new CarrierOrdersService(Mvx.Resolve <ICarrierOrdersApi>(), Mvx.Resolve <INotificationsProvider>());
Mvx.RegisterSingleton <ICarrierOrdersService>(carrierOrdersService);
var salepointOrdersService = new SalepointOrdersService(Mvx.Resolve <ISalepointOrdersApi>(), Mvx.Resolve <IStorageProvider>(), Mvx.Resolve <INotificationsProvider>());
Mvx.RegisterSingleton <ISalepointOrdersService>(salepointOrdersService);
var routesService = new RoutesService(Mvx.Resolve <IRoutesApi>(), Mvx.Resolve <INotificationsProvider>(), Mvx.Resolve <ISessionProvider>());
Mvx.RegisterSingleton <IRoutesService>(routesService);
RegisterNavigationServiceAppStart <SignInViewModel>();
}
public void Can_collect_stats()
{
MemDb memDb = new MemDb();
ISnapshotableDb stateDb = new StateDb(memDb);
StateTree stateTree = new StateTree(stateDb);
StateProvider stateProvider = new StateProvider(stateTree, stateDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
stateProvider.CreateAccount(TestItem.AddressA, 1);
Keccak codeHash = stateProvider.UpdateCode(new byte[] {1, 2, 3});
stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, Istanbul.Instance);
stateProvider.CreateAccount(TestItem.AddressB, 1);
Keccak codeHash2 = stateProvider.UpdateCode(new byte[] {1, 2, 3, 4});
stateProvider.UpdateCodeHash(TestItem.AddressB, codeHash2, Istanbul.Instance);
for (int i = 0; i < 1000; i++)
{
StorageCell storageCell = new StorageCell(TestItem.AddressA, (UInt256)i);
storageProvider.Set(storageCell, new byte[] {(byte)i});
}
storageProvider.Commit();
stateProvider.Commit(Istanbul.Instance);
storageProvider.CommitTrees();
stateProvider.CommitTree();
stateDb.Commit();
memDb.Delete(codeHash2); // missing code
Keccak storageKey = new Keccak("0x345e54154080bfa9e8f20c99d7a0139773926479bc59e5b4f830ad94b6425332");
memDb.Delete(storageKey); // deletes some storage
TrieStatsCollector statsCollector = new TrieStatsCollector(stateDb, LimboLogs.Instance);
stateTree.Accept(statsCollector, stateTree.RootHash, true);
string stats = statsCollector.Stats.ToString();
statsCollector.Stats.CodeCount.Should().Be(1);
statsCollector.Stats.MissingCode.Should().Be(1);
statsCollector.Stats.NodesCount.Should().Be(1348);
statsCollector.Stats.StateBranchCount.Should().Be(1);
statsCollector.Stats.StateExtensionCount.Should().Be(1);
statsCollector.Stats.AccountCount.Should().Be(2);
statsCollector.Stats.StorageCount.Should().Be(1343);
statsCollector.Stats.StorageBranchCount.Should().Be(337);
statsCollector.Stats.StorageExtensionCount.Should().Be(12);
statsCollector.Stats.StorageLeafCount.Should().Be(994);
statsCollector.Stats.MissingStorage.Should().Be(1);
}
public IList <SeriesValue> GetSeries(Unit eenheid, DateTime from, DateTime to, SeriesResolution resolution, bool negate, bool smoothing)
{
Logger.LogTrace("Enter, counter = {0}, unit = {1}, from = {2}, to = {3}, resolution = {4}, negate = {5}, smoothing = {6}",
CounterId, eenheid, from, to, resolution, negate, smoothing);
Guard.IsBefore(from, to, "From cannot be later than to");
if (resolution == SeriesResolution.FiveMinutes && CounterId == 2421)
{
resolution = SeriesResolution.Hour;
}
var values = SeriesValueListBuilder.BuildSeries(from, to, resolution);
if (CounterId == 2421)
{
//todo: refactor hack, this can be properly handled when we have Energy and Power as units.
eenheid = Unit.M3;
}
var result = StorageProvider.GetRecords(from, to, eenheid, values, negate);
if (smoothing)
{
var data = values.OrderByDescending(o => o.Begin).ToList();
var currentIndex = 0;
foreach (var rec in data)
{
if (rec != null && rec.Value != null)
{
if (rec.Value == 0m)
{
var distance = 1;
while (currentIndex + distance < data.Count && data[currentIndex + distance].Value == 0m)
{
distance++;
}
rec.Value = Math.Round(1m / FormulaForTime(rec.Begin) * 60m * 1000m) / (distance + 1m);
}
else if (currentIndex + 1 < data.Count && data[currentIndex + 1].Value == 0m)
{
var distance = 1;
while (currentIndex + distance < data.Count && data[currentIndex + distance].Value == 0m)
{
distance++;
}
rec.Value = rec.Value / distance;
}
}
currentIndex++;
}
}
Logger.LogTrace("Return");
return(values);
}
/// <summary>
/// 新增仓库
/// </summary>
/// <returns></returns>
public ActionResult Add()
{
string StorageNum = WebUtil.GetFormValue <string>("StorageNum");
string StorageName = WebUtil.GetFormValue <string>("StorageName");
int StorageType = WebUtil.GetFormValue <int>("StorageType");
double Length = WebUtil.GetFormValue <double>("Length");
double Width = WebUtil.GetFormValue <double>("Width");
double Height = WebUtil.GetFormValue <double>("Height");
string Action = WebUtil.GetFormValue <string>("Action");
string Remark = WebUtil.GetFormValue <string>("Remark");
string Contact = WebUtil.GetFormValue <string>("Contact");
string Phone = WebUtil.GetFormValue <string>("Phone");
string Address = WebUtil.GetFormValue <string>("Address");
double Area = WebUtil.GetFormValue <double>("Area");
string DepartNum = WebUtil.GetFormValue <string>("DepartNum");
string CreateUser = WebUtil.GetFormValue <string>("CreateUser");
string CompanyID = WebUtil.GetFormValue <string>("CompanyID");
DateTime LeaseTime = WebUtil.GetFormValue <DateTime>("LeaseTime", DateTime.Now.AddYears(1));
StorageEntity entity = new StorageEntity();
entity.StorageName = StorageName;
entity.StorageType = StorageType;
entity.Length = Length;
entity.Width = Width;
entity.Height = Height;
entity.Action = Action;
entity.IsDelete = (int)EIsDelete.NotDelete;
entity.CreateTime = DateTime.Now;
entity.Remark = Remark;
entity.Contact = Contact;
entity.Phone = Phone;
entity.Address = Address;
entity.Area = Area;
entity.DepartNum = DepartNum;
entity.LeaseTime = LeaseTime;
entity.CreateUser = CreateUser;
entity.CompanyID = CompanyID;
StorageProvider provider = new StorageProvider(CompanyID);
int line = provider.Add(entity);
DataResult result = new DataResult();
if (line > 0)
{
result.Code = (int)EResponseCode.Success;
result.Message = "仓库新增成功";
}
else
{
result.Code = (int)EResponseCode.Exception;
result.Message = "仓库新增失败";
}
return(Content(JsonHelper.SerializeObject(result)));
}
public static void ProviderIsNot(StorageProvider disallowedProviders, string reason = null)
{
var info = StorageProviderInfo.Instance;
if (!info.CheckProviderIsNot(disallowedProviders))
{
IgnoreMe(
"This test requires any provider except the following: {0}",
disallowedProviders.ToString().ToLowerInvariant(), reason);
}
}
public static void ProviderIs(StorageProvider allowedProviders, string reason = null)
{
var info = StorageProviderInfo.Instance;
if (!info.CheckProviderIs(allowedProviders))
{
IgnoreMe(
"This test requires one of the following providers: {0}",
allowedProviders.ToString().ToLowerInvariant(), reason);
}
}
public async Task SaveBlobStream_Test()
{
var testFileName = GetTestFileName();
await StorageProvider.SaveBlobStream(ContainerName, testFileName, TestStream);
var result = await StorageProvider.GetBlobFileInfo(ContainerName, testFileName);
result.ShouldNotBeNull();
result.Name.ShouldNotBeNullOrWhiteSpace();
result.Name.ShouldBe(testFileName);
}
public void Same_address_different_index(int snapshot)
{
StorageProvider provider = BuildStorageProvider();
provider.Set(new StorageAddress(_address1, 1), _values[1]);
provider.Set(new StorageAddress(_address1, 2), _values[2]);
provider.Set(new StorageAddress(_address1, 3), _values[3]);
provider.Restore(snapshot);
Assert.AreEqual(_values[Math.Min(snapshot + 1, 1)], provider.Get(new StorageAddress(_address1, 1)));
}
public void Disposing()
{
using (StorageProvider provider = Provider)
{
provider.LoadDataContainer(DomainObjectIDs.Order1);
}
RdbmsProvider rdbmsProvider = Provider;
Assert.That(rdbmsProvider.IsConnected, Is.False);
}
public void Reset_resets_transient_state()
{
Context ctx = new();
StorageProvider provider = BuildStorageProvider(ctx);
provider.SetTransientState(new StorageCell(ctx.Address1, 2), _values[1]);
Assert.AreEqual(_values[1], provider.GetTransientState(new StorageCell(ctx.Address1, 2)));
provider.Reset();
Assert.True(provider.GetTransientState(new StorageCell(ctx.Address1, 2)).IsZero());
}
public void TestDelete()
{
using (_provider = new StorageProvider(PathToStorageDir))
{
_provider.DeleteAll <int>();
_provider.Write <int>(new[] { 1, 2, 3, 4, 5 });
_provider.Delete <int>(i => i == 2);
Assert.AreEqual(new[] { 1, 3, 4, 5 }, _provider.GetTable <int>().ToArray());
_provider.DeleteAll <int>();
}
}
public void Same_address_same_index_different_values_restore(int snapshot)
{
StorageProvider provider = BuildStorageProvider();
provider.Set(new StorageCell(_address1, 1), _values[1]);
provider.Set(new StorageCell(_address1, 1), _values[2]);
provider.Set(new StorageCell(_address1, 1), _values[3]);
provider.Restore(snapshot);
Assert.AreEqual(_values[snapshot + 1], provider.Get(new StorageCell(_address1, 1)));
}
void StartWaitSendThread(TcpSocketClient client)
{
//开启线程读取上次未发送的消息
ThreadPool.QueueUserWorkItem((obj) =>
{
var spNumber = spClientPool.First(i => i.Socket == client).SPNumber;
//读取为发送的消息
var deliverDao = StorageProvider <DeliverStorage> .GetStorage();
var deliverList = deliverDao.GetList(spNumber);
if (deliverList.Count() > 0)
{
foreach (var deliver in deliverList)
{
var d = new Deliver
{
SPNumber = deliver.SPNumber,
UserNumber = deliver.UserNumber,
TP_pid = 0,
TP_udhi = 0,
MessageCoding = MessageCodes.GBK,
MessageContent = deliver.Content
};
client.Send(d.GetBytes());
//映射序列号
MapSequeue(d.SequenceNumberString, deliver.SequenceNumber);
}
}
//读取上次未发送的报告
var reportDao = StorageProvider <ReportStorage> .GetStorage();
var reportList = reportDao.GetList(spNumber);
if (reportList.Count() > 0)
{
foreach (var report in reportList)
{
var r = new Report
{
SubmitSequenceNumber = report.TargetSubmitSequenceNumber,
ReportType = (uint)report.ReportType,
State = (uint)report.State,
ErrorCode = (uint)report.ErrorCode,
UserNumber = report.UserNumber
};
client.Send(r.GetBytes());
//映射序列号
MapSequeue(r.SequenceNumberString, report.SubmitSequenceNumber);
}
}
});
}
public async Task GetBlobFileInfo_Test()
{
var fileName = await CreateTestFile();
var result = await StorageProvider.GetBlobFileInfo(ContainerName, fileName);
result.Name.ShouldBe(fileName);
result.Length.ShouldBeGreaterThan(0);
result.Url.ShouldNotBeNullOrWhiteSpace();
result.ETag.ShouldNotBeNull();
result.ContentType.ShouldNotBeNull();
}
private static void MapMediaLibraries(StorageProvider provider)
{
// Map all site media libraries to azure
var siteNames = SiteInfo.Provider.Get()
.Select(site => site.SiteName)
.ToList();
foreach (var siteName in siteNames)
{
StorageHelper.MapStoragePath($"~/{siteName}/media", provider);
}
}
/// <summary>
/// Creates a <see cref="IUpdateInfoModel" /> for create a new captcha.
/// </summary>
/// <param name="controller">
/// The specified <see cref="ControllerBase" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="IUpdateInfoModel" />.
/// </returns>
public virtual IUpdateInfoModel GenerateNew(ControllerBase controller, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(controller, "controller");
Validate.ArgumentNotNull(parameterContainer, "parameterContainer");
KeyValuePair <string, ICaptchaValue> captchaPair = CreateCaptchaPair(parameterContainer, null);
StorageProvider.Add(captchaPair);
var urlHelper = new UrlHelper(controller.ControllerContext.RequestContext);
string imgUrl = ImageUrlFactory(urlHelper, captchaPair);
return(new DefaultUpdateInfoModel(TokenElementName, captchaPair.Key, imgUrl, ImageElementName));
}
/// <summary>
/// 设置仓库
/// </summary>
private void SetStorage()
{
StorageProvider provider = new StorageProvider();
List <StorageEntity> list = provider.GetList();
list = list.IsNull() ? new List <StorageEntity>() : list;
ViewBag.MenuStorage = list;
string storageNum = DefaultStore;
storageNum = storageNum.IsEmpty() ? ResourceManager.GetSettingEntity("STORE_DEFAULT_PRODUCT").Value : storageNum;
ViewBag.MenuStorageName = list.First(a => a.StorageNum == storageNum).StorageName;
}
public static IStorage Get(StorageProvider provider)
{
switch (provider)
{
case StorageProvider.Azure: return(new Azure());
//case StorageProvider.OneDrive: return new OneDrive();
case StorageProvider.Local: return(new LocalStorage());
default: throw new ArgumentNullException("Set StorageProvider in config");
}
}
public void Setup()
{
_specProvider = MainNetSpecProvider.Instance;
StateDb stateDb = new StateDb();
_stateProvider = new StateProvider(stateDb, new MemDb(), LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(_stateProvider, storageProvider, Substitute.For <IBlockhashProvider>(), _specProvider, LimboLogs.Instance);
_transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, LimboLogs.Instance);
}
public void Commit_no_changes()
{
StorageProvider provider = BuildStorageProvider();
provider.Set(new StorageAddress(_address1, 1), _values[1]);
provider.Set(new StorageAddress(_address1, 2), _values[2]);
provider.Set(new StorageAddress(_address1, 3), _values[3]);
provider.Restore(-1);
provider.Commit(Frontier.Instance);
Assert.AreEqual(Keccak.EmptyTreeHash, provider.GetRoot(_address1));
}
public void Commit_no_changes()
{
StorageProvider provider = BuildStorageProvider();
provider.Set(new StorageCell(_address1, 1), _values[1]);
provider.Set(new StorageCell(_address1, 2), _values[2]);
provider.Set(new StorageCell(_address1, 3), _values[3]);
provider.Restore(-1);
provider.Commit();
Assert.IsTrue(provider.Get(new StorageCell(_address1, 1)).IsZero());
}
public ConsoleCommandsProcessor()
{
var storage = new StorageProvider();
commandsList = new Dictionary <string, ICommand>
{
{ "add", new AddCommand(storage) },
{ "remove", new RemoveCommand(storage) },
{ "update", new UpdateCommand(storage) },
{ "list", new ListCommand(storage) }
};
}
public static void Execute()
{
Console.WriteLine($"// Count Ids by Index");
var count =
StorageProvider.SelectTagCount(
Configuration.Container,
Configuration.Tag_Upload);
Console.WriteLine($"UPLOAD Count: {count}");
Console.WriteLine("");
}
/// <summary>
/// 查询仓库列表
/// </summary>
/// <returns></returns>
public ActionResult GetList()
{
string CompanyID = WebUtil.GetFormValue <string>("CompanyID");
StorageProvider provider = new StorageProvider(CompanyID);
List <StorageEntity> list = provider.GetList();
DataListResult <StorageEntity> result = new DataListResult <StorageEntity>()
{
Code = (int)EResponseCode.Success, Message = "响应成功", Result = list
};
return(Content(JsonHelper.SerializeObject(result)));
}
/*
* also need to test:
* BALANCE
* EXTCODECOPY
* CALLDATACOPY
* GASPRICE
* CREATE
*/
private static GethLikeTxTracer RunVirtualMachine(byte[] code)
{
GethLikeTxTracer txTracer = new GethLikeTxTracer(GethTraceOptions.Default);
IDb stateDbDevice = new MemDb();
IDb codeDbDevice = new MemDb();
ISnapshotableDb stateDb = new StateDb(stateDbDevice);
ISnapshotableDb codeDb = new StateDb(codeDbDevice);
IStateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
IStorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
IStateUpdateHashProvider stateUpdateHashProvider = new StateUpdateHashProvider();
ISpecProvider specProvider = new CatalystSpecProvider();
// these values will be set by the tx processor within the state update logic
ExecutionEnvironment env = new ExecutionEnvironment();
env.Originator = Address.Zero; // tx sender
env.Sender = Address.Zero; // sender of this call for a given call depth
env.ExecutingAccount = Address.Zero; // account in which context the code is executed, it may be different from the code source when invoking a lib
env.Value = 1.Kat(); // sometimes the value is just a description of an upper level call to be used by a an invoke library method
env.TransferValue = 1.Kat(); // this is the actual value transferred from sender to recipient
env.GasPrice = 0; // conversion from gas units to FULs
env.InputData = new byte[0]; // only needed for contracts requiring input (ensure that this is not limited to 60bytes)
env.CallDepth = 0; // zero when starting tx
StateUpdate stateUpdate = new StateUpdate(); // Catalyst single state update context (all phases together)
stateUpdate.Difficulty = 1; // some metric describing the state update that is relevant for consensus
stateUpdate.Number = 1; // state update sequence number
stateUpdate.Timestamp = 1; // state update T0
stateUpdate.GasLimit = 1_000_000; // max gas units to be available for this tx inside the kvm
stateUpdate.GasBeneficiary = Address.Zero; // will get all the gas fees
stateUpdate.GasUsed = 0L; // zero if this is the first transaction in the update (accumulator over txs)
env.CurrentBlock = stateUpdate;
// this would be loaded by the tx processor from the recipient's code storage
CodeInfo codeInfo = new CodeInfo(code);
env.CodeInfo = codeInfo;
env.CodeSource = Address.Zero;
// this would be set by the tx processor that understands the type of transaction
VmState vmState = new VmState(1_000_000L, env, ExecutionType.Transaction, false, true, false);
KatVirtualMachine virtualMachine = new KatVirtualMachine(stateProvider, storageProvider, stateUpdateHashProvider, specProvider, LimboLogs.Instance);
virtualMachine.Run(vmState, txTracer);
return(txTracer);
}
private void HandleRekeyResponse(IEnumerable <object> args)
{
GenerateNewAppKey();
SockIO.EmitAsync("rekeyed", new
{
plugin = AppName,
data = new
{
origin = AppName,
appkey = StorageProvider.GetAppkey()
}
});
}
public AddStorageProviderResult AddStoragePreferences(StorageProvider provider, byte[] token)
{
var parameters = new NameValueCollection() { { "userId", this.UserId }, { "provider", provider.ToString() } };
var template = UserManagementUriTemplates.BuildUriTemplate(UserManagementUriTemplates.AddStorageProvider);
var providerInfo = new StorageProviderInfo { Provider = provider, Token = token };
using (var content = HttpContentNetExtensions.CreateJsonNetDataContract<StorageProviderInfo>(providerInfo))
{
var response = SubmitRequest<AddStorageProviderResponse>(template, parameters, "POST", content);
if (response.Code != ResponseCode.Ok)
{
throw new GroupdocsServiceException(response.ErrorMessage);
}
return response.Result;
}
}
public async Task SerializeDocuments(object obj)
{
var documents = obj as ObservableCollection<Document>;
var storageProvider = new StorageProvider();
await storageProvider.WriteToFile<ObservableCollection<Document>>(
FileNameDocuments, documents);
}
public async Task SerializeCategories(object obj)
{
var categories = obj as ObservableCollection<Category>;
var storageProvider = new StorageProvider();
await storageProvider.WriteToFile<ObservableCollection<Category>>(FileNameCategories, categories);
}
public async Task<ObservableCollection<Document>> DeserializeDocuments()
{
ObservableCollection<Document> deserializedData = null;
var storageProvider = new StorageProvider();
deserializedData = await storageProvider.ReadFromFile<ObservableCollection<Document>>(FileNameDocuments);
if (deserializedData == null)
{
deserializedData = new ObservableCollection<Document>();
}
return deserializedData;
}
public async Task<ObservableCollection<Category>> DeserializeCategories()
{
ObservableCollection<Category> deserializedData = null;
var storageProvider = new StorageProvider();
deserializedData =
await storageProvider.ReadFromFile<ObservableCollection<Category>>(FileNameCategories);
if (deserializedData == null)
{
deserializedData = new ObservableCollection<Category>();
}
return deserializedData;
}
public async Task SerializePages(object obj)
{
var pages = obj as ObservableCollection<Page>;
var storageProvider = new StorageProvider();
await storageProvider.WriteToFile<ObservableCollection<Page>>(FileNamePages, pages);
}
