public List <Subscription> GetSubscriptions(string userEmail, string order = null)
{
var userId = GetUser(userEmail).Id;
var subsIds = UserSubscriptions
.Where(x => x.UserId == userId)
.Select(x => x.SubscriptionId);
var subs = Subscriptions
.Where(s => subsIds.Any(id => id == s.Id));
foreach (var s in subs)
{
while ((s.LastPayment + TimeSpan.FromDays(s.Period)).Date < DateTime.Today)
{
s.LastPayment += TimeSpan.FromDays(s.Period);
}
}
SaveChanges();
if (order == "descendingDate")
{
return(subs.ToList().OrderByDescending(x => x.LastPayment + TimeSpan.FromDays(x.Period)).ToList());
}
if (order == "ascendingName")
{
return(subs.ToList().OrderBy(x => x.Name).ToList());
}
if (order == "descendingName")
{
return(subs.ToList().OrderByDescending(x => x.Name).ToList());
}
return(subs.ToList().OrderBy(x => x.LastPayment + TimeSpan.FromDays(x.Period)).ToList());
}
/// <summary>
/// Currents the users subscriptions.
/// </summary>
/// <param name="showActiveOnly">if set to <c>true</c> [show active only].</param>
/// <returns></returns>
public UserSubscriptions CurrentUsersSubscriptions(bool showActiveOnly = false)
{
try
{
#region pre-processing
string additionalQuery = string.Empty;
if (showActiveOnly)
{
additionalQuery = "?active=true";
}
#endregion end pre-processing
#region processing
UserSubscriptions result = new UserSubscriptions();
var basicResult = GetRequest <BasicUserSubscriptions>(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.SubscriptionUrls.Subscriptions, additionalQuery).Trim());
foreach (var sub in basicResult.Subscriptions)
{
result.Subscriptions.Add(ConvertFromBasicSubscription(sub));
}
return(result);
#endregion processing
}
catch (Exception)
{
throw;
}
}
private async Task <UserSubscriptions> GetUserSubscriptions(string emailAddress, string accessToken)
{
UserSubscriptions userSubscriptions = null;
User user = await GetUser(emailAddress, accessToken);
if (user != null)
{
string url = $"{_apimUrl}/users/{user.name}/subscriptions?api-version=2019-12-01";
_httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("SharedAccessSignature", accessToken);
HttpResponseMessage response = await _httpClient.GetAsync(url);
if (response.IsSuccessStatusCode)
{
string responseContent = await response.Content.ReadAsStringAsync();
userSubscriptions = JsonConvert.DeserializeObject <UserSubscriptions>(responseContent);
}
else
{
string responseContent = await response.Content.ReadAsStringAsync();
}
}
return(userSubscriptions);
}
public async Task <bool> Post(UserSubscriptions userSubscriptions)
{
var subscriptions = userSubscriptions.Subscriptions;
if (!subscriptions.Any())
{
return(false);
}
int id = subscriptions[0].UserId;
if (subscriptions.Any(x => x.UserId != id))
{
return(false);
}
// remove all subscriptions that user chose to remove
var subscriptionsToDelete = subscriptions.Where(x => !x.IsActive).ToList();
if (subscriptionsToDelete.Any())
{
await userSubscriptionRepository.RemoveSubscriptions(subscriptionsToDelete);
}
// add all subscriptions that user now has active
var subscriptionsToAdd = subscriptions.Where(x => x.IsActive).ToList();
if (subscriptionsToAdd.Any())
{
await userSubscriptionRepository.AddSubscriptions(subscriptionsToAdd);
}
return(true);
}
public async Task <IActionResult> Register(UserSubscriptions UserSubscriptions)
{
//var userWithSameEmail = _dbContext.ADMINMast.SingleOrDefault(u => u.EmailID == ADMINMast.EmailID);
//if (userWithSameEmail != null) return BadRequest("User with this email already exists");
var UserSubscriptionsObj = new UserSubscriptions
{
UserSubscriptionID = Guid.NewGuid(),
DiscountApplied = UserSubscriptions.DiscountApplied,
FamMembID = UserSubscriptions.FamMembID,
ItemAddOnQty = UserSubscriptions.ItemAddOnQty,
ItemID = UserSubscriptions.ItemID,
OfferID = UserSubscriptions.OfferID,
Quantity = UserSubscriptions.Quantity,
ScheduledDates = UserSubscriptions.ScheduledDates,
ScheduledTime = UserSubscriptions.ScheduledTime,
SubSchID = UserSubscriptions.SubSchID,
SubscriptionEndDate = UserSubscriptions.SubscriptionEndDate,
SubscriptionPrice = UserSubscriptions.SubscriptionPrice,
SubscriptionStartDate = UserSubscriptions.SubscriptionStartDate,
userId = UserSubscriptions.userId
};
_dbContext.UserSubscriptions.Add(UserSubscriptionsObj);
await _dbContext.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created));
}
public void Update(UserSubscriptions sub)
{
using (IDbConnection dbConnection = Connection)
{
dbConnection.Open();
dbConnection.Execute("team4.UpdateSubscription", sub, commandType: CommandType.StoredProcedure);
}
}
public static async Task GetRandomActivationCode(this UserSubscriptions userSubscription)
{
var crypto = new System.Security.Cryptography.RNGCryptoServiceProvider();
var bytes = new byte[5];
crypto.GetBytes(bytes);
userSubscription.ActivationCode = BitConverter.ToString(bytes).Replace("-", string.Empty);
}
private Result.Result <Boolean> UpdateUserSubscriptionStatus(string key, Core.SubscriptionEnum status)
{
if (!UserSubscriptions.ContainsKey(key))
{
return(new Result.Result <Boolean>(new SystemException(Extensions.DataConstants.FailedToFind)));
}
UserSubscriptions[key].SetStatus(status);
return(new Result.Result <Boolean>(true));
}
public Task <Guid> Handle(CreateUserSubscriptionCommand request, CancellationToken cancellationToken)
{
UserSubscriptions subscription = UserSubscriptions.Create(request.SubscriptionId, request.UserId, request.APIKey);
_subscriptionRepository.Save(subscription);
_unitOfWork.Save();
return(Task.FromResult <Guid>(subscription.Id));
}
public bool AddSubscription(string curentUserId, string userId)
{
var subscription = new UserSubscriptions {
UserId = curentUserId, SubscribedToUserId = userId
};
Context.Set <UserSubscriptions>().Add(subscription);
Context.Entry(subscription).State = EntityState.Added;
return(Context.SaveChanges() > 0);
}
public async void Delete(string id)
{
var httpClient = Helpers.CouchDBConnect.GetClient("UserSubscripton");
UserSubscriptions u = await DoesSubscriptionExist(id);
if (u != null)
{
await httpClient.DeleteAsync("UserSubscripton/" + u._id + "?rev=" + u._rev);
}
}
public void AddServiceToUser(Subscription subscription, string userEmail)
{
Subscriptions.Add(subscription);
SaveChanges();
UserSubscriptions.Add(new UserSubscription()
{
UserId = GetUser(userEmail).Id,
SubscriptionId = subscription.Id
});
SaveChanges();
}
public int Insert(int streamerId)
{
using (IDbConnection dbConnection = Connection)
{
UserSubscriptions sub = new UserSubscriptions
{
StreamerId = streamerId,
UserLoginId = 2
};
dbConnection.Open();
return(dbConnection.Query <InsertID>("team4.AddSubscription", sub, commandType: CommandType.StoredProcedure)?.FirstOrDefault()?.ID ?? 0);
}
}
public override void Initialize(IApplicationContext applicationContext)
{
base.Initialize(applicationContext);
statusBarViewModel = this.ApplicationContext.GetService <StatusBarViewModel>();
var cachedintegrationAccountDetails = this.ApplicationContext.GetService <IntegrationAccountDetails>();
var cachedintegrationServiceDetails = this.ApplicationContext.GetService <IntegrationServiceDetails>();
AzureLoginButtonClickCommand = new RelayCommand(o => AzureLoginButtonClick("AzureLoginButton"));
if (cachedintegrationAccountDetails != null)
{
UserSubscriptions = this.ApplicationContext.GetProperty("Subscriptions") as ObservableCollection <Subscription.RootObject>;
UserResourceGroups = this.ApplicationContext.GetProperty("ResourceGroups") as ObservableCollection <ResourceGroup.RootObject>;
UserIntegrationAccounts = this.ApplicationContext.GetProperty("IntegrationAccounts") as ObservableCollection <IntegrationAccount.RootObject>;
UserKeyVaults = this.ApplicationContext.GetProperty("KeyVaults") as ObservableCollection <KeyVault.RootObject>;
SelectedSubscription = UserSubscriptions.Where(x => x.SubscriptionId == cachedintegrationAccountDetails.SubscriptionId).First();
SelectedResourceGroup = UserResourceGroups.Where(x => x.Name == cachedintegrationAccountDetails.ResourceGroupName).First();
SelectedIntegrationAccount = UserIntegrationAccounts.Where(x => x.Name == cachedintegrationAccountDetails.IntegrationAccountName).First();
if (!string.IsNullOrEmpty(cachedintegrationAccountDetails.KeyVaultName))
{
SelectedKeyVault = UserKeyVaults.Where(x => x.Name == cachedintegrationAccountDetails.KeyVaultName).First();
}
IsLoginButttonEnabled = false;
SubscriptionVisible = true;
}
else
{
UserSubscriptions = new ObservableCollection <Subscription.RootObject>();
UserResourceGroups = new ObservableCollection <ResourceGroup.RootObject>();
UserIntegrationAccounts = new ObservableCollection <IntegrationAccount.RootObject>();
UserKeyVaults = new ObservableCollection <KeyVault.RootObject>();
IsLoginButttonEnabled = true;
SubscriptionVisible = false;
ResourceGroupVisible = false;
IntegrationAccountVisible = false;
KeyVaultVisible = false;
}
if (cachedintegrationServiceDetails != null)
{
this.integrationServiceDetails = cachedintegrationServiceDetails;
}
else
{
this.integrationServiceDetails = new IntegrationServiceDetails();
this.ApplicationContext.AddService(this.integrationServiceDetails);
}
}
public Task <Guid> Handle(EditUserSubscriptionCommand request, CancellationToken cancellationToken)
{
UserSubscriptions subscription = _subscriptionRepository.Find(request.Id);
if (subscription == null)
{
throw new Exception(typeof(UserSubscriptions).Name + " not found.");
}
subscription.Edit(request.SubcriptionId, request.UserId, request.APIKey);
_unitOfWork.Save();
return(Task.FromResult(subscription.Id));
}
public async Task <UserSubscriptions> Get(int id)
{
if (id <= 0)
{
return(new UserSubscriptions());
}
// Return a static list of people
var subscriptions = await userSubscriptionRepository.FetchSubscriptions(id);
UserSubscriptions userSubscriptionsToSave = new UserSubscriptions();
userSubscriptionsToSave.Subscriptions = subscriptions.ToList();
return(userSubscriptionsToSave);
}
public async Task Update(UserSubscriptions userSubscription)
{
var userSubs = await _context.UserSubscriptions
.FirstOrDefaultAsync(x => x.UserId == userSubscription.UserId && x.GuildId == userSubscription.GuildId)
.ConfigureAwait(false);
userSubs.Works = userSubscription.Works;
userSubs.Training = userSubscription.Training;
userSubs.Adventure = userSubscription.Adventure;
_context.UserSubscriptions.Attach(userSubs);
_context.Entry(userSubs).State = EntityState.Modified;
await _context.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <UserSubscriptions> GetUserSubscriptions(string session, bool onlyAppSubscriptions)
{
var userId = await GetUserFromSession(session);
var result = new UserSubscriptions()
{
Subscriptions = new List <Models.Subscription>()
};
string sqlQuery = $@"SELECT
SUS_titulosaudio.id AS id_suscription,
SUS_titulosaudio.des_corta AS suscription_code,
SUS_titulosaudio.descripcion AS suscription_description
FROM SUS_audio, SUS_titulosaudio
WHERE SUS_audio.id_usuario={userId} AND
SUS_titulosaudio.id = SUS_audio.id_titulo";
// Only subscriptions for app list
if (onlyAppSubscriptions)
{
sqlQuery += " AND SUS_audio.id_formato = 5";
}
using (SqlConnection connection = new SqlConnection(
_connectionString))
{
SqlCommand commandDeatils = new SqlCommand(sqlQuery, connection);
connection.Open();
using SqlDataReader reader = await commandDeatils.ExecuteReaderAsync();
while (reader.Read())
{
result.Subscriptions.Add(new Models.Subscription
{
Id = Convert.ToInt32(reader[0]),
Code = reader[1].ToString().Trim(),
Description = reader[2].ToString().Trim()
});
}
}
return(result);
}
public Task <UserSubcriptionReadModel> Handle(UserSubscriptionDetailQuery request, CancellationToken cancellationToken)
{
UserSubscriptions subscription = _subscriptionRepository.Find(request.Id);
UserSubcriptionReadModel subscriptionReadModel = null;
if (subscription != null)
{
subscriptionReadModel = new UserSubcriptionReadModel
{
Id = subscription.Id,
APIKey = subscription.APIKey,
SubcriptionId = subscription.SubcriptionId,
UserId = subscription.UserId
};
}
return(Task.FromResult(subscriptionReadModel));
}
public void UserSubscriptionsCreatedSuccessfully()
{
var _userSubscriptionsRepository = StartUpTests.ServiceProvider.GetService <IUserSubscriptionsRepository>();
Guid userId = Guid.NewGuid();
Guid subscriptionId = Guid.NewGuid();
UserSubscriptions userSubscription = UserSubscriptions.Create(subscriptionId, userId, "KKKL");
_userSubscriptionsRepository.Save(userSubscription);
StartUpTests.UnitOfWork.Save();
Assert.IsNotNull(userSubscription.Id);
UserSubscriptions userSubscriptionRead = _userSubscriptionsRepository.Find(userSubscription.Id);
Assert.IsNotNull(userSubscriptionRead);
Assert.AreEqual(userId, userSubscriptionRead.UserId);
Assert.AreEqual(subscriptionId, userSubscriptionRead.SubcriptionId);
}
public async Task UpdateUserProfileForSubscriptions(Agreement createdAgreement, string paypalPlanId)
{
var user = await _userManager.GetUserAsync(User);
//add all subscriptions as Payment already has happened!!
UserSubscriptions subscriptionToUpdate = _dbContext.UserSubscriptions.Where(x => x.PayPalPlanId == paypalPlanId && x.UserId == user.Id).FirstOrDefault();
if (user != null && subscriptionToUpdate != null)
{
subscriptionToUpdate.PayPalAgreementId = createdAgreement.Id;
subscriptionToUpdate.SubscriptionId = createdAgreement.Id;
subscriptionToUpdate.State = createdAgreement.State;
subscriptionToUpdate.Description = createdAgreement.Description;
subscriptionToUpdate.PayerEmail = createdAgreement.Payer.PayerInfo.Email;
subscriptionToUpdate.PayerFirstName = createdAgreement.Payer.PayerInfo.FirstName;
subscriptionToUpdate.PayerLastName = createdAgreement.Payer.PayerInfo.LastName;
await _dbContext.SaveChangesAsync();
}
}
/// <summary>
/// Get the current user's subscriptions.
/// </summary>
/// <returns></returns>
public UserSubscriptions CurrentUsersSubscriptions()
{
try
{
#region processing
UserSubscriptions result = new UserSubscriptions();
string jsonResult = GetRequest(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.SubscriptionUrls.Subscriptions));
var basicResult = JsonSerializer.Deserialize <BasicUserSubscriptions>(jsonResult);
foreach (var sub in basicResult.subscriptions)
{
result.Subscriptions.Add(ConvertFromBasicSubscription(sub));
}
return(result);
#endregion processing
}
catch (Exception)
{
throw;
}
}
public async Task <int> RemoveSubscribee([FromBody] Subscription subscription)
{
Subscribee sub = null;
var httpClient = Helpers.CouchDBConnect.GetClient("subscriptions");
HttpContent httpContent;
HttpResponseMessage response;
UserSubscriptions u = await DoesSubscriptionExist(subscription.id);
if (u != null)
{
u.RemoveSubscribee(sub);
httpContent = new StringContent(
JsonConvert.SerializeObject(u),
System.Text.Encoding.UTF8,
"application/json"
);
response = await httpClient.PutAsync("subscriptions/" + u._id, httpContent);
return(1);
}
return(-1);
}
protected override async void OnAppearing()
{
if (_model.Loading)
{
UserDialogs.Instance.ShowLoading("Cargando suscripciones");
try
{
_subscriptions = await AudioLibrary.Instance.GetUserSubscriptions(true);
if (_subscriptions == null)
{
return;
}
// bind model
listView.SetBinding(ListView.ItemsSourceProperty, new Binding("."));
listView.BindingContext = _model.Items;
listView.BeginRefresh();
_subscriptions.Subscriptions
.OrderBy(o => o.Description)
.ToList()
.ForEach(item => _model.Items.Add(item));
listView.EndRefresh();
}
catch
{
}
_model.Loading = false;
UserDialogs.Instance.HideLoading();
}
}
public async Task <IHttpActionResult> SubscribeVideo(SubscribeVideoBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (SkriblContext ctx = new SkriblContext())
{
var box = ctx.Boxes.FirstOrDefault(x => x.Id == model.Box_Id && x.IsDeleted == false);
if (box != null)
{
switch (model.Type)
{
case (int)BoxCategoryOptions.Junior:
model.ExpiryDate = model.Month.AddMonths(1);
break;
case (int)BoxCategoryOptions.Monthly:
model.ExpiryDate = model.Month.AddMonths(1);
break;
case (int)BoxCategoryOptions.ProBox:
model.ExpiryDate = model.Month.AddMonths(1);
break;
case (int)BoxCategoryOptions.HallOfFame:
model.ExpiryDate = model.Month.AddMonths(1);
break;
}
UserSubscriptions subscription = new UserSubscriptions {
CreatedDate = DateTime.Now, Type = box.BoxCategory_Id, Box_Id = model.Box_Id, User_Id = model.User_Id, SubscriptionDate = model.Month, ExpiryDate = model.ExpiryDate
};
subscription.GetRandomActivationCode();
ctx.UserSubscriptions.Add(subscription);
ctx.SaveChanges();
return(Ok(new CustomResponse <UserSubscriptions>
{
Message = Global.ResponseMessages.Success,
StatusCode = (int)HttpStatusCode.OK,
Result = subscription
}));
}
else
{
return(Ok(new CustomResponse <Error> {
Message = Global.ResponseMessages.BadRequest, StatusCode = (int)HttpStatusCode.BadRequest, Result = new Error {
ErrorMessage = "Invalid Box_Id"
}
}));
}
}
}
catch (Exception ex)
{
return(StatusCode(Utility.LogError(ex)));
}
}
private async Task CheckUpdateUserSubscriptionDetails(ApplicationUser user)
{
List <UserSubscriptions> userSubs = _dbContext.UserSubscriptions
.Where(x => x.UserId == user.Id && x.PayPalAgreementId != null)
.ToList();
if (userSubs.Count() > 0)
{
List <string> userSubscriptionIds = _dbContext.UserSubscriptions
.Where(x => x.UserId == user.Id && x.PayPalAgreementId != null)
.Select(x => x.PayPalAgreementId)
.ToList();
foreach (var Id in userSubscriptionIds)
{
//get user subscription
var client = _clientFactory.GetClient();
AgreementGetRequest request = new AgreementGetRequest(Id);
BraintreeHttp.HttpResponse result = await client.Execute(request);
Agreement agreement = result.Result <Agreement>();
//get user subscription
UserSubscriptions userExistingSubscription = user.Subscriptions.Where(x => x.PayPalAgreementId == Id).FirstOrDefault();
//first time user is cancelling.
if (agreement.State == "Cancelled" && userExistingSubscription.State != "Cancelled")
{
//if this is the first cancellation.
if (userExistingSubscription.ExpiryDate.Year < 1995)
{
//set expiry date in the User Subscription to the next billing date.
//"last_payment_date": "2020-06-15T17:57:02Z",
// "next_billing_date": "2020-07-15T10:00:00Z",
string expiryDateAsString = agreement.AgreementDetails.NextBillingDate.Substring(0, 10);
DateTime expiryDate = DateTime.ParseExact(expiryDateAsString, "yyyy-MM-dd", null);
userExistingSubscription.ExpiryDate = expiryDate;
//update user subscription status.
userExistingSubscription.State = agreement.State;
//only send cancellation email when Paypal first sends cancellation confirmation.
var cancellationEmailAlreadyBeenSent = _dbContext.UserSubscriptions.Where(x => x.UserId == user.Id && x.PayPalAgreementId == agreement.Id && x.State != "Cancelled").Any();
if (!cancellationEmailAlreadyBeenSent)
{
//Send user an email and let them know expiry date.
var confirmationHtml = $"<h2>As per your request, your Subscription <strong>{userExistingSubscription.Description}</strong> has been cancelled.</h2> <p>However, you can continue enjoy your access till your paid period expired on {userExistingSubscription.ExpiryDate}.</p>";
var sendGridKey = _configuration.GetValue <string>("SendGridApi");
await Emailer.SendEmail(user.Email, "AndyTipster Subscription, has been cancelled", confirmationHtml, sendGridKey);
//Send admin an email and let them know expiry date.
var confirmationAdminHtml = $"<h2>User {user.Email} has cancelled their subscription for <strong>{userExistingSubscription.Description}</strong>.</h2> <p>However, user has access till their paid period expired on {userExistingSubscription.ExpiryDate}.</p><p>An email confirmation has been sent to user on {user.Email}</p>";
await Emailer.SendEmail("*****@*****.**", "A user has cancelled a Subscription", confirmationAdminHtml, sendGridKey);
}
}
}
if (agreement.State == "Cancelled" && userExistingSubscription.State == "Cancelled")
{
//check if subscription date has expired.
if (userExistingSubscription.ExpiryDate < DateTime.Now) // user subs expired, delete their subscription.
{
//delete Subscription.
var subsTobeDeleted = _dbContext.Subscriptions.Where(x => x.PayPalAgreementId == agreement.Id).FirstOrDefault();
if (subsTobeDeleted != null)
{
_dbContext.Subscriptions.Remove(subsTobeDeleted);
}
//delete user Subscription
var userSubsToBeDeleted = _dbContext.UserSubscriptions.Where(x => x.UserId == user.Id && x.State == "Cancelled" && x.PayPalAgreementId == agreement.Id).FirstOrDefault();
if (userSubsToBeDeleted != null)
{
_dbContext.UserSubscriptions.Remove(userSubsToBeDeleted);
}
_dbContext.SaveChanges();
//Send user an email and let them know subscription now has expired.
var expiredHtml = $"<h2>Your Subscription <strong>{userExistingSubscription.Description}</strong> has now expired.</h2>";
var sendGridKey = _configuration.GetValue <string>("SendGridApi");
await Emailer.SendEmail(user.Email, "Andy Tipster Subscription has expired.", expiredHtml, sendGridKey);
//Send admin an email and let them know expiry.
var expiredAdminHtml = $"<h2>User {user.Email} subscription for <strong>{userExistingSubscription.Description}</strong>. has now expired.</h2><p>An email confirmation has been sent to user on {user.Email}</p>";
await Emailer.SendEmail("*****@*****.**", $"{userExistingSubscription.PayerEmail} : Subscription has expired.", expiredAdminHtml, sendGridKey);
}
}
await userManager.UpdateAsync(user);
}
}
}
public async Task RegisterUserNotifications()
{
string deviceToken = GetDeviceToken();
var notificationsSubscriptions = GetNotificationsSubscriptions();
if (string.IsNullOrEmpty(deviceToken))
{
return;
}
var credentials = new BasicAWSCredentials(
AppSettings.Instance.AwsKey,
AppSettings.Instance.AwsSecret
);
var client = new AmazonSimpleNotificationServiceClient(
credentials,
Amazon.RegionEndpoint.EUWest1
);
if (string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint) ||
notificationsSubscriptions.DeviceToken != deviceToken)
{
// **********************************************
// de-register old endpoint and all subscriptions
if (!string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint))
{
try
{
var response = await client.DeleteEndpointAsync(new DeleteEndpointRequest { EndpointArn = notificationsSubscriptions.ApplicationEndPoint });
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error eliminando endpoint: {response.HttpStatusCode}");
}
}
catch { /*Silent error in case endpoint doesn´t exist */ }
notificationsSubscriptions.ApplicationEndPoint = null;
foreach (var sub in notificationsSubscriptions.Subscriptions)
{
try
{
await client.UnsubscribeAsync(sub.Value);
}
catch { /*Silent error in case endpoint doesn´t exist */ }
}
notificationsSubscriptions.Subscriptions.Clear();
}
// register with SNS to create a new endpoint
var endPointResponse = await client.CreatePlatformEndpointAsync(
new CreatePlatformEndpointRequest
{
Token = deviceToken,
PlatformApplicationArn = Device.RuntimePlatform == Device.iOS ?
AppSettings.Instance.AwsPlatformApplicationArnIOS :
AppSettings.Instance.AwsPlatformApplicationArnAndroid
}
);
if (endPointResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error registrando endpoint: {endPointResponse.HttpStatusCode}, {endPointResponse.ResponseMetadata}");
}
// Save device token and application endpoint created
notificationsSubscriptions.DeviceToken = deviceToken;
notificationsSubscriptions.ApplicationEndPoint = endPointResponse.EndpointArn;
}
// Retrieve subscriptions
var subscriptions = await AudioLibrary.Instance.GetUserSubscriptions(false);
if (subscriptions == null)
{
subscriptions = new UserSubscriptions {
Subscriptions = new List <Models.Api.Subscription>()
}
}
;
// Register non existings subscriptions
var subscriptionsCodes = subscriptions.Subscriptions.Select(s => s.Code).ToList();
foreach (var code in subscriptionsCodes)
{
if (!notificationsSubscriptions.Subscriptions.ContainsKey(code))
{
var topicArn = AppSettings.Instance.AwsTopicArn;
topicArn += string.IsNullOrEmpty(code) ? "" : $"-{code}";
if (!await TopicExists(topicArn, client))
{
var topicResponse = await client.CreateTopicAsync(new CreateTopicRequest { Name = $"{AppSettings.Instance.AwsTopicName}-{code}" });
if (topicResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error creando topic: {topicResponse.HttpStatusCode}, {topicResponse.ResponseMetadata}");
}
topicArn = topicResponse.TopicArn;
}
// Subscribe
var subscribeResponse = await client.SubscribeAsync(new SubscribeRequest
{
Protocol = "application",
Endpoint = notificationsSubscriptions.ApplicationEndPoint,
TopicArn = topicArn
});
if (subscribeResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error creando suscripción: {subscribeResponse.HttpStatusCode}, {subscribeResponse.ResponseMetadata}");
}
// Add to the list
notificationsSubscriptions.Subscriptions.Add(code, subscribeResponse.SubscriptionArn);
}
}
// Remove subscriptions not in user list
var currentSubscriptions = notificationsSubscriptions.Subscriptions.ToList();
foreach (var subs in currentSubscriptions)
{
if (!subscriptionsCodes.Contains(subs.Key))
{
try
{
await client.UnsubscribeAsync(subs.Value);
}
catch { /*Silent error in case endpoint doesn´t exist */ }
notificationsSubscriptions.Subscriptions.Remove(subs.Key);
}
}
// Save notifications subscriptions
await SaveNotificationsSubscriptions(notificationsSubscriptions);
}
public async Task <IActionResult> Purchase(PurchaseVm model)
{
var plan = _dbContext.BillingPlans.FirstOrDefault(x => x.PayPalPlanId == model.Product.PayPalPlanId);
var product = _dbContext.Products.FirstOrDefault(x => x.PayPalPlanId == model.Product.PayPalPlanId);
//check DUPLICATES
ApplicationUser currentUser = await _userManager.GetUserAsync(User);
var userhasAnySubscriptions = _dbContext.UserSubscriptions.Any(x => x.UserId == currentUser.Id && x.SubscriptionId != null);
if (userhasAnySubscriptions)
{
List <UserSubscriptions> subscribedPlans = _dbContext.UserSubscriptions.Where(x => x.UserId == currentUser.Id && x.SubscriptionId != null).ToList();
bool alreadySusbcribedToThisPlan = subscribedPlans.Any(x => x.PayPalPlanId == product.PayPalPlanId);
if (alreadySusbcribedToThisPlan)
{
return(RedirectToAction("DuplicateSubscriptionFound", product));
}
}
if (ModelState.IsValid && plan != null)
{
// Since we take an Initial Payment (instant payment), the start date of the recurring payments will be next month.
//var startDate = DateTime.UtcNow.AddMonths(1);
//set subscription start date based on plan.
var startDate = DateTime.UtcNow;
if (plan.Name.Contains("Monthly"))
{
startDate = DateTime.UtcNow.AddMonths(1);
}
if (plan.Name.Contains("3 Months"))
{
startDate = DateTime.UtcNow.AddMonths(3);
}
//start_date string required
//The date and time when this agreement begins, in Internet date and time format.
//The start date must be no less than 24 hours after the current date as the agreement can take up to 24 hours to activate.
//The start date and time in the create agreement request might not match the start date and time that the API returns
//in the execute agreement response. When you execute an agreement, the API internally converts the start date and time to
//the start of the day in the time zone of the merchant account.For example, the API converts a 2017 - 01 - 02T14: 36:21Z start date and time
//for an account in the Berlin time zone(UTC + 1) to 2017 - 01 - 02T00:00:00.When the API returns this date and time in the
//execute agreement response, it shows the converted date and time in the UTC time zone.So,
//the internal 2017-01-02T00:00:00 start date and time becomes 2017-01-01T23:00:00 externally.
string formatedStringDate = startDate.ToString("o", CultureInfo.InvariantCulture);
var formatedStartDate = DateTime.Parse(formatedStringDate, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
//DateTime.UtcNow.ToString("o");
var subscription = new Subscription()
{
FirstName = currentUser.FirstName,
LastName = currentUser.LastName,
Email = currentUser.Email,
StartDate = formatedStartDate, //stat date has to be greator than now.
PayPalPlanId = plan.PayPalPlanId
};
_dbContext.Subscriptions.Add(subscription);
var userNewSubscriptoin = new UserSubscriptions()
{
PayPalPlanId = plan.PayPalPlanId,
Description = plan.Description,
User = currentUser,
UserId = currentUser.Id
};
_dbContext.UserSubscriptions.Add(userNewSubscriptoin);
_dbContext.SaveChanges();
var agreement = new Agreement()
{
Name = plan.Name,
Description = plan.Description,
StartDate = startDate.ToString("yyyy-MM-ddTHH:mm:ssZ"),
Plan = new PlanWithId()
{
Id = Convert.ToString(plan.PayPalPlanId)
},
Payer = new Payer()
{
PaymentMethod = "paypal"
}
};
// Send the agreement to PayPal
var client = _clientFactory.GetClient();
var request = new AgreementCreateRequest()
.RequestBody(agreement);
var result = await client.Execute(request);
Agreement createdAgreement = result.Result <Agreement>();
// Find the Approval URL to send our user to (also contains the token)
var approvalUrl =
createdAgreement.Links.FirstOrDefault(
x => x.Rel.Equals("approval_url", StringComparison.OrdinalIgnoreCase));
var token = QueryHelpers.ParseQuery(approvalUrl?.Href)["token"].First();
// Save the token so we can match the returned request to our subscription.
subscription.PayPalAgreementToken = token;
_dbContext.SaveChanges();
// Send the user to PayPal to approve the payment
return(Redirect(approvalUrl.Href));
}
model.Product = product;
return(View(model));
}
public async Task <Result.Result <Boolean> > AddUserSubscriptionAsync(Models.UserSubscription entity)
{
return(await UserSubscriptions.AddOneAsync(entity).ConfigureAwait(false));
}
public async Task <Result.Result <Boolean> > DeleteUserSubscriptionAsync(string key)
{
return(await UserSubscriptions.RemoveOneAsync(key).ConfigureAwait(false));
}
