private static void StartSubscriptionService()
{
Console.Out.WriteLine("starting the subscription service");
var subscriptionSagaRepository = new InMemorySagaRepository<SubscriptionSaga>();
var clientSagaRepository = new InMemorySagaRepository<SubscriptionClientSaga>();
using (var serviceBus =
ServiceBusFactory.New(sbc =>
{
sbc.UseStomp();
sbc.UseControlBus();
sbc.ReceiveFrom("{0}/queue/matt_subscriptions".FormatWith(Constants.HostUri));
sbc.SetConcurrentConsumerLimit(1);
}))
{
using (var subscriptionService = new SubscriptionService(serviceBus, subscriptionSagaRepository,
clientSagaRepository))
{
subscriptionService.Start();
Console.WriteLine("ready... type 'exit' to stop");
while (Console.ReadLine() != "exit")
{
Console.WriteLine("type 'exit' to stop");
}
}
}
}
public void SubscriptionServiceSubscribeWithArgsExpectedAddsSubscription()
{
var publisher = CreatePublisher();
var service = new SubscriptionService<object>(publisher.Object);
Assert.AreEqual(0, service.Count);
service.Subscribe(null, memo => { });
service.Subscribe(o => o != null, memo => { });
Assert.AreEqual(2, service.Count);
}
public void SubscriptionServiceDisposeExpectedDisposesSubscriptions()
{
var publisher = CreatePublisher();
var service = new SubscriptionService<object>(publisher.Object);
service.Subscribe(null, obj => { });
Assert.AreEqual(1, service.Count);
service.Dispose();
Assert.AreEqual(0, service.Count);
}
public override Task <IList <string> > GetRolesAsync(Guid userId)
{
var orgUser = this.FindById(userId) as OrgUser;
if (orgUser != null && orgUser.AccountType == AccountType.MobileAccount)
{
var subscriptionService = new SubscriptionService(new UnitOfWork(new SurveyContext()));
if (!subscriptionService.HasValidSubscription(userId))
{
return(Task.FromResult <IList <string> >(new List <string>(new string[] { Role.RESTRICTED_USER })));
}
}
return(base.GetRolesAsync(userId));
}
public OpenpayAPI( string api_key, string merchant_id,bool production = false)
{
this.httpClient = new OpenpayHttpClient(api_key, merchant_id, production);
CustomerService = new CustomerService(this.httpClient);
CardService = new CardService(this.httpClient);
BankAccountService = new BankAccountService(this.httpClient);
ChargeService = new ChargeService(this.httpClient);
PayoutService = new PayoutService(this.httpClient);
TransferService = new TransferService(this.httpClient);
FeeService = new FeeService(this.httpClient);
PlanService = new PlanService(this.httpClient);
SubscriptionService = new SubscriptionService(this.httpClient);
OpenpayFeesService = new OpenpayFeesService(this.httpClient);
WebhooksService = new WebhookService (this.httpClient);
}
//public Subscription CreateSubscription([FromBody] CreateSubscriptionRequest req)
public Subscription CreateSubscription(Customer customer, string price)
{
//// Attach payment method
//var options = new PaymentMethodAttachOptions
//{
// Customer = req.Customer,
//};
//var service = new PaymentMethodService();
//var paymentMethod = service.Attach(req.PaymentMethod, options);
//// Update customer's default invoice payment method
//var customerOptions = new CustomerUpdateOptions
//{
// InvoiceSettings = new CustomerInvoiceSettingsOptions
// {
// DefaultPaymentMethod = paymentMethod.Id,
// },
//};
//var customerService = new CustomerService();
//customerService.Update(req.Customer, customerOptions);
// Create subscription
var subscriptionOptions = new SubscriptionCreateOptions
{
Customer = customer.Id,
Items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Price = Environment.GetEnvironmentVariable(price),
},
},
};
subscriptionOptions.AddExpand("latest_invoice.payment_intent");
var subscriptionService = new SubscriptionService();
try
{
Subscription subscription = subscriptionService.Create(subscriptionOptions);
return(subscription);
}
catch (StripeException e)
{
Console.WriteLine($"Failed to create subscription.{e}");
return(null);
}
}
public IHttpActionResult Subscription()
{
var userManager = System.Web.HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>();
var user = userManager.FindById(User.Identity.GetUserId());
var service = new SubscriptionService();
var subscriptions = service.List(new SubscriptionListOptions
{
Customer = user.StripeCustomerId
});
if (subscriptions.Count() > 1)
{
return(InternalServerError());
}
var subscription = subscriptions.FirstOrDefault();
if (subscription == null)
{
return(NotFound());
}
var items = subscription.Items;
if (items.Count() != 1)
{
return(InternalServerError());
}
var priceId = items.First().Price.Id;
var planName = "";
if (priceId == Config.StripeBasicPlanPriceId)
{
planName = "Basic";
}
else if (priceId == Config.StripePremiumPlanPriceId)
{
planName = "Premium";
}
return(Ok(new {
status = subscription.Status,
priceId = priceId,
planName = planName
}));
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
var unitOfWork = ServiceContext.UnitOfWork;
var currentUser = ServiceContext.CurrentUser;
if (currentUser is OrgUser && ((OrgUser)currentUser).AccountType == AccountType.MobileAccount)
{
var subscriptionService = new SubscriptionService(unitOfWork);
var expiryDate = subscriptionService.GetLatest(currentUser.Id);
var fixedQuota = GetFixedMonthlyQuota();
var lastMonth = DateTimeService.UtcNow.AddMonths(-1);
var lastMonthRecords = unitOfWork.FilledFormsRepository.AllAsNoTracking
.Count(x => x.FilledById == currentUser.Id && x.DateCreated >= lastMonth);
if (expiryDate == null)
{
// unsubscribed user. check fixed quota and if exceeded, return unauthorized.
if (lastMonthRecords >= fixedQuota)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Unauthorized));
}
}
else
{
var subscription = subscriptionService.GetLastSubscription(currentUser.Id);
if (subscription.Type == UserSubscriptionType.Paid && subscription.SubscriptionPlan.IsLimited)
{
var quota = subscription.SubscriptionPlan.MonthlyQuota.Value;
if (lastMonthRecords >= quota)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Unauthorized));
}
}
if (subscription.Type == UserSubscriptionType.Voucher)
{
// check fixed quota.
if (lastMonthRecords >= fixedQuota)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Unauthorized));
}
}
}
}
base.OnActionExecuting(actionContext);
}
public async Task <Subscription> Subscribe(string customerId, string productId)
{
var service = new SubscriptionService();
var prices = await GetPrices(productId);
var item = await service.CreateAsync(new SubscriptionCreateOptions
{
Customer = customerId,
Items = prices.Where(x => x.Type == "recurring").Select(x => new SubscriptionItemOptions
{
Price = x.Id
}).ToList(),
});
return(item);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
ILogger log, ExecutionContext context)
{
var config = new ConfigurationBuilder().SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var authenticationService = new AuthenticationService(config["tenantId"], config["clientId"], config["clientSecret"]);
var subscriptionService = new SubscriptionService(authenticationService, config["graphEndpoint"], config["notificationEndpoint"]);
var subscription = await subscriptionService.CreateAsync("created", config["resource"], DateTime.Now.AddMinutes(4230));
return(new OkObjectResult(subscription));
}
public void CancelSubscription(StripeChargeRequest req)
{
var info = GetByBusinessId(req.BusinessId);
var service = new SubscriptionService();
Subscription subscription = service.Cancel(info.StripeSubscriptionId, null);
dataProvider.ExecuteNonQuery(
"Subscriptions_Cancel",
(parameters) =>
{
parameters.AddWithValue("@BusinessId", req.BusinessId);
}
);
}
public static string Unsubscribe(string subscriptionId)
{
StripeConfiguration.ApiKey = key;
try
{
new SubscriptionService().Cancel(subscriptionId);
}
catch (Exception)
{
return("Already Unsubscribed");
}
var subscription = new SubscriptionService().Get(subscriptionId);
return(subscription.Status);
}
public ActionResult pauseSubscription()
{
StripeConfiguration.ApiKey = "sk_test_51GxEfiHhYK7K9XttqUpv12yjajZLs01TY95VhvzVfPEb5Ed8GaF3GFUV2iuhFZGkBgHoNib4iHBDlpALqWPplth6008EdMnnaw";
var options = new SubscriptionUpdateOptions
{
PauseCollection = new SubscriptionPauseCollectionOptions
{
Behavior = "void",
},
};
var service = new SubscriptionService();
service.Update("sub_HXNOGgEcJT2vvM", options);
return(Redirect("/Home/Billing"));
}
public async void Get_null_record()
{
var mock = new ServiceMockFacade <ISubscriptionRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult <Subscription>(null));
var service = new SubscriptionService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SubscriptionModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLSubscriptionMapperMock,
mock.DALMapperMockFactory.DALSubscriptionMapperMock);
ApiSubscriptionResponseModel response = await service.Get(default(string));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <string>()));
}
/// <summary>
/// Initializes a new instance of the <see cref="HomeController" /> class.
/// </summary>
/// <param name="apiClient">The API Client<see cref="IFulfilmentApiClient" /></param>
/// <param name="subscriptionRepo">The subscription repository.</param>
/// <param name="planRepository">The plan repository.</param>
/// <param name="userRepository">The user repository.</param>
/// <param name="applicationLogRepository">The application log repository.</param>
/// <param name="subscriptionLogsRepo">The subscription logs repository.</param>
public HomeController(ILogger <HomeController> logger, IFulfillmentApiClient apiClient, ISubscriptionsRepository subscriptionRepo, IPlansRepository planRepository, IUsersRepository userRepository, IApplicationLogRepository applicationLogRepository, ISubscriptionLogRepository subscriptionLogsRepo, IApplicationConfigRepository applicationConfigRepository, IEmailTemplateRepository emailTemplateRepository)
{
this.apiClient = apiClient;
this.subscriptionRepository = subscriptionRepo;
this.subscriptionLogRepository = subscriptionLogsRepo;
this.applicationLogRepository = applicationLogRepository;
this.planRepository = planRepository;
this.userRepository = userRepository;
this.userService = new UserService(this.userRepository);
this.subscriptionService = new SubscriptionService(this.subscriptionRepository, this.planRepository);
this.applicationLogService = new ApplicationLogService(this.applicationLogRepository);
this.applicationConfigRepository = applicationConfigRepository;
this.emailTemplateRepository = emailTemplateRepository;
this.logger = logger;
}
static void removeSubscription()
{
// se elimina correctamente pero el json de respuesta no devuelve vacio
Paymill.ApiKey = Properties.Settings.Default.ApiKey;
Paymill.ApiUrl = Properties.Settings.Default.ApiUrl;
SubscriptionService susbscriptionService = Paymill.GetService <SubscriptionService>();
Console.WriteLine("Removing subscription...");
string subscriptionID = "sub_569df922b4506cd73030";
bool reply = susbscriptionService.RemoveSubscription(subscriptionID);
Console.WriteLine("Result remove:" + reply);
Console.Read();
}
static void updateSubscription()
{
Paymill.ApiKey = Properties.Settings.Default.ApiKey;
Paymill.ApiUrl = Properties.Settings.Default.ApiUrl;
SubscriptionService susbscriptionService = Paymill.GetService <SubscriptionService>();
Subscription subscription = new Subscription();
subscription.Cancel_At_Period_End = true;
subscription.Id = "sub_569df922b4506cd73030";
Subscription updatedSubscription = susbscriptionService.UpdateSubscription(subscription);
Console.WriteLine("SubscriptionID:" + updatedSubscription.Id);
Console.Read();
}
// subscriptions
static void getSubscriptions()
{
Paymill.ApiKey = Properties.Settings.Default.ApiKey;
Paymill.ApiUrl = Properties.Settings.Default.ApiUrl;
SubscriptionService susbscriptionService = Paymill.GetService <SubscriptionService>();
Console.WriteLine("Waiting request list subscriptions...");
List <Subscription> lstSubscriptions = susbscriptionService.GetSubscriptions();
foreach (Subscription s in lstSubscriptions)
{
Console.WriteLine(String.Format("SubscriptionID:{0}", s.Id));
}
Console.Read();
}
public void UpdateSubscriptionPlan_RequiredParameters()
{
var internalServiceCallVo = InternalServiceCallVo.ConcreteBuilder
.SetToken("0469eba2ddf84cb49eff254fe353638d")
.Build();
var output = new ResultSrv <SubscriptionPlanSrv>();
var updateSubscriptionPlanVo = UpdateSubscriptionPlanVo.ConcreteBuilder
.SetServiceCallParameters(internalServiceCallVo)
.SetId(85)
.Build();
SubscriptionService.UpdateSubscriptionPlan(updateSubscriptionPlanVo,
response => Listener.GetResult(response, out output));
Assert.False(output.HasError);
}
public async void Get_ShouldReturnNullBecauseRecordNotFound()
{
var mock = new ServiceMockFacade <ISubscriptionService, ISubscriptionRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <Subscription>(null));
var service = new SubscriptionService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SubscriptionModelValidatorMock.Object,
mock.DALMapperMockFactory.DALSubscriptionMapperMock);
ApiSubscriptionServerResponseModel response = await service.Get(default(int));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
}
public async Task TestSubscriptiondbFailure()
{
var mailservice = new Mock <IEmailService>();
var subrepo = new Mock <ISubscriptionRepository>();
subrepo.Setup(sr => sr.Create(It.IsAny <Subscription>())).ReturnsAsync(false);
var service = new SubscriptionService(mailservice.Object, subrepo.Object);
var subscription = new Subscription("Simon", "*****@*****.**");
var isFailure = await service.Subscribe(subscription);
Assert.IsFalse(isFailure);
subrepo.Verify(sr => sr.Create(It.Is <Subscription>(s => s.Email == "*****@*****.**")));
subrepo.VerifyNoOtherCalls();
}
public async Task TestVerificationOK()
{
var verificationCode = "0a70862f-d4f9-436b-9a46-4ed1c990f7c5";
var email = "*****@*****.**";
var verificationRequest = new Subscription(null, email, verificationCode);
var subFromDB = new Subscription(null, null, verificationCode);
var subrepo = new Mock <ISubscriptionRepository>();
subrepo.Setup(sr => sr.ReadByEmail(email)).ReturnsAsync(subFromDB);
subrepo.Setup(sr => sr.Update(It.IsAny <Subscription>())).ReturnsAsync(true);
var service = new SubscriptionService(null, subrepo.Object);
var sucsess = await service.Verify(verificationRequest);
Assert.IsTrue(sucsess);
subrepo.Verify(sr => sr.Update(It.IsAny <Subscription>()));
}
public void Initialize()
{
store = new Mock <ISubscriptionStore>();
store.Setup(s => s.Add(It.Is <WebhookSubscription>(sub => sub.Event == "anevent1")))
.Returns("asubscriptionid1");
store.Setup(s => s.Add(It.Is <WebhookSubscription>(sub => sub.Event == "anevent2")))
.Returns("asubscriptionid2");
request = new Mock <IRequest>();
request.Setup(req => req.TryResolve <ICurrentCaller>())
.Returns(Mock.Of <ICurrentCaller>(cc => cc.UserId == "auserid"));
service = new SubscriptionService
{
Store = store.Object,
Request = request.Object
};
}
public void Setup()
{
_messageHelper = new MessageHelper();
_topicService = new TopicService();
_subscriptionService = new SubscriptionService();
var configurationHelper = new ConfigurationHelper();
_projectId = configurationHelper.ProjectId;
_topicId = $"{configurationHelper.TopicId}-{Guid.NewGuid()}";
_subscriptionId = $"{configurationHelper.SubscriptionId}-{Guid.NewGuid()}";
_ackTimeoutInSeconds = 60;
_sut = new FluentQueueApi();
}
public void Setup()
{
_mockedServiceLocator = MockRepository.GenerateMock <IServiceLocator>();
_eventSubscriberAssembliesProvider = MockRepository.GenerateMock <IEventSubscriberAssembliesProvider>();
_eventSubscriberAssembliesProvider.Stub(x => x.GetEventSubscriberAssemblies()).Return(new List <Assembly>()
{
this.GetType().Assembly
});
ServiceLocator.SetLocatorProvider(() => _mockedServiceLocator);
_cache = MockRepository.GenerateMock <IObjectLookupCache>();
_service = new SubscriptionService(_cache, _eventSubscriberAssembliesProvider);
}
public Subscription CreateSubscription(string PlanId, string CustomerId)
{
var subService = new SubscriptionService();
return(subService.Create(new SubscriptionCreateOptions()
{
Items = new List <SubscriptionItemOption>()
{
new SubscriptionItemOption()
{
PlanId = PlanId
}
},
CustomerId = CustomerId
}));
}
public async Task <Subscription> Subscribe(string customerId, string paymentMethod, List <SubscribeItemOption> items)
{
var service = new SubscriptionService();
var item = await service.CreateAsync(new SubscriptionCreateOptions
{
Customer = customerId,
DefaultPaymentMethod = paymentMethod,
Items = items.Select(x => new SubscriptionItemOptions
{
Price = x.PriceId,
Quantity = x.Quantity
}).ToList(),
});
return(item);
}
public double GetPaymentAmount(long customerId, DateTimeOffset fromDate, DateTimeOffset toDate)
{
Customer customer = CustomerService.GetCustomerById(customerId);
if (customer == null)
{
return(0);
}
IList <Subscription> subscriptions = SubscriptionService.GetSortedSubscriptions(customer.SubscriptionIds);
if (subscriptions.Count == 0)
{
subscriptions.Add(new Subscription
{
Id = 1,
SubscriptionType = SubscriptionTypes.Free,
Priority = 1,
PriceDetails = new Dictionary <string, double>
{
{ "FixPrice", 0 },
{ "OldBookDiscount", 10 },
{ "NewBookDiscount", 0 },
{ "NewBookDiscountAmmount", 0 }
}
});
}
IList <PurchaseTransaction> purchaseTransactions = PurchaseTransactionService.GetPurchaseTransactions(customerId, fromDate, toDate);
if (purchaseTransactions == null)
{
return(0);
}
IList <Book> books = BookService.GetBooks(purchaseTransactions);
if (books == null)
{
return(0);
}
double totalSubscriptionPrice = SubscriptionService.GetTotalSubscriptionPrice(subscriptions);
double totalTransactionPrice = PurchaseTransactionService.GetTotalTransactionPrice(books, subscriptions);
return(totalSubscriptionPrice + totalTransactionPrice);
}
public ActionResult Subscribe(int id)
{
var user = _database.Users.Where(u => u.Id == id).FirstOrDefault();
try
{
// Use Stripe's library to make request
StripeConfiguration.ApiKey = key;
StripeConfiguration.MaxNetworkRetries = 2;
var options = new SubscriptionCreateOptions
{
Customer = customerId,
Items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Price = productPrice1,
},
},
};
var service = new SubscriptionService();
Subscription subscription = service.Create(options);
var model = new SubscriptionViewModel();
model.SubscriptionId = subscription.Id;
user.CustomerId = subscription.CustomerId;
user.RoleId = 2;
_putItem.AddNewEntry(subscription.Id, subscription.LatestInvoiceId, user.Id);
_database.Users.Update(user);
_database.SaveChanges();
return(View("OrderStatus"));
}
catch (StripeException e)
{
var x = new
{
status = "Failed",
message = e.Message
};
return(this.Json(x));
}
}
GivenMultipleSubscriptionEntriesWithOneInvalidTechnicalMessageTypeWhenSendingSubscriptionMessageThenTheMessageShouldBeNotBeAccepted()
{
var subscriptionService =
new SubscriptionService(new HttpMessagingService(HttpClient));
var subscriptionParameters = new SubscriptionParameters
{
OnboardResponse = OnboardResponse,
TechnicalMessageTypes = new List <Subscription.Types.MessageTypeSubscriptionItem>()
};
var technicalMessageTypeForTaskdata = new Subscription.Types.MessageTypeSubscriptionItem
{
TechnicalMessageType = TechnicalMessageTypes.ImgPng
};
subscriptionParameters.TechnicalMessageTypes.Add(technicalMessageTypeForTaskdata);
var technicalMessageTypeForProtobuf = new Subscription.Types.MessageTypeSubscriptionItem
{
TechnicalMessageType = TechnicalMessageTypes.Iso11783DeviceDescriptionProtobuf
};
subscriptionParameters.TechnicalMessageTypes.Add(technicalMessageTypeForProtobuf);
subscriptionService.Send(subscriptionParameters);
Thread.Sleep(TimeSpan.FromSeconds(5));
var fetchMessageService = new FetchMessageService(HttpClient);
var fetch = fetchMessageService.Fetch(OnboardResponse);
Assert.Single(fetch);
var decodedMessage = DecodeMessageService.Decode(fetch[0].Command.Message);
Assert.Equal(400, decodedMessage.ResponseEnvelope.ResponseCode);
Assert.Equal(ResponseEnvelope.Types.ResponseBodyType.AckWithFailure,
decodedMessage.ResponseEnvelope.Type);
var messages = DecodeMessageService.Decode(decodedMessage.ResponsePayloadWrapper.Details);
Assert.NotNull(messages);
Assert.NotEmpty(messages.Messages_);
Assert.Single(messages.Messages_);
Assert.Equal("VAL_000006", messages.Messages_[0].MessageCode);
Assert.Equal(
"Subscription to \"iso:11783:-10:device_description:protobuf\" is not valid per reported capabilities.",
messages.Messages_[0].Message_);
}
public override string GetCartNumber(HttpRequest request, IDictionary <string, string> settings)
{
var cartNumber = "";
try
{
request.MustNotBeNull("request");
settings.MustNotBeNull("settings");
// If in test mode, write out the form data to a text file
if (settings.ContainsKey("mode") && settings["mode"] == "test")
{
LogRequest <StripeSubscription>(request, logPostData: true);
}
// Get the current stripe api key based on mode
var apiKey = settings[settings["mode"] + "_secret_key"];
var stripeEvent = GetStripeEvent(request);
// We are only interested in charge events
if (stripeEvent != null && stripeEvent.Type.StartsWith("invoice."))
{
var invoice = Mapper <Invoice> .MapFromJson(stripeEvent.Data.Object.ToString());
if (!string.IsNullOrWhiteSpace(invoice.SubscriptionId))
{
var subscriptionService = new SubscriptionService(apiKey);
var subscription = subscriptionService.Get(invoice.SubscriptionId);
if (subscription?.Metadata != null && subscription.Metadata.ContainsKey("cartNumber"))
{
cartNumber = subscription.Metadata["cartNumber"];
}
}
}
else
{
HttpContext.Current.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
}
catch (Exception exp)
{
LoggingService.Instance.Error <StripeSubscription>("StripeSubscription - GetCartNumber", exp);
}
return(cartNumber);
}
public void HandleEvent(RecurringPaymentsEnabledEventData eventData)
{
var subscriptionPayment = GetLastCompletedSubscriptionPayment(eventData.TenantId);
if (subscriptionPayment == null || subscriptionPayment.ExternalPaymentId.IsNullOrEmpty())
{
return;
}
var subscriptionService = new SubscriptionService();
subscriptionService.Update(subscriptionPayment.ExternalPaymentId, new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
CollectionMethod = "charge_automatically"
});
}
public ActionResult Signup(EmailSignupModel model)
{
if (!ModelState.IsValid)
{
return(View("EmailsSignup", model));
}
Subscription subscription = new Subscription()
{
Email = model.Email,
IsActive = true
};
var subscriptionService = new SubscriptionService();
subscriptionService.Subscribe(model.Email);
ViewBag.Message = "You have subscriber successfully.";
return(View("EmailsSignup"));
}
public StripePaymentGateway(ProductService productService, CustomerService customerService, PlanService planService,
CardService cardService, InvoiceService invoiceService, CouponService couponService, IMapper mapper, RefundService refundService,
SubscriptionService subscriptionService, InvoiceItemService invoiceItemService,
IOptions <AppSettings> appSettings)
{
_productService = productService;
_mapper = mapper;
_planService = planService;
_appSettings = appSettings.Value;
_cardService = cardService;
_invoiceService = invoiceService;
_customerSer = customerService;
_couponService = couponService;
_refundService = refundService;
_subscriptionService = subscriptionService;
_invoiceItemService = invoiceItemService;
}
public async Task DoAsync()
{
using (var context = await CreateContext())
{
var episodeRepo = new EpisodeRepository(context);
var showsRepo = new ShowsRepository(context);
var usersRepo = new UsersRepository(context);
var calendar = new GregorianCalendar();
var episodeCalendar = new EpisodeCalendar(episodeRepo, calendar);
var service = new SubscriptionService(usersRepo);
await service.Subscribe(5, 8);
// Console.WriteLine(JsonConvert.SerializeObject(data, Formatting.Indented));
}
}
private static void StartSubscriptionService()
{
Console.Out.WriteLine("starting the subscription service");
var subscriptionSagaRepository = new InMemorySagaRepository<SubscriptionSaga>();
var clientSagaRepository = new InMemorySagaRepository<SubscriptionClientSaga>();
var serviceBus =
ServiceBusFactory.New(sbc =>
{
sbc.UseStomp();
sbc.ReceiveFrom("{0}/mt_subscriptions".FormatWith(Host));
sbc.SetConcurrentConsumerLimit(1);
});
var subscriptionService = new SubscriptionService(serviceBus, subscriptionSagaRepository,
clientSagaRepository);
subscriptionService.Start();
}
private static void InitializeSubscriptionService(ISessionFactory sessionFactory)
{
Console.Write("Initializing the subscription service... ");
var subscriptionBus = ServiceBusFactory.New(sbc =>
{
sbc.UseMsmq();
sbc.VerifyMsmqConfiguration();
sbc.SetConcurrentConsumerLimit(1);
sbc.ReceiveFrom(Constants.QueueSubscriptions);
});
var subscriptionSagas = new NHibernateSagaRepository<SubscriptionSaga>(sessionFactory);
var subscriptionClientSagas = new NHibernateSagaRepository<SubscriptionClientSaga>(sessionFactory);
var subscriptionService = new SubscriptionService(subscriptionBus, subscriptionSagas, subscriptionClientSagas);
subscriptionService.Start();
Utils.WriteToConsole("done", ConsoleColor.Green);
}
private string StartSubscriptionService(TransportSettings settings)
{
string subscriptionQueueUri = settings.GetQueueUri(SubscriptionServiceQueueName ?? STR_DefaultSubscriptionServiceQueueName);
//
// setup the subscription service
//
var subscriptionBus = ServiceBusFactory.New(sbc =>
{
sbc.UseRabbitMq();
sbc.SetConcurrentConsumerLimit(1);
sbc.ReceiveFrom(subscriptionQueueUri);
});
var subscriptionSagas = new InMemorySagaRepository<SubscriptionSaga>();
var subscriptionClientSagas = new InMemorySagaRepository<SubscriptionClientSaga>();
var subscriptionService = new SubscriptionService(subscriptionBus, subscriptionSagas, subscriptionClientSagas);
subscriptionService.Start();
return subscriptionQueueUri;
}
public void SubscriptionServiceConstructorWithNullArgsExpectedThrowsArgumentNullException()
{
var service = new SubscriptionService<object>(null);
}
public async Task<Podcast> AddPodcastAsync(Uri podcastUri)
{
await LoadFileAsync();
var results = await EvaluatePodcastFeedAsync(podcastUri);
if (results.RedirectUri != null)
{
podcastUri = results.RedirectUri;
}
var feed = results.Feed;
var podcast = new Podcast
{
Title = feed.Title,
Location = podcastUri,
Image = feed.Image.Url,
};
await SaveNewPodcastToFileAsync(podcast);
using (var subscription = new SubscriptionService(new Uri("http://localhost:3333"), new BasicAuthStrategy("my_user", "password")))
{
await subscription.PostSubscriptionAsync(podcast.Location.AbsoluteUri);
}
return podcast;
}
