public static async Task <bool> DeleteTrackFollow(string userId, string trackId, bool ownerOverride = false) { try { TrackAuth track = await TrackRepository.GetTrack(trackId); if (track.PartitionKey == userId && ownerOverride == false) { return(false); } UserFollowTableEntity userFollow = await TableStorageRepository.GetUserFollow(userId, trackId); TrackFollowTableEntity trackFollow = await TableStorageRepository.GetTrackFollow(trackId, userId); if (userFollow != null) { await TableStorageRepository.DeleteUserFollow(userFollow); } if (trackFollow != null) { await TableStorageRepository.DeleteTrackFollow(trackFollow); } return(true); } catch { return(false); } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "track/{trackId}/follow")] HttpRequest req, string trackId, TraceWriter log) { try { // check postId and trackId provided if (!Tools.IsValidGuid(trackId)) { return(new UnauthorizedResult()); } string authToken = req.Headers["Authorization"]; if (authToken == null) { return(new UnauthorizedResult()); } // validate authKey AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken); if (authClaim == null) { return(new UnauthorizedResult()); } // get the track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null || (track.is_private && track.PartitionKey != authClaim.user_id)) { return(new UnauthorizedResult()); } // trackFollow body string requestBody = new StreamReader(req.Body).ReadToEnd(); TrackFollowDTO dto = JsonConvert.DeserializeObject <TrackFollowDTO>(requestBody); // insert or update the follow TrackFollow trackFollow = new TrackFollow(); trackFollow.feed_follow_type = dto.feed?.ToLower() == "all" || dto.feed?.ToLower() == "none" ? dto.feed.ToLower() : null; trackFollow.notifications_follow_type = dto.notifications?.ToLower() == "all" || dto.notifications?.ToLower() == "none" ? dto.notifications.ToLower() : null; trackFollow.criteria = dto.criteria; trackFollow.user_id = authClaim.user_id; trackFollow.track_id = track.RowKey; FollowRepository.InsertOrReplaceTrackFollow(trackFollow); return(new OkResult()); } catch (Exception e) { log.Error(e.Message); return(new UnauthorizedResult()); } }
private static async void InsertOrReplaceUserFollow(string userId, string trackId) { TrackAuth track = await TrackRepository.GetTrack(trackId); TableStorageRepository.InsertOrReplaceUserFollow(new UserFollowTableEntity(userId, trackId) { description = track.description, has_image = track.has_image, is_private = track.is_private, name = track.name }); }
public static async Task <TrackAuth> CreateTrack(TrackAuth track) { if (track.PartitionKey == null || track.name == null) { return(null); } var extendedUser = await ExtendedUserRepository.GetExtendedUser(track.PartitionKey); // check private maxed out if (track.is_private) { if (extendedUser.Private_Tracks >= extendedUser.Private_Tracks_Max) { return(null); } } // check public maxed out if (!track.is_private) { if (extendedUser.Public_Tracks >= extendedUser.Public_Tracks_Max) { return(null); } } track.RowKey = track.RowKey ?? Guid.NewGuid().ToString(); track.subscribers = 0; track.rate_limit = extendedUser.Rate_Per_Track; track.track_key = AuthRepository.GenerateRandomString(64); track.track_secret = AuthRepository.GenerateSHA256(track.RowKey + track.track_key); // insert into table storage var newTrack = await TableStorageRepository.InsertTrackAuth(track); if (newTrack == null) { return(null); } // insert into Cosmos await(dynamic) CosmosRepository <Track> .CreateItemAsync(new Track(track)); // increment user's track count ExtendedUserRepository.IncrementTrackCount(track.PartitionKey, track.is_private); return(newTrack); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "track/{trackId}/follow")] HttpRequest req, string trackId, TraceWriter log) { try { // check postId and trackId provided if (!Tools.IsValidGuid(trackId)) { return(new UnauthorizedResult()); } string authToken = req.Headers["Authorization"]; if (authToken == null) { return(new UnauthorizedResult()); } // validate authKey AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken); if (authClaim == null) { return(new UnauthorizedResult()); } // get the track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null || track.is_private) { return(new UnauthorizedResult()); } // insert or update the follow var result = await FollowRepository.DeleteTrackFollow(authClaim.user_id, track.RowKey); if (!result) { return(new BadRequestResult()); } return(new OkResult()); } catch (Exception e) { log.Error(e.Message); return(new UnauthorizedResult()); } }
internal static async void UpdateTrack(TrackAuth track) { try { // get the table CloudTable table = tableClient.GetTableReference(TracksTable); await table.CreateIfNotExistsAsync(); TableOperation op = TableOperation.InsertOrReplace(track); await table.ExecuteAsync(op); } catch (StorageException e) { throw; } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "track/{trackId}/post/{postId}")] HttpRequest req, string trackId, string postId, TraceWriter log) { try { KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(req.Headers["X-Track-Key"]); // validate authKey if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret)) { return(new UnauthorizedResult()); } // get track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null || track.track_key != keySecret.Key) { return(new UnauthorizedResult()); } // get post Post post = await PostRepository.GetPost(trackId, postId); if (post == null || track.RowKey != post.PartitionKey) { return(new UnauthorizedResult()); } // delete the post TableStorageRepository.AddMessageToQueue("process-delete-post", $"{trackId}.{postId}"); // return response return(new OkResult()); } catch (Exception e) { log.Info(e.Message); return(new UnauthorizedResult()); } }
/// <summary> /// Insert track into Table Storage. /// </summary> /// <param name="track"></param> /// <returns>Returns the inserted track.</returns> internal static async Task <TrackAuth> InsertTrackAuth(TrackAuth track) { try { // reference track table CloudTable table = tableClient.GetTableReference(TracksTable); await table.CreateIfNotExistsAsync(); // insert the track TableOperation op = TableOperation.Insert(track); var result = await table.ExecuteAsync(op); if (result == null) { return(null); } return(track); } catch { throw; } }
public async Task <IActionResult> OnPostAsync() { var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } if (!ModelState.IsValid) { return(Page()); } var track = new TrackAuth(user.Id, Guid.NewGuid().ToString()) { description = Input.Description, is_private = Input.IsPrivate, name = Input.Name, tags = string.IsNullOrWhiteSpace(Input.Tags) ? null : string.Join(",", Tools.ValidateTags(Input.Tags.Split(',').ToList())) }; // generate small thumb if (Input.UploadTrackImage != null) { using (MemoryStream uploadStream = new MemoryStream()) { await Input.UploadTrackImage.CopyToAsync(uploadStream); byte[] data = uploadStream.ToArray(); using (MemoryStream input = new MemoryStream(data)) { using (MemoryStream output = new MemoryStream()) { Images.CropSquare(150, input, output); await BlobRepository.UploadFileAsync(BlobRepository.TracksContainer, output.ToArray(), track.RowKey + "/thumb"); } } using (MemoryStream input = new MemoryStream(data)) { using (MemoryStream output = new MemoryStream()) { Images.CropSquare(32, input, output); await BlobRepository.UploadFileAsync(BlobRepository.TracksContainer, output.ToArray(), track.RowKey + "/thumb_mini"); } } track.has_image = true; } } // create track TrackAuth createdTrack = await TrackRepository.CreateTrack(track); FollowRepository.InsertOrReplaceTrackFollow(new TrackFollow() { track_id = createdTrack.RowKey, user_id = user.Id, feed_follow_type = "none", notifications_follow_type = "none" }); _logger.LogInformation($"Track with ID '{createdTrack.RowKey}' has been created by '{user.Id}'."); return(RedirectToPage("./Index")); }
public static void UpdateTrack(TrackAuth track) { TableStorageRepository.UpdateTrack(track); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "track/{trackId}/post")] HttpRequest req, string trackId, TraceWriter log) { try { KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(req.Headers["X-Track-Key"]); if (keySecret == null) { return(new UnauthorizedResult()); } // validate authKey if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret)) { return(new UnauthorizedResult()); } // get post from req body string requestBody = new StreamReader(req.Body).ReadToEnd(); PostSubmitDTO post = JsonConvert.DeserializeObject <PostSubmitDTO>(requestBody); // validate post PostValidateDTO validatedPost = PostRepository.ValidatePost(post); if (validatedPost.invalid_reason != null) { return(new BadRequestObjectResult(validatedPost.invalid_reason)); } // get track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null || track.track_key != keySecret.Key) { return(new UnauthorizedResult()); } // check rate limit if (track.rate_limit_exceeded) { return(new ForbidResult()); } // create the post validatedPost.post.track_id = trackId; validatedPost.post.track_name = track.name; Post newPost = await PostRepository.InsertPost(validatedPost.post); // if didn't create return bad response if (newPost == null) { return(new BadRequestResult()); } // convert to post DTO return(new OkObjectResult(new PostQueryDTO() { date_created = newPost.date_created, id = newPost.RowKey, summary = newPost.summary, tags = newPost.tags.Split(',').ToList(), title = newPost.title, track_id = newPost.PartitionKey, track_name = newPost.track_name, type = newPost.type, url = newPost.url })); } catch (Exception e) { log.Info(e.Message); return(new UnauthorizedResult()); } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}/posts")] HttpRequest req, string trackId, TraceWriter log) { try { // check valid trackId provided if (!Tools.IsValidGuid(trackId)) { return(new UnauthorizedResult()); } // get the track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null) { return(new UnauthorizedResult()); } // private track so check keys if (track.is_private) { string trackKeyHeader = req.Headers["X-Track-Key"]; string authToken = req.Headers["Authorization"]; if (authToken != null) { // validate authKey AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken); if (authClaim == null) { return(new UnauthorizedResult()); } // check track userID matches authClaim userId if (track.PartitionKey != authClaim.user_id) { return(new UnauthorizedResult()); } } else if (trackKeyHeader != null) { KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader); // validate authKey if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret)) { return(new UnauthorizedResult()); } // validate track key if (track.track_key != keySecret.Key) { return(new UnauthorizedResult()); } } else { return(new UnauthorizedResult()); } } // get query object from query params PostQuery query = Tools.GetQueryFromQueryParams(trackId, req.Query["tags"], req.Query["continuation"]); PostReturnObject posts = query.tags.Count > 0 ? await PostRepository.QueryPosts(query) : await PostRepository.GetPosts(query); return(new OkObjectResult(posts)); } catch (Exception e) { log.Info(e.Message); return(new BadRequestObjectResult(e.Message)); } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}")] HttpRequest req, string trackId, TraceWriter log) { try { // check postId and trackId provided if (!Tools.IsValidGuid(trackId)) { return(new UnauthorizedResult()); } // get the track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null) { return(new UnauthorizedResult()); } // is private if (track.is_private) { string trackKeyHeader = req.Headers["X-Track-Key"]; string authToken = req.Headers["Authorization"]; if (authToken != null) { // validate authKey AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken); if (authClaim == null) { return(new UnauthorizedResult()); } // check track userID matches authClaim userId if (track.PartitionKey != authClaim.user_id) { return(new UnauthorizedResult()); } } else if (trackKeyHeader != null) { KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader); // validate authKey if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret)) { return(new UnauthorizedResult()); } // validate track key if (track.track_key != keySecret.Key) { return(new UnauthorizedResult()); } } else { return(new UnauthorizedResult()); } } return(new OkObjectResult(new Track(track))); } catch (Exception e) { log.Error(e.Message); return(new UnauthorizedResult()); } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}/post/{postId}")] HttpRequest req, string trackId, string postId, TraceWriter log) { try { // check postId and trackId provided if (!Tools.IsValidGuid(trackId)) { return(new UnauthorizedResult()); } // get the track TrackAuth track = await TrackRepository.GetTrack(trackId); if (track == null) { return(new UnauthorizedResult()); } if (track.is_private) { string trackKeyHeader = req.Headers["X-Track-Key"]; string authToken = req.Headers["Authorization"]; if (authToken != null) { // validate authKey AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken); if (authClaim == null) { return(new UnauthorizedResult()); } // check track userID matches authClaim userId if (track.PartitionKey != authClaim.user_id) { return(new UnauthorizedResult()); } } else if (trackKeyHeader != null) { KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader); // validate authKey if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret)) { return(new UnauthorizedResult()); } // validate track key if (track.track_key != keySecret.Key) { return(new UnauthorizedResult()); } } else { return(new UnauthorizedResult()); } } // get the post Post post = await PostRepository.GetPost(trackId, postId); if (post == null) { return(new UnauthorizedResult()); } // convert to post DTO return(new OkObjectResult(new PostDTO() { body = post.body, date_created = post.date_created, id = post.RowKey, summary = post.summary, tags = post.tags.Split(',').ToList(), title = post.title, track_id = post.PartitionKey, track_name = post.track_name, type = post.type, url = post.url })); } catch (Exception e) { log.Info(e.Message); return(new UnauthorizedResult()); } }