private async Task <bool> getSubDetails()
{
UserSubscriptionModel sub = await session.GetUserSubscription();
UserSoundQuality = sub.HighestSoundQuality;
return(true);
}
public async Task <IActionResult> CreateNewUserAsync(UserSubscriptionModel newUser)
{
IdentityResult result = new IdentityResult();
result = await userManager.CreateAsync(new MyUser
{
UserName = newUser.Mail,
Email = newUser.Mail,
Nom = newUser.Nom,
Prenom = newUser.Prenom,
Mobile = newUser.Mobile,
Sexe = newUser.Sexe,
DateDeNaissance = newUser.DateDeNaissance,
Professionnel = newUser.Professionnel
}, newUser.Password);
if (result.Succeeded)
{
return(Created("mysite.com", result));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError(item.Code, item.Description);
}
return(BadRequest(ModelState));
}
}
/// <summary>
/// Updates a record
/// </summary>
/// <param name="model">Record model</param>
/// <returns>If operation has succeded</returns>
public async Task <UserSubscriptionModel> Update(UserSubscriptionModel model)
{
var collection = _SettingsModel.GetCollection <UserSubscriptionModel>(collectionName);
var result = await collection.ReplaceOneAsync(GetFilterId(model.Id), model);
return(result.ModifiedCount > 0 ? model : null);
}
/// <summary>
/// Creates a new subscription
/// </summary>
/// <param name="model">Suscription data</param>
/// <returns>Updated record</returns>
public async Task <UserSubscriptionModel> Create(UserSubscriptionModel model)
{
var collection = _SettingsModel.GetCollection <UserSubscriptionModel>(collectionName);
await collection.InsertOneAsync(model);
return(model);
}
/// <summary>
/// Activate UserSubscription
/// </summary>
/// <param name="userSubscriptionID"></param>
/// <returns></returns>
public async Task ActivateUserSubscription(UserSubscriptionModel model)
{
var status = await this.GetStatus("ACT"); //Deactivated status
model.StatusID = status.ID;
await this.UpdateUserSubscription(model);
}
public void GetChannelUserSubscription()
{
TestWrapper(async(TwitchConnection connection) =>
{
ChannelModel channel = await ChannelsServiceUnitTests.GetCurrentChannel(connection);
UserModel user = await connection.V5API.Users.GetCurrentUser();
UserSubscriptionModel result = await connection.V5API.Channels.GetChannelUserSubscription(channel, user);
Assert.IsNotNull(result);
});
}
public async Task <ActionResult> RemoveUserSubscription(UserSubscriptionModel subscription)
{
if (subscription.Id <= 0 || string.IsNullOrWhiteSpace(subscription.UserId))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
using (var db = ApplicationDbContext.Create())
{
var subscriptions = db.UserSubscriptions.Where(us => us.UserId == subscription.UserId && us.SubscriptionId == subscription.Id);
db.UserSubscriptions.RemoveRange(subscriptions);
await db.SaveChangesAsync();
}
return(RedirectToAction("Subscription", "Account", new { subscription.UserId }));
}
public void CheckUserSubscription()
{
TestWrapper(async(TwitchConnection connection) =>
{
UserModel user = await UsersServiceUnitTests.GetCurrentUser(connection);
ChannelModel channel = await connection.V5API.Channels.GetCurrentChannel();
Assert.IsNotNull(channel);
Assert.IsNotNull(channel.id);
UserSubscriptionModel subscription = await connection.V5API.Users.CheckUserSubscription(user, channel);
Assert.IsNotNull(subscription);
});
}
/// <summary>
/// Updates a record
/// </summary>
/// <param name="model">Record model</param>
/// <returns>Record model</returns>
public async Task <UserSubscriptionModel> Update(UserSubscriptionModel model)
{
var currentRecord = await _DbService.GetSingle(model.Id);
if (currentRecord.CreationDate != model.CreationDate)
{
model.CreationDate = currentRecord.CreationDate;
}
if (model.Enabled && model.DeletionDate.HasValue)
{
model.DeletionDate = null;
}
if (!model.Enabled && !model.DeletionDate.HasValue)
{
model.DeletionDate = DateTime.Now;
}
return(await _DbService.Update(model));
}
public async Task <IActionResult> Update([FromBody] UserSubscriptionModel record)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var updatedRecord = await _AppService.Update(record);
return(Accepted($"api/[controller]/{ record.Id }", updatedRecord));
}
catch (ApplicationException ex)
{
return(new BadRequestObjectResult(ex));
}
catch (Exception ex)
{
return(new BadRequestObjectResult(ex));
}
}
/// <summary>
/// Creates a new subscription
/// </summary>
/// <param name="model">Suscription data</param>
/// <returns>Updated record</returns>
public async Task <UserSubscriptionModel> Create(UserSubscriptionModel model)
{
model.Id = Guid.NewGuid();
model.CreationDate = DateTime.Now;
var user = await this._UserAppService.GetUser(model.UserId);
if (user == null)
{
throw new ApplicationException("User doesn't exist");
}
model.UserCode = user.Code;
model.UserName = user.Name;
if (!model.Enabled && !model.DeletionDate.HasValue)
{
model.DeletionDate = model.CreationDate;
}
if (model.Enabled && model.DeletionDate.HasValue)
{
model.DeletionDate = null;
}
return(await _DbService.Create(model));
}
/// <summary>
/// Update existing UserSubscription
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task UpdateUserSubscription(UserSubscriptionModel model)
{
await this.UpdateEntity <UserSubscriptionEntity, UserSubscriptionModel>(model);
}
/// <summary>
/// Add a new UserSubscription
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task AddUserSubscription(UserSubscriptionModel model)
{
await this.AddEntity <UserSubscriptionEntity, UserSubscriptionModel>(model);
}
/// <summary>
/// Update existing UserSubscription
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task UpdateUserSubscription(UserSubscriptionModel model)
{
await _subscriptionRepository.UpdateUserSubscription(model);
}
/// <summary>
/// Add a new UserSubscription
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task AddUserSubscription(UserSubscriptionModel model)
{
await _subscriptionRepository.AddUserSubscription(model);
}
public async Task <APIResponseModel <NTModel> > ActivateUserSubscription([FromBody] UserSubscriptionModel model)
{
return(await APIHelper.SaveAsync(m => _domain.ActivateUserSubscription(model), SubscriptionMessages.UserSubscriptionActivatedSuccess));
}
