protected override void beforeEach()
{
const string viewPath = "/_Package1_/Handlers/Models/SerieSL.spark";
var appRoot = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Templates");
var packageRoot = Path.Combine(appRoot, "App", "fubu-packages", "Package1", "WebContent");
var binding1 = new Template(Path.Combine(packageRoot, "Handlers", "Shared", "bindings.xml"), packageRoot, "Package1");
var binding2 = new Template(Path.Combine(appRoot, "Shared", "bindings.xml"), appRoot, TemplateConstants.HostOrigin);
var viewPathPolicy = new ViewPathPolicy <ITemplate>();
viewPathPolicy.Apply(binding1);
viewPathPolicy.Apply(binding2);
_viewFolder = MockFor <IViewFolder>();
_viewFolder.Expect(x => x.GetViewSource(binding1.ViewPath)).Return(new FileSystemViewFile(binding1.FilePath));
_viewFolder.Expect(x => x.GetViewSource(binding2.ViewPath)).Return(new FileSystemViewFile(binding2.FilePath));
_request = new BindingRequest(_viewFolder)
{
ViewPath = viewPath
};
_templateRegistry = MockFor <ISparkTemplateRegistry>();
_templateRegistry.Expect(x => x.BindingsForView(viewPath)).Return(new[] { binding1, binding2 });
}
public async Task <ActionResult> HttpBinding([FromServices] DaprClient daprClient)
{
var request = new BindingRequest("httpbinding", "get");
var result = await daprClient.InvokeBindingAsync(request, cancellationToken : _cts.Token);
return(Ok());
}
public async Task InvokeBindingAsync_WithRequest_ValidateRequest()
{
await using var client = TestClient.CreateForDaprClient();
var payload = new InvokeRequest()
{
RequestParameter = "Hello "
};
var bindingRequest = new BindingRequest("test", "create")
{
Data = JsonSerializer.SerializeToUtf8Bytes(payload, client.InnerClient.JsonSerializerOptions),
Metadata =
{
{ "key1", "value1" },
{ "key2", "value2" }
}
};
var request = await client.CaptureGrpcRequestAsync(async daprClient =>
{
return(await daprClient.InvokeBindingAsync(bindingRequest));
});
var gRpcResponse = new Autogen.Grpc.v1.InvokeBindingResponse()
{
Data = ByteString.CopyFrom(JsonSerializer.SerializeToUtf8Bytes(new Widget()
{
Color = "red",
}, client.InnerClient.JsonSerializerOptions)),
Metadata =
{
{ "anotherkey", "anothervalue" },
}
};
var response = await request.CompleteWithMessageAsync(gRpcResponse);
var envelope = await request.GetRequestEnvelopeAsync <InvokeBindingRequest>();
envelope.Name.Should().Be("test");
envelope.Metadata.Count.Should().Be(2);
envelope.Metadata.Keys.Contains("key1").Should().BeTrue();
envelope.Metadata.Keys.Contains("key2").Should().BeTrue();
envelope.Metadata["key1"].Should().Be("value1");
envelope.Metadata["key2"].Should().Be("value2");
var json = envelope.Data.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json, client.InnerClient.JsonSerializerOptions);
typeFromRequest.RequestParameter.Should().Be("Hello ");
Assert.Same(bindingRequest, response.Request);
Assert.Equal("red", JsonSerializer.Deserialize <Widget>(response.Data.Span, client.InnerClient.JsonSerializerOptions).Color);
Assert.Collection(
response.Metadata,
kvp =>
{
Assert.Equal("anotherkey", kvp.Key);
Assert.Equal("anothervalue", kvp.Value);
});
}
private void RegisterRemoteVariable(BindingRequest req)
{
var variable = varCache.VariableByNumber(req.Index);
var entry = RegisterVariable(variable);
entry.TrySendValue();
}
public IEnumerable<Binding> GetBindings(BindingRequest bindingRequest)
{
var providers = _container.ResolveAll<IBindingProvider>();
var bindings = providers.SelectMany(x => x.GetBindings(bindingRequest));
providers.ToList().ForEach(x => _container.Release(x));
return bindings;
}
public override IEnumerable <Binding> GetBindings(BindingRequest bindingRequest)
{
var locatedFiles =
Directory.GetFiles(this.rootPathProvider.GetRootPath(), "bindings.xml", SearchOption.AllDirectories);
return(locatedFiles.Any() ?
locatedFiles.SelectMany(this.LoadBindings) :
Enumerable.Empty <Binding>());
}
public override IEnumerable<Binding> GetBindings(BindingRequest bindingRequest)
{
var locatedFiles =
Directory.GetFiles(this.rootPathProvider.GetRootPath(), "bindings.xml", SearchOption.AllDirectories);
return locatedFiles.Any() ?
locatedFiles.SelectMany(this.LoadBindings) :
Enumerable.Empty<Binding>();
}
public RestfulResult Bind(BindingRequest request, int?authuid, UserModel authUser)
{
request.AuthUser = authUser;
request.AuthUid = authuid.Value;
return(new RestfulResult {
Data = _cardDataService.Binding(request)
});
}
private IEnumerable <Binding> FindBindings(string viewPath)
{
if (this.BindingProvider == null)
{
return(new Binding[0]);
}
BindingRequest bindingRequest = new BindingRequest(this.ViewFolder)
{
ViewPath = viewPath
};
return(this.BindingProvider.GetBindings(bindingRequest));
}
public ExecuteResult <CardInfoResponse> UnBinding(BindingRequest request)
{
throw new NotSupportedException("不支持该方法");
if (request == null || request.AuthUser == null)
{
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "参数错误"
});
}
var entities = _cardRepository.GetListForUserId(request.AuthUser.Id, CardType.YintaiMemberCard, DataStatus.Normal).ToList();
if (entities.Count == 0)
{
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "你还没有绑定银泰卡，请您先绑定"
});
}
if (entities.Count > 1)
{
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.InternalServerError, Message = "服务器开小差了，请您等等再试"
});
}
var entity = entities[0];
using (var ts = new TransactionScope())
{
var delEntity = _cardRepository.GetItem(entity.Id);
delEntity.UpdatedDate = DateTime.Now;
delEntity.UpdatedUser = request.AuthUser.Id;
delEntity.Status = (int)DataStatus.Deleted;
_cardRepository.Delete(delEntity);
_userService.SetCardBinder(entity.User_Id, false);
ts.Complete();
}
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.Success, Message = "解除绑定成功"
});
}
public async Task <Result <BindingInfo> > Create(string sourceBinding, string destinationBinding, BindingType bindingType, string vhost,
string bindingKey = null, Action <BindingConfigurator> configurator = null, CancellationToken cancellationToken = default)
{
cancellationToken.RequestCanceled();
var impl = new BindingConfiguratorImpl();
configurator?.Invoke(impl);
impl.Validate();
BindingRequest request = new BindingRequest(bindingKey, impl.Arguments.Value);
Debug.Assert(request != null);
var errors = new List <Error>();
errors.AddRange(impl.Errors.Value);
if (string.IsNullOrWhiteSpace(sourceBinding))
{
errors.Add(new ErrorImpl("The name of the source binding (queue/exchange) is missing."));
}
if (string.IsNullOrWhiteSpace(destinationBinding))
{
errors.Add(new ErrorImpl("The name of the destination binding (queue/exchange) is missing."));
}
if (string.IsNullOrWhiteSpace(vhost))
{
errors.Add(new ErrorImpl("The name of the virtual host is missing."));
}
string virtualHost = vhost.ToSanitizedName();
string url = bindingType == BindingType.Exchange
? $"api/bindings/{virtualHost}/e/{sourceBinding}/e/{destinationBinding}"
: $"api/bindings/{virtualHost}/e/{sourceBinding}/q/{destinationBinding}";
if (errors.Any())
{
return(new FaultedResult <BindingInfo>(new DebugInfoImpl(url, request.ToJsonString(), errors)));
}
Result <BindingInfoImpl> result = await PostRequest <BindingInfoImpl, BindingRequest>(url, request, cancellationToken).ConfigureAwait(false);
Result <BindingInfo> MapResult(Result <BindingInfoImpl> result) => new ResultCopy(result);
return(MapResult(result));
}
public override IEnumerable<Binding> GetBindings(BindingRequest bindingRequest)
{
if (bindingRequest.ViewFolder.HasView("bindings.xml") == false)
return new Binding[0];
var file = bindingRequest.ViewFolder.GetViewSource("bindings.xml");
using (var stream = file.OpenViewStream())
{
using (var reader = new StreamReader(stream))
{
return LoadStandardMarkup(reader);
}
}
}
public override IEnumerable<Binding> GetBindings(BindingRequest bindingRequest)
{
if (!bindingRequest.ViewFolder.HasView(_service + "/Bindings.xml"))
{
return Enumerable.Empty<Binding>();
}
var file = bindingRequest.ViewFolder.GetViewSource(_service + "/Bindings.xml");
using (var stream = file.OpenViewStream())
{
using (var reader = new StreamReader(stream))
{
return LoadStandardMarkup(reader);
}
}
}
public override IEnumerable<Binding> GetBindings(BindingRequest request)
{
var viewFolder = request.ViewFolder;
var bindings = new List<Binding>();
foreach (var binding in _bindingTemplates)
{
using (var stream = viewFolder.GetViewSource(binding.ViewPath).OpenViewStream())
using (var reader = new StreamReader(stream))
{
bindings.AddRange(LoadStandardMarkup(reader));
}
}
return bindings;
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger <Startup> logger, DaprClient daprClient)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCloudEvents();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapSubscribeHandler();
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync("Hello World!");
});
endpoints.MapPost("/history", async context =>
{
var history = await context.Request.ReadFromJsonAsync <TransactionHistory>();
if (history.StartingBalance - history.EndingBalance >= 200m)
{
logger.LogInformation(
"Whoa there {Username} is a big spender! Before: {StartingBalance} After:{EndingBalance}",
history.Username,
history.StartingBalance,
history.EndingBalance);
// TODO - keep a record of all the big transactions
var request = new BindingRequest("auditstore", "create")
{
Data = CreateUpload(history),
};
await daprClient.InvokeBindingAsync(request);
}
// Returning a 2XX status code will mark the message as 'read'
//
// This would be the default, so it's not explicitly necessary to put in code.
context.Response.StatusCode = 200;
}).WithTopic("pubsub", "history");
});
}
public override IEnumerable <Binding> GetBindings(BindingRequest request)
{
var viewFolder = request.ViewFolder;
var viewPath = request.ViewPath;
var bindings = new List <Binding>();
foreach (var binding in _templateRegistry.BindingsForView(viewPath))
{
using (var stream = viewFolder.GetViewSource(binding.ViewPath).OpenViewStream())
using (var reader = new StreamReader(stream))
{
bindings.AddRange(LoadStandardMarkup(reader));
}
}
return(bindings);
}
public async Task Verify_can_create_exchange_binding_without_arguments2()
{
var services = GetContainerBuilder().BuildServiceProvider();
var result = await services.GetService <IBrokerObjectFactory>()
.CreateExchangeBinding("E2", "Q1", "HareDu");
Assert.Multiple(() =>
{
Assert.IsFalse(result.HasFaulted);
Assert.IsNotNull(result.DebugInfo);
Assert.IsNotNull(result.DebugInfo.Request);
BindingRequest request = result.DebugInfo.Request.ToObject <BindingRequest>();
Assert.That(request.BindingKey, Is.Empty.Or.Null);
Assert.IsNull(request.Arguments);
});
}
public async Task <IPEndPoint> GetMappedAddressAsync()
{
NetworkStream stream = _control.GetStream();
var request = new BindingRequest();
await SendMessageAsync(stream, request);
StunMessage response =
await _responses[request.TransactionId].Task;
if (response is BindingSuccessResponse success)
{
return(success.MappedAddress);
}
throw new TurnClientException(
"BindingRequest failed.",
response);
}
public async Task <DeployProcessResponse> DeployProcess([FromForm] DeployProcessRequest request)
{
await using var memoryStream = new MemoryStream();
var(fileContent, fileName) = request;
await fileContent.OpenReadStream().CopyToAsync(memoryStream);
var bindingRequest = new BindingRequest("command", Commands.DeployProcess)
{
Data = memoryStream.ToArray().AsMemory()
};
bindingRequest.Metadata.Add("fileName", fileName);
var bindingResponse = await _daprClient.InvokeBindingAsync(bindingRequest);
var responseJson = await JsonSerializer.DeserializeAsync <DeployProcessResponse>(
bindingResponse.Data.AsStream(), SerializerOptions.Json);
return(responseJson);
}
public void EncodeToBytes()
{
var request = new BindingRequest()
{
TransactionId = new byte[]
{
0xb9, 0x5e, 0x6c, 0xcd, 0xa3, 0x84, 0x74, 0xfb, 0x43, 0xe9,
0xae, 0xb1,
}
};
Assert.Equal(
new byte[]
{
0x00, 0x01, 0x00, 0x08, 0x21, 0x12, 0xa4, 0x42, 0xb9, 0x5e,
0x6c, 0xcd, 0xa3, 0x84, 0x74, 0xfb, 0x43, 0xe9, 0xae, 0xb1,
0x80, 0x28, 0x00, 0x04, 0xa7, 0xca, 0x62, 0xd4,
},
request.Encode(new TestStunContext()));
}
public async Task <IPEndPoint> GetMappedAddressAsync(
CancellationToken cancellationToken = default(CancellationToken))
{
NetworkStream stream = _control.GetStream();
var request = new BindingRequest();
await SendMessageAsync(stream, request, cancellationToken);
StunMessage response = await ReceiveMessage(request.TransactionId);
if (response is BindingSuccessResponse success)
{
Log.Debug($"Mapped address: {success.MappedAddress}");
return(success.MappedAddress);
}
throw new TurnClientException(
"BindingRequest failed.",
response);
}
public async Task Verify_can_create_queue_binding_with_arguments2()
{
var services = GetContainerBuilder().BuildServiceProvider();
var result = await services.GetService <IBrokerObjectFactory>()
.CreateExchangeBindingToQueue("E2", "Q1", "HareDu", "*.", x =>
{
x.Add("arg1", "value1");
});
Assert.Multiple(() =>
{
Assert.IsFalse(result.HasFaulted);
Assert.IsNotNull(result.DebugInfo);
Assert.IsNotNull(result.DebugInfo.Request);
BindingRequest request = result.DebugInfo.Request.ToObject <BindingRequest>();
Assert.AreEqual("*.", request.BindingKey);
Assert.AreEqual("value1", request.Arguments["arg1"].ToString());
});
}
public async Task <bool> IsConnectable(
CancellationToken cancellationToken = default(CancellationToken))
{
try
{
using var client = new TcpClient();
#pragma warning disable PC001 // API not supported on all platforms
client.Connect(_host, _port);
#pragma warning restore PC001 // API not supported on all platforms
NetworkStream stream = client.GetStream();
var request = new BindingRequest();
var asBytes = request.Encode(this);
await stream.WriteAsync(asBytes, 0, asBytes.Length, cancellationToken);
await StunMessage.ParseAsync(stream, cancellationToken);
return(true);
}
catch (Exception)
{
return(false);
}
}
//Implement IBindingSource.Bind
public Binding Bind(BindingRequest request)
{
return(BindingInstance);
}
public abstract IEnumerable<Binding> GetBindings(BindingRequest bindingRequest);
public IUpdateableBinding BindSingle(BindingRequest bindingRequest)
{
return(new FullBinding(bindingRequest));
}
public abstract Binding Bind(BindingRequest request);
public override Binding Bind(BindingRequest request)
{
return(_binding);
}
public FullBinding(BindingRequest bindingRequest)
{
_bindingDescription = bindingRequest.Description;
CreateTargetBinding(bindingRequest.Target);
CreateSourceBinding(bindingRequest.Source);
}
//Used for imported modules
public Binding BindToExport(BindingRequest request)
{
return(null);
}
Binding IBindingSource.Bind(BindingRequest request)
{
return(BindToExport(request));
}
public async Task InvokeBindingAsync_WithRequest_ValidateRequest()
{
// Configure Client
var httpClient = new TestHttpClient();
var daprClient = new DaprClientBuilder()
.UseGrpcChannelOptions(new GrpcChannelOptions {
HttpClient = httpClient
})
.Build();
var payload = new InvokeRequest()
{
RequestParameter = "Hello "
};
var request = new BindingRequest("test", "create")
{
Data = JsonSerializer.SerializeToUtf8Bytes(payload, daprClient.JsonSerializerOptions),
Metadata =
{
{ "key1", "value1" },
{ "key2", "value2" }
}
};
var task = daprClient.InvokeBindingAsync(request);
// Get Request and validate
httpClient.Requests.TryDequeue(out var entry).Should().BeTrue();
var gRpcRequest = await GrpcUtils.GetRequestFromRequestMessageAsync <InvokeBindingRequest>(entry.Request);
gRpcRequest.Name.Should().Be("test");
gRpcRequest.Metadata.Count.Should().Be(2);
gRpcRequest.Metadata.Keys.Contains("key1").Should().BeTrue();
gRpcRequest.Metadata.Keys.Contains("key2").Should().BeTrue();
gRpcRequest.Metadata["key1"].Should().Be("value1");
gRpcRequest.Metadata["key2"].Should().Be("value2");
var json = gRpcRequest.Data.ToStringUtf8();
var typeFromRequest = JsonSerializer.Deserialize <InvokeRequest>(json, daprClient.JsonSerializerOptions);
typeFromRequest.RequestParameter.Should().Be("Hello ");
var gRpcResponse = new Autogen.Grpc.v1.InvokeBindingResponse()
{
Data = ByteString.CopyFrom(JsonSerializer.SerializeToUtf8Bytes(new Widget()
{
Color = "red",
}, daprClient.JsonSerializerOptions)),
Metadata =
{
{ "anotherkey", "anothervalue" },
}
};
var streamContent = await GrpcUtils.CreateResponseContent(gRpcResponse);
entry.Completion.SetResult(GrpcUtils.CreateResponse(HttpStatusCode.OK, streamContent));
var response = await task;
Assert.Same(request, response.Request);
Assert.Equal("red", JsonSerializer.Deserialize <Widget>(response.Data.Span, daprClient.JsonSerializerOptions).Color);
Assert.Collection(
response.Metadata,
kvp =>
{
Assert.Equal("anotherkey", kvp.Key);
Assert.Equal("anothervalue", kvp.Value);
});
}
/// <summary>
/// 绑定
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ExecuteResult <CardInfoResponse> Binding(BindingRequest request)
{
//1.当前用户是否绑定过该卡
//2.该卡是否被绑定过
//3.验证是否可以绑定
// 3.1 集团验证
//4.入库
//5.查询积点
if (request == null || request.AuthUser == null)
{
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "参数错误"
});
}
var entity = _cardRepository.GetItemByCard(request.CardNo, CardType.YintaiMemberCard, DataStatus.Normal);
if (entity != null)
{
if (entity.User_Id != request.AuthUser.Id)
{
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "该会员卡已经被绑定"
});
}
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "您已经绑定过该会员卡"
});
}
var result = _groupCardService.GetInfo(new GroupCardInfoRequest
{
CardNo = request.CardNo,
Passwd = request.Password
});
if (result.RetType == GroupCardRetType.Ok)
{
using (var ts = new TransactionScope())
{
//入库
var e = _cardRepository.Insert(new CardEntity
{
CardNo = request.CardNo,
CardProfile = JsonExtension.ToJson_(new CardProfile
{
Lvl = result.Lvl,
Type = result.Type
}),
CreatedDate = DateTime.Now,
CreatedUser = request.AuthUser.Id,
Status = (int)DataStatus.Normal,
Type = (int)CardType.YintaiMemberCard,
UpdatedDate = DateTime.Now,
UpdatedUser = request.AuthUser.Id,
User_Id = request.AuthUser.Id
});
//成功后
_userService.SetCardBinder(e.User_Id, true);
ts.Complete();
}
return(GetInfo(new GetCardInfoRequest
{
AuthUser = request.AuthUser,
CardNo = request.CardNo,
Client_Version = request.Client_Version,
Method = request.Method,
Token = request.Token
}, "恭喜您绑定会员卡成功"));
}
return(new ExecuteResult <CardInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "会员卡号或密码错"
});
}
public Binding Bind(BindingRequest request)
{
return(null);
}
