public SubscriptionsResponse Post(Subscriptions request)
{
if (request.Subscription.Id > 0)
{
Bm2s.Data.Common.BLL.Article.Subscription item = Datas.Instance.DataStorage.Subscriptions[request.Subscription.Id];
item.ArticleId = request.Subscription.Article.Id;
item.Code = request.Subscription.Code;
item.Designation = request.Subscription.Designation;
item.EndingDate = request.Subscription.EndingDate;
item.PeriodId = request.Subscription.Period.Id;
item.StartingDate = request.Subscription.StartingDate;
}
else
{
Bm2s.Data.Common.BLL.Article.Subscription item = new Data.Common.BLL.Article.Subscription()
{
ArticleId = request.Subscription.Article.Id,
Code = request.Subscription.Code,
Designation = request.Subscription.Designation,
EndingDate = request.Subscription.EndingDate,
PeriodId = request.Subscription.Period.Id,
StartingDate = request.Subscription.StartingDate
};
Datas.Instance.DataStorage.Subscriptions.Add(item);
request.Subscription.Id = item.Id;
}
SubscriptionsResponse response = new SubscriptionsResponse();
response.Subscriptions.Add(request.Subscription);
return response;
}
public SubscriptionsResponse Delete(Subscriptions request)
{
Bm2s.Data.Common.BLL.Article.Subscription item = Datas.Instance.DataStorage.Subscriptions[request.Subscription.Id];
Datas.Instance.DataStorage.Subscriptions.Remove(item);
SubscriptionsResponse response = new SubscriptionsResponse();
response.Subscriptions.Add(request.Subscription);
return response;
}
public Model(
Subscriptions.SubscriptionService subscriptionService,
Media.MediaCacheService mediaCacheService,
CommuterApplication application)
{
_subscriptionService = subscriptionService;
_mediaCacheService = mediaCacheService;
_application = application;
}
public Server(int port)
{
Version = 1;
Methods = new Methods();
Subscriptions = new Subscriptions();
Publications = new Publications();
new PublicationMethods(this).AttachMethods();
var messageMethods = new MessageMethods(this).GetMethods();
var messageProcessor = new MessageProcessor(messageMethods);
_messageQueue = new ResultQueue<KeyValuePair<IWebSocketConnection, string>>(messageProcessor);
_connector = new Connector(this, "127.0.0.1", port);
}
public MyCommuteViewModel(
Subscriptions.SubscriptionService subscriptions,
Search.SearchService search,
Images.ImageCacheService imageCacheService,
CommuterApplication application,
Media.MediaCacheService mediaCacheService)
{
_subscriptions = subscriptions;
_search = search;
_imageCacheService = imageCacheService;
_application = application;
_mediaCacheService = mediaCacheService;
}
public SubscriptionsResponse Get(Subscriptions request)
{
SubscriptionsResponse response = new SubscriptionsResponse();
List<Bm2s.Data.Common.BLL.Article.Subscription> items = new List<Data.Common.BLL.Article.Subscription>();
if (!request.Ids.Any())
{
items.AddRange(Datas.Instance.DataStorage.Subscriptions.Where(item =>
(request.ArticleId == 0 || item.ArticleId == request.ArticleId) &&
(string.IsNullOrWhiteSpace(request.Code) || item.Code.ToLower().Contains(request.Code.ToLower())) &&
(string.IsNullOrWhiteSpace(request.Designation) || item.Code.ToLower().Contains(request.Designation.ToLower())) &&
(!request.Date.HasValue || (request.Date >= item.StartingDate && (!item.EndingDate.HasValue || request.Date < item.EndingDate.Value)))
));
}
else
{
items.AddRange(Datas.Instance.DataStorage.Subscriptions.Where(item => request.Ids.Contains(item.Id)));
}
var collection = (from item in items
select new Bm2s.Poco.Common.Article.Subscription()
{
Article = new ArticlesService().Get(new Articles() { Ids = new List<int>() { item.ArticleId } }).Articles.FirstOrDefault(),
Code = item.Code,
Designation = item.Designation,
EndingDate = item.EndingDate,
Id = item.Id,
Period = new PeriodsService().Get(new Periods() { Ids = new List<int>() { item.PeriodId } }).Periods.FirstOrDefault(),
StartingDate = item.StartingDate
}).AsQueryable().OrderBy(request.Order, !request.DescendingOrder);
response.ItemsCount = collection.Count();
if (request.PageSize > 0)
{
response.Subscriptions.AddRange(collection.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize));
}
else
{
response.Subscriptions.AddRange(collection);
}
try
{
response.PagesCount = collection.Count() / response.Subscriptions.Count + (collection.Count() % response.Subscriptions.Count > 0 ? 1 : 0);
}
catch
{
response.PagesCount = 1;
}
return response;
}
/// <summary>
/// Add Market Data Required - generic data typing support as long as Type implements BaseData.
/// </summary>
/// <param name="dataType">Set the type of the data we're subscribing to.</param>
/// <param name="tickType">Tick type for the subscription.</param>
/// <param name="symbol">Symbol of the asset we're like</param>
/// <param name="resolution">Resolution of Asset Required</param>
/// <param name="dataTimeZone">The time zone the subscription's data is time stamped in</param>
/// <param name="exchangeTimeZone">Specifies the time zone of the exchange for the security this subscription is for. This
/// is this output time zone, that is, the time zone that will be used on BaseData instances</param>
/// <param name="isCustomData">True if this is custom user supplied data, false for normal QC data</param>
/// <param name="fillDataForward">when there is no data pass the last tradebar forward</param>
/// <param name="extendedMarketHours">Request premarket data as well when true </param>
/// <param name="isInternalFeed">Set to true to prevent data from this subscription from being sent into the algorithm's OnData events</param>
/// <param name="isFilteredSubscription">True if this subscription should have filters applied to it (market hours/user filters from security), false otherwise</param>
/// <returns>The newly created <see cref="SubscriptionDataConfig"/></returns>
public SubscriptionDataConfig Add(Type dataType, TickType tickType, Symbol symbol, Resolution resolution, DateTimeZone dataTimeZone, DateTimeZone exchangeTimeZone, bool isCustomData, bool fillDataForward = true, bool extendedMarketHours = false, bool isInternalFeed = false, bool isFilteredSubscription = true)
{
if (dataTimeZone == null)
{
throw new ArgumentNullException(nameof(dataTimeZone), "DataTimeZone is a required parameter for new subscriptions. Set to the time zone the raw data is time stamped in.");
}
if (exchangeTimeZone == null)
{
throw new ArgumentNullException(nameof(exchangeTimeZone), "ExchangeTimeZone is a required parameter for new subscriptions. Set to the time zone the security exchange resides in.");
}
//Create:
var newConfig = new SubscriptionDataConfig(dataType, symbol, resolution, dataTimeZone, exchangeTimeZone, fillDataForward, extendedMarketHours, isInternalFeed, isCustomData, isFilteredSubscription: isFilteredSubscription, tickType: tickType);
//Add to subscription list: make sure we don't have this symbol:
if (_subscriptions.ContainsKey(newConfig))
{
Log.Trace("SubscriptionManager.Add(): subscription already added: " + newConfig);
return(newConfig);
}
_subscriptions.TryAdd(newConfig, 0);
// count data subscriptions by symbol, ignoring multiple data types
var uniqueCount = Subscriptions
.Where(x => !x.Symbol.IsCanonical())
.DistinctBy(x => x.Symbol.Value)
.Count();
if (uniqueCount > _algorithmSettings.DataSubscriptionLimit)
{
throw new Exception(
$"The maximum number of concurrent market data subscriptions was exceeded ({_algorithmSettings.DataSubscriptionLimit}). Please reduce the number of symbols requested or increase the limit using Settings.DataSubscriptionLimit.");
}
// add the time zone to our time keeper
_timeKeeper.AddTimeZone(exchangeTimeZone);
// if is custom data, sets HasCustomData to true
HasCustomData = HasCustomData || isCustomData;
return(newConfig);
}
public void UnSubscribeAll()
{
_connector.AddInfoLog(nameof(UnSubscribeAll));
var subscriptions = new List <Subscription>();
lock (_syncObject)
{
_keeped.Clear();
_keeped.AddRange(_subscriptions.Values);
subscriptions.AddRange(Subscriptions.Where(s => s.State.IsActive()));
}
foreach (var subscription in subscriptions)
{
UnSubscribe(subscription);
}
}
public static bool IsSubscriber(string userId, string broadcasterId)
{
bool isSubscriber = false;
try
{
string channelOauth = ConfigurationManager.AppSettings["channelOauth"];
string helixChannelSubscriptionToken = ConfigurationManager.AppSettings["helixChannelSubscriptionToken"];
Subscriptions subscriptions = new Subscriptions();
string url = "https://api.twitch.tv/helix/subscriptions?broadcaster_id=" + broadcasterId + "&user_id=" + userId;
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
if (webRequest != null)
{
webRequest.Method = "GET";
webRequest.Timeout = 12000;
webRequest.Headers.Add("Client-ID", channelOauth);
webRequest.ContentType = "application/json";
webRequest.Accept = "application/vnd.twitchtv.v5+json";
webRequest.Headers.Add("Authorization: " + helixChannelSubscriptionToken);
}
using (Stream s = webRequest.GetResponse().GetResponseStream())
{
using (System.IO.StreamReader sr = new System.IO.StreamReader(s))
{
var jsonResponse = sr.ReadToEnd();
subscriptions = JsonConvert.DeserializeObject <Subscriptions>(jsonResponse);
}
}
if (subscriptions.data.Count != 0)
{
isSubscriber = true;
}
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder(DateTime.Now.ToString("dd-MM-yyyy") + " : " + ex.Message);
Console.WriteLine(sb);
}
return(isSubscriber);
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public override void Dispose()
{
#if DEBUG
GC.SuppressFinalize(this);
#endif
foreach (var observeChangesAndEvictItemsFromCacheForDatabase in observeChangesAndEvictItemsFromCacheForDatabases)
{
observeChangesAndEvictItemsFromCacheForDatabase.Value.Dispose();
}
var tasks = new List <Task>();
foreach (var databaseChange in databaseChanges)
{
var remoteDatabaseChanges = databaseChange.Value as RemoteDatabaseChanges;
if (remoteDatabaseChanges != null)
{
tasks.Add(remoteDatabaseChanges.DisposeAsync());
}
else
{
using (databaseChange.Value as IDisposable) { }
}
}
foreach (var replicationInformer in replicationInformers)
{
replicationInformer.Value.Dispose();
}
// try to wait until all the async disposables are completed
Task.WaitAll(tasks.ToArray(), TimeSpan.FromSeconds(3));
// if this is still going, we continue with disposal, it is for graceful shutdown only, anyway
Subscriptions?.Dispose();
AsyncSubscriptions?.Dispose();
WasDisposed = true;
AfterDispose?.Invoke(this, EventArgs.Empty);
jsonRequestFactory?.Dispose();
}
public Subscribe(FixedHeader header, byte[] data)
: base(header)
{
if (header.RemainingLength > 0)
{
using (var stream = new MemoryStream(data))
{
if (Header.QualityOfService != QualityOfService.AtMostOnce)
{
MessageId = MessageId.FromStream(stream);
while (stream.Position < stream.Length)
{
Subscriptions.Add(new Subscription(MQString.FromStream(stream), (QualityOfService)stream.ReadByteOrFail()));
}
}
}
}
}
public virtual DynamicJsonValue ToJson()
{
return(new DynamicJsonValue(GetType())
{
[nameof(DatabaseRecord)] = DatabaseRecord.ToJson(),
[nameof(Documents)] = Documents.ToJson(),
[nameof(RevisionDocuments)] = RevisionDocuments.ToJson(),
[nameof(Tombstones)] = Tombstones.ToJson(),
[nameof(Conflicts)] = Conflicts.ToJson(),
[nameof(Identities)] = Identities.ToJson(),
[nameof(Indexes)] = Indexes.ToJson(),
[nameof(CompareExchange)] = CompareExchange.ToJson(),
[nameof(Subscriptions)] = Subscriptions.ToJson(),
[nameof(Counters)] = Counters.ToJson(),
[nameof(CompareExchangeTombstones)] = CompareExchangeTombstones.ToJson(),
[nameof(TimeSeries)] = TimeSeries.ToJson(),
[nameof(ReplicationHubCertificates)] = ReplicationHubCertificates.ToJson(),
});
}
public void SaveSubscriptions(string subscriptionsDataFile)
{
if (subscriptionsDataFile == null)
{
throw new ArgumentNullException("subscriptionsDataFile");
}
var subscriptionsXml = new Subscriptions
{
Subscription = Subscriptions.Values.Select(subscription =>
{
var subscriptionsSubscription = new SubscriptionsSubscription
{
CurrentStorageAccount = subscription.CurrentStorageAccount,
name = subscription.SubscriptionName,
ServiceEndpoint = subscription.ServiceEndpoint,
SQLAzureServiceEndpoint = subscription.SqlAzureServiceEndpoint,
SubscriptionId = subscription.SubscriptionId
};
if (subscription.Certificate != null)
{
// Make sure certificate is in store
General.AddCertificateToStore(subscription.Certificate);
// Save the thumbprint for the certificate
subscriptionsSubscription.Thumbprint = subscription.Certificate.Thumbprint;
}
return(subscriptionsSubscription);
}
).ToArray()
};
var parentDirectory = Directory.GetParent(subscriptionsDataFile);
if (!parentDirectory.Exists)
{
parentDirectory.Create();
}
General.SerializeXmlFile(subscriptionsXml, subscriptionsDataFile);
}
private bool IsValidUrl(Subscriptions sub)
{
HttpClient client = new HttpClient();
try {
var response = client.GetAsync(sub.Url).GetAwaiter().GetResult();
if ((int)response.StatusCode != 200)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception) {
return(false);
}
}
/// <summary>
/// Prepares the subscription response.
/// </summary>
/// <param name="subscription">The subscription.</param>
/// <param name="allPlanDetails">All plan details.</param>
/// <returns></returns>
private SubscriptionResultExtension PrepareSubscriptionResponse(Subscriptions subscription, List <Plans> allPlanDetails)
{
SubscriptionResultExtension subscritpionDetail = new SubscriptionResultExtension();
subscritpionDetail.Id = subscription.AmpsubscriptionId;
subscritpionDetail.SubscribeId = subscription.Id;
subscritpionDetail.PlanId = string.IsNullOrEmpty(subscription.AmpplanId) ? string.Empty : subscription.AmpplanId;
subscritpionDetail.Quantity = subscription.Ampquantity;
subscritpionDetail.Name = subscription.Name;
subscritpionDetail.SaasSubscriptionStatus = GetSubscriptionStatus(subscription.SubscriptionStatus);
subscritpionDetail.IsActiveSubscription = subscription.IsActive ?? false;
subscritpionDetail.CustomerName = subscription.User?.FullName;
subscritpionDetail.CustomerEmailAddress = subscription.User?.EmailAddress;
var existingPlanDetail = allPlanDetails.Where(s => s.PlanId == subscritpionDetail.PlanId).FirstOrDefault();
subscritpionDetail.IsMeteringSupported = existingPlanDetail != null ? (existingPlanDetail.IsmeteringSupported ?? false) : false;
return(subscritpionDetail);
}
public void GetSubscriptionsWithSearch(string overideSecretKey)
{
var subscription = CreateBasicSubscription(overideSecretKey);
var request = new SubscriptionSearchRequest {
customer_id = subscription.resource.data.customer.customer_id
};
SubscriptionItemsResponse response;
if (overideSecretKey != null)
{
response = new Subscriptions(overideSecretKey).Get(request);
}
else
{
response = new Subscriptions().Get(request);
}
Assert.IsTrue(response.IsSuccess);
Assert.AreEqual(1, response.resource.data.Count());
}
public void AddSubscriber(Type messageType, QueueName destination)
{
Condition.Requires(messageType, "messageType").IsNotNull();
Condition.Requires(destination, "destination").IsNotNull();
SubscriptionRegistration registration;
if (!Subscriptions.TryGet(messageType, out registration))
{
registration = new SubscriptionRegistration();
}
if (!registration.SubscriberQueueNames.Any(q => q == destination))
{
registration.SubscriberQueueNames.Add(destination.Name);
}
Subscriptions.Put(messageType, registration);
}
public IActionResult AddNewSubscription(Subscriptions subscription)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
subscription.UserID = Convert.ToInt64(User.Claims.Where(x => x.Type == "user_id").FirstOrDefault().Value);
ResultObject result = con.ResultObject.FromSql($"[phi].[usp_createNewSubscription] {subscription.subscriptionType},{subscription.subscriptionName},{subscription.UserID}").FirstOrDefault();
return(StatusCode(200, result));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private void AddSubscription(long APartnerKey, string APublicationCode, string AConsentCode)
{
TVerificationResultCollection VerificationResult;
List <string> Subscriptions;
List <string> PartnerTypes;
string DefaultEmailAddress;
string DefaultPhoneMobile;
string DefaultPhoneLandline;
PartnerEditTDS MainDS = TSimplePartnerEditWebConnector.GetPartnerDetails(APartnerKey,
out Subscriptions,
out PartnerTypes,
out DefaultEmailAddress,
out DefaultPhoneMobile,
out DefaultPhoneLandline);
if (!Subscriptions.Contains(APublicationCode))
{
Subscriptions.Add(APublicationCode);
}
string EmailChangeObject = "{\"PartnerKey\":\"" + APartnerKey + "\",\"Type\":\"email address\"," +
"\"Value\":\"" + DefaultEmailAddress + "\",\"ChannelCode\":\"PHONE\",\"Permissions\":\"" + AConsentCode + "\"," +
"\"ConsentDate\":\"" + DateTime.Today.ToString("yyyy-MM-dd") + "\"," +
"\"Valid\":true}";
bool SendMail = true;
bool result = TSimplePartnerEditWebConnector.SavePartner(MainDS,
Subscriptions,
PartnerTypes,
new List <string>()
{
EmailChangeObject
},
SendMail,
DefaultEmailAddress,
DefaultPhoneMobile,
DefaultPhoneLandline,
out VerificationResult);
Assert.IsTrue(result, "AddSubscription.SavePartner");
}
private void HandleEmpty()
{
Image image = new Image()
{
Path = "img/establishments/none/empty.jpg"
};
List <Image> images = new List <Image>();
images.Add(image);
if (Subscriptions.Count == 0)
{
Establishment establishment = new Establishment()
{
Name = "Je hebt nog geen abonnementen",
Images = images
};
Subscriptions.Add(establishment);
}
if (Promotions.Count == 0)
{
Promotion p = new Promotion()
{
Name = "Er zijn nog geen promoties toegevoegd",
Images = images
};
Promotions.Add(p);
}
if (Events.Count == 0)
{
Event e = new Event()
{
Name = "Er zijn nog geen events toegevoegd",
Images = images
};
Events.Add(e);
}
}
public ActionResult SubscriptionsAdd(BackEndSubscriptionsAdd backEndSubscriptionsAdd)
{
if (ModelState.IsValidOrRefresh())
{
Subscriptions subscriptions = new Subscriptions();
int? result = subscriptions.Add(backEndSubscriptionsAdd.Email,
backEndSubscriptionsAdd.Password,
backEndSubscriptionsAdd.FirstName,
backEndSubscriptionsAdd.LastName,
backEndSubscriptionsAdd.Birthdate.ToDateTime(),
backEndSubscriptionsAdd.PhoneNumber,
backEndSubscriptionsAdd.Address,
backEndSubscriptionsAdd.City,
backEndSubscriptionsAdd.PostCode,
backEndSubscriptionsAdd.CountryCode,
backEndSubscriptionsAdd.SubscriptionStatusId,
backEndSubscriptionsAdd.WantsNewsletter,
DateTime.Now,
Request.UserHostAddress,
DateTime.Now.Ticks.ToBase36() + Session.SessionID,
backEndSubscriptionsAdd.Notes);
switch (result)
{
case 0:
ModelState.Clear();
backEndSubscriptionsAdd = new BackEndSubscriptionsAdd();
ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings.ItemSuccessfullyAdded);
break;
case 2:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.EmailAlreadyExists);
break;
default:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError);
break;
}
}
return(View(backEndSubscriptionsAdd));
}
public async Task SupervisionStrategy_Decider_on_Producer_Upstream_should_work()
{
var topic = CreateTopic(1);
var group = CreateGroup(1);
var topicPartition = new TopicPartition(topic, 0);
var callCount = 0;
// create a custom Decider with a "Restart" directive in the event of DivideByZeroException
Directive Decider(Exception cause)
{
callCount++;
return(cause is DivideByZeroException
? Directive.Restart
: Directive.Stop);
}
var consumerSettings = CreateConsumerSettings <string>(group);
var numbers = Source.From(new [] { 9, 8, 7, 6, 0, 5, 4, 3, 2, 1 });
await numbers
// a DivideByZeroException will be thrown here, and since this happens upstream of the producer sink,
// the whole stream got restarted when the exception happened, and the offending message will be ignored.
// All the messages prior and after the exception are sent to the Kafka producer.
.Via(Flow.Create <int>().Select(x => $"1/{x} is {1/x} w/ integer division"))
.WithAttributes(ActorAttributes.CreateSupervisionStrategy(Decider))
.Select(elem => new ProducerRecord <Null, string>(topicPartition, elem))
.RunWith(KafkaProducer.PlainSink(ProducerSettings), Materializer);
var(_, probe) = KafkaConsumer
.PlainSource(consumerSettings, Subscriptions.Assignment(topicPartition))
.Select(c => c.Message.Value)
.ToMaterialized(this.SinkProbe <string>(), Keep.Both)
.Run(Materializer);
probe.Request(10);
for (var i = 0; i < 9; i++)
{
Log.Info(probe.ExpectNext(TimeSpan.FromSeconds(10)));
}
probe.Cancel();
callCount.Should().BeGreaterThan(0);
}
public void Subscribe(NatsSubscription natsSubscription)
{
if (Subscriptions.ContainsKey(natsSubscription))
{
return;
}
Logger.Info($"{nameof(Subscribe)}: {natsSubscription.Subject}");
List <IAsyncSubscription> subs = new List <IAsyncSubscription>();
foreach (var conn in ConnectionsByName.Values)
{
IAsyncSubscription sub = conn.SubscribeAsync(natsSubscription.Subject, OnMessage);
subs.Add(sub);
}
Subscriptions[natsSubscription] = subs;
natsSubscription.Subscribed = subs.Any();
Subscribed?.Invoke(natsSubscription);
}
/// <summary>
/// Configures a topic subscription.
/// </summary>
/// <typeparam name="T">The type of the message to subscribe to.</typeparam>
/// <param name="topicNameOverride">The name of the topic that this queue will be subscribed to. Overrides the default set by the <see cref="ITopicNamingConvention"/>.</param>
/// <param name="configure">A delegate to a method to use to configure a topic subscription.</param>
/// <returns>
/// The current <see cref="SubscriptionsBuilder"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="configure"/> is <see langword="null"/>.
/// </exception>
public SubscriptionsBuilder ForTopic <T>(string topicNameOverride, Action <TopicSubscriptionBuilder <T> > configure)
where T : Message
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
if (topicNameOverride == null)
{
throw new ArgumentNullException(nameof(topicNameOverride));
}
var builder = new TopicSubscriptionBuilder <T>().WithTopicName(topicNameOverride);
configure(builder);
Subscriptions.Add(builder);
return(this);
}
public ActionResult editSubscription(FormCollection fc)
{
int Id = int.Parse(fc["subID"].ToString());
int membershipID = int.Parse(fc["membership"]);
Subscriptions sb = new Subscriptions();
sb.Id = Id;
sb.MembershipID = membershipID;
bool flag = subs.UpdateSubscriptions(sb);
if (flag)
{
ViewBag.Message = "Membership Updated Successfully";
}
else
{
ViewBag.Message = "Something went wrong !!! ";
}
return(RedirectToAction("Subscriptions"));
}
/// <summary>
/// Adds/Update partner subscriptions.
/// </summary>
/// <param name="subscriptionDetail">The subscription detail.</param>
public int AddUpdatePartnerSubscriptions(SaasKitModels.SubscriptionResult subscriptionDetail)
{
var isActive = GetSubscriptionStateFromStatus(Convert.ToString(subscriptionDetail.SaasSubscriptionStatus));
Subscriptions newSubscription = new Subscriptions()
{
Id = 0,
AmpplanId = subscriptionDetail.PlanId,
Ampquantity = subscriptionDetail.Quantity,
AmpsubscriptionId = subscriptionDetail.Id,
CreateBy = CurrentUserId,
CreateDate = DateTime.Now,
IsActive = isActive,
ModifyDate = DateTime.Now,
Name = subscriptionDetail.Name,
SubscriptionStatus = Convert.ToString(subscriptionDetail.SaasSubscriptionStatus),
UserId = CurrentUserId,
};
return(SubscriptionRepository.Add(newSubscription));
}
private async Task ExecuteMessages(Subscriptions subscriptionsClient, int index, TriggeredFunctionData messages, IEnumerable <string> ackIds, IDisposable logScope, CancellationToken cancellationToken)
{
int bucketIndex = 0;
if (messages != null && ackIds != null && ackIds.Any())
{
logger.LogInformation($"Fetch {ackIds.Count()} items for bucket #{++bucketIndex}");
var functionResult = await executor.TryExecuteAsync(messages, cancellationToken);
if (functionResult.Succeeded)
{
await AcknowledgeAsync(subscriptionsClient, ackIds, cancellationToken);
}
else
{
logger.Log(Microsoft.Extensions.Logging.LogLevel.Error, new Microsoft.Extensions.Logging.EventId(index, "TryExecuteAsync"), logScope, functionResult.Exception, null);
}
}
}
public async Task SubscribeToChunk(ChunkKey key)
{
if (Subscriptions.ContainsKey(key))
{
return;
}
var channel = OutgoingChannel;//copy to local for closure;
var chunkHandlerSubscription = await BattleHandler.GetChunkHandlerAndSubscribeAsync(key, (chunkKey, update) => OnChunkUpdateAsync(key, update, channel));
if (Subscriptions.TryAdd(key, chunkHandlerSubscription))
{
await SendChunkStateAsync(key, chunkHandlerSubscription);
}
else
{
chunkHandlerSubscription.Dispose();
throw new InvalidOperationException("Duplicate subscription is detected.");
}
}
public static string SubscribeToTicket(RestCommand command, int ticketIDOrNumber, int userId)
{
TicketsViewItem ticket = TicketsView.GetTicketsViewItemByIdOrNumber(command.LoginUser, ticketIDOrNumber);
if (ticket == null || ticket.OrganizationID != command.Organization.OrganizationID)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
UsersViewItem subscribingUser = UsersView.GetUsersViewItem(command.LoginUser, userId);
if (subscribingUser == null || subscribingUser.OrganizationID != command.Organization.OrganizationID)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
Subscriptions.AddSubscription(command.LoginUser, userId, ReferenceType.Tickets, ticket.TicketID);
return(ticket.GetXml("Ticket", true));
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public override void Dispose()
{
#if DEBUG
GC.SuppressFinalize(this);
#endif
foreach (var observeChangesAndEvictItemsFromCacheForDatabase in observeChangesAndEvictItemsFromCacheForDatabases)
{
observeChangesAndEvictItemsFromCacheForDatabase.Value.Dispose();
}
var tasks = new List <Task>();
foreach (var databaseChange in databaseChanges)
{
var remoteDatabaseChanges = databaseChange.Value as RemoteDatabaseChanges;
//TODO iftah
/*if (remoteDatabaseChanges != null)
* {
* tasks.Add(remoteDatabaseChanges.DisposeAsync());
* }
* else
* {
* using (databaseChange.Value as IDisposable) { }
* }*/
}
// try to wait until all the async disposables are completed
Task.WaitAll(tasks.ToArray(), TimeSpan.FromSeconds(3));
// if this is still going, we continue with disposal, it is for graceful shutdown only, anyway
//return unused hilo keys
AsyncHelpers.RunSync(() => _asyncMultiDbHiLo?.ReturnUnusedRange());
Subscriptions?.Dispose();
AsyncSubscriptions?.Dispose();
WasDisposed = true;
AfterDispose?.Invoke(this, EventArgs.Empty);
}
public void Ask_Adds1Limit_With1Order_When1LimitExists_ButPriceGreaterThanExistingLimit()
{
// Arrange.
var sub = new Subscription {
Owned = 5, UserId = _userId1
};
Subscriptions.Add(sub.UserId, sub);
// Act.
Ask(_userId1, 2, 1);
// Assert.
var order = new Order
{
Id = 1,
Shares = 1,
Subscription = new Subscription
{
Owned = 5,
UserId = _userId1
}
};
var limit = new Limit
{
AskHead = order,
Price = 2 * ScaleFactor
};
order.ParentLimit = limit;
Assert.AreEqual(2, Limits.Count);
Assert.AreEqual(1, Orders.Count);
Assert.AreEqual(1, Subscriptions.Count);
CollectionAssert.AreEqual(new Limit[] { new Limit {
Price = 1 * ScaleFactor
}, limit }, Limits, _limitTestComparer);
CollectionAssert.AreEqual(new Order[] { order }, (ICollection)Orders.Values, _orderTestComparer);
CollectionAssert.AreEqual(new Subscription[] { order.Subscription }, (ICollection)Subscriptions.Values, _subscriptionTestComparer);
}
public Response Create(NewSubscriptions subscription)
{
Response response = new Response();
try
{
using (IDbConnection conn = GetConnection())
{
var exists = conn.GetList <Subscriptions>("Where CustomerId = ?CustomerId and ProductId = ?ProductId", subscription).ToList();
if (exists.Count > 0)
{
response.Status = false;
response.Description = "Record exists";
return(response);
}
var customers = conn.Get <Customers>(subscription.CustomerId);
var products = conn.Get <Products>(subscription.ProductId);
var frequencies = conn.Get <Frequencies>(subscription.FrequencyId);
Subscriptions sub = new Subscriptions()
{
CustomerId = subscription.CustomerId,
CustomerName = customers.FullName,
ProductId = subscription.ProductId,
ProductName = products.ProductName,
Quantity = subscription.Quantity,
Status = true,
FrequencyId = subscription.FrequencyId,
Frequency = frequencies.Frequency
};
conn.Insert(sub);
response.Status = true;
response.Description = "Record saved";
}
}
catch (Exception ex)
{
response.Description = ex.Message;
response.Status = false;
}
return(response);
}
public IObservable <IEnumerable <string> > Listen()
{
CreateStoresIfNotExistsAsync().Wait();
var stream = Observable.Create <IEnumerable <string> >(obs =>
{
var factory = new SampleObserverFactory(obs);
var processor = new ChangeFeedProcessorBuilder()
.WithFeedCollection(new DocumentCollectionInfo {
Uri = CosmosUri, MasterKey = CosmosKey, DatabaseName = DatabaseName, CollectionName = MonitoredCollection
})
.WithLeaseCollection(new DocumentCollectionInfo {
Uri = CosmosUri, MasterKey = CosmosKey, DatabaseName = DatabaseName, CollectionName = LeaseCollection
})
.WithHostName("SampleHost")
.WithObserverFactory(factory)
/* the explicit checkpoint is important because otherwise when the stream blows, it still checkpoints, and we 'lose' the message */
.WithProcessorOptions(new ChangeFeedProcessorOptions {
MaxItemCount = 2, CheckpointFrequency = new CheckpointFrequency {
ExplicitCheckpoint = true
}
})
.BuildAsync().Result;
processor.StartAsync().Wait();
var sub = Tuple.Create(obs, processor);
Subscriptions.Add(sub);
return(Disposable.Create(() =>
{
// the ConfigureAwait(false) is *critical* to ensure the processor stops!
processor.StopAsync().ConfigureAwait(false).AsTask().Wait();
Subscriptions.Remove(sub);
Log.Warning("Disposable run for subscription");
}));
});
Log.Information("Subscription created");
return(stream);
}
public SubscriptionResponse Update(Subscriptions subscription)
{
SubscriptionResponse response = new SubscriptionResponse();
try
{
using (IDbConnection conn = GetConnection())
{
var customers = conn.Get <Customers>(subscription.CustomerId);
var products = conn.Get <Products>(subscription.ProductId);
var frequencies = conn.Get <Frequencies>(subscription.FrequencyId);
int MerchantId = subscription.MerchantId == 0 ? 1 : subscription.MerchantId;
var merchants = conn.Get <Merchants>(MerchantId);
Subscriptions sub = new Subscriptions()
{
CustomerId = subscription.CustomerId,
CustomerName = customers.FullName,
ProductId = subscription.ProductId,
ProductName = products.ProductName,
Quantity = subscription.Quantity,
Status = true,
FrequencyId = subscription.FrequencyId,
Frequency = frequencies.Frequency,
SubscriptionId = subscription.SubscriptionId,
MerchantId = MerchantId,
MerchantName = merchants.MerchantName
};
conn.Update(sub);
response.Status = true;
response.Description = "Record updated";
response.Subscription = sub;
}
}
catch (Exception ex)
{
response.Description = ex.Message;
response.Status = false;
}
return(response);
}
public ActionResult Index(FrontEndCmsPage page, FrontEndSubscriptionProfile frontEndSubscriptionProfile)
{
if (ModelState.IsValidOrRefresh())
{
Subscriptions subscriptions = new Subscriptions();
int? result = subscriptions.EditProfile(FrontEndSessions.CurrentSubscription.Email,
frontEndSubscriptionProfile.FirstName,
frontEndSubscriptionProfile.LastName,
frontEndSubscriptionProfile.Birthdate.ToDateTime(),
frontEndSubscriptionProfile.PhoneNumber,
frontEndSubscriptionProfile.Address,
frontEndSubscriptionProfile.City,
frontEndSubscriptionProfile.PostCode,
frontEndSubscriptionProfile.CountryCode,
frontEndSubscriptionProfile.WantsNewsletter);
switch (result)
{
case 0:
FrontEndSessions.CurrentSubscription = subscriptions.GetSubscriptionByEmail(FrontEndSessions.CurrentSubscription.Email);
ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings_Subscription.ProfileEditSuccess);
ViewData.IsFormVisible(false);
break;
case 2:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.ItemDoesNotExist);
ViewData.IsFormVisible(false);
break;
case 3:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.EmailAlreadyExists);
break;
default:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError);
break;
}
}
return(View(frontEndSubscriptionProfile));
}
private void button_SaveAdd_Click(object sender, EventArgs e)
{
if (!CheckFields())
{
return;
}
try
{
using (var db = new SportEntities(SportProgramSettings.ConnectionString))
{
DateTime startDate = new DateTime(Years[box_StartDateYear.SelectedIndex], box_StartDateMonth.SelectedIndex, int.Parse(box_StartDateDay.Text));
DateTime formDate = new DateTime(Years[box_StartDateYear.SelectedIndex], box_StartDateMonth.SelectedIndex, int.Parse(box_StartDateDay.Text));
List <Subscriptions> subs = new List <Subscriptions>();
for (int i = 0; i < SportProgramSettings.Subscribe_DurationList[box_Duration.SelectedIndex]; i++)
{
Subscriptions sub = new Subscriptions
{
StudentId = CurrentStudentId,
GroupId = CurrentGroupId,
BuyTime = DateTime.Now,
IsUnlimited = radioButton_TypeUnlim.Checked,
SubHoursMax = (int?)numeric_Hours.Value,
SubHoursLeft = (int)numeric_Hours.Value,
DateStart = startDate.AddDays(0),
DateEnd = formDate.AddMonths(i + 1).AddDays(-1)
};
subs.Add(sub);
startDate = sub.DateEnd.AddDays(1);
}
db.Subscriptions.AddRange(subs);
db.SaveChanges();
IsNewAdded = true;
this.Close();
}
}
catch (Exception ex)
{
MessageBox.Show("Произошла ошибка при сохранении данных. Exception: " + ex);
}
}
public void SaveSubscriptions(string subscriptionsDataFile)
{
if (subscriptionsDataFile == null)
{
throw new ArgumentNullException("subscriptionsDataFile");
}
var subscriptionsXml = new Subscriptions
{
Subscription = Subscriptions.Values.Select(subscription =>
{
var subscriptionsSubscription = new SubscriptionsSubscription
{
CurrentStorageAccount = subscription.CurrentStorageAccount,
name = subscription.SubscriptionName,
ServiceEndpoint = subscription.ServiceEndpoint,
SQLAzureServiceEndpoint = subscription.SqlAzureServiceEndpoint,
SubscriptionId = subscription.SubscriptionId
};
if (subscription.Certificate != null)
{
// Make sure certificate is in store
General.AddCertificateToStore(subscription.Certificate);
// Save the thumbprint for the certificate
subscriptionsSubscription.Thumbprint = subscription.Certificate.Thumbprint;
}
return subscriptionsSubscription;
}
).ToArray()
};
var parentDirectory = Directory.GetParent(subscriptionsDataFile);
if (!parentDirectory.Exists)
{
parentDirectory.Create();
}
General.SerializeXmlFile(subscriptionsXml, subscriptionsDataFile);
}
