private static FileResourceCollection CreateResources(string[] files, SimpleCompressionConfiguration configuration)
{
var resources = new FileResourceCollection();
foreach (var file in files)
{
var resource = new FileResource(file);
resources.Add(resource);
}
return resources;
}
/// <summary>
/// Depending on the resource type, <see cref="AssemblyResource"/> or <see cref="FileResource"/> is decorated.
/// </summary>
/// <param name="resource"></param>
public FileAssemblyResource(string resource)
{
if (File.Exists(resource))
{
innerResource = new FileResource(resource);
}
else
{
innerResource = new AssemblyResource(resource);
}
}
public PdfResult(FileResource fileResource) : base(fileResource.OriginalCompleteFileName, fileResource.FileResourceData, FileResourceMimeType.PDF)
{
Check.Require(fileResource.FileResourceMimeType == FileResourceMimeType.PDF, "Only a real PDF file can be saved off as PDF");
ConstructorImpl(fileResource.OriginalCompleteFileName);
}
public async Task ConnectionLost()
{
// arrange
var connections = new Dictionary <string, HttpClient>();
IHttpClientFactory clientFactory = CreateRemoteSchemas(connections);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder =>
builder.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer")
.RenameType("CreateCustomerInput", "CreateCustomerInput2")
.AddExtensionsFromString(
FileResource.Open("StitchingExtensions.graphql"))
.AddSchemaConfiguration(c =>
c.RegisterType <PaginationAmountType>())
.AddExecutionConfiguration(b =>
{
b.AddErrorFilter(error =>
{
if (error.Exception is Exception ex)
{
return(ErrorBuilder.FromError(error)
.ClearExtensions()
.SetMessage(ex.GetType().FullName)
.SetException(null)
.Build());
}
;
return(error);
});
}));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
IExecutionResult result = null;
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"
mutation {
createCustomer(input: { name: ""a"" })
{
customer {
name
contracts {
id
}
}
}
}")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
var client = new HttpClient
{
BaseAddress = new Uri("http://127.0.0.1")
};;
connections["contract"] = client;
connections["customer"] = client;
// act
using (IServiceScope scope = services.CreateScope())
{
IReadOnlyQueryRequest request =
QueryRequestBuilder.New()
.SetQuery(@"
mutation {
createCustomer(input: { name: ""a"" })
{
customer {
name
contracts {
id
}
}
}
}")
.SetServices(scope.ServiceProvider)
.Create();
result = await executor.ExecuteAsync(request);
}
// assert
result.MatchSnapshot();
}
private void DownloadCurrentFile()
{
FileResource file = this.Module.GetFileById(this.Module.CurrentFileId);
Stream fileStream = this.Module.GetFileAsStream(file);
try
{
byte[] buffer = new byte[BufferSize];
// Total bytes to read:
long dataToRead = fileStream.Length;
// Support for resuming downloads
long position = 0;
if (Request.Headers["Range"] != null)
{
Response.StatusCode = 206;
Response.StatusDescription = "Partial Content";
position = long.Parse(Request.Headers["Range"].Replace("bytes=", "").Replace("-", ""));
}
if (position != 0)
{
Response.AddHeader("Content-Range", "bytes " + position.ToString() + "-" + ((long)(dataToRead - 1)).ToString() + "/" + dataToRead.ToString());
}
Response.ContentType = file.MimeType;
Response.AppendHeader("Content-Disposition", "attachment; filename=" + file.FileName);
// The content length depends on the amount that is already transfered in an earlier request.
Response.AppendHeader("Content-Length", (fileStream.Length - position).ToString());
// Stream the actual content
bool isInterrupted = false;
while (dataToRead > 0 && !isInterrupted)
{
// Verify that the client is connected.
if (Response.IsClientConnected)
{
// Read the data in buffer.
int length = fileStream.Read(buffer, 0, BufferSize);
// Write the data to the current output stream.
Response.OutputStream.Write(buffer, 0, length);
// Flush the data to the HTML output.
Response.Flush();
buffer = new byte[BufferSize];
dataToRead = dataToRead - length;
}
else
{
//prevent infinite loop if user disconnects
isInterrupted = true;
}
}
// Only update download statistics if the download is succeeded.
if (!isInterrupted)
{
this.Module.IncreaseNrOfDownloads(file);
}
}
finally
{
if (fileStream != null)
{
fileStream.Close();
fileStream.Dispose();
}
Response.End();
}
}
public async Task ExecuteOperationMiddleware_Mutation_ExecutedSerially()
{
// arrange
var state = 0;
var schema = Schema.Create(
FileResource.Open("MutationExecutionSchema.graphql"),
cnf =>
{
cnf.BindResolver(() => state)
.To("Query", "state");
cnf.BindResolver(() => state)
.To("CurrentState", "theNumber");
cnf.BindResolver(
ctx => state = ctx.Argument <int>("newNumber"))
.To("Mutation", "changeTheNumber");
});
DocumentNode query = Parser.Default.Parse(
FileResource.Open("MutationExecutionQuery.graphql"));
OperationDefinitionNode operationNode = query.Definitions
.OfType <OperationDefinitionNode>()
.FirstOrDefault();
var operation = new Operation(
query, operationNode, schema.MutationType,
null);
IReadOnlyQueryRequest request = new QueryRequest("{ a }")
.ToReadOnly();
var services = new DictionaryServiceProvider(
new KeyValuePair <Type, object>(
typeof(IErrorHandler),
ErrorHandler.Default));
var context = new QueryContext(
schema, services.CreateRequestServiceScope(), request)
{
Document = query,
Operation = operation,
Variables = new VariableValueBuilder(
schema, operation.Definition)
.CreateValues(new Dictionary <string, object>())
};
var options = new QueryExecutionOptions();
var strategyResolver = new ExecutionStrategyResolver(options);
var middleware = new ExecuteOperationMiddleware(
c => Task.CompletedTask,
strategyResolver,
new Cache <DirectiveLookup>(10));
// act
await middleware.InvokeAsync(context);
// assert
Assert.NotNull(context.Result);
context.Result.Snapshot();
}
private async Task StartDevice()
{
BrainDeviceManager.Init();
var sender = await BrainDeviceManager.Connnect("127.0.0.1", 9211);
_currentState = default(BrainDevState);
//保证设备参数正常才继续跑逻辑
BrainDeviceManager.BrainDeviceState.Subscribe(ss =>
{
_currentState = ss;
var pmax = 4.5f * 2 / _currentState.Gain;
YVisibleRange = new DoubleRange(-pmax, pmax);
AppLogger.Debug($"Brain Device State Changed Detected: {ss}");
}, () =>
{
AppLogger.Debug("device stop detected");
});
int totalReceived = 0;
BrainDeviceManager.SampleDataStream.Subscribe(tuple =>
{
var(order, datas, arr) = tuple;
var copyArr = datas.CopyToArray();
if (copyArr != null)
{
_viewStream.OnNext(copyArr);
}
//Console.Write($" {order} ");
totalReceived++;
//AppLogger.Debug($"order:{order}");
//AppLogger.Debug($"converted values:{datas.Show()}");
//AppLogger.Debug($"original datas:{arr.Show()}");
}, () =>
{
AppLogger.Debug("device sampling stream closed detected");
});
var cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to QueryParam, stop");
BrainDeviceManager.DisConnect();
return;
}
cmdResult = await sender.SetFilter(false);
AppLogger.Debug("SetFilter result:" + cmdResult);
cmdResult = await sender.SetTrap(TrapSettingEnum.NoTrap);
AppLogger.Debug("SetTrap result:" + cmdResult);
cmdResult = await sender.SetSampleRate(SampleRateEnum.SPS_2k);
AppLogger.Debug("SetSampleRate result:" + cmdResult);
cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
var fs = new FileResource(_currentState, 19801983, 1, BrainDeviceManager.BufMgr);
fs.StartRecord(BrainDeviceManager.SampleDataStream);
cmdResult = await sender.Start();
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to start sampler");
}
else
{
AppLogger.Debug($"start receive sample data");
await Task.Delay(1000 *60);
AppLogger.Debug($"stoping");
await sender.Stop();
AppLogger.Debug($"stop receive sample data");
await Task.Delay(1000);
}
BrainDeviceManager.DisConnect();
fs.Dispose();
}
/// <summary>
/// Increase the number of downloads for the given file.
/// </summary>
/// <param name="fileResource"></param>
public virtual void IncreaseNrOfDownloads(FileResource fileResource)
{
this._fileResourceService.IncreaseDownloadCount(fileResource);
}
public async Task Object_With_Fragment()
{
// arrange
var path = HotChocolate.Path.New("root");
DocumentNode document = Utf8GraphQLParser.Parse(
@"
query search {
droid(id: ""foo"") {
... SomeDroid
}
}
fragment SomeDroid on Droid {
name
}
");
var operation = document.Definitions
.OfType <OperationDefinitionNode>()
.First();
var field = operation.SelectionSet.Selections
.OfType <FieldNode>()
.First();
var query = new QueryDescriptor(
"Simple_Query",
"Foo.Bar.Ns",
"1234",
"12345",
new byte[] { 1, 2, 3 },
document);
var schema = SchemaBuilder.New()
.AddDocumentFromString(FileResource.Open("StarWars.graphql"))
.Use(next => context => Task.CompletedTask)
.Create();
var context = new ModelGeneratorContext(
schema,
query,
"StarWarsClient",
"Foo.Bar.Ns");
var droid = schema.GetType <ObjectType>("Droid");
// act
var generator = new ObjectModelGenerator();
generator.Generate(
context,
operation,
droid,
droid,
field,
context.CollectFields(droid, field.SelectionSet, path),
path);
// assert
var typeLookup = new TypeLookup(
LanguageVersion.CSharp_8_0,
CollectFieldsVisitor.MockLookup(document, context.FieldTypes));
string output = await WriteAllAsync(context.Descriptors, typeLookup);
output.MatchSnapshot();
}
public async Task Interface_Two_Cases_3()
{
// arrange
var path = HotChocolate.Path.New("root");
DocumentNode document = Utf8GraphQLParser.Parse(
@"
query getHero {
hero {
...Hero
}
}
fragment Hero on Character {
...HasName
...SomeDroid
...SomeHuman
}
fragment SomeDroid on Droid {
...HasName
primaryFunction
}
fragment SomeHuman on Human {
...HasName
homePlanet
}
fragment HasName on Character {
name
}
");
var operation = document.Definitions
.OfType <OperationDefinitionNode>()
.First();
var field = operation.SelectionSet.Selections
.OfType <FieldNode>()
.First();
var query = new QueryDescriptor(
"Simple_Query",
"Foo.Bar.Ns",
"1234",
"12345",
new byte[] { 1, 2, 3 },
document);
var schema = SchemaBuilder.New()
.AddDocumentFromString(FileResource.Open("StarWars.graphql"))
.Use(next => context => Task.CompletedTask)
.Create();
var context = new ModelGeneratorContext(
schema,
query,
"StarWarsClient",
"Foo.Bar.Ns");
var character = schema.GetType <InterfaceType>("Character");
// act
var generator = new InterfaceModelGenerator();
generator.Generate(
context,
operation,
character,
character,
field,
context.CollectFields(character, field.SelectionSet, path),
path);
// assert
var typeLookup = new TypeLookup(
LanguageVersion.CSharp_8_0,
CollectFieldsVisitor.MockLookup(document, context.FieldTypes),
"Foo.Bar");
string output = await WriteAllAsync(context.Descriptors, typeLookup);
output.MatchSnapshot();
}
public FileLink Expand(FileResource file) => Folder.Link.Then(file);
public override void UpdateModel(Models.ProjectImageUpdate projectImageUpdate, Person person)
{
base.UpdateModel(projectImageUpdate, person);
projectImageUpdate.FileResource = FileResource.CreateNewFromHttpPostedFileAndSave(FileResourceData, person);
}
private static async Task TestBrainDeviceManager()
{
var cfg = ClientConfig.GetConfig();
var lowFilter = new LowPassFilter()
{
LowPassRate = 10
};
var highFilter = new HighPassFilter()
{
HighPassRate = 10000
};
var bPassFilter = new BandPassFilter()
{
LowCutoffRate = 20, HighCutoffRate = 30
};
var bStopFilter = new BandStopFilter()
{
LowPassRate = 35, HighPassRate = 38
};
var mFilter = new MedianFilter()
{
HalfMedianWindowSize = 7
};
var bandFilter = new BandPassStopFilter
{
BandFilterList = new List <BandFilter> {
lowFilter, highFilter, bPassFilter, bStopFilter
}
};
bandFilter.Disable = true;
var allFilter = new FilterTypeList()
{
Filters = new List <FilterType> {
bandFilter, mFilter
}
};
var filterParameters = new Dictionary <string, string>
{
{ FilterTypeList.FIRhalfOrderOptionName, 10.ToString() }
};
cfg.FilterLst = allFilter;
IOnlineFilter filter = null;
WaveletReconstruction waveletRec = null;
cfg.WaveletRecCfg = new WaveletReconstructionConfig
{
AvgLevel = 8,
ConvolutionMode = ConvolutionModeEnum.Normal,
ExtensionMode = SignalExtension.ExtensionMode.SymmetricHalfPoint,
Level = 8,
MotherWaveletName = "db5",
WindowSize = 15
};
cfg.WriteToFile(ClientConfig.DefaultConfigFileName);
BrainDeviceManager.Init();
var sender = await BrainDeviceManager.Connnect("127.0.0.1", 9211);
BrainDevState currentState = default(BrainDevState);
//保证设备参数正常才继续跑逻辑
BrainDeviceManager.BrainDeviceState.Subscribe(ss =>
{
currentState = ss;
filterParameters.Update(
FilterTypeList.SampleRateOptionName,
BrainDevState.SampleCountPer1Sec(ss.SampleRate).ToString()
);
//AppLogger.Debug($"Brain Device State Changed Detected: {ss}");
}, () =>
{
AppLogger.Debug("device stop detected");
});
int totalReceived = 0;
var medianFilter = OnlineFirFilter.CreateDenoise(7);
var fastMedianFilter = new OnlineFastMedianFilter(3);
BrainDeviceManager.SampleDataStream.Subscribe(tuple =>
{
var(order, datas, arr) = tuple;
//Console.Write($" {order} ");
var passTimes = BrainDevState.PassTimeMs(currentState.SampleRate, totalReceived) / 1000;
var intArr = datas.CopyToArray();
var val = intArr[0];
var voltage = BitDataConverter.Calculatevoltage(val, 4.5f, currentState.Gain);
totalReceived++;
var m1 = medianFilter.ProcessSample(voltage);
var m2 = fastMedianFilter.ProcessSample(voltage);
AppLogger.Debug($"passTimes:{passTimes},val:{val},voltage:{voltage},median filter:{m1},fast:{m2},{m1==m2}");
if (filter == null)
{
filter = allFilter.CreateFilter(filterParameters);
waveletRec = cfg.WaveletRecCfg.Create(
BrainDevState.SampleCountPer1Sec(currentState.SampleRate));
waveletRec.ReconstructionStream.Subscribe(reconstruct =>
{
var(vol, tim) = reconstruct;
AppLogger.Debug($"wavelet reconstruction:{vol} at {tim}");
});
}
waveletRec?.BufferData((voltage, passTimes));
AppLogger.Debug($"filter processed:{filter.ProcessSample(voltage)}");
//AppLogger.Debug($"order:{order}");
//AppLogger.Debug($"converted values:{datas.Show()}");
//AppLogger.Debug($"original datas:{arr.Show()}");
}, () =>
{
AppLogger.Debug("device sampling stream closed detected");
});
var cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to QueryParam, stop");
BrainDeviceManager.DisConnect();
return;
}
cmdResult = await sender.SetFilter(true);
AppLogger.Debug("SetFilter result:" + cmdResult);
cmdResult = await sender.SetTrap(TrapSettingEnum.Trap_50);
AppLogger.Debug("SetTrap result:" + cmdResult);
cmdResult = await sender.SetSampleRate(SampleRateEnum.SPS_2k);
AppLogger.Debug("SetSampleRate result:" + cmdResult);
cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
cmdResult = await sender.QueryFaultState();
AppLogger.Debug("QueryFaultState result:" + cmdResult);
cmdResult = await sender.TestSingleImpedance(1);
AppLogger.Debug("TestSingleImpedance result:" + cmdResult);
cmdResult = await sender.TestMultiImpedance(30);
AppLogger.Debug("TestMultiImpedance result:" + cmdResult);
Console.ReadLine();
var fs = new FileResource(currentState, 19801983, 1, BrainDeviceManager.BufMgr);
fs.StartRecord(BrainDeviceManager.SampleDataStream);
cmdResult = await sender.Start();
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to start sampler");
}
else
{
AppLogger.Debug($"start receive sample data");
await Task.Delay(1000 *10);
AppLogger.Debug($"stoping");
await sender.Stop();
AppLogger.Debug($"stop receive sample data");
await Task.Delay(1000);
}
BrainDeviceManager.DisConnect();
fs.Dispose();
var readf = new FileSampleData(fs.ResourceId, BrainDeviceManager.BufMgr);
Console.WriteLine($"expecte to read {totalReceived} blocks");
Console.WriteLine($"start reading saved sampling data");
int readCount = 0;
readf.DataStream.Subscribe(tuple =>
{
var(order, datas, arr) = tuple;
Console.Write($" {order} ");
readCount++;
//AppLogger.Debug($"order:{order}");
//AppLogger.Debug($"converted values:{datas.Show()}");
//AppLogger.Debug($"original datas:{arr.Show()}");
}, () =>
{
AppLogger.Debug($"read sampling data file end,count :{readCount},expected count:{totalReceived}");
});
readf.Start();
await Task.Delay(1000 *10);
Console.Write($"wait complete");
}
public Uri GetFileResourceUri(FileResource resource)
{
return(new Uri(Address + Url.Files + "/" + resource.Id));
}
public Stream GetFileResource(FileResource resource)
{
return(Rest.DownloadFile(Address + Url.Files, resource.Id));
}
public void Generate_StarWarsIntegrationTest()
{
AssertStarWarsResult(
FileResource.Open("QueryWithSubscription.graphql"));
}
private void SaveFile(FileResource file)
{
// This will persist the meta data about the file to a database (I.E., size, filename, file location, etc)
new FileRepository().AddFile(file);
}
public void Parse_Kitchen_Sink_Query_AllProps_No_Cache()
{
// arrange
byte[] source = Encoding.UTF8.GetBytes(
JsonConvert.SerializeObject(
new GraphQLRequestDto
{
Query = FileResource.Open("kitchen-sink.graphql")
.NormalizeLineBreaks(),
NamedQuery = "ABC",
OperationName = "DEF",
Variables = new Dictionary <string, object>
{
{ "a", "b" },
{ "b", new Dictionary <string, object>
{
{ "a", "b" },
{ "b", true },
{ "c", 1 },
{ "d", 1.1 },
} },
{ "c", new List <object>
{
new Dictionary <string, object>
{
{ "a", "b" },
}
} },
},
Extensions = new Dictionary <string, object>
{
{ "aa", "bb" },
{ "bb", new Dictionary <string, object>
{
{ "aa", "bb" },
{ "bb", true },
{ "cc", 1 },
{ "df", 1.1 },
} },
{ "cc", new List <object>
{
new Dictionary <string, object>
{
{ "aa", "bb" },
{ "ab", null },
{ "ac", false },
}
} },
}
}).NormalizeLineBreaks());
// act
var parserOptions = new ParserOptions();
var requestParser = new Utf8GraphQLRequestParser(
source, parserOptions);
IReadOnlyList <GraphQLRequest> batch = requestParser.Parse();
// assert
Assert.Collection(batch,
r =>
{
Assert.Equal("ABC", r.QueryName);
Assert.Equal("DEF", r.OperationName);
r.Variables.MatchSnapshot(
new SnapshotNameExtension("Variables"));
r.Extensions.MatchSnapshot(
new SnapshotNameExtension("Extensions"));
QuerySyntaxSerializer.Serialize(r.Query, true)
.MatchSnapshot(new SnapshotNameExtension("Query"));
});
}
private void SetStatusAsCreated(FileResource file)
{
var location = new Uri(m_Request.UriTemplateMatch.RequestUri.AbsoluteUri + "/" + file.Id);
m_Response.SetStatusAsCreated(location);
}
public LanguageCatalogueExporter(FileResource fileResource)
{
_fileResource = fileResource ?? throw new ArgumentNullException(nameof(fileResource));
}
public FileLink ExpandInData(FileResource file) => DataFolder.Link.Then(file);
public byte[] RetrieveFileResourceDataAsByteArray(FileResource fileResource)
{
return(File.ReadAllBytes(fileResource.Path));
}
public void InvalidFieldsShouldNotRaiseValidationError()
{
ExpectValid(FileResource.Open("InvalidIntrospectionQuery.graphql"));
}
public FileStream RetrieveDataAsFileStream(FileResource fileResource)
{
return(File.OpenRead(fileResource.Path));
}
private ISchema CreateSchema()
{
return(Schema.Create(
FileResource.Open("CostSchema.graphql"),
c => c.Use(next => context => Task.CompletedTask)));
}
public async Task AutoMerge_HotReload_ClearOperationCaches()
{
// arrange
using var cts = new CancellationTokenSource(20_000);
NameString configurationName = "C" + Guid.NewGuid().ToString("N");
var schemaDefinitionV2 = FileResource.Open("AccountSchemaDefinition.json");
IHttpClientFactory httpClientFactory = CreateDefaultRemoteSchemas(configurationName);
DocumentNode document = Utf8GraphQLParser.Parse("{ foo }");
var queryHash = "abc";
IDatabase database = _connection.GetDatabase();
while (!cts.IsCancellationRequested)
{
if (await database.SetLengthAsync(configurationName.Value) == 4)
{
break;
}
await Task.Delay(150, cts.Token);
}
ServiceProvider serviceProvider =
new ServiceCollection()
.AddSingleton(httpClientFactory)
.AddGraphQL()
.AddQueryType(d => d.Name("Query").Field("foo").Resolve("foo"))
.AddRemoteSchemasFromRedis(configurationName, _ => _connection)
.Services
.BuildServiceProvider();
IRequestExecutorResolver executorResolver =
serviceProvider.GetRequiredService <IRequestExecutorResolver>();
IDocumentCache documentCache =
serviceProvider.GetRequiredService <IDocumentCache>();
IPreparedOperationCache preparedOperationCache =
serviceProvider.GetRequiredService <IPreparedOperationCache>();
await executorResolver.GetRequestExecutorAsync(cancellationToken : cts.Token);
var raised = false;
executorResolver.RequestExecutorEvicted += (_, args) =>
{
if (args.Name.Equals(Schema.DefaultName))
{
raised = true;
}
};
Assert.False(documentCache.TryGetDocument(queryHash, out _));
Assert.False(preparedOperationCache.TryGetOperation(queryHash, out _));
IRequestExecutor requestExecutor =
await executorResolver.GetRequestExecutorAsync(cancellationToken : cts.Token);
await requestExecutor
.ExecuteAsync(QueryRequestBuilder
.New()
.SetQuery(document)
.SetQueryHash(queryHash)
.Create(),
cts.Token);
Assert.True(preparedOperationCache.TryGetOperation("_Default-1-abc", out _));
// act
await database.StringSetAsync($"{configurationName}.{_accounts}", schemaDefinitionV2);
await _connection.GetSubscriber().PublishAsync(configurationName.Value, _accounts);
while (!cts.IsCancellationRequested)
{
if (raised)
{
break;
}
await Task.Delay(150, cts.Token);
}
// assert
Assert.True(documentCache.TryGetDocument(queryHash, out _));
Assert.False(preparedOperationCache.TryGetOperation(queryHash, out _));
}
public Task <ResultData> UploadImg()
{
ResultData result = new ResultData();
try
{
var httpRequest = HttpContext.Current.Request;
if (httpRequest.Files.Count > 0)
{
var maxHeight = Convert.ToInt32(httpRequest.Form["maxHeight"]);
var maxWidth = Convert.ToInt32(httpRequest.Form["maxWidth"]);
if (maxHeight <= 0)
{
maxHeight = 100;
}
if (maxWidth <= 0)
{
maxWidth = 100;
}
List <FileResource> lstFileResource = new List <FileResource>();
var filePath = HttpContext.Current.Server.MapPath(mscTEMP);
Guid gFID = Guid.NewGuid();
foreach (string file in httpRequest.Files)
{
var postedFile = httpRequest.Files[file];
postedFile.InputStream.Seek(0, SeekOrigin.Begin);
FileResource objResource = new FileResource();
objResource.FileType = Path.GetExtension(postedFile.FileName);
objResource.FileResourceID = gFID;
objResource.FileName = postedFile.FileName;
objResource.FileNameNExt = Path.GetFileNameWithoutExtension(postedFile.FileName);
objResource.FileSize = (float)Math.Ceiling((float)postedFile.ContentLength / 1024);
var destinationPath = Path.Combine(filePath, $"{objResource.FileResourceID.ToString()}");
ImageBuilder.Current.Build(
new ImageJob(
postedFile,
destinationPath,
new Instructions($"maxwidth={maxWidth}&maxheight={maxHeight}&format=png"),
false,
true));
lstFileResource.Add(objResource);
}
result.Data = lstFileResource;
result.Code = HttpStatusCode.OK;
result.Success = true;
}
else
{
result.Code = HttpStatusCode.BadRequest;
result.Success = false;
}
}
catch (Exception ex)
{
result.Code = HttpStatusCode.BadRequest;
result.SetError(ex);
}
return(Task.FromResult(result));
}
public FileResourceEventArgs(FileResource resource)
{
ActivityId = resource.ActivityId;
Resource = resource;
}
private static ISchema CreateSchema()
{
return(Schema.Create(
FileResource.Open("ArgumentValueBuilder.graphql"),
c => c.Use(next => context => Task.CompletedTask)));
}
public Asset(Id id, FileResource file, string caption)
{
Id = id;
File = file;
Caption = caption;
}
public void Delete(FileResource resource)
{
_system.Activities[resource.ActivityId].FileResources.Remove(resource);
_system.DeleteFileResource(resource);
}
public async Task AutoMerge_HotReload_Schema()
{
// arrange
NameString configurationName = "C" + Guid.NewGuid().ToString("N");
var schemaDefinitionV2 = FileResource.Open("AccountSchemaDefinition.json");
IHttpClientFactory httpClientFactory = CreateDefaultRemoteSchemas(configurationName);
IDatabase database = _connection.GetDatabase();
for (var i = 0; i < 10; i++)
{
if (await database.SetLengthAsync(configurationName.Value) == 4)
{
break;
}
await Task.Delay(150);
}
IRequestExecutorResolver executorResolver =
new ServiceCollection()
.AddSingleton(httpClientFactory)
.AddGraphQL()
.AddQueryType(d => d.Name("Query"))
.AddRemoteSchemasFromRedis(configurationName, s => _connection)
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>();
await executorResolver.GetRequestExecutorAsync();
var raised = false;
executorResolver.RequestExecutorEvicted += (sender, args) =>
{
if (args.Name.Equals(Schema.DefaultName))
{
raised = true;
}
};
// act
Assert.False(raised, "eviction was raised before act.");
await database.StringSetAsync($"{configurationName}.{_accounts}", schemaDefinitionV2);
await _connection.GetSubscriber().PublishAsync(configurationName.Value, _accounts);
for (var i = 0; i < 10; i++)
{
if (raised)
{
break;
}
await Task.Delay(150);
}
// assert
Assert.True(raised, "schema evicted.");
IRequestExecutor executor = await executorResolver.GetRequestExecutorAsync();
ObjectType type = executor.Schema.GetType <ObjectType>("User");
Assert.True(type.Fields.ContainsField("foo"), "foo field exists.");
}
