public async Task <ActionResult> Subscriptions(string userId)
{
if (userId == null || userId.Equals(string.Empty))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var model = new UserSubscriptionViewModel();
var db = new ApplicationDbContext();
model.UserSubscriptions = await
(from us in db.UserSubscriptions
join s in db.Subscriptions on us.SubscriptionId equals s.Id
where us.UserId.Equals(userId)
select new UserSubscriptionModel
{
Id = us.SubscriptionId,
StartDate = us.StartDate,
EndDate = us.EndDate,
Description = s.Description,
RegistrationCode = s.RegistrationCode,
Title = s.Title
}).ToListAsync();
var ids = model.UserSubscriptions.Select(us => us.Id);
model.Subscriptions = await db.Subscriptions.Where(
s => !ids.Contains(s.Id)).ToListAsync();
model.DisableDropDown = model.Subscriptions.Count.Equals(0);
model.UserId = userId;
return(View(model));
}
public async Task <ActionResult> Subscriptions(
UserSubscriptionViewModel model)
{
try
{
if (model == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var db = new ApplicationDbContext();
db.UserSubscriptions.Add(new UserSubscription
{
UserId = model.UserId,
SubscriptionId = model.SubscriptionId,
StartDate = DateTime.Now,
EndDate = DateTime.MaxValue
});
await db.SaveChangesAsync();
}
}
catch { }
return(RedirectToAction("Subscriptions", "Account", new { userId = model.UserId }));
}
public ActionResult Add(AddSubscriptionViewModel model)
{
if (ModelState.IsValid)
{
var user = _dbContext.Users.Single(x => x.Email == WebSecurity.CurrentUserName);
try
{
var userSubscription = _feedsService.AddNewFeed(model.FeedUrl.Trim(), user);
var successModel = new UserSubscriptionViewModel
{
Id = userSubscription.Subscription.Id,
SiteUrl = userSubscription.Subscription.SiteUrl,
Title = userSubscription.Subscription.Title,
UnreadItems = userSubscription.Subscription.SubscriptionPosts.Count(y => y.PostsRead == null ||
!y.PostsRead
.Any(z => z.UserSubscription.User.Email == WebSecurity.CurrentUserName &&
z.SubscriptionPost.Id == y.Id))
};
var json = JsonConvert.SerializeObject(successModel);
return(PartialView("_AddSuccess", json));
}
catch (BralekTechnicalException ex)
{
ModelState.AddModelError(String.Empty, ex.Message);
}
}
return(PartialView("_Add", model));
}
public IActionResult SubscriptionList()
{
var viewModel = new UserSubscriptionViewModel();
var userSubscriptionRes = Integration.ApiIntegration.User.
GetSubscriptionList(SessionHelper.Get(HttpContext, SessionKeys.AccessToken));
viewModel.UserSubscriptionListResponse = userSubscriptionRes?.Result;
#region dummyDataForAssesment
if (viewModel.UserSubscriptionListResponse == null &&
!string.IsNullOrEmpty(""))
{
viewModel.UserSubscriptionListResponse = new Integration.UserSubscriptionListResponse
{
Books = new List <Integration.BookModel>
{
new Integration.BookModel {
Id = new Guid().ToString(), Name = "The Country Of White Lilies", Text = "Author By Grigory Spiridonovich Petrov", PurchasePrice = 12
},
new Integration.BookModel {
Id = new Guid().ToString(), Name = "The Sun Also Rises", Text = "Author by Ernest Hemingway", PurchasePrice = 10
},
}
};
}
else
{
return(RedirectToAction("Index", "Home"));
}
#endregion
return(View(viewModel));
}
public static UserSubscriptionViewModel Convert(UserSubscription subscription)
{
UserSubscriptionViewModel model = new UserSubscriptionViewModel();
model.Id = subscription.Id;
model.Frequency = subscription.Frequency;
model.Modified = subscription.Modified;
model.NextDelivery = subscription.NextDelivery;
return(model);
}
public async Task <UserSubscriptionViewModel> GetUserSubscriptionByIdAsync(string id, CancellationToken ct = default)
{
ApplicationUser user = await this._userManager.FindByIdAsync(id);
if (user != null)
{
UserSubscription userSubscription = await this._userSubscriptionRepository.GetUserSubscriptionByUserId(id);
if (userSubscription != null)
{
UserSubscriptionViewModel userSubscriptionView = UserSubscriptionConverter.Convert(userSubscription);
userSubscriptionView.UserSubscriptionProducts = UserSubscriptionProductConverter.ConvertList(await this._userSubscriptionProductsRepository.GetAllByUserSubscriptionIdAsync(userSubscription.Id, ct));
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Subscriptions(string id)
{
var subscriptions = Db.Subscriptions.OfType <OccurrenceSubscription>().Where(s => s.UserId.Equals(id)).OrderBy(s => s.TimeStamp).ToList();
var model = new UserSubscriptionViewModel();
// Alle Subscriptions
foreach (var subscription in subscriptions)
{
model.Subscriptions.Add(new UserSubscriptionModel
{
Subscription = subscription,
Summary = subscription.Occurrence != null ? ActivityService.GetSummary(subscription.Occurrence.Id) : null,
});
}
// Test: Abfrage der WPMs
var semester = SemesterService.GetSemester(DateTime.Today);
var wpmList = Db.Activities.OfType <Course>().Where(a =>
a.Occurrence.Subscriptions.Any(u => u.UserId.Equals(id)) &&
a.SemesterGroups.Any(g => g.Semester.Id == semester.Id) &&
a.SemesterGroups.Any(g => g.CapacityGroup.CurriculumGroup.Name.Equals("WPM"))).ToList();
foreach (var wpm in wpmList)
{
// es könnten ja auch mehrere Eintragungen vorliegen
var wpmsubs = wpm.Occurrence.Subscriptions.Where(s => s.UserId.Equals(id));
foreach (var subscription in wpmsubs)
{
model.WPMSubscriptions.Add(new UserSubscriptionModel
{
Subscription = subscription,
Summary = subscription.Occurrence != null ? ActivityService.GetSummary(subscription.Occurrence.Id) : null,
});
}
}
model.Semester = Db.Subscriptions.OfType <SemesterSubscription>().Where(s => s.UserId.Equals(id)).OrderBy(s => s.TimeStamp).ToList();
return(View(model));
}
public ActionResult AllSubcriptions()
{
UserSubscriptionViewModel _objuserSubscriptionViewModel = new UserSubscriptionViewModel();
_objuserSubscriptionViewModel.UserSubscriptionResults = Mapper.Map <IEnumerable <UserSubscription> >(_userService.GetAllUserSubscriptionByOrganizationID(0, HCRGCLIENT.ClientID));
foreach (var objorganizationResult in _objuserSubscriptionViewModel.UserSubscriptionResults)
{
objorganizationResult.EncryptedUserSubscriptionID = EncryptString(objorganizationResult.UserSubscriptionID.ToString());
}
if (HCRGCLIENT.ClientTypeID == 1)
{
_objuserSubscriptionViewModel.IsHCRGAdmin = true;
}
else
{
_objuserSubscriptionViewModel.IsHCRGAdmin = false;
}
return(View(_objuserSubscriptionViewModel));
}
public async Task <ActionResult> Subscriptions(string userId)
{
if (userId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var model = new UserSubscriptionViewModel();
var db = new ApplicationDbContext();
model.UserSubscriptions = await(
from us in db.UserSubscriptions
join s in db.Subscriptions on us.SubscriptionId equals s.Id
where us.UserId.Equals(userId)
select new UserSubscriptionModel
{
Id = us.SubscriptionId,
StartDate = us.StartDate,
EndDate = us.EndDate,
Description = s.Description,
RegistrationCode = s.RegistrationCode,
Title = s.Title
}).ToListAsync();
var ids = model.UserSubscriptions.Select(us => us.Id);
// subscriptionModel
// filtering out the subscriptions that we don't already have
model.Subscriptions = await db.Subscriptions.Where(s => !ids.Contains(s.Id)).ToListAsync();
model.DisableDropDown = model.Subscriptions.Count.Equals(0);
model.UserId = userId;
// get user from db and add user name
ApplicationUser user = await UserManager.FindByIdAsync(userId);
model.UserName = user.Email;
return(View(model));
}
[Authorize(Roles = "Admin")] //Only admins can access this action.
public async Task <ActionResult> Subscriptions(string userID)
{
if (userID == null || userID.Equals(string.Empty))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var model = new UserSubscriptionViewModel();
var db = new ApplicationDbContext();
//Get list of a user's subscriptions to display at bottom section of Subscriptions view
model.UserSubscriptions = await
(from us in db.User_Subscriptions
join s in db.Subscriptions on us.SubscriptionID equals s.ID
where us.UserID.Equals(userID)
select new UserSubscriptionModel
{
ID = us.SubscriptionID,
StartDate = us.StartDate,
EndDate = us.EndDate,
FirstName = us.FirstName,
LastName = us.LastName,
Description = s.Description,
RegistrationCode = s.RegistrationCode,
Title = s.Title
}).ToListAsync();
//Select subscriptions that this user has????
var ids = model.UserSubscriptions.Select(us => us.ID);
// Fetch all IDs from the subscriptions table where the ID of the subscription is not in this list of user descriptionss (????)
//Fetch subscriptions where that ID isn't present ("available" subscriptions)
model.Subscriptions = await db.Subscriptions.Where(s => !ids.Contains(s.ID)).ToListAsync();
model.disableDropdown = model.Subscriptions.Count.Equals(0);
model.UserID = userID;
return(View(model));
}
public async Task <ActionResult> Subscriptions(string userid)
{
if (userid == null || userid.Equals(string.Empty))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
// Instansiate model and db
var model = new UserSubscriptionViewModel();
var db = new ApplicationDbContext();
// Get UserSub List
model.UserSubscription = await
(from us in db.UserSubscriptions
join s in db.Subscriptions on us.SubscriptionId equals s.Id
where us.UserId.Equals(userid)
select new UserSubscriptionModel
{
Id = us.SubscriptionId,
StartDate = us.StartDate,
EndDate = us.EndDate,
Description = s.Description,
RegistrationCode = s.RegistrationCode,
Title = s.Title
}).ToListAsync();
// Select all the Ids in the model.userSub
var ids = model.UserSubscription.Select(us => us.Id);
// Get Subscriptions List ids does not contain subId for dropdown list
model.Subscriptions = await db.Subscriptions.Where(s =>
!ids.Contains(s.Id)).ToListAsync();
// Disable dropdownlist if model subs are empty
model.DisableDropDownList = model.Subscriptions.Count.Equals(0);
model.UserId = userid;
return(View(model));
}
// GET: Account/Subscription
public async Task <ActionResult> Subscription(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var model = new UserSubscriptionViewModel();
using (var db = ApplicationDbContext.Create())
{
model.UserSubscriptions = await db.UserSubscriptions
.Join(db.Subscriptions,
userSubscription => userSubscription.SubscriptionId,
subscription => subscription.Id,
(userSubscription, subscription) => new { userSubscription, subscription })
.Where(join => join.userSubscription.UserId == userId)
.Select(join => new UserSubscriptionModel
{
Id = join.subscription.Id,
StartDate = join.userSubscription.StartDate,
EndDate = join.userSubscription.EndDate,
Description = join.subscription.Description,
RegistrationCode = join.subscription.RegistrationCode,
Title = join.subscription.Title
})
.ToListAsync();
var ids = model.UserSubscriptions.Select(s => s.Id);
model.AttachableSubscriptions = await db.Subscriptions.Where(s => !ids.Contains(s.Id)).ToListAsync();
}
model.DisableDropDown = !model.AttachableSubscriptions.Any();
model.UserId = userId;
return(View(model));
}
public async Task <ActionResult> Subscriptions(string userId)
{
if (userId.IsNullOrEmpty())
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var model = new UserSubscriptionViewModel();
var db = new ApplicationDbContext();
//Getting user subscriptions assigned to the current userId
model.UserSubscriptions = await db.UserSubscriptions
.Where(us => us.UserId.Equals(userId))
.Join(db.Subscriptions,
us => us.SubscriptionId,
sub => sub.Id,
(us, sub) => new UserSubscriptionModel
{
Id = us.SubscriptionId,
StartDate = us.StartDate,
EndDate = us.EndDate,
Description = sub.Description,
RegistrationCode = sub.RegistrationCode,
Title = sub.Title
}).ToListAsync();
var ids = model.UserSubscriptions.Select(us => us.Id);
model.Subscriptions = await db.Subscriptions
.Where(s => !ids.Contains(s.Id))
.ToListAsync();
model.DisableDropDown = model.Subscriptions.Count.Equals(0);
model.UserId = userId;
return(View(model));
}
