public ActionResult SlackCallback(string code)
{
var siteSettings = _settingsService.GetSiteSettings();
var slackService = new SlackService(siteSettings.SlackSettings);
var oauthToken = slackService.ExchangeCodeForToken(code);
var slackExists = _linkedAccountRepository.GetBy(l => l.AccountType == LinkedAccountType.Slack && l.UserId == WebUser.Id);
if (slackExists != null)
{
slackExists.AccessToken = oauthToken.access_token;
slackExists.Scope = oauthToken.scope;
_linkedAccountRepository.Update(slackExists);
_unitOfWork.Commit();
}
else
{
var linkedAccount = new LinkedAccount
{
AccountType = LinkedAccountType.Slack,
UserId = WebUser.Id,
AccessToken = oauthToken.access_token,
Scope = oauthToken.scope
};
_linkedAccountRepository.Create(linkedAccount);
_unitOfWork.Commit();
}
return(RedirectToAction("Index"));
}
protected override void ProcessHTML()
{
if (HtmlDoc != null && HtmlDoc.HasData)
{
string firstItem = string.Empty;
List <LinkedAccount> items = new List <LinkedAccount>();
List <ParseDataItem> components = null;
IEnumerable <ParseDataItem> htmlItems = HtmlDoc.Items.Where(x => !x.Header.ToUpper().Contains("DEFINITION"));
IEnumerable <ParseDataItem> toSearch = htmlItems.Count() > 1 ? htmlItems : htmlItems.ElementAt(0).Children;
//IEnumerable<ParseDataItem> toSearch = HtmlDoc.Items.Count() > 1 ? HtmlDoc.Items : HtmlDoc.Items.ElementAt(0).Children;
if (toSearch != null && toSearch.Any())
{
if (toSearch != null && toSearch.Any())
{
foreach (ParseDataItem item in toSearch)
{
if (string.IsNullOrEmpty(firstItem))
{
firstItem = item.Header;
}
if (item.Header.Equals(firstItem) && components != null && components.Any())
{
LinkedAccount newItem = new LinkedAccount(Logger, DisplaySectionName, components);
if (newItem.HasData)
{
items.Add(newItem);
}
components = null;
}
if (components == null)
{
components = new List <ParseDataItem>();
}
components.Add(item);
}
if (components != null && components.Any())
{
LinkedAccount newItem = new LinkedAccount(Logger, DisplaySectionName, components);
if (newItem.HasData)
{
items.Add(newItem);
}
}
}
if (items.Count == 0)
{
throw new SectionEmptyException(DisplaySectionName);
}
Items = items;
}
}
if (!HasData)
{
throw new SectionEmptyException(DisplaySectionName);
}
}
public ActionResult LinkedInCallback(string code, string state)
{
var linkedInService = new LinkedInService("81ed9a1o1frnfw", "1LhWRlz3ZCWxSjyF");
var urlHelper = new UrlHelper(ControllerContext.RequestContext);
var callbackUrl = urlHelper.Action("LinkedInCallback", "Profile", null, "http");
state = Session["linkedin_state"].ToString();
var oauthToken = linkedInService.ExchangeCodeForToken(code, state, callbackUrl);
var linkedInExists = _linkedAccountRepository.GetBy(l => l.AccountType == LinkedAccountType.LinkedIn && l.UserId == WebUser.Id);
if (linkedInExists != null)
{
linkedInExists.AccessToken = oauthToken.access_token;
linkedInExists.Scope = oauthToken.scope;
_linkedAccountRepository.Update(linkedInExists);
_unitOfWork.Commit();
}
else
{
var linkedAccount = new LinkedAccount
{
AccountType = LinkedAccountType.LinkedIn,
UserId = WebUser.Id,
AccessToken = oauthToken.access_token,
Scope = oauthToken.scope
};
_linkedAccountRepository.Create(linkedAccount);
_unitOfWork.Commit();
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "disconnect")]
HttpRequest request,
[Table("LinkedAccounts")] CloudTable table,
ILogger logger,
CancellationToken cancellationToken)
{
(ClaimsPrincipal user, SecurityToken _) = await _auth0Authenticator.AuthenticateAsync(request, logger, cancellationToken);
string userId = _auth0Authenticator.GetUserId(user);
logger.LogInformation($"User authenticated, user id='{userId}'");
try
{
LinkedAccount linkedAccount = await _linkedAccountService.GetLinkedAccountAsync(userId, table, logger);
// De-authorize Strava account
await DeauthorizeAsync(linkedAccount, logger, cancellationToken);
// Delete linked account from table storage
TableOperation operation = TableOperation.Delete(linkedAccount);
await table.ExecuteAsync(operation);
// todo: delete workout files from blob storage
return(new OkResult());
}
catch (Exception ex)
{
logger.LogError(ex, "Error occurred while trying to unlink Strava account");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public static void Evaluate(LinkedAccount account)
{
if (account.Directory.Account.Mail != account.Directory.Account.PrincipalName)
{
account.Actions.Add(new PrincipalNameMustEqualMail());
account.Directory.FlagWarning();
account.OK = false;
}
}
protected override void RemoveLinkedAccount(LinkedAccount item)
{
var removed =
this.LinkedAccountsCollection.SingleOrDefault(
x =>
x.ProviderAccountID == item.ProviderAccountID && x.ProviderName == item.ProviderName
&& x.LastLogin == item.LastLogin);
this.LinkedAccountsCollection.Remove(removed);
}
protected override void AddLinkedAccount(LinkedAccount item)
{
var linkedAccount = new NhLinkedAccount();
linkedAccount.GetType().GetProperty("LastLogin").SetValue(linkedAccount, item.LastLogin);
linkedAccount.GetType().GetProperty("ProviderAccountID").SetValue(linkedAccount, item.ProviderAccountID);
linkedAccount.GetType().GetProperty("ProviderName").SetValue(linkedAccount, item.ProviderName);
linkedAccount.GetType().GetProperty("Account").SetValue(linkedAccount, this);
this.LinkedAccountsCollection.Add(linkedAccount);
}
public static void Evaluate(LinkedAccount account)
{
if (!account.Smartschool.Account.BirthPlace.Equals(account.Wisa.Account.PlaceOfBirth, StringComparison.CurrentCulture))
{
account.Smartschool.FlagWarning();
account.Actions.Add(new ModifySmartschoolBirthPlace());
account.OK = false;
}
}
protected override void AddLinkedAccount(LinkedAccount item)
{
var linkedAccount = new NhLinkedAccount();
linkedAccount.GetType().GetProperty("LastLogin").SetValue(linkedAccount, item.LastLogin);
linkedAccount.GetType().GetProperty("ProviderAccountID").SetValue(linkedAccount, item.ProviderAccountID);
linkedAccount.GetType().GetProperty("ProviderName").SetValue(linkedAccount, item.ProviderName);
linkedAccount.GetType().GetProperty("Account").SetValue(linkedAccount, this);
this.LinkedAccountsCollection.Add(linkedAccount);
}
protected override void RemoveLinkedAccount(LinkedAccount item)
{
var removed =
this.LinkedAccountsCollection.SingleOrDefault(
x =>
x.ProviderAccountID == item.ProviderAccountID && x.ProviderName == item.ProviderName &&
x.LastLogin == item.LastLogin);
this.LinkedAccountsCollection.Remove(removed);
}
public async override Task Apply(LinkedAccount account, DateTime deletionDate)
{
bool connected = await State.App.Instance.AD.Connect().ConfigureAwait(false);
if (!connected)
{
return;
}
account.Directory.Account.PrincipalName = account.Directory.Account.Mail;
}
public ActionResult DeleteConfirmed(int id)
{
int loggedUser = (int)Session["id"];
id = db.LinkedAccounts.Where(x => ((x.Account1ID == id && x.Account2ID == loggedUser) ||
(x.Account1ID == loggedUser && x.Account2ID == id))).Select(x => x.ID).First();
LinkedAccount linkedAccount = db.LinkedAccounts.Find(id);
db.LinkedAccounts.Remove(linkedAccount);
db.SaveChanges();
return(RedirectToAction("Details2", "Users", new { id = (int)Session["id"] }));
}
private async Task <string> GetValidStravaAccessTokenAsync(LinkedAccount linkedAccount, CloudTable table, ILogger logger, CancellationToken cancellationToken)
{
if (linkedAccount.ExpiresAt > DateTime.Now)
{
return(linkedAccount.AccessToken);
}
try
{
logger.LogInformation($"Access token expired at '{linkedAccount.ExpiresAt}', trying to refresh...");
RefreshTokenModel refreshTokenModel = new RefreshTokenModel()
{
ClientId = _configuration["Strava:ClientId"],
ClientSecret = _configuration["Strava:ClientSecret"],
RefreshToken = linkedAccount.RefreshToken
};
var json = JsonConvert.SerializeObject(refreshTokenModel);
HttpResponseMessage response = await _httpClient.PostAsync(new Uri("https://www.strava.com/api/v3/oauth/token"), new StringContent(json, Encoding.UTF8, "application/json"), cancellationToken);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
logger.LogInformation($"Received token response from Strava: '{responseBody}'");
AccessTokenModel accessTokenModel = JsonConvert.DeserializeObject <AccessTokenModel>(responseBody);
logger.LogInformation($"Parsed Access token: '{accessTokenModel.AccessToken}', expires at '{accessTokenModel.ExpiresAt}'");
// Update tokens in the table storage
logger.LogInformation($"Saving access token for user: '******' '{linkedAccount.IdpUserName}'. Strava user:'******' {linkedAccount.FirstName} {linkedAccount.LastName}");
linkedAccount.TokenType = accessTokenModel.TokenType;
linkedAccount.AccessToken = accessTokenModel.AccessToken;
linkedAccount.ExpiresAt = accessTokenModel.ExpiresAt;
linkedAccount.RefreshToken = accessTokenModel.RefreshToken;
TableOperation operation = TableOperation.Merge(linkedAccount);
await table.ExecuteAsync(operation);
return(accessTokenModel.AccessToken);
}
catch (Exception ex)
{
logger.LogError(ex, "Error occurred while requesting athlete info from Strava");
return(null);
}
}
private async Task DeauthorizeAsync(LinkedAccount linkedAccount, ILogger logger, CancellationToken cancellationToken)
{
logger.LogInformation($"Calling deauthorize endpoint for user: '******' '{linkedAccount.IdpUserName}'. Strava user:'******' {linkedAccount.FirstName} {linkedAccount.LastName}");
var request = new HttpRequestMessage(HttpMethod.Post, new Uri("https://www.strava.com/oauth/deauthorize"));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", linkedAccount.AccessToken);
HttpResponseMessage response = await _httpClient.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
logger.LogInformation($"Received token response from Strava: '{responseBody}'");
}
public async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "connect")]
[FromBody] Shared.Models.ConnectStravaApp connectStravaApp,
HttpRequest request,
[Table("LinkedAccounts")] CloudTable table,
ILogger logger,
CancellationToken cancellationToken)
{
(ClaimsPrincipal user, SecurityToken _) = await _auth0Authenticator.AuthenticateAsync(request, logger, cancellationToken);
string userId = _auth0Authenticator.GetUserId(user);
logger.LogInformation($"User authenticated, user id='{userId}'");
// Hit the auth0 user_info API and see what we get back about this user
var authorizationHeader = AuthenticationHeaderValue.Parse(request.Headers["Authorization"]);
Auth0UserInfo userInfo = await GetAuth0UserinfoAsync(authorizationHeader, logger, cancellationToken);
logger.LogInformation($"Got user info from auth0: '{userInfo}'");
AccessTokenModel stravaAccessToken = await PerformCodeExchangeAsync(connectStravaApp.AuthorizationCode, userInfo, logger, cancellationToken);
// Save token in the table storage
LinkedAccount linkedAccount = new LinkedAccount()
{
IdpUserId = userInfo.UserId,
IdpUserName = userInfo.Name,
StravaAccountId = stravaAccessToken.Athlete.Id,
FirstName = stravaAccessToken.Athlete.FirstName,
LastName = stravaAccessToken.Athlete.LastName,
Profile = stravaAccessToken.Athlete.Profile,
TokenType = stravaAccessToken.TokenType,
AccessToken = stravaAccessToken.AccessToken,
ExpiresAt = stravaAccessToken.ExpiresAt,
RefreshToken = stravaAccessToken.RefreshToken,
};
logger.LogInformation($"Saving access token for user: '******' '{linkedAccount.IdpUserName}'. Strava user:'******' {linkedAccount.FirstName} {linkedAccount.LastName}");
linkedAccount.PartitionKey = Constants.LinkedAccountPartitionKey;
linkedAccount.RowKey = linkedAccount.IdpUserId;
linkedAccount.ETag = "*";
TableOperation operation = TableOperation.InsertOrMerge(linkedAccount);
await table.ExecuteAsync(operation);
return(new OkResult());
}
public override FlowDocument GetDetails(LinkedAccount account)
{
var result = new FlowTableCreator(true);
result.SetHeaders(new string[] { "Active Directory", "Smartschool" });
result.AddRow(new List <string>()
{
"Email", account.Directory.Account.PrincipalName, account.Smartschool.Account.Mail
});
FlowDocument document = new FlowDocument();
document.Blocks.Add(result.Create());
return(document);
}
public async Task <LinkedAccount> GetLinkedAccountAsync(string userId, CloudTable table, ILogger logger)
{
try
{
TableOperation retrieveOperation = TableOperation.Retrieve <LinkedAccount>(Constants.LinkedAccountPartitionKey, userId);
TableResult result = await table.ExecuteAsync(retrieveOperation);
LinkedAccount linkedAccount = result.Result as LinkedAccount;
return(linkedAccount);
}
catch (StorageException ex)
{
logger.LogError(ex, "Cannot read linked account from the table storage");
return(null);
}
}
// GET: LinkedAccounts/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
int loggedUser = (int)Session["id"];
id = db.LinkedAccounts.Where(x => ((x.Account1ID == id && x.Account2ID == loggedUser) ||
(x.Account1ID == loggedUser && x.Account2ID == id))).Select(x => x.ID).First();
LinkedAccount linkedAccount = db.LinkedAccounts.Find(id);
if (linkedAccount == null)
{
return(HttpNotFound());
}
return(View(linkedAccount));
}
public async Task LinkAccount(string linkedService, string link)
{
if (supportedLinks.Any(x => x.Equals(linkedService, StringComparison.OrdinalIgnoreCase)))
{
LinkedAccount acc = new LinkedAccount
{
User = await _database.UserData.FirstOrDefaultAsync(usr => usr.UserId == Context.User.Id),
LinkedServiceLink = link,
Type = linkedService
};
}
else
{
await ReplyAsync("This service is not supported for linking");
return;
}
}
public ActionResult LinkAccount(User model)
{
/*
* This will check if the username is in the database while also retrieving the password asociated with the user.
* If the user isn't in the database, then the query returns null which is handled by the ??. If a result is null
* The the var password is assigned whatever is put on the right side of ??
*/
string password = db.Users.Where(x => x.Username == model.Username.ToString()).Select(x => x.Password).FirstOrDefault() ?? "NoUser";
if (password != model.Password.ToString() || password == "NoUser")
{
ModelState.AddModelError(string.Empty, "Incorrect user name or password");
return(View(model));
}
else
{
int userId = (int)(from x in db.Users where x.Username == model.Username.ToString() select x.ID).SingleOrDefault();
User user = db.Users.Find(userId);
//Check if trying to link to yourself
int loggedInId = (int)Session["id"];
if (user.ID == loggedInId)
{
ModelState.AddModelError(string.Empty, "Cannot link to yourself");
return(View(model));
}
//Check if this other account is already linked to be sure
if (db.LinkedAccounts.Where(x => x.Account1ID == user.ID || x.Account2ID == user.ID).Count() == 0)
{
LinkedAccount newLink = new LinkedAccount();
newLink.Account1ID = (int)Session["id"];
newLink.Account2ID = userId;
db.LinkedAccounts.Add(newLink);
db.SaveChanges();
}
else
{
ModelState.AddModelError(string.Empty, "That Account is already linked");
return(View(model));
}
return(RedirectToAction("Details2", "Users", new { id = (int)Session["id"] }));
}
}
public override FlowDocument GetDetails(LinkedAccount account)
{
var result = new FlowTableCreator(false);
result.SetHeaders(new string[] { "Veld", "Waarde" });
result.AddRow(new List <string>()
{
"Mail", account.Directory.Account.Mail
});
result.AddRow(new List <string>()
{
"UserPrincipalName", account.Directory.Account.PrincipalName
});
FlowDocument document = new FlowDocument();
document.Blocks.Add(result.Create());
return(document);
}
private async Task <AthleteModel> GetAthleteAsync(string token, LinkedAccount linkedAccount, CloudTable table, ILogger logger, CancellationToken cancellationToken)
{
try
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("https://www.strava.com/api/v3/athlete"));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
HttpResponseMessage response = await _httpClient.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
logger.LogInformation($"Received response from Strava: '{responseBody}'");
AthleteModel athleteModel = JsonConvert.DeserializeObject <AthleteModel>(responseBody);
// Update linked account in the table storage if the user profile changed
if (linkedAccount.StravaAccountId != athleteModel.Id ||
linkedAccount.FirstName != athleteModel.FirstName ||
linkedAccount.LastName != athleteModel.LastName)
{
logger.LogInformation($"Updating Strava account for user: '******' '{linkedAccount.IdpUserName}'. Strava user:'******' {linkedAccount.FirstName} {linkedAccount.LastName}");
linkedAccount.StravaAccountId = athleteModel.Id;
linkedAccount.FirstName = athleteModel.FirstName;
linkedAccount.LastName = athleteModel.LastName;
TableOperation operation = TableOperation.Merge(linkedAccount);
await table.ExecuteAsync(operation);
}
return(athleteModel);
}
catch (Exception ex)
{
logger.LogError(ex, "Error occurred while requesting athlete info from Strava");
return(null);
}
}
protected override OpResult _Store(LinkedAccount _obj)
{
if (_obj == null)
{
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.ObjectIsNull, _obj, "LinkedAccount object cannot be created as it is null"));
}
if (Exists(_obj))
{
ExecuteNonQuery(GetQuery_UpdateQuery(_obj));
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Updated, _obj));
}
ExecuteNonQuery(GetQuery_InsertQuery(_obj));
if (_obj.LinkedAccountID == null)
{
_obj.LinkedAccountID = DbMgr.GetLastInsertID();
}
_obj.FromDb = true;
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Created, _obj));
}
private async Task <AthleteStatsModel> GetAthleteStatsAsync(string token, LinkedAccount linkedAccount, ILogger logger, CancellationToken cancellationToken)
{
try
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("https://" + $"www.strava.com/api/v3/athletes/{linkedAccount.StravaAccountId}/stats"));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
HttpResponseMessage response = await _httpClient.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
logger.LogInformation($"Received response from Strava: '{responseBody}'");
AthleteStatsModel statsModel = JsonConvert.DeserializeObject <AthleteStatsModel>(responseBody);
return(statsModel);
}
catch (Exception ex)
{
logger.LogError(ex, "Error occurred while requesting athlete info from Strava");
return(null);
}
}
protected internal override void RemoveLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Remove((TLinkedAccount)item);
}
protected internal override void AddLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Add(item);
}
protected internal override void AddLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Add(new TLinkedAccount {
ParentKey = this.Key, ProviderName = item.ProviderName, ProviderAccountID = item.ProviderAccountID, LastLogin = item.LastLogin
});
}
public async override Task Apply(LinkedAccount linkedAccount, DateTime deletionDate)
{
linkedAccount.Smartschool.Account.BirthPlace = linkedAccount.Wisa.Account.PlaceOfBirth;
await AccountApi.Smartschool.AccountManager.Save(linkedAccount.Smartschool.Account, "").ConfigureAwait(false);
}
protected internal override void AddLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Add(new RelationalLinkedAccount { UserAccountID = this.ID, ProviderName = item.ProviderName, ProviderAccountID = item.ProviderAccountID, LastLogin = item.LastLogin });
}
// GET: Users/Details/5
public ActionResult Details2(int?id, string sortOrder, string currentFilter, int?page, string postAndOrUsername)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserAndPosts user = new UserAndPosts();
user.user = db.Users.Find(id);
user.posts = (from x in db.UserPosts where x.User_ID == id select x).ToList();
/*
* There are several situations when it comes to being able to follow
* and see if you are already following. We also have to consider whether
* a user is viewing their own page in which case the option to follow
* or unfollow shouldn't appear as a user can't follow themseves
*/
//No one is logged in or user is viewing themselves
if (Session["username"] == null ||
Session["username"].ToString() == user.user.Username)
{
user.following = "invalid";
if (Session["username"] == null || Session["username"].ToString() == user.user.Username)
{
if (db.LinkedAccounts.Where(x => x.Account1ID == id || x.Account2ID == id).Count() > 0)
{
LinkedAccount link = db.LinkedAccounts.Where(x => x.Account1ID == id || x.Account2ID == id).Single();
if (link.Account1ID == id)
{
user.otherAccount = db.Users.Find(link.Account2ID);
}
else
{
user.otherAccount = db.Users.Find(link.Account1ID);
}
}
}
}
//User is viewing another profile and is logged in
else
{
int sessionID = (int)Session["id"];
//int followingint = db.FollowLists.Where(x => (x.FolloweeID == id) && (x.FollowerID == sessionID)).Select(x => x.ID);
if ((db.FollowLists.Where(x => (x.FolloweeID == id) && (x.FollowerID == sessionID)).Select(x => x.ID)).FirstOrDefault() != 0)
{
//There is a following between current user and profile of the user they are on,
//meaning they should get the option to unfollow
user.following = "Unfollow";
}
else
{
//They are not following the user profile they are currently on.
//meaning they should get the option to follow
user.following = "Follow";
}
user.otherAccount = null;
}
//Sorting the Table
ViewBag.CurrentSort = sortOrder;
List <string> list = new List <string>();
list.Add("Post Title");
list.Add("Username");
list.Add("Both");
ViewBag.PostAndOrUsername = new SelectList(list);
ViewBag.SelectedPostAndOrUsername = postAndOrUsername;
ViewBag.DateSortParm = String.IsNullOrEmpty(sortOrder) ? "date_asc" : "";
ViewBag.TitleSortParm = sortOrder == "Title" ? "title_desc" : "Title";
ViewBag.LikesSortParm = sortOrder == "Likes" ? "likes_desc" : "Likes";
ViewBag.DislikesSortParm = sortOrder == "Dislikes" ? "dislikes_desc" : "Dislikes";
ViewBag.UserNameSortParm = sortOrder == "UserName" ? "userName_desc" : "UserName";
page = 1;
switch (sortOrder)
{
case "date_asc":
user.posts = user.posts.OrderBy(p => p.Date_Posted);
break;
case "title_desc":
user.posts = user.posts.OrderByDescending(p => p.Title);
break;
case "Title":
user.posts = user.posts.OrderBy(p => p.Title);
break;
case "likes_desc":
user.posts = user.posts.OrderByDescending(p => p.Likes);
break;
case "Likes":
user.posts = user.posts.OrderBy(p => p.Likes);
break;
case "dislikes_desc":
user.posts = user.posts.OrderByDescending(p => p.Dislikes);
break;
case "Dislikes":
user.posts = user.posts.OrderBy(p => p.Dislikes);
break;
default:
user.posts = user.posts.OrderByDescending(p => p.Date_Posted);
break;
}
//End of sorting the Table
/* USE FOR PAGING THE TABLE
* int pageSize = 3;
* int pageNumber = (page ?? 1);
*/
return(View(user));
}
private DbUpdateStatement GetQuery_UpdateQuery(LinkedAccount _obj)
{
return(DbMgr.CreateUpdateClause("LinkedAccounts", GetFields(_obj), "LinkedAccountID", _obj.LinkedAccountID));
}
protected internal override void RemoveLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Remove((RelationalLinkedAccountInt)item);
}
public async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "userinfo")]
HttpRequest request,
[Table("LinkedAccounts")] CloudTable table,
ILogger logger,
CancellationToken cancellationToken)
{
try
{
// The "user" returned here is an actual ClaimsPrincipal with the claims that were in the access_token.
// The "token" is a SecurityToken that can be used to invoke services on the part of the user. E.g., create a Google Calendar event on the user's calendar.
(ClaimsPrincipal user, SecurityToken token) = await _auth0Authenticator.AuthenticateAsync(request, logger, cancellationToken);
string userId = _auth0Authenticator.GetUserId(user);
logger.LogInformation($"User authenticated, user id='{userId}'");
UserInfoModel userInfo = new UserInfoModel();
LinkedAccount linkedAccount = await _linkedAccountService.GetLinkedAccountAsync(userId, table, logger);
if (linkedAccount != null)
{
// validate that the access token has not expired and renew if needed
string accessToken = await GetValidStravaAccessTokenAsync(linkedAccount, table, logger, cancellationToken);
if (accessToken != null)
{
AthleteModel athlete = await GetAthleteAsync(accessToken, linkedAccount, table, logger, cancellationToken);
if (athlete != null)
{
logger.LogInformation($"Got athlete info from Strava: '{athlete}'");
userInfo.FirstName = athlete.FirstName;
userInfo.LastName = athlete.LastName;
userInfo.Country = athlete.Country;
userInfo.City = athlete.City;
userInfo.PictureUrl = athlete.Profile;
userInfo.IsStravaAccountLinked = true;
}
AthleteStatsModel stats = await GetAthleteStatsAsync(accessToken, linkedAccount, logger, cancellationToken);
if (stats != null)
{
logger.LogInformation($"Got athlete stats from Strava: '{stats}'");
userInfo.Runs = stats.AllRunsTotals.Count;
userInfo.Swims = stats.AllSwimsTotals.Count;
userInfo.Rides = stats.AllRidesTotals.Count;
}
}
}
return(new OkObjectResult(userInfo));
}
catch (AuthException)
{
return(new UnauthorizedResult());
}
}
protected internal override void AddLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Add(new RelationalLinkedAccount {
UserAccountID = this.ID, ProviderName = item.ProviderName, ProviderAccountID = item.ProviderAccountID, LastLogin = item.LastLogin
});
}
protected internal override void RemoveLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Remove(item);
}
protected internal override void AddLinkedAccount(LinkedAccount item)
{
LinkedAccountCollection.Add(item);
}
