private static async Task SendSubscriptionRequestsAuthenticated(CoinbaseWebsocketClient client)
{
//create an authenticator with your apiKey, apiSecret and passphrase
var authenticator = new CoinbaseAuthentication(API_KEY, API_SECRET, API_PASSPHRASE);
var subscription = new SubscribeRequest(
new[]
{
"BTC-EUR",
"BTC-USD"
},
new[]
{
ChannelSubscriptionType.Heartbeat,
ChannelSubscriptionType.Ticker,
ChannelSubscriptionType.Matches,
ChannelSubscriptionType.Heartbeat,
ChannelSubscriptionType.User,
ChannelSubscriptionType.Level2,
//ChannelSubscriptionType.Status
},
authenticator);
client.Send(subscription);
}
internal SubscribeResponse Subscribe(SubscribeRequest request)
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return(Invoke <SubscribeRequest, SubscribeResponse>(request, marshaller, unmarshaller));
}
public virtual bool addRequestToBatch(SubscribeRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
string key = request.SubscriptionId.ToString();
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
//can never happen that an ADD request substitutes a REMOVE request for 2 reasons:
// *if those requests are part of the same session than to remove and re-add a table
// changes its key.
// *if those requests are not part of the same session than during session change
// all pending request are removed.
//so, all cases should pass from the if (requestType == ControlRequest.REMOVE) case
// thus, this is an unexpected case, let's handle it anyway
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
private void SetupEventStore()
{
var ChannelName = Configuration["StatusControlKubeMQSettings:ChannelName"];
var ClientID = Configuration["StatusControlKubeMQSettings:ClientID"];
var KubeMQServerAddress = Configuration["StatusControlKubeMQSettings:KubeMQServerAddress"];
statusConsumptionService = new StatusConsumptionService(new StatusControlDBSettings()
{
ConnectionString = Configuration["StatusControlDBSettings:ConnectionString"],
DatabaseName = Configuration["StatusControlDBSettings:DatabaseName"],
StatusConsumptionCollectionName = Configuration["StatusControlDBSettings:StatusConsumptionCollectionName"],
});
var subscriber = new Subscriber(KubeMQServerAddress);
SubscribeRequest subscribeRequest = new SubscribeRequest()
{
Channel = ChannelName,
ClientID = ClientID,
EventsStoreType = EventsStoreType.StartAtSequence,
EventsStoreTypeValue = 1,
SubscribeType = SubscribeType.EventsStore
};
subscriber.SubscribeToEvents(subscribeRequest, HandleIncomingEvents, HandeIncomingErrors);
}
public override void Given()
{
Mediator = new Mock <IMediator>();
Request = new SubscribeRequest();
CancellationToken = new CancellationTokenSource().Token;
Controller = new EpcisSoapQueryController(Mediator.Object);
}
public async Task StartRecvListener(NBSTopic topic, Func <SubscribeResponse, T> func)
{
SubscribeRequest request = new SubscribeRequest {
Topics = topic.ToString()
};
Logged("Topic [" + topic.ToString() + "] starting ....");
try {
using (var call = pubsubClient.Subscribe(request))
{
while (await call.ResponseStream.MoveNext(CancellationToken.None))
{
SubscribeResponse response = call.ResponseStream.Current;
Console.WriteLine(">>>Recv Message:" + response.From);
T t = func(response);
if (response.From != selfID)
{
collection.Add(t);
}
}
}
} catch (Exception e) {
Logged(e, "subscribe failure.");
}
}
private void HandleSubscriptionRequests()
{
if (this.m_queuedSubscriptions.Count > 0)
{
long elapsedMilliseconds = this.m_stopWatch.ElapsedMilliseconds;
this.m_presenceSubscriptionBalance = Math.Min((float)0f, (float)(this.m_presenceSubscriptionBalance + ((elapsedMilliseconds - this.m_lastPresenceSubscriptionSent) * 0.003333333f)));
this.m_lastPresenceSubscriptionSent = elapsedMilliseconds;
List <EntityId> list = new List <EntityId>();
foreach (EntityId id in this.m_queuedSubscriptions)
{
if ((this.m_presenceSubscriptionBalance - 1f) < -100f)
{
break;
}
PresenceRefCountObject obj2 = this.m_presenceSubscriptions[id];
SubscribeRequest message = new SubscribeRequest();
message.SetObjectId(ChannelAPI.GetNextObjectId());
message.SetEntityId(id);
obj2.objectId = message.ObjectId;
base.m_battleNet.Channel.AddActiveChannel(message.ObjectId, new ChannelAPI.ChannelReferenceObject(id, ChannelAPI.ChannelType.PRESENCE_CHANNEL));
base.m_rpcConnection.QueueRequest(this.m_presenceService.Id, 1, message, new RPCContextDelegate(this.PresenceSubscribeCallback), 0);
this.m_presenceSubscriptionBalance--;
list.Add(id);
}
foreach (EntityId id2 in list)
{
this.m_queuedSubscriptions.Remove(id2);
}
}
}
private static void Subscribe(IWebHost host)
{
var channel = GrpcChannel.ForAddress(EndpointsConstants.BrokerAddress);
var client = new Subscriber.SubscriberClient(channel);
var address = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses.First();
Console.WriteLine($"Subscriber listening at: {address}");
Console.Write("Enter the topic: ");
var topic = Console.ReadLine().ToLower();
// var address = host.ServerFeatures.Get<IServerAddressesFeature>().Addresses.First();
var request = new SubscribeRequest()
{
Topic = topic, Address = address
};
try
{
var reply = client.Subscribe(request);
Console.WriteLine($"Subscribed reply: { reply.IsSuccess}");
}
catch (Exception e)
{
Console.WriteLine($"Error subscrbing: { e.Message}");
}
}
/////////////////////////////////////////////////SUBSCRIPTIONS API CALLS
public virtual void sendSubscription(SubscribeRequest request, RequestTutor tutor)
{
if (this.session != null)
{
this.session.sendSubscription(request, tutor);
}
}
public void Subscribe(string id, string rpcQueueTopic, CancellationToken cancellationToken,
Dictionary <string, CancellationToken> queueTopic)
{
try
{
Subscriber subscriber = new Subscriber(_logger);
foreach (var(channel, token) in queueTopic)
{
SubscribeRequest subscribeRequest = new SubscribeRequest(SubscribeType.EventsStore,
$"{id}{Guid.NewGuid()}", channel, EventsStoreType.StartNewOnly, 0, id);
subscriber.SubscribeToEvents(subscribeRequest, r => HandleIncomingEvents(r, id), ErrorDelegate,
token);
}
Responder responder = new Responder();
SubscribeRequest rpcSubscribeRequest = new SubscribeRequest(SubscribeType.Queries,
$"{id}{Guid.NewGuid()}", rpcQueueTopic, EventsStoreType.Undefined, 0, id);
responder.SubscribeToRequests(rpcSubscribeRequest, (request) => HandleRpcRequest(request, id),
ErrorDelegate, cancellationToken);
}
catch (Exception e)
{
_logger.LogError(e, "Can`t subscribe to events");
}
}
public void ShouldSendEmailOnSubscription()
{
//Arrange
var userId = "*****@*****.**";
var topics = new[] { 1, 3 };
var request = new SubscribeRequest {
Topics = topics, UserId = userId
};
this.topicsService.Topics.Returns(new List <Topic>
{
new Topic {
TopicId = 1, DisplayName = "Topic one"
},
new Topic {
TopicId = 2, DisplayName = "Topic two"
},
new Topic {
TopicId = 3, DisplayName = "Topic three"
}
});
//Act
this.cut.SubscribeAsync(request).Wait();
//Assert
//We do not have to test second argument, it is tested in formatter unit test
this.mailingService.Received(1).SendEmailAsync(userId, Arg.Any <string>(), "Subscribed");
}
private async void SubscribeToMessages(SubscribeRequest subscribeRequest, string clientDisplayName)
{
Metadata metadata = null;
if (string.IsNullOrWhiteSpace(clientDisplayName))
{
metadata = new Metadata {
{ "client_tag", clientDisplayName }
};
}
using (var call = GetWarpGrpcClient().SubscribeToChannel(subscribeRequest, metadata))
{
// Wait for message..
while (await call.ResponseStream.MoveNext())
{
// Recived a message
InnerMessage message = call.ResponseStream.Current;
// add message to queue
_RecivedMessages.Post(message);
LogIncomingMessage(message);
}
}
}
public ActionResult Index(Subscribe model)
{
if (ModelState.IsValid)
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
var appAccessToken = ConfigurationManager.AppSettings["AppKey"];
SubscribeRequest subscribeRequest = new SubscribeRequest(connection, appAccessToken, model.Email);
SubscribeResponse subscribeResponse = subscribeRequest.Send();
if (subscribeResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
TempData["Success"] = "You have been subscribed to our newsletter!";
return(RedirectToAction("Index", "Home"));
}
else if (subscribeResponse.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
TempData["Errors"] = "That email address is already subscribed.";
return(RedirectToAction("Index", "Home"));
}
else
{
TempData["Errors"] = "There was an error processing your request.";
return(RedirectToAction("Index", "Home"));
}
}
else
{
return(View(model));
}
}
public async Task <string> SubscribeQueueToTopic(string queueArn, string topicArn)
{
var subScribeRequest = new SubscribeRequest(topicArn, sqsProtocol, queueArn);
var response = await _sns.SubscribeAsync(subScribeRequest);
return(response.SubscriptionArn);
}
public async Task <CreatedResult> Post(SubscribeRequest subscribeRequest, CancellationToken cancellationToken)
{
var subscriptionId = Guid.NewGuid().ToString();
var scheduleId = Guid.NewGuid().ToString();
await _schedulerService.ScheduleJob(CreateRequest(subscriptionId, scheduleId, Constants.JobNames.PubSubHeartbeatJob), cancellationToken);
await _schedulerService.ScheduleJob(CreateRequest(subscriptionId, scheduleId, Constants.JobNames.PubSubTelemetryJob), cancellationToken);
var request = new Subscription()
{
Request = subscribeRequest,
ScheduleId = scheduleId
};
_stateManager.AddSchedule(subscriptionId, request);
var response = new PubSubSimulator.Models.SubscribeResponse()
{
SubscriptionId = subscriptionId
};
Console.Out.WriteLine($"Subscription: {subscriptionId} created");
return(Created("/hello", response));
}
public MemstateClient(MemstateSettings config)
{
_config = config;
_serializer = config.CreateSerializer();
_pendingRequests = new Dictionary <Guid, TaskCompletionSource <Message> >();
_logger = _config.LoggerFactory.CreateLogger <MemstateClient <TModel> >();
_cancellationSource = new CancellationTokenSource();
_events = new ClientEvents();
_events.SubscriptionAdded += async(type, filters) =>
{
var request = new SubscribeRequest(type, filters.ToArray());
await SendAndReceive(request);
};
_events.SubscriptionRemoved += async type =>
{
var request = new UnsubscribeRequest(type);
await SendAndReceive(request);
};
_events.GlobalFilterAdded += async filter =>
{
var request = new FilterRequest(filter);
await SendAndReceive(request);
};
}
public void SubcribeToEventsWithoutStore()
{
subscriber = new Subscriber(logger);
SubscribeRequest subscribeRequest = CreateSubscribeRequest(SubscribeType.Events);
subscriber.SubscribeToEvents(subscribeRequest, HandleIncomingEvents);
}
/// <inheritdoc/>
public SubscribeResponse Subscribe(SubscribeRequest request)
{
return(AggregateExceptionExtract.Extract(() =>
{
return SubscribeAsync(request).Result;
}));
}
private void SubcribeToEventsWithStore()
{
subscriber = new Subscriber(logger);
SubscribeRequest subscribeRequest = CreateSubscribeRequest(SubscribeType.EventsStore, EventsStoreType.StartAtSequence, 2);
subscriber.SubscribeToEvents(subscribeRequest, HandleIncomingEvents);
}
internal bool Subscribe(string eventId, EventHandler handler)
{
_eventHandlers.Add(eventId, handler);
var request = new SubscribeRequest()
{
objectId = _objectId,
eventId = eventId
};
var response = _client.Request(request);
switch (response)
{
case ExceptionResponse exResp:
throw exResp.exception;
case SubscribeResponse subscribeResp:
if (subscribeResp.objectId != _objectId)
{
throw new InvalidResponseException($"Incorrect object ID. Expected '{_objectId}', but received '{subscribeResp.objectId}'.");
}
else if (subscribeResp.eventId != eventId)
{
throw new InvalidResponseException($"Incorrect event ID. Expected '{eventId}', but received '{subscribeResp.eventId}'.");
}
break;
default:
throw new InvalidResponseException($"Incorrect response type. Expected '{ResponseType.subscribe}', but received '{response.responseType}'.");
}
return(true);
}
public void SubscribeNoArgsTest()
{
// Arrange
string objectId = "objId1";
var expectedRequest = new SubscribeRequest()
{
objectId = objectId,
eventId = ObjectDescriptor.GetEventId <IRegisteredObject>(nameof(IRegisteredObject.NotifyOnNonDataChanged))
};
SubscribeRequest actualRequest = null;
_clientMock.Setup(o => o.Request(It.IsAny <SubscribeRequest>())).Returns <SubscribeRequest>(req =>
{
actualRequest = req;
return(new SubscribeResponse()
{
objectId = objectId,
eventId = ObjectDescriptor.GetEventId <IRegisteredObject>(nameof(IRegisteredObject.NotifyOnNonDataChanged))
});
});
var objProxy = RuntimeProxy.Create <IRegisteredObject>(objectId, _clientMock.Object);
// Act
objProxy.NotifyOnNonDataChanged += (s, e) => { };
// Assert
_clientMock.VerifyAll();
Assert.AreEqual(expectedRequest.objectId, actualRequest.objectId);
Assert.AreEqual(expectedRequest.eventId, actualRequest.eventId);
}
/// <summary>
/// 添加订阅
/// </summary>
public void Subscribe()
{
// 设置请求对象
SubscribeRequest request = new SubscribeRequest
{
TopicUrn = "urn:smn:cn-north-1:cffe4fc4c9a54219b60dbaf7b586e132:SmnApi",
Protocol = ProtocolType.EMAIL,
Endpoint = "*****@*****.**",
Remark = "api订阅接口测试成功"
};
try
{
// 发送请求并返回响应
SubscribeResponse response = smnClient.SendRequest(request);
string result = response.RequestId;
Console.WriteLine("{0}", result);
Console.ReadLine();
}
catch (Exception e)
{
// 处理异常
Console.WriteLine("{0}", e.Message);
}
}
//[Dependency]
//public ISubscribes Biz {
// get;
// set;
//}
public override Reply Handle(string tag, SubscribeRequest msg)
{
Task.Factory.StartNew(() => {
//this.Biz.Subscribe(tag, msg.FromUserName);
var method = new UserInfo()
{
OpenID = msg.FromUserName
};
var client = ApiClient.GetInstance(tag);
var user = client.Execute(method);
if (!user.HasError)
{
//this.Biz.UpdateInfo(tag, msg.FromUserName, user);
}
var method2 = new MessageSend()
{
OpenID = msg.FromUserName,
Message = new TextMessage()
{
Content = "谢谢关注"
}
};
client.Execute(method2);
});
return(null);
}
public async Task <IActionResult> Subscribe([FromBody] SubscribeRequest request)
{
try
{
var model = new Subscriber();
model.EmailAddress = request.EmailAddress;
if (string.IsNullOrEmpty(request.EmailAddress))
{
return(new JsonResult("Email Address must have a value"));
}
if (!request.EmailAddress.Contains("@"))
{
return(new JsonResult("Invalid email address"));
}
await _mongoRepository.CreateSubscriberAsync(request.EmailAddress);
return(new JsonResult(true));
}
catch (Exception ex)
{
return(new JsonResult(new PicturesReponse(false)
{
Message = $"An unknown error occurred while subscribing\r\n{ex}"
}));
}
}
public override async Task Subscribe(
SubscribeRequest request, IServerStreamWriter <SubscribeResponse> responseStream, ServerCallContext context)
{
var token = context.CancellationToken;
while (!token.IsCancellationRequested)
{
try
{
var message = await _orderMessages.ReadAsync(token);
var response = new SubscribeResponse
{
CrustId = message.CrustId,
ToppingIds = { message.ToppingIds },
Time = message.Time.ToTimestamp()
};
await responseStream.WriteAsync(response);
}
catch (OperationCanceledException)
{
break;
}
}
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <SubscribeResponse> SubscribeAsync(SubscribeRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return(Invoke <IRequest, SubscribeRequest, SubscribeResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
private void HandleSubscriptionRequests()
{
if (this.m_queuedSubscriptions.Count > 0)
{
long elapsedMilliseconds = this.m_stopWatch.ElapsedMilliseconds;
this.m_presenceSubscriptionBalance = Math.Min(0f, this.m_presenceSubscriptionBalance + (float)(elapsedMilliseconds - this.m_lastPresenceSubscriptionSent) * 0.00333333341f);
this.m_lastPresenceSubscriptionSent = elapsedMilliseconds;
List <bnet.protocol.EntityId> list = new List <bnet.protocol.EntityId>();
foreach (bnet.protocol.EntityId entityId in this.m_queuedSubscriptions)
{
if (this.m_presenceSubscriptionBalance - 1f < -100f)
{
break;
}
PresenceAPI.PresenceRefCountObject presenceRefCountObject = this.m_presenceSubscriptions[entityId];
SubscribeRequest subscribeRequest = new SubscribeRequest();
subscribeRequest.SetObjectId(ChannelAPI.GetNextObjectId());
subscribeRequest.SetEntityId(entityId);
presenceRefCountObject.objectId = subscribeRequest.ObjectId;
this.m_battleNet.Channel.AddActiveChannel(subscribeRequest.ObjectId, new ChannelAPI.ChannelReferenceObject(entityId, ChannelAPI.ChannelType.PRESENCE_CHANNEL));
this.m_rpcConnection.QueueRequest(this.m_presenceService.Id, 1u, subscribeRequest, new RPCContextDelegate(this.PresenceSubscribeCallback), 0u);
this.m_presenceSubscriptionBalance -= 1f;
list.Add(entityId);
}
foreach (bnet.protocol.EntityId item in list)
{
this.m_queuedSubscriptions.Remove(item);
}
}
}
/// <summary>
/// Register to kubeMQ Channel using KubeMQ.SDK.csharp.Subscription.SubscribeRequest .
/// </summary>
/// <param name="subscribeRequest">Parameters list represent by KubeMQ.SDK.csharp.Subscription.SubscribeRequest that will determine the subscription configuration.</param>
/// <param name="handler">Method the perform when receiving KubeMQ.SDK.csharp.PubSub.EventReceive .</param>
/// <param name="errorDelegate">Method the perform when receiving error from KubeMQ.SDK.csharp.PubSub.EventReceive .</param>
/// <param name="cancellationToken">Optional param if needed to cancel the subscriber ,will receive RPC exception with status canceled through the error Delegate is called.</param>
/// <returns>A task that represents the Subscribe Request. Possible Exception: fail on ping to kubemq.</returns>
public void SubscribeToEvents(SubscribeRequest subscribeRequest, HandleEventDelegate handler, HandleEventErrorDelegate errorDelegate, CancellationToken cancellationToken = default(CancellationToken))
{
ValidateSubscribeRequest(subscribeRequest); // throws ArgumentException
try {
this.Ping();
} catch (Exception pingEx) {
logger.LogWarning(pingEx, "An exception occurred while sending ping to kubemq");
throw pingEx;
}
var grpcListnerTask = Task.Run((Func <Task>)(async() => {
while (true)
{
try {
await SubscribeToEvents(subscribeRequest, cancellationToken);
} catch (RpcException rpcx) {
if (rpcx.StatusCode == StatusCode.Cancelled)
{
logger.LogWarning(rpcx, $"Cancellation was called ");
errorDelegate(rpcx);
break;
}
else
{
logger.LogWarning(rpcx, $"An RPC exception occurred while listening for events");
errorDelegate(rpcx);
}
} catch (Exception ex) {
logger.LogWarning(ex, $"An exception occurred while listening for events");
errorDelegate(ex);
}
await Task.Delay(1000);
}
}));
// send events to end-user
Task evenSenderTask = Task.Run((Func <Task>)(async() => {
while (true)
{
// await for event from queue
InnerRecivedEvent innerEvent = await _RecivedEvents.ReceiveAsync();
LogIncomingEvent(innerEvent);
// Convert KubeMQ.Grpc.Event to outer Event
EventReceive evnt = new EventReceive(innerEvent);
try {
// Activate end-user event handler Delegate
handler(evnt);
} catch (Exception ex) {
logger.LogError(ex, "An exception occurred while handling the event");
errorDelegate(ex);
}
}
}));
}
public static Connection From(SubscribeRequest request) =>
new Connection
{
Address = request.Address,
Sensor = request.Sensor,
ExecutorType = request.ExecutorType,
GrpcChannel = CreateSecureChannel(request.Address)
};
public IHttpActionResult RegisterPhoneNumber(string phoneNumber)
{
var subscribeRequest = new SubscribeRequest(TopicArn, "sms", phoneNumber);
var response = Client.Subscribe(subscribeRequest);
NumberToArn.Add(phoneNumber, response.SubscriptionArn);
return(Ok());
}
private object GetFilterInstance(SubscribeRequest request)
{
if (request.Filter != null)
{
var filterType = _filterMap.GetFilterType(request.Filter.Dialect);
return request.Filter.DeserializeAs(filterType);
}
return null;
}
//Handles AddButton.Click
//The user wants to add a new user to their Roster
//Prompt for the information.
//Submit the new roster item and presence subscription request.
//Refresh the local copy of the Roster from the server.
//Send the server the current presence,
private void AddButton_Click(object sender, System.EventArgs e)
{
ContactListUserAddForm addForm = new ContactListUserAddForm();
if (addForm.ShowDialog() != DialogResult.OK)
{
return;
}
JabberID jid = new JabberID(addForm.JabberIDTextBox.Text.Trim());
SubscribeRequest p = new SubscribeRequest(jid);
_SessionManager.Send(p);
}
public SubscribeRequest CreatSubscriptionRequest(DateTime date)
{
String rateplanid = CreateRatePlanToSubscribe();
SubscribeRequest subrequest = new SubscribeRequest();
subrequest.Account = MakeTestAccount();
subrequest.BillToContact = MakeTestContact();
subrequest.PaymentMethod = MakeTestPaymentMethod();
SubscriptionData sd = new SubscriptionData();
sd.Subscription = MakeTestSubscription(date);
RatePlanData rpd = new RatePlanData();
RatePlan rp = new RatePlan();
rp.ProductRatePlanId = rateplanid;
rpd.RatePlan = rp;
sd.RatePlanData = new RatePlanData[] { rpd };
subrequest.SubscriptionData = sd;
return subrequest;
}
private void testSubscribe()
{
ProductRatePlanCharge charge = getChargeByAccountingCode(ACCOUNTING_CODE);
Account acc = makeAccount();
Contact con = makeContact();
PaymentMethod pm = makePaymentMethod();
Subscription subscription = makeSubscription();
var sd = new SubscriptionData();
sd.Subscription = subscription;
RatePlanData[] subscriptionRatePlanDataArray = makeRatePlanData(charge);
sd.RatePlanData = subscriptionRatePlanDataArray;
var sub = new SubscribeRequest();
sub.Account = acc;
sub.BillToContact = con;
sub.PaymentMethod = pm;
sub.SubscriptionData = sd;
var subscribes = new SubscribeRequest[1];
subscribes[0] = sub;
SubscribeResult[] result = client.subscribe(sessionHeader, subscribes);
print(createMessage(result));
}
protected void testSubscribe()
{
ProductRatePlanCharge charge = queryChargeByAccountingCode(ACCOUNTING_CODE);
Account acc = makeAccount();
Contact con = makeContact();
PaymentMethod pm = makePaymentMethod();
Subscription subscription = makeSubscription("New Signup" + DateTime.Now.Ticks, null);
SubscriptionData sd = new SubscriptionData();
sd.Subscription = subscription;
RatePlanData[] subscriptionRatePlanDataArray = makeRatePlanData(new ProductRatePlanCharge[]{charge});
sd.RatePlanData = subscriptionRatePlanDataArray;
SubscribeRequest sub = new SubscribeRequest();
sub.Account = acc;
sub.BillToContact = con;
sub.PaymentMethod = pm;
sub.SubscriptionData = sd;
SubscribeRequest[] subscribes = new SubscribeRequest[1];
subscribes[0] = sub;
SubscribeResult[] result = binding.subscribe(subscribes);
String message = createMessage(result[0]);
print(message);
}
public override void Subscribe(Google.ProtocolBuffers.IRpcController controller, SubscribeRequest request, Action<bnet.protocol.NoData> done) {
done(bnet.protocol.NoData.CreateBuilder().Build());
}
/*public ResponseHolder GetCurrentSubscription(String subscriptionId)
{
String subscriptionQuery = "SELECT Id,Name,Status,Version,PreviousSubscriptionId,ContractEffectiveDate,TermStartDate FROM Subscription WHERE AccountId='" + subscriptionId + "' AND Status='Active'AND Status='Active'";
Subscription activeSubscription = (Subscription)zs.Query(subscriptionQuery).Objects[0];
String RatePlanString = "SELECT Id,Name,ProductRatePlanId FROM RatePlan WHERE SubscriptionId='" + activeSubscription.Id + "'";
ResponseHolder ratePlans = zs.Query(RatePlanString);
foreach (zObject ratePlan in ratePlans.Objects)
{
}
}*/
public SubscribeResponseHolder Subscribe(Account acc, Contact con, PaymentMethod pay, List<ProductRatePlanHolder> productRatePlans, Subscription sub, PreviewOptions po, SubscribeOptions so)
{
SubscribeRequest subscribeRequest = new SubscribeRequest();
subscribeRequest.SubscribeOptions = so;
subscribeRequest.PreviewOptions = po;
subscribeRequest.Account = acc;
subscribeRequest.BillToContact = con;
//Payment Method isn't required to subscribe
if (pay != null)
{
subscribeRequest.PaymentMethod = pay;
}
SubscriptionData subData = new SubscriptionData();
sub.AccountId = acc.Id;
subData.Subscription = sub;
List<RatePlanData> rpdList = new List<RatePlanData>();
foreach (ProductRatePlanHolder prph in productRatePlans)
{
RatePlanData ratePlanData = new RatePlanData();
RatePlan ratePlan = new RatePlan();
ratePlan.ProductRatePlanId = prph.ProductRatePlan.Id;
ratePlanData.RatePlan = ratePlan;
List<RatePlanChargeData> rpcData = new List<RatePlanChargeData>();
if (prph.ProductRatePlanCharges != null)
{
foreach (ProductRatePlanChargeHolder prpch in prph.ProductRatePlanCharges)
{
ProductRatePlanCharge prpc = prpch.ProductRatePlanCharge;
//set quantity and add chargeData if applicable
if ((prpc.ChargeModel.Equals("Per Unit Pricing") || prpc.ChargeModel.Equals("Tiered Pricing") || prpc.ChargeModel.Equals("Volume Pricing")))
{
RatePlanChargeData ratePlanChargeData = new RatePlanChargeData();
RatePlanCharge ratePlanCharge = new RatePlanCharge();
ratePlanCharge.ProductRatePlanChargeId = prpc.Id;
ratePlanCharge.QuantitySpecified = true;
ratePlanCharge.Quantity = prpc.DefaultQuantity;
ratePlanChargeData.RatePlanCharge = ratePlanCharge;
rpcData.Add(ratePlanChargeData);
}
}
}
if (rpcData.Count != 0)
{
ratePlanData.RatePlanChargeData = rpcData.ToArray();
}
rpdList.Add(ratePlanData);
}
subData.RatePlanData = rpdList.ToArray();
subscribeRequest.SubscriptionData = subData;
return zs.Subscribe(new List<SubscribeRequest> { subscribeRequest })[0];
}
private void btnOk_Click(object sender, EventArgs e)
{
Hide();
if (ValidateInput() == false)
{
DialogResult = DialogResult.None;
return;
}
Contact contact = AppController.Instance.Contacts[cbContactname.SelectedItem.ToString()];
JabberID Jid =
new JabberID(contact.UserName.ToString(), contact.ServerName.ToString(), Settings.Default.Resource);
Contact delContact = new Contact(Jid, contact.GroupName.ToString(), LoginState.Offline);
Contact editContact = new Contact(Jid, tbnewGpName.Text.Trim(), LoginState.Offline);
UnsubscribedResponse resp = new UnsubscribedResponse(Jid);
AppController.Instance.SessionManager.Send(resp);
AppController.Instance.SessionManager.BeginSend(new RosterRemove(Jid, contact.UserName.ToString()));
AppController.Instance.Contacts.Remove(delContact);
SubscribeRequest p = new SubscribeRequest(Jid);
AppController.Instance.SessionManager.Send(p);
AppController.Instance.SessionManager.BeginSend(
new RosterAdd(Jid, contact.UserName.ToString(), tbnewGpName.Text.ToString()));
AppController.Instance.Contacts.Add(editContact);
AppController.Instance.MainWindow.UpdateContactList();
}
public override void Subscribe(Google.ProtocolBuffers.IRpcController controller, SubscribeRequest request, Action<SubscribeResponse> done) {
Debug.WriteLine("Subscribe request");
var response = SubscribeResponse.CreateBuilder();
done(response.Build());
}
public override void Subscribe(IRpcController controller, SubscribeRequest request, Action<NoData> done)
{
done(new NoData.Builder().Build());
}
internal SubscribeResult subscribe(
String SubscriptionName,
ProductRatePlanCharge[] charges,
string Name,
string FirstName,
string LastName,
string WorkEmail,
string WorkPhone,
string Address1,
string Address2,
string City,
string State,
string Country,
string PostalCode,
string CreditCardType,
string CreditCardNumber,
string CreditCardHolderName,
int CreditCardExpirationMonth,
int CreditCardExpirationYear)
{
Account acc = makeAccount(Name, "USD");
Contact con = makeContact(FirstName, LastName, WorkEmail, WorkPhone, Address1, Address2, City, State, Country, PostalCode);
PaymentMethod pm = makePaymentMethod(CreditCardHolderName, Address1, City, State, Country, PostalCode, CreditCardType, CreditCardNumber, CreditCardExpirationMonth, CreditCardExpirationYear);
Subscription subscription = makeSubscription(SubscriptionName, null);
SubscriptionData sd = new SubscriptionData();
sd.Subscription = subscription;
RatePlanData[] subscriptionRatePlanDataArray = makeRatePlanData(charges);
sd.RatePlanData = subscriptionRatePlanDataArray;
SubscribeOptions options = new SubscribeOptions();
options.GenerateInvoice = GENERATE_INVOICE;
options.ProcessPayments = PROCESS_PAYMENTS;
SubscribeRequest sub = new SubscribeRequest();
sub.Account = acc;
sub.BillToContact = con;
sub.PaymentMethod = pm;
sub.SubscriptionData = sd;
sub.SubscribeOptions = options;
SubscribeRequest[] subscribes = new SubscribeRequest[1];
subscribes[0] = sub;
SubscribeResult[] result = binding.subscribe(subscribes);
return result[0];
}
private void btnOk_Click(object sender, EventArgs e)
{
if (ValidateInput() == false)
{
DialogResult = DialogResult.None;
return;
}
JabberID JID = null;
string message = "The User ID you entered is not valid. Please enter a valid User ID";
try
{
JID = new JabberID(tbUserName.Text.ToString(), tbServerName.Text.ToString(), Settings.Default.Resource);
if (JID.UserName.Length == 0 ||
JID.Server.Length == 0)
{
MessageBox.Show(message, "Invalid UserID");
DialogResult = DialogResult.None;
return;
}
}
catch
{
MessageBox.Show(message, "Invalid UserID");
DialogResult = DialogResult.None;
return;
}
Contact newContact = new Contact(JID, tbGroupName.Text.Trim(), LoginState.Offline);
foreach (Contact contact in AppController.Instance.Contacts)
{
if (contact.Equals(newContact))
{
MessageBox.Show("Contact already exists!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
DialogResult = DialogResult.None;
return;
}
}
SubscribeRequest subscribeRequest = new SubscribeRequest(JID);
AppController.Instance.SessionManager.Send(subscribeRequest);
AppController.Instance.SessionManager.BeginSend(
new RosterAdd(JID, tbUserName.Text.Trim(), tbGroupName.Text.Trim()));
AppController.Instance.Contacts.Add(newContact);
AppController.Instance.MainWindow.UpdateContactList();
}
private void IncomingAsycPresenceThreadSafe(Packet p)
{
PresencePacket IncomingPresencePacket = p as PresencePacket;
if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.ProbeRequest)
{
//A Probe means we should send ouur presence to the probing entity
//Maybe we should get some user input here. Not really sure if theyd want to know, though.
_SessionManager.SendCurrentPresence(IncomingPresencePacket.From);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.SubscribeRequest)
{
string displayString = String.Format("Allow User '{0}; to subscribe to your presence?", IncomingPresencePacket.From.JabberIDNoResource);
if (MessageBox.Show(displayString, "Subscription Request", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
SubscribedResponse resp = new SubscribedResponse(IncomingPresencePacket.From);
_SessionManager.Send(resp);
SubscribeRequest subscribe = new SubscribeRequest(new JabberID(IncomingPresencePacket.From.JabberIDNoResource));
_SessionManager.Send(subscribe);
}
else
{
UnsubscribedResponse resp = new UnsubscribedResponse();
resp.To = IncomingPresencePacket.From;
_SessionManager.Send(resp);
}
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.SubscribedResponse)
{
//Let the user know when someone accepts our subscription request
string displayString = String.Format("User '{0}' has accepted your presence subscription request.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Accept", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.UnsubscribedResponse)
{
//Let the user know when someone revoked our presence subscription
string displayString = String.Format("User '{0}' rejected your reqeust.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Denied", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.ErrorResponse)
{
//Let the user know of any presence errors that are received
//Dim PresenceError As SoapBox.Core.Presence.ErrorResponse = CType(IncomingPresencePacket, SoapBox.Core.Presence.ErrorResponse)
//MsgBox("The following presence error was received:" & vbCrLf & vbCrLf & "Code: " & PresenceError.ErrorCode & vbCrLf & "Text: " & PresenceError.ErrorText, MsgBoxStyle.Exclamation, "Presence Error")
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.AvailableRequest)
{
AvailableRequest avail = WConvert.ToAvailableRequest(IncomingPresencePacket);
ListViewRosterItem lvri = this.GetListViewRosterItem(avail.From);
if (lvri != null)
lvri.Presence = avail;
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.UnavailableRequest)
{
UnavailableRequest avail = WConvert.ToUnavailableRequest(IncomingPresencePacket);
ListViewRosterItem lvri = this.GetListViewRosterItem(avail.From);
if (lvri != null)
lvri.Presence = avail;
}
}
public SubscribeResponseHolder SubscribeWithExisitingAccount(String accountId, List<ProductRatePlanHolder> productRatePlans, Subscription sub, PreviewOptions po, SubscribeOptions so)
{
SubscribeRequest subscribeRequest = new SubscribeRequest();
subscribeRequest.SubscribeOptions = so;
subscribeRequest.PreviewOptions = po;
Account acc = new Account();
acc.Id = accountId;
subscribeRequest.Account = acc;
SubscriptionData subData = new SubscriptionData();
sub.AccountId = accountId;
subData.Subscription = sub;
List<RatePlanData> rpdList = new List<RatePlanData>();
foreach (ProductRatePlanHolder prph in productRatePlans)
{
RatePlanData ratePlanData = new RatePlanData();
RatePlan ratePlan = new RatePlan();
ratePlan.ProductRatePlanId = prph.ProductRatePlan.Id;
ratePlanData.RatePlan = ratePlan;
List<RatePlanChargeData> rpcData = new List<RatePlanChargeData>();
foreach(ProductRatePlanChargeHolder prpch in prph.ProductRatePlanCharges)
{
ProductRatePlanCharge prpc = prpch.ProductRatePlanCharge;
//set quantity and add chargeData if applicable
if ((prpc.ChargeModel.Equals("Per Unit Pricing") || prpc.ChargeModel.Equals("Tiered Pricing") || prpc.ChargeModel.Equals("Volume Pricing")))
{
RatePlanChargeData ratePlanChargeData = new RatePlanChargeData();
RatePlanCharge ratePlanCharge = new RatePlanCharge();
ratePlanCharge.ProductRatePlanChargeId = prpc.Id;
ratePlanCharge.QuantitySpecified = true;
ratePlanCharge.Quantity = prpc.DefaultQuantity;
ratePlanChargeData.RatePlanCharge = ratePlanCharge;
rpcData.Add(ratePlanChargeData);
}
}
if (rpcData.Count != 0)
{
ratePlanData.RatePlanChargeData = rpcData.ToArray();
}
rpdList.Add(ratePlanData);
}
subData.RatePlanData = rpdList.ToArray();
subscribeRequest.SubscriptionData = subData;
return zs.Subscribe(new List<SubscribeRequest>{subscribeRequest})[0];
}
private void HandlePresenceRequest(Packet packet)
{
PresencePacket IncomingPresencePacket = packet as PresencePacket;
if (IncomingPresencePacket is ProbeRequest)
{
//A Probe means we should send our presence to the probing entity
//Maybe we should get some user input here. Not really sure if theyd want to know, though.
SendCurrentPresence(IncomingPresencePacket.From);
}
else if (IncomingPresencePacket is SubscribeRequest)
{
string displayString =
String.Format("Allow User '{0}; to subscribe to your presence?",
IncomingPresencePacket.From.JabberIDNoResource);
if (
MessageBox.Show(displayString, "Subscription Request", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
SubscribedResponse resp = new SubscribedResponse(IncomingPresencePacket.From);
SessionManager.Send(resp);
SubscribeRequest subscribe =
new SubscribeRequest(new JabberID(IncomingPresencePacket.From.JabberIDNoResource));
SessionManager.Send(subscribe);
}
else
{
UnsubscribedResponse resp = new UnsubscribedResponse();
resp.To = IncomingPresencePacket.From;
SessionManager.Send(resp);
}
}
else if (IncomingPresencePacket is SubscribedResponse)
{
//Let the user know when someone accepts our subscription request
string displayString =
String.Format("User '{0}' has accepted your presence subscription request.",
IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Accept", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is UnsubscribedResponse)
{
//Let the user know when someone revoked our presence subscription
string displayString =
String.Format("User '{0}' rejected your reqeust.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Denied", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is AvailableRequest)
{
AvailableRequest availableReq = WConvert.ToAvailableRequest(IncomingPresencePacket);
LoginState state = LoginState.Offline;
if (availableReq.From.Server.Contains(".com"))
{
state = (LoginState) availableReq.Show;
}
else
{
state = (LoginState) Enum.Parse(typeof (LoginState), availableReq.Status);
}
string userName = availableReq.From.UserName;
Contact contact = Instance.Contacts[userName];
if (contact != null)
{
contact.UserStatus = state;
if (availableReq.HasVCardAvatarUpdateHash)
{
if (availableReq.HasJabberXAvatarHash)
{
contact.AvatatType = Contact.AvatarType.JabberXAvatar;
}
/*else - we prefere VCardAvatar*/
if (availableReq.HasVCardAvatarUpdateHash)
{
contact.AvatatType = Contact.AvatarType.VCardAvatar;
}
contact.AvatarHash = availableReq.VCardAvatarUpdateHash;
}
}
}
else if (IncomingPresencePacket is UnavailableRequest)
{
UnavailableRequest avail = WConvert.ToUnavailableRequest(IncomingPresencePacket);
string userName = avail.From.UserName;
Contact contact = Instance.Contacts[userName];
contact.UserStatus = LoginState.Offline;
}
}
public override void Subscribe(IRpcController controller, SubscribeRequest request, Action<NoData> done)
{
ProtoOutputBuffer.Write(request.GetType(), request.ToString());
}
public override void Subscribe(IRpcController controller, SubscribeRequest request, Action<SubscribeResponse> done)
{
throw new NotImplementedException();
}
private void btnOk_Click(object sender, EventArgs e)
{
Hide();
ArrayList editgroup = new ArrayList();
if (ValidateInput() == false)
{
DialogResult = DialogResult.None;
return;
}
foreach (Contact contact in AppController.Instance.Contacts)
{
if (contact.GroupName.Equals(cbOldgroup.SelectedItem.ToString(), StringComparison.OrdinalIgnoreCase))
{
editgroup.Add(contact.UserName);
}
}
for (int i = 0; i < editgroup.Count; i++)
{
Contact editGp = AppController.Instance.Contacts[editgroup[i].ToString()];
JabberID Jid =
new JabberID(editGp.UserName.ToString(), editGp.ServerName.ToString(), Settings.Default.Resource);
Contact delContact = new Contact(Jid, editGp.GroupName.ToString(), LoginState.Offline);
Contact editContact = new Contact(Jid, tbNewGroup.Text.Trim(), LoginState.Offline);
UnsubscribedResponse resp = new UnsubscribedResponse(Jid);
AppController.Instance.SessionManager.Send(resp);
AppController.Instance.SessionManager.BeginSend(new RosterRemove(Jid, editGp.UserName.ToString()));
AppController.Instance.Contacts.Remove(delContact);
SubscribeRequest p = new SubscribeRequest(Jid);
AppController.Instance.SessionManager.Send(p);
AppController.Instance.SessionManager.BeginSend(
new RosterAdd(Jid, editGp.UserName.ToString(), tbNewGroup.Text.ToString()));
AppController.Instance.Contacts.Add(editContact);
AppController.Instance.MainWindow.UpdateContactList();
}
}
