/// <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);
