Beispiel #1
0
        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 <string> GenerateRefreshToken(string userId)
        {
            // create
            var token = GenerateSHA256(userId + Tools.ConvertToEpoch(DateTime.UtcNow).ToString());

            // insert to db
            await TableStorageRepository.InsertRefreshToken(new RefreshToken(userId, token));

            return(EncodeKeyAndSecret(userId, token));
        }
Beispiel #3
0
        public static async Task <TrackAuth> GetTrack(string trackId)
        {
            var track = await TableStorageRepository.GetTrack(trackId);

            if (track == null)
            {
                return(null);
            }

            return(track);
        }
Beispiel #4
0
        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 <PostReturnObject> GetPosts(PostQuery query)
        {
            List <PostQueryDTO> data = await TableStorageRepository.GetPosts(query);

            string continuation = data.Count > 1 ? data[data.Count - 1].date_created.ToString() : null;

            return(new PostReturnObject()
            {
                continuation = continuation,
                count = data.Count,
                data = data
            });
        }
Beispiel #6
0
        public static async Task <List <TrackFollow> > GetTrackFollows(string trackId, Enums.FollowMode followMode = Enums.FollowMode.Feed)
        {
            List <TrackFollowTableEntity> results = await TableStorageRepository.GetTrackFollows(trackId, followMode);

            List <TrackFollow> trackFollows = new List <TrackFollow>();

            foreach (TrackFollowTableEntity result in results)
            {
                trackFollows.Add(TableEntityToTrackFollow(result));
            }

            return(trackFollows);
        }
        // table storage stuff
        public static async Task <Post> InsertPost(PostSubmitDTO postDTO)
        {
            long   now       = Tools.ConvertToEpoch(DateTime.UtcNow);
            long   countdown = Tools.GetCountdownFromDateTime(now);
            string id        = countdown.ToString() + Guid.NewGuid().ToString();

            Post post = new Post(id, postDTO.track_id)
            {
                body         = postDTO.body,
                url          = postDTO.url,
                summary      = postDTO.summary,
                date_created = now,
                track_name   = postDTO.track_name,
                tags         = string.Join(",", postDTO.tags),
                title        = postDTO.title,
                type         = postDTO.type,
                has_image    = false
            };


            // TODO: process image
            if (Tools.ValidateUri(postDTO.image_url))
            {
                post.has_image = await ProcessImage(id, postDTO.image_url);
            }

            var result = await TableStorageRepository.InsertPost(post);

            if (result == null)
            {
                return(null);
            }

            // shit hack to remove body for queue processing
            post.body = null;

            // add to queues for further processing
            TableStorageRepository.AddMessageToQueue("process-new-post-increment-track-tags", JsonConvert.SerializeObject(post));
            TableStorageRepository.AddMessageToQueue("process-new-post-add-to-cosmos", JsonConvert.SerializeObject(post));

            // check rate limit
            Random rnd = new Random();

            if (rnd.Next(1, 8) == 3)
            {
                TableStorageRepository.AddMessageToQueue("process-new-post-check-rate-limit", post.PartitionKey);
            }

            return(post);
        }
Beispiel #8
0
        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 <string> GetRefreshTokenUserAndDestroyToken(string encodedToken)
        {
            KeySecret keySecret = DecodeKeyAndSecret(encodedToken);

            var refreshToken = await TableStorageRepository.GetRefreshToken(keySecret.Key, keySecret.Secret);

            if (refreshToken == null)
            {
                return(null);
            }

            TableStorageRepository.DeleteRefreshToken(refreshToken);

            return(keySecret.Key);
        }
Beispiel #10
0
        public static async Task <TrackAuth> GetTrackVerifyOwner(string trackId, string userId)
        {
            var track = await TableStorageRepository.GetTrack(trackId);

            if (track == null)
            {
                return(null);
            }

            if (track.PartitionKey != userId)
            {
                return(null);
            }

            return(track);
        }
Beispiel #11
0
        public static async Task <bool> DeleteTrack(string trackId)
        {
            // decrement the count
            var track = await GetTrack(trackId);

            ExtendedUserRepository.DecrementTrackCount(track.PartitionKey, track.is_private);

            // send messages to queue
            TableStorageRepository.AddMessageToQueue("delete-posts-from-track", trackId);
            TableStorageRepository.AddMessageToQueue("delete-tracktags-from-track", trackId);

            // then delete track cosmos
            CosmosRepository <Track> .DeleteItemAsync(trackId);

            // then delete profile pics
            DeleteImages(trackId);

            // then delete from table storage, and return
            return(await TableStorageRepository.DeleteTrack(trackId));
        }
Beispiel #12
0
        public static async Task <List <TrackDTO> > GetUserFollows(string userId)
        {
            var results = await TableStorageRepository.GetUserFollows(userId);

            List <TrackDTO> tracks = new List <TrackDTO>();

            foreach (var result in results)
            {
                tracks.Add(new TrackDTO()
                {
                    id          = result.RowKey,
                    name        = result.name,
                    description = result.description,
                    has_image   = result.has_image,
                    is_private  = result.is_private
                });
            }

            return(tracks.OrderBy(t => t.name).ToList());
        }
Beispiel #13
0
        public static void InsertOrReplaceTrackFollow(TrackFollow trackFollow)
        {
            // check user and track id
            if (trackFollow?.user_id == null || trackFollow?.track_id == null)
            {
                return;
            }

            // validate criteria
            List <TagCriteria> validatedTagCriteria = new List <TagCriteria>();

            // ensure the follow is in the user follow table toowoo woo
            InsertOrReplaceUserFollow(trackFollow.user_id, trackFollow.track_id);

            if (trackFollow.criteria != null && trackFollow.criteria.Count > 0)
            {
                foreach (var criterion in trackFollow.criteria.Take(12))
                {
                    criterion.feed          = trackFollow.feed_follow_type != null ? false : criterion.feed;
                    criterion.notifications = trackFollow.notifications_follow_type != null ? false : criterion.notifications;

                    TagCriteria validatedCriterion = ValidateTagCriteria(criterion);

                    if (validatedCriterion != null)
                    {
                        validatedTagCriteria.Add(validatedCriterion);
                    }
                }
            }

            trackFollow.criteria = validatedTagCriteria;

            // get basic follow modes
            trackFollow.feed_follow_type          = trackFollow.feed_follow_type == "all" || trackFollow.feed_follow_type == "none" ? trackFollow.feed_follow_type : GetFollowType(trackFollow.criteria, Enums.FollowMode.Feed);
            trackFollow.notifications_follow_type = trackFollow.notifications_follow_type == "all" || trackFollow.notifications_follow_type == "none" ? trackFollow.notifications_follow_type : GetFollowType(trackFollow.criteria, Enums.FollowMode.Notification);

            TableStorageRepository.InsertOrReplaceTrackFollow(TrackFollowToTableEntity(trackFollow));
        }
Beispiel #14
0
        public static async Task <TrackFollow> GetTrackFollow(string trackId, string userId)
        {
            TrackFollowTableEntity result = await TableStorageRepository.GetTrackFollow(trackId, userId);

            return(TableEntityToTrackFollow(result));
        }
 public static void InsertOrIncrementTrackTag(TrackTag trackTag)
 {
     TableStorageRepository.InsertOrIncrementTrackTag(trackTag);
 }
 public static async Task <List <string> > GetPostIdsInTrack(string trackId)
 {
     return(await TableStorageRepository.GetPostIdsInTrack(trackId));
 }
 public static void DeletePostFromTableStorage(Post postMeta)
 {
     TableStorageRepository.DeletePost(postMeta);
 }
 public static async Task <Post> GetPost(string trackId, string postId)
 {
     return(await TableStorageRepository.GetPost(trackId, postId));
 }
 public static async Task <int> PostsLastHourCount(string trackId)
 {
     return(await TableStorageRepository.GetPostCountSince(trackId, 60));
 }
Beispiel #20
0
        /// <summary>
        /// Get tracks by ownerId.
        /// </summary>
        /// <param name="ownerId"></param>
        /// <returns>List of tracks.</returns>
        public static async Task <List <TrackAuth> > GetTracksByOwnerId(string ownerId)
        {
            List <TrackAuth> tracks = await TableStorageRepository.GetTracksByOwnerId(ownerId);

            return(tracks);
        }
 public static void DeleteTrackTag(TrackTag trackTag)
 {
     TableStorageRepository.DeleteTrackTag(trackTag);
 }
Beispiel #22
0
 public static async Task <ExtendedUser> GetExtendedUser(string userId)
 {
     return(await TableStorageRepository.GetExtendedUser(userId));
 }
Beispiel #23
0
 public static async Task <List <TrackAuth> > GetRateLimitedTracks()
 {
     return(await TableStorageRepository.GetRateLimitedTracks());
 }
Beispiel #24
0
 public static void UpdateTrack(TrackAuth track)
 {
     TableStorageRepository.UpdateTrack(track);
 }
Beispiel #25
0
 public static async Task <ExtendedUser> UpdateExtendedUser(ExtendedUser user)
 {
     return(await TableStorageRepository.UpdateExtendedUser(user));
 }
 public static async Task <List <TrackTag> > GetTagsByTrack(string trackId)
 {
     return(await TableStorageRepository.GetTagsByTrack(trackId));
 }