/// <summary> /// Subscriptionses this instance. /// </summary> /// <returns></returns> public IActionResult Subscriptions() { SubscriptionViewModel subscriptionDetail = new SubscriptionViewModel(); if (User.Identity.IsAuthenticated) { this.TempData["ShowWelcomeScreen"] = "True"; List <SubscriptionResult> allSubscriptions = new List <SubscriptionResult>(); var allSubscriptionDetails = subscriptionRepo.Get().ToList(); var allPlans = planRepository.Get().ToList(); foreach (var subscription in allSubscriptionDetails) { SubscriptionResult subscritpionDetail = PrepareSubscriptionResponse(subscription, allPlans); if (subscritpionDetail != null && subscritpionDetail.SubscribeId > 0) { allSubscriptions.Add(subscritpionDetail); } } subscriptionDetail.Subscriptions = allSubscriptions; if (this.TempData["ErrorMsg"] != null) { subscriptionDetail.IsSuccess = false; subscriptionDetail.ErrorMessage = Convert.ToString(this.TempData["ErrorMsg"]); } } else { return(RedirectToAction(nameof(Index))); } return(this.View(subscriptionDetail)); }
public static string ProcessTemplate(SubscriptionResult Subscription, IEmailTemplateRepository emailTemplateRepository, IApplicationConfigRepository applicationConfigRepository) { string body = emailTemplateRepository.GetTemplateBody(Subscription.SaasSubscriptionStatus.ToString()); string applicationName = applicationConfigRepository.GetValuefromApplicationConfig("ApplicationName"); Hashtable hashTable = new Hashtable(); hashTable.Add("ApplicationName", applicationName); hashTable.Add("CustomerEmailAddress", Subscription.CustomerEmailAddress); hashTable.Add("CustomerName", Subscription.CustomerName); hashTable.Add("Id", Subscription.Id); hashTable.Add("SubscriptionName", Subscription.Name); hashTable.Add("SaasSubscriptionStatus", Subscription.SaasSubscriptionStatus); ExtendedProperties p = new ExtendedProperties(); VelocityEngine v = new VelocityEngine(); v.Init(p); VelocityContext context = new VelocityContext(hashTable); StringWriter writer = new StringWriter(); v.Evaluate(context, writer, string.Empty, body); return(writer.ToString()); }
public IActionResult ActivateSubscription(Guid subscriptionId, string planId) { this.logger.LogInformation("Home Controller / ActivateSubscription subscriptionId:{0} :: planId:{1}", subscriptionId, planId); SubscriptionResult subscriptionDetail = new SubscriptionResult(); if (User.Identity.IsAuthenticated) { var userId = this.userService.AddPartnerDetail(GetCurrentUserDetail()); var currentUserId = this.userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress); this.webSubscriptionService = new WebSubscriptionService(this.subscriptionRepo, this.planRepository, userId); //this.log.Info("User authenticate successfully"); this.logger.LogInformation("User authenticate successfully & GetSubscriptionByIdAsync SubscriptionID :{0}", JsonConvert.SerializeObject(subscriptionId)); this.TempData["ShowWelcomeScreen"] = false; var subscriptionData = this.fulfillApiClient.GetSubscriptionByIdAsync(subscriptionId).ConfigureAwait(false).GetAwaiter().GetResult(); //var subscribeId = this.webSubscriptionService.AddUpdatePartnerSubscriptions(subscriptionData); var oldValue = this.webSubscriptionService.GetSubscriptionsByScheduleId(subscriptionId); var serializedParent = JsonConvert.SerializeObject(subscriptionData); subscriptionDetail = JsonConvert.DeserializeObject <SubscriptionResult>(serializedParent); this.logger.LogInformation("serializedParent :{0}", serializedParent); //subscriptionDetail = (SubscriptionResultExtension)subscriptionData; subscriptionDetail.ShowWelcomeScreen = false; subscriptionDetail.SaasSubscriptionStatus = oldValue.SaasSubscriptionStatus; subscriptionDetail.CustomerEmailAddress = oldValue.CustomerEmailAddress; subscriptionDetail.CustomerName = oldValue.CustomerName; } return(this.View(subscriptionDetail)); }
/// <summary> /// Example for performing charge subscription request with Agreement. /// </summary> public void ChargeSubscriptionWithAgreement() { //Set up an agreement / setupSubscription / Reserving amount in order to charge it later PaymentResult createPaymentResult = ReserveAmount(Amount.Get(7777.00, Currency.EUR), AuthType.subscription, "IT_AGREEMENTS_UI_"); //Transaction ID is returned from the gateway when payment request was successful string transactionId = createPaymentResult.Payment.TransactionId; //WaitForDataToFlowIntoReporting Thread.Sleep(3000); //initialise charge subscription request class, this class is used for forwarding all the data needed for charging an agreement / charge subscription request var chargeSubscriptionRequest = new ChargeSubscriptionRequest() { AgreementId = transactionId, Amount = Amount.Get(7777, Currency.XXX), AgreementUnscheduledType = AgreementUnscheduledType.incremental, }; //call capture method SubscriptionResult subscriptionResult = _api.ChargeSubscription(chargeSubscriptionRequest); //Result property contains information if the request was successful or not if ((subscriptionResult.Result == Result.Success) && (createPaymentResult.Payment.TransactionId == subscriptionResult.Payment.TransactionId) && (subscriptionResult.Payment.TransactionStatus == "recurring_confirmed") && (subscriptionResult.RecurringPayment.TransactionStatus == "captured")) { //subscription charge was successful Transaction transaction = subscriptionResult.Payment; } else { //capture unsuccessful //error messages contain information about what went wrong string errorMerchantMessage = subscriptionResult.ResultMerchantMessage; string errorMessage = subscriptionResult.ResultMessage; } }
public async Task Ensure_That_Combined_Token_Is_Not_Disposed_On_Stream() { using var cts = new CancellationTokenSource(); IExecutionResult result = await new ServiceCollection() .AddGraphQL() .AddQueryType <TimeoutQuery>() .AddSubscriptionType <Subscriptions>() .ExecuteRequestAsync("subscription { onFoo }", cancellationToken: cts.Token); SubscriptionResult stream = Assert.IsType <SubscriptionResult>(result); IAsyncEnumerable <IQueryResult> enumerable = stream.ReadResultsAsync(); IAsyncEnumerator <IQueryResult> enumerator = enumerable.GetAsyncEnumerator( CancellationToken.None); // we should get the first result! await enumerator.MoveNextAsync(); enumerator.Current.ToJson().MatchSnapshot(); cts.Cancel(); Assert.False(await enumerator.MoveNextAsync(), "the stream should be canceled."); }
public static void SendEmail(SubscriptionResult Subscription, IApplicationConfigRepository applicationConfigRepository, IEmailTemplateRepository emailTemplateRepository) { MailMessage mail = new MailMessage(); string FromMail = applicationConfigRepository.GetValuefromApplicationConfig("SMTPFromEmail"); string password = applicationConfigRepository.GetValuefromApplicationConfig("SMTPPassword"); string username = applicationConfigRepository.GetValuefromApplicationConfig("SMTPUserName"); string Subject = emailTemplateRepository.GetSubject(Subscription.SaasSubscriptionStatus.ToString()); bool smtpSsl = bool.Parse(applicationConfigRepository.GetValuefromApplicationConfig("SMTPSslEnabled")); mail.From = new MailAddress(FromMail); mail.Subject = Subject; string body = TemplateService.ProcessTemplate(Subscription, emailTemplateRepository, applicationConfigRepository); mail.Body = body; mail.IsBodyHtml = true; if (!string.IsNullOrEmpty(emailTemplateRepository.GetToRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] ToEmails = (emailTemplateRepository.GetToRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in ToEmails) { mail.To.Add(new MailAddress(Multimailid)); } } if (!string.IsNullOrEmpty(emailTemplateRepository.GetCCRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] CcEmails = (emailTemplateRepository.GetCCRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in CcEmails) { mail.CC.Add(new MailAddress(Multimailid)); } } if (!string.IsNullOrEmpty(emailTemplateRepository.GetBccRecipients(Subscription.SaasSubscriptionStatus.ToString()))) { string[] BccEmails = (emailTemplateRepository.GetBccRecipients(Subscription.SaasSubscriptionStatus.ToString())).Split(';'); foreach (string Multimailid in BccEmails) { mail.Bcc.Add(new MailAddress(Multimailid)); } } SmtpClient smtp = new SmtpClient(); smtp.Host = applicationConfigRepository.GetValuefromApplicationConfig("SMTPHost"); smtp.Port = int.Parse(applicationConfigRepository.GetValuefromApplicationConfig("SMTPPort")); smtp.UseDefaultCredentials = false; smtp.Credentials = new NetworkCredential( username, password); smtp.EnableSsl = smtpSsl; smtp.Send(mail); }
/// <summary> /// Prepares the subscription response. /// </summary> /// <param name="subscription">The subscription.</param> /// <returns></returns> private SubscriptionResult PrepareSubscriptionResponse(Subscriptions subscription) { SubscriptionResult subscritpionDetail = new SubscriptionResult(); subscritpionDetail.Id = subscription.AmpsubscriptionId; subscritpionDetail.SubscribeId = subscription.Id; subscritpionDetail.PlanId = string.IsNullOrEmpty(subscription.AmpplanId) ? string.Empty : subscription.AmpplanId; subscritpionDetail.Name = subscription.Name; subscritpionDetail.SaasSubscriptionStatus = GetSubscriptionStatus(subscription.SubscriptionStatus); subscritpionDetail.IsActiveSubscription = subscription.IsActive ?? false; return(subscritpionDetail); }
public SubscriptionResult( SubscriptionResult subscriptionResult, IDisposable?session = null) { _resultStreamFactory = subscriptionResult._resultStreamFactory; _errors = subscriptionResult._errors; _extensions = subscriptionResult._extensions; _contextData = subscriptionResult._contextData; _session = session is null ? subscriptionResult : DisposableExtensions.Combine((IAsyncDisposable)subscriptionResult, session); }
/// <summary> /// Подписаться на инструмент. /// </summary> /// <param name="instrument"> /// Инструмент для подписки. /// </param> public async Task <SubscriptionResult> Subscribe(Instrument instrument) { var symbol = await adapter.ResolveSymbolAsync(instrument); if (symbol == null) { return(SubscriptionResult.Error(instrument, "Unable to resolve symbol")); } adapter.SendMessage(new QLInstrumentParamsSubscriptionRequest(symbol)); return(SubscriptionResult.OK(instrument)); }
public void ReserveSubscriptionChargeReturnsSuccess() { PaymentResult createPaymentResult = ReserveAmount(1.23, AuthType.subscription); this.WaitForDataToFlowIntoReporting(); var request = new ReserveSubscriptionChargeRequest { SubscriptionId = createPaymentResult.Payment.TransactionId, Amount = Amount.Get(1, Currency.XXX), }; SubscriptionResult result = _api.ReserveSubscriptionCharge(request); Assert.AreEqual(Result.Success, result.Result); }
/// <summary> /// Gets the subscriptions for subscription identifier. /// </summary> /// <param name="subscriptionId">The subscription identifier.</param> /// <param name="includeUnsubscribed">if set to <c>true</c> [include unsubscribed].</param> /// <returns></returns> public SubscriptionResult GetSubscriptionsByScheduleId(Guid subscriptionId, bool includeUnsubscribed = false) { var subscriptionDetail = SubscriptionRepository.GetSubscriptionsByScheduleId(subscriptionId, includeUnsubscribed); if (subscriptionDetail != null) { SubscriptionResult subscritpionDetail = PrepareSubscriptionResponse(subscriptionDetail); if (subscritpionDetail != null) { return(subscritpionDetail); } } return(new SubscriptionResult()); }
internal static MarketplaceSubscription From(SubscriptionResult subscription) { return(new MarketplaceSubscription { SubscriptionId = subscription.SubscriptionId, OfferId = subscription.OfferId, PlanId = subscription.PlanId, Quantity = subscription.Quantity, SubscriptionName = subscription.Name, PublisherId = subscription.PublisherId, BeneficiaryTenantId = subscription.Beneficiary.TenantId, PurchaserTenantId = subscription.Purchaser.TenantId, State = subscription.SaasSubscriptionStatus }); }
public JObject Subscribe(string email) { SubscriptionApi api = new SubscriptionApi(); SubscriptionResult result = api.Subscribe(email); if (result == SubscriptionResult.Success) { return(GetSubscriptionResult(true)); } else { _log.Information("Unable to subcribe '{0}' to a public list. Result: {1}", email, result); return(GetSubscriptionResult(false)); } }
public JObject Unsubscribe(string email, int recipientList) { SubscriptionApi api = new SubscriptionApi(); SubscriptionResult result = api.Unsubscribe(email, recipientList); if (result == SubscriptionResult.Success) { return(GetSubscriptionResult(true)); } else { _log.Information("Unable to unsubcribe '{0}' from list '{1}'. Result: {2}", email, recipientList, result); return(GetSubscriptionResult(false)); } }
/// <summary> /// Gets the subscriptions for partner. /// </summary> /// <param name="partnerEmailAddress">The partner email address.</param> /// <param name="subscriptionId">The subscription identifier.</param> /// <param name="includeUnsubscribed">if set to <c>true</c> [include unsubscribed].</param> /// <returns></returns> public List <SubscriptionResult> GetPartnerSubscription(string partnerEmailAddress, Guid subscriptionId, bool includeUnsubscribed = false) { List <SubscriptionResult> allSubscriptions = new List <SaasKitModels.SubscriptionResult>(); var allSubscriptionsForEmail = SubscriptionRepository.GetSubscriptionsByEmailAddress(partnerEmailAddress, subscriptionId, includeUnsubscribed).OrderByDescending(s => s.CreateDate).ToList(); foreach (var subscription in allSubscriptionsForEmail) { SubscriptionResult subscritpionDetail = PrepareSubscriptionResponse(subscription); if (subscritpionDetail != null && subscritpionDetail.SubscribeId > 0) { allSubscriptions.Add(subscritpionDetail); } } return(allSubscriptions); }
public void ReserveSubscriptionChargeReturnsBothPayments() { PaymentResult createPaymentResult = ReserveAmount(1.23, AuthType.subscription); this.WaitForDataToFlowIntoReporting(); var request = new ReserveSubscriptionChargeRequest { SubscriptionId = createPaymentResult.Payment.TransactionId, Amount = Amount.Get(1, Currency.XXX), }; SubscriptionResult result = _api.ReserveSubscriptionCharge(request); Assert.AreEqual(createPaymentResult.Payment.TransactionId, result.Payment.TransactionId); Assert.AreEqual("recurring_confirmed", result.Payment.TransactionStatus); Assert.AreEqual("preauth", result.RecurringPayment.TransactionStatus); }
/// <summary> /// Prepares the subscription response. /// </summary> /// <param name="subscription">The subscription.</param> /// <returns></returns> private SubscriptionResult PrepareSubscriptionResponse(Subscriptions subscription) { SubscriptionResult subscritpionDetail = new SubscriptionResult { Id = subscription.AmpsubscriptionId, SubscribeId = subscription.Id, PlanId = string.IsNullOrEmpty(subscription.AmpplanId) ? string.Empty : subscription.AmpplanId, Name = subscription.Name, SaasSubscriptionStatus = GetSubscriptionStatus(subscription.SubscriptionStatus), IsActiveSubscription = subscription.IsActive ?? false, CustomerEmailAddress = subscription.User?.EmailAddress, CustomerName = subscription.User?.FullName }; return(subscritpionDetail); }
/// <summary> /// Prepares the subscription response. /// </summary> /// <param name="subscription">The subscription.</param> /// <param name="allPlanDetails">All plan details.</param> /// <returns></returns> private SubscriptionResult PrepareSubscriptionResponse(Subscriptions subscription, List <Plans> allPlanDetails) { SubscriptionResult subscritpionDetail = new SubscriptionResult(); subscritpionDetail.Id = subscription.AmpsubscriptionId; subscritpionDetail.SubscribeId = subscription.Id; subscritpionDetail.PlanId = string.IsNullOrEmpty(subscription.AmpplanId) ? string.Empty : subscription.AmpplanId; 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 ReserveSubscriptionChargeWithAgreementReturnsSuccess() { PaymentResult createPaymentResult = ReserveAmount(7.77, AuthType.subscription, "IT_AGREEMENTS_UI_"); this.WaitForDataToFlowIntoReporting(); var request = new ReserveSubscriptionChargeRequest { AgreementId = createPaymentResult.Payment.TransactionId, Amount = Amount.Get(7.77, Currency.XXX), AgreementUnscheduledType = AgreementUnscheduledType.incremental, }; SubscriptionResult result = _api.ReserveSubscriptionCharge(request); Assert.AreEqual(Result.Success, result.Result); Assert.AreEqual(createPaymentResult.Payment.TransactionId, result.Payment.TransactionId); Assert.AreEqual("recurring_confirmed", result.Payment.TransactionStatus); Assert.AreEqual("preauth", result.RecurringPayment.TransactionStatus); }
public IEnumerable <SubscriptionResult> GetUserStalkSubscriptionsInChannel(IBotUser user, IIrcChannel channel) { var channelSubscribed = channel.Users.Where(x => x.Subscribed).Any(x => x.Mask.Equals(user.Mask)); var results = new List <SubscriptionResult>(); foreach (var stalk in channel.Stalks) { var result = new SubscriptionResult { Channel = channel, BotUser = user, Stalk = stalk.Value, Complete = true }; if (channelSubscribed) { result.IsSubscribed = true; result.Source = SubscriptionSource.Channel; } var subscription = stalk.Value.Subscribers.FirstOrDefault(x => x.Mask.Equals(user.Mask)); if (subscription == null) { // use the channel result. results.Add(result); continue; } if (subscription.Subscribed) { result.IsSubscribed = true; result.Source = SubscriptionSource.Stalk; } else { result.IsSubscribed = false; result.Overridden = true; result.Source = SubscriptionSource.Stalk; } results.Add(result); } return(results); }
/// <summary> /// Подписаться на инструмент. /// </summary> /// <param name="instrument"> /// Инструмент для подписки. /// </param> public async Task <SubscriptionResult> Subscribe(Instrument instrument) { using (LogManager.Scope()) { var data = await instrumentConverter.ResolveInstrumentAsync(this, instrument); if (data == null) { return(SubscriptionResult.Error(instrument, $"Unable to resolve symbol for {instrument}")); } // Забираем подписку из коллекции или создаем новую InstrumentSubscription subscription; bool isNewSubscription; using (instrumentSubscriptionsLock.Lock()) { if (instrumentSubscriptionsByInstrument.TryGetValue(instrument, out subscription)) { isNewSubscription = false; } else { subscription = new InstrumentSubscription(instrument, data, OnInstrumentSubscriptionTimedOut); instrumentSubscriptionsByInstrument.Add(instrument, subscription); instrumentSubscriptionsByCode[subscription.Code] = subscription; isNewSubscription = true; } } if (isNewSubscription) { // Если подписка уже существовала, то ничего не делаем // В противном случае требуется подписаться // Подписываемся socketL1.Subscribe(subscription.Code); subscription.BeginTimeout(); } return(await subscription.Task); } }
/// <summary> /// Adds/Update partner subscriptions. /// </summary> /// <param name="subscriptionDetail">The subscription detail.</param> /// <returns>Subscription Id.</returns> public int AddOrUpdatePartnerSubscriptions(SubscriptionResult subscriptionDetail) { var isActive = this.IsSubscriptionDeleted(Convert.ToString(subscriptionDetail.SaasSubscriptionStatus)); Subscriptions newSubscription = new Subscriptions() { Id = 0, AmpplanId = subscriptionDetail.PlanId, Ampquantity = subscriptionDetail.Quantity, AmpsubscriptionId = subscriptionDetail.Id, CreateBy = this.currentUserId, CreateDate = DateTime.Now, IsActive = isActive, ModifyDate = DateTime.Now, Name = subscriptionDetail.Name, SubscriptionStatus = Convert.ToString(subscriptionDetail.SaasSubscriptionStatus), UserId = this.currentUserId, PurchaserEmail = subscriptionDetail.Purchaser.EmailId, PurchaserTenantId = subscriptionDetail.Purchaser.TenantId, }; return(this.subscriptionRepository.Save(newSubscription)); }
public async Task <SubscriptionResult> Subscribe(Instrument instrument) { var code = await connector.ResolveInstrumentAsync(instrument); if (code == null) { return(SubscriptionResult.Error(instrument, "Unable to resolve instrument symbol")); } using (allInstrumentLock.WriteLock()) { if (allInstruments.Contains(code)) { if (!subscribedInstruments.Contains(code)) { subscribedInstruments.Add(code); InstrumentParams ip; if (instrumentsParams.TryGetValue(code, out ip)) { OnMessageReceived(ip); } else { ip = new InstrumentParams { Instrument = instrument }; instrumentsParams[code] = ip; } return(SubscriptionResult.OK(instrument)); } return(SubscriptionResult.Error(instrument, "Already subscribed.")); } } return(SubscriptionResult.Error(instrument, "Instrument doesn't exist.")); }
public async Task <IActionResult> ChangeSubscriptionQuantity(SubscriptionResult subscriptionDetail) { this.logger.LogInformation("Home Controller / ChangeSubscriptionPlan subscriptionDetail:{0}", JsonSerializer.Serialize(subscriptionDetail)); if (this.User.Identity.IsAuthenticated) { try { if (subscriptionDetail != null && subscriptionDetail.Id != default && subscriptionDetail.Quantity > 0) { try { var subscriptionId = subscriptionDetail.Id; var quantity = subscriptionDetail.Quantity; var currentUserId = this.userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress); var jsonResult = await this.fulfillApiClient.ChangeQuantityForSubscriptionAsync(subscriptionId, quantity).ConfigureAwait(false); var changeQuantityOperationStatus = OperationStatusEnum.InProgress; if (jsonResult != null && jsonResult.OperationId != default) { while (OperationStatusEnum.InProgress.Equals(changeQuantityOperationStatus) || OperationStatusEnum.NotStarted.Equals(changeQuantityOperationStatus)) { var changeQuantityOperationResult = await this.fulfillApiClient.GetOperationStatusResultAsync(subscriptionId, jsonResult.OperationId).ConfigureAwait(false); changeQuantityOperationStatus = changeQuantityOperationResult.Status; this.logger.LogInformation("changeQuantity Operation Status : " + changeQuantityOperationStatus + " For SubscriptionId " + subscriptionId + "Model SubscriptionID): {0} :: quantity:{1}", JsonSerializer.Serialize(subscriptionId), JsonSerializer.Serialize(quantity)); this.applicationLogService.AddApplicationLog("Operation Status : " + changeQuantityOperationStatus + " For SubscriptionId " + subscriptionId); } var oldValue = this.subscriptionService.GetSubscriptionsBySubscriptionId(subscriptionId, true); this.subscriptionService.UpdateSubscriptionQuantity(subscriptionId, quantity); this.logger.LogInformation("Quantity Successfully Changed."); this.applicationLogService.AddApplicationLog("Quantity Successfully Changed."); if (oldValue != null) { SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs() { Attribute = Convert.ToString(SubscriptionLogAttributes.Quantity), SubscriptionId = oldValue.SubscribeId, NewValue = quantity.ToString(), OldValue = oldValue.Quantity.ToString(), CreateBy = currentUserId, CreateDate = DateTime.Now, }; this.subscriptionLogRepository.Save(auditLog); } } } catch (FulfillmentException fex) { this.TempData["ErrorMsg"] = fex.Message; this.logger.LogError("Message:{0} :: {1} ", fex.Message, fex.InnerException); } } return(this.RedirectToAction(nameof(this.Subscriptions))); } catch (Exception ex) { this.logger.LogError("Message:{0} :: {1} ", ex.Message, ex.InnerException); return(this.View("Error", ex)); } } else { return(this.RedirectToAction(nameof(this.Index))); } }
public async Task RegisterSubscriptionTrigger(string subscriptionId, SubscriptionResult result, string reason, CancellationToken cancellationToken) { var command = new CommandDefinition(SqlSubscriptionQueries.RegisterTrigger, new { subscriptionId, Result = result.Id, reason }, cancellationToken: cancellationToken); await _connection.ExecuteAsync(command); }
public async Task <IActionResult> ChangeSubscriptionPlan(SubscriptionResult subscriptionDetail) { this.logger.LogInformation("Home Controller / ChangeSubscriptionPlan subscriptionDetail:{0}", JsonConvert.SerializeObject(subscriptionDetail)); try { var subscriptionId = new Guid(); var planId = string.Empty; if (Convert.ToBoolean(applicationConfigRepository.GetValuefromApplicationConfig(MainMenuStatusEnum.IsLicenseManagementEnabled.ToString())) == true) { this.TempData["ShowLicensesMenu"] = true; } if (subscriptionDetail != null) { subscriptionId = subscriptionDetail.Id; planId = subscriptionDetail.PlanId; } if (subscriptionId != default && !string.IsNullOrEmpty(planId)) { try { var currentUserId = this.userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress); var jsonResult = await this.fulfillApiClient.ChangePlanForSubscriptionAsync(subscriptionId, planId).ConfigureAwait(false); var changePlanOperationStatus = OperationStatusEnum.InProgress; if (jsonResult != null && jsonResult.OperationId != default) { while (OperationStatusEnum.InProgress.Equals(changePlanOperationStatus) || OperationStatusEnum.NotStarted.Equals(changePlanOperationStatus)) { var changePlanOperationResult = await this.fulfillApiClient.GetOperationStatusResultAsync(subscriptionId, jsonResult.OperationId).ConfigureAwait(false); changePlanOperationStatus = changePlanOperationResult.Status; this.logger.LogInformation("Operation Status : " + changePlanOperationStatus + " For SubscriptionId " + subscriptionId + "Model SubscriptionID): {0} :: planID:{1}", JsonConvert.SerializeObject(subscriptionId), JsonConvert.SerializeObject(planId)); this.applicationLogService.AddApplicationLog("Operation Status : " + changePlanOperationStatus + " For SubscriptionId " + subscriptionId); } var oldValue = this.subscriptionService.GetSubscriptionsForSubscriptionId(subscriptionId); this.subscriptionService.UpdateSubscriptionPlan(subscriptionId, planId); this.logger.LogInformation("Plan Successfully Changed."); this.applicationLogService.AddApplicationLog("Plan Successfully Changed."); if (oldValue != null) { SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs() { Attribute = Convert.ToString(SubscriptionLogAttributes.Plan), SubscriptionId = oldValue.SubscribeId, NewValue = planId, OldValue = oldValue.PlanId, CreateBy = currentUserId, CreateDate = DateTime.Now }; this.subscriptionLogRepository.Add(auditLog); } } } catch (FulfillmentException fex) { this.TempData["ErrorMsg"] = fex.Message; } } return(this.RedirectToAction(nameof(this.Subscriptions))); } catch (Exception ex) { this.logger.LogError("Message:{0} :: {1} ", ex.Message, ex.InnerException); return(View("Error")); } }
public IActionResult SubscriptionOperation(Guid subscriptionId, string planId, string operation, int NumberofProviders) { this.logger.LogInformation("Home Controller / SubscriptionOperation subscriptionId:{0} :: planId : {1} :: operation:{2} :: NumberofProviders : {3}", JsonConvert.SerializeObject(subscriptionId), JsonConvert.SerializeObject(planId), JsonConvert.SerializeObject(operation), JsonConvert.SerializeObject(NumberofProviders)); try { bool isSuccess = false; if (subscriptionId != default) { SubscriptionResult subscriptionDetail = new SubscriptionResult(); this.logger.LogInformation("GetPartnerSubscription"); var oldValue = this.webSubscriptionService.GetSubscriptionsByScheduleId(subscriptionId); this.logger.LogInformation("GetUserIdFromEmailAddress"); var currentUserId = userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress); if (operation == "Activate") { var response = this.fulfillApiClient.ActivateSubscriptionAsync(subscriptionId, planId).ConfigureAwait(false).GetAwaiter().GetResult(); this.webSubscriptionService.UpdateStateOfSubscription(subscriptionId, SubscriptionStatusEnum.Subscribed, true); isSuccess = true; this.logger.LogInformation("GetPartnerSubscription"); this.logger.LogInformation("GetAllSubscriptionPlans"); subscriptionDetail = this.webSubscriptionService.GetSubscriptionsByScheduleId(subscriptionId); subscriptionDetail.PlanList = this.webSubscriptionService.GetAllSubscriptionPlans(); var subscriptionData = this.fulfillApiClient.GetSubscriptionByIdAsync(subscriptionId).ConfigureAwait(false).GetAwaiter().GetResult(); bool checkIsActive = emailTemplateRepository.GetIsActive(subscriptionDetail.SaasSubscriptionStatus.ToString()).HasValue ? emailTemplateRepository.GetIsActive(subscriptionDetail.SaasSubscriptionStatus.ToString()).Value : false; this.logger.LogInformation("sendEmail"); if (Convert.ToBoolean(applicationConfigRepository.GetValuefromApplicationConfig(EmailTriggerConfigurationConstants.ISEMAILENABLEDFORSUBSCRIPTIONACTIVATION)) == true) { EmailHelper.SendEmail(subscriptionDetail, applicationConfigRepository, emailTemplateRepository); } } if (operation == "Deactivate") { try { this.logger.LogInformation("operation == Deactivate"); this.logger.LogInformation("DeleteSubscriptionAsync"); var response = this.fulfillApiClient.DeleteSubscriptionAsync(subscriptionId, planId).ConfigureAwait(false).GetAwaiter().GetResult(); this.logger.LogInformation("UpdateStateOfSubscription"); this.webSubscriptionService.UpdateStateOfSubscription(subscriptionId, SubscriptionStatusEnum.Unsubscribed, false); subscriptionDetail = this.webSubscriptionService.GetSubscriptionsByScheduleId(subscriptionId, true); subscriptionDetail.SaasSubscriptionStatus = SubscriptionStatusEnum.Unsubscribed; isSuccess = true; this.logger.LogInformation("GetIsActive"); bool checkIsActive = emailTemplateRepository.GetIsActive(subscriptionDetail.SaasSubscriptionStatus.ToString()).HasValue ? emailTemplateRepository.GetIsActive(subscriptionDetail.SaasSubscriptionStatus.ToString()).Value : false; if (Convert.ToBoolean(applicationConfigRepository.GetValuefromApplicationConfig(EmailTriggerConfigurationConstants.ISEMAILENABLEDFORUNSUBSCRIPTION)) == true) { this.logger.LogInformation("SendEmail to {0} :: Template{1} ", JsonConvert.SerializeObject(applicationConfigRepository), JsonConvert.SerializeObject(emailTemplateRepository)); EmailHelper.SendEmail(subscriptionDetail, applicationConfigRepository, emailTemplateRepository); } } catch (FulfillmentException fex) { this.logger.LogError($"Deactive Subscription plan Error - {fex.Message} with StackTrace- {fex.StackTrace}."); this.TempData["ErrorMsg"] = fex.Message; } } var newValue = this.webSubscriptionService.GetSubscriptionsByScheduleId(subscriptionId, true); if (isSuccess) { if (oldValue != null && newValue != null) { SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs() { Attribute = Convert.ToString(SubscriptionLogAttributes.Status), SubscriptionId = newValue.SubscribeId, NewValue = Convert.ToString(newValue.SaasSubscriptionStatus), OldValue = Convert.ToString(oldValue.SaasSubscriptionStatus), CreateBy = currentUserId, CreateDate = DateTime.Now }; this.subscriptionLogRepository.Add(auditLog); //auditLog = new SubscriptionAuditLogs() //{ // Attribute = Convert.ToString(SubscriptionLogAttributes.ProviderCount), // SubscriptionId = newValue.SubscribeId, // NewValue = Convert.ToString(newValue.NumberofProviders), // OldValue = Convert.ToString(oldValue.NumberofProviders), // CreateBy = currentUserId, // CreateDate = DateTime.Now //}; //this.subscriptionLogRepository.Add(auditLog); } } } return(this.RedirectToAction(nameof(this.ActivatedMessage))); } catch (Exception ex) { this.logger.LogInformation("Message:{0} :: {1}", ex.Message, ex.InnerException); return(View("Error")); } }
/// <summary> /// Get All Subscription List for Current Logged in User. /// </summary> /// <param name="token">The MS Token<see cref="string" />..</param> /// <returns> /// The <see cref="IActionResult" />. /// </returns> public async Task <IActionResult> Index(string token = null) { try { this.logger.LogInformation($"Landing page with token {token}"); SubscriptionResult subscriptionDetail = new SubscriptionResult(); SubscriptionResultExtension subscriptionExtension = new SubscriptionResultExtension(); this.applicationConfigService.SaveFileToDisk("LogoFile", "contoso-sales.png"); this.applicationConfigService.SaveFileToDisk("FaviconFile", "favicon.ico"); if (this.User.Identity.IsAuthenticated) { var userId = this.userService.AddUser(this.GetCurrentUserDetail()); var currentUserId = this.userService.GetUserIdFromEmailAddress(this.CurrentUserEmailAddress); this.subscriptionService = new SubscriptionService(this.subscriptionRepository, this.planRepository, userId); this.logger.LogInformation("User authenticated successfully"); if (!string.IsNullOrEmpty(token)) { this.TempData["ShowWelcomeScreen"] = null; token = token.Replace(' ', '+'); var newSubscription = await this.apiService.ResolveAsync(token).ConfigureAwait(false); if (newSubscription != null && newSubscription.SubscriptionId != default) { Offers offers = new Offers() { OfferId = newSubscription.OfferId, OfferName = newSubscription.OfferId, UserId = currentUserId, CreateDate = DateTime.Now, OfferGuid = Guid.NewGuid(), }; Guid newOfferId = this.offersRepository.Add(offers); var subscriptionPlanDetail = await this.apiService.GetAllPlansForSubscriptionAsync(newSubscription.SubscriptionId).ConfigureAwait(false); subscriptionPlanDetail.ForEach(x => { x.OfferId = newOfferId; x.PlanGUID = Guid.NewGuid(); }); this.subscriptionService.AddPlanDetailsForSubscription(subscriptionPlanDetail); var currentPlan = this.planRepository.GetById(newSubscription.PlanId); var subscriptionData = await this.apiService.GetSubscriptionByIdAsync(newSubscription.SubscriptionId).ConfigureAwait(false); var subscribeId = this.subscriptionService.AddOrUpdatePartnerSubscriptions(subscriptionData); if (subscribeId > 0 && subscriptionData.SaasSubscriptionStatus == SubscriptionStatusEnum.PendingFulfillmentStart) { SubscriptionAuditLogs auditLog = new SubscriptionAuditLogs() { Attribute = Convert.ToString(SubscriptionLogAttributes.Status), SubscriptionId = subscribeId, NewValue = SubscriptionStatusEnum.PendingFulfillmentStart.ToString(), OldValue = "None", CreateBy = currentUserId, CreateDate = DateTime.Now, }; this.subscriptionLogRepository.Save(auditLog); } subscriptionExtension = this.subscriptionService.GetSubscriptionsBySubscriptionId(newSubscription.SubscriptionId, true); subscriptionExtension.ShowWelcomeScreen = false; subscriptionExtension.CustomerEmailAddress = this.CurrentUserEmailAddress; subscriptionExtension.CustomerName = this.CurrentUserName; subscriptionExtension.SubscriptionParameters = this.subscriptionService.GetSubscriptionsParametersById(newSubscription.SubscriptionId, currentPlan.PlanGuid); subscriptionExtension.IsAutomaticProvisioningSupported = Convert.ToBoolean(this.applicationConfigRepository.GetValueByName("IsAutomaticProvisioningSupported")); } } else { this.TempData["ShowWelcomeScreen"] = "True"; subscriptionExtension.ShowWelcomeScreen = true; return(this.View(subscriptionExtension)); } } else { if (!string.IsNullOrEmpty(token)) { return(this.Challenge( new AuthenticationProperties { RedirectUri = "/?token=" + token, }, OpenIdConnectDefaults.AuthenticationScheme)); } else { this.TempData["ShowWelcomeScreen"] = "True"; subscriptionExtension.ShowWelcomeScreen = true; return(this.View(subscriptionExtension)); } } return(this.View(subscriptionExtension)); } catch (Exception ex) { this.logger.LogError("Message:{0} :: {1} ", ex.Message, ex.InnerException); return(this.View("Error", ex)); } }
private async Task <SubscriptionResult> SubscribeAsync(Instrument instrument, SubscriptionFlags flags) { using (LogManager.Scope()) { InstrumentSubscription subscription = null; ContractMetadata metadata = null; var hasSubscriptionLock = false; try { // Получаем параметры подписки на инструмент using (subscriptionsLock.Lock()) { subscriptionsByInstrument.TryGetValue(instrument, out subscription); } if (subscription == null) { // Получаем ID инструмента var contractId = await instrumentResolver.GetContractIdAsync(instrument); if (contractId == uint.MaxValue) { return(SubscriptionResult.Error(instrument, "Symbol is not resolved in tree node for CQG")); } using (subscriptionsLock.Lock()) { if (!subscriptionsByInstrument.TryGetValue(instrument, out subscription)) { if (!subscriptionsByContractId.TryGetValue(contractId, out subscription)) { subscription = new InstrumentSubscription(instrumentResolver, instrument, contractId); // Сразу захватываем блокировку subscription.AcquireFlagsLock(); hasSubscriptionLock = true; subscriptionsByContractId.Add(contractId, subscription); contractMetadatas.TryGetValue(contractId, out metadata); } subscriptionsByInstrument.Add(instrument, subscription); } } } else { // Захватываем блокировку subscription.AcquireFlagsLock(); hasSubscriptionLock = true; } // Подписываемся на инструмент с учетом флагов подписки if ((subscription.Flags & flags) != flags) { // Нужные флаги подписки не проставлены, требуется доподписаться MarketDataSubscription.Level?level = null; switch (subscription.Flags | flags) { case SubscriptionFlags.InstrumentParams: level = MarketDataSubscription.Level.TRADES_BBA_VOLUMES; break; case SubscriptionFlags.OrderBook: level = MarketDataSubscription.Level.TRADES_BBA_DOM; break; case SubscriptionFlags.InstrumentParams | SubscriptionFlags.OrderBook: level = MarketDataSubscription.Level.TRADES_BBA_DOM; break; } if (level != null) { subscription.Flags |= flags; RequestMarketDataSubscription(subscription, level.Value); } } // При необходимости обрабатываем метаданные и выбрасываем события if (metadata != null) { Process(subscription, metadata, (s, data) => s.Handle(data)); } // Готово var result = SubscriptionResult.OK(instrument); return(result); } catch (OperationCanceledException) { _Log.Warn().Print($"Unable to subscribe to {instrument} (operation has been cancelled)"); return(SubscriptionResult.Error(instrument, "Operation has been cancelled")); } catch (Exception e) { _Log.Error().Print(e, $"Unable to subscribe to {instrument}"); return(SubscriptionResult.Error(instrument, e.Message)); } finally { if (subscription != null && hasSubscriptionLock) { subscription.ReleaseFlagsLock(); } } } }
public async Task RegisterSubscriptionTrigger(string subscriptionId, SubscriptionResult subscriptionResult, string reason, CancellationToken cancellationToken) => await _unitOfWork.Execute(PgSqlSubscriptionRequests.StoreTrigger, new { Id = Guid.NewGuid(), subscriptionId, Status = subscriptionResult, reason }, cancellationToken);