Revert filescoped (#2227)

* Revert "Add git blame entry (#2226)"

This reverts commit 239286737d.

* Revert "Turn on file scoped namespaces (#2225)"

This reverts commit 34fb4cca2a.

src/Core/Repositories/TableStorage/EventRepository.cs

@@ -4,184 +4,185 @@ using Bit.Core.Settings;
 using Bit.Core.Utilities;
 using Microsoft.Azure.Cosmos.Table;
 
-namespace Bit.Core.Repositories.TableStorage;
-
-public class EventRepository : IEventRepository
+namespace Bit.Core.Repositories.TableStorage
 {
-    private readonly CloudTable _table;
-
-    public EventRepository(GlobalSettings globalSettings)
-        : this(globalSettings.Events.ConnectionString)
-    { }
-
-    public EventRepository(string storageConnectionString)
+    public class EventRepository : IEventRepository
     {
-        var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
-        var tableClient = storageAccount.CreateCloudTableClient();
-        _table = tableClient.GetTableReference("event");
-    }
+        private readonly CloudTable _table;
 
-    public async Task<PagedResult<IEvent>> GetManyByUserAsync(Guid userId, DateTime startDate, DateTime endDate,
-        PageOptions pageOptions)
-    {
-        return await GetManyAsync($"UserId={userId}", "Date={{0}}", startDate, endDate, pageOptions);
-    }
+        public EventRepository(GlobalSettings globalSettings)
+            : this(globalSettings.Events.ConnectionString)
+        { }
 
-    public async Task<PagedResult<IEvent>> GetManyByOrganizationAsync(Guid organizationId,
-        DateTime startDate, DateTime endDate, PageOptions pageOptions)
-    {
-        return await GetManyAsync($"OrganizationId={organizationId}", "Date={0}", startDate, endDate, pageOptions);
-    }
-
-    public async Task<PagedResult<IEvent>> GetManyByOrganizationActingUserAsync(Guid organizationId, Guid actingUserId,
-        DateTime startDate, DateTime endDate, PageOptions pageOptions)
-    {
-        return await GetManyAsync($"OrganizationId={organizationId}",
-            $"ActingUserId={actingUserId}__Date={{0}}", startDate, endDate, pageOptions);
-    }
-
-    public async Task<PagedResult<IEvent>> GetManyByProviderAsync(Guid providerId,
-        DateTime startDate, DateTime endDate, PageOptions pageOptions)
-    {
-        return await GetManyAsync($"ProviderId={providerId}", "Date={0}", startDate, endDate, pageOptions);
-    }
-
-    public async Task<PagedResult<IEvent>> GetManyByProviderActingUserAsync(Guid providerId, Guid actingUserId,
-        DateTime startDate, DateTime endDate, PageOptions pageOptions)
-    {
-        return await GetManyAsync($"ProviderId={providerId}",
-            $"ActingUserId={actingUserId}__Date={{0}}", startDate, endDate, pageOptions);
-    }
-
-    public async Task<PagedResult<IEvent>> GetManyByCipherAsync(Cipher cipher, DateTime startDate, DateTime endDate,
-        PageOptions pageOptions)
-    {
-        var partitionKey = cipher.OrganizationId.HasValue ?
-            $"OrganizationId={cipher.OrganizationId}" : $"UserId={cipher.UserId}";
-        return await GetManyAsync(partitionKey, $"CipherId={cipher.Id}__Date={{0}}", startDate, endDate, pageOptions);
-    }
-
-    public async Task CreateAsync(IEvent e)
-    {
-        if (!(e is EventTableEntity entity))
+        public EventRepository(string storageConnectionString)
         {
-            throw new ArgumentException(nameof(e));
+            var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
+            var tableClient = storageAccount.CreateCloudTableClient();
+            _table = tableClient.GetTableReference("event");
         }
 
-        await CreateEntityAsync(entity);
-    }
-
-    public async Task CreateManyAsync(IEnumerable<IEvent> e)
-    {
-        if (!e?.Any() ?? true)
+        public async Task<PagedResult<IEvent>> GetManyByUserAsync(Guid userId, DateTime startDate, DateTime endDate,
+            PageOptions pageOptions)
         {
-            return;
+            return await GetManyAsync($"UserId={userId}", "Date={{0}}", startDate, endDate, pageOptions);
         }
 
-        if (!e.Skip(1).Any())
+        public async Task<PagedResult<IEvent>> GetManyByOrganizationAsync(Guid organizationId,
+            DateTime startDate, DateTime endDate, PageOptions pageOptions)
         {
-            await CreateAsync(e.First());
-            return;
+            return await GetManyAsync($"OrganizationId={organizationId}", "Date={0}", startDate, endDate, pageOptions);
         }
 
-        var entities = e.Where(ev => ev is EventTableEntity).Select(ev => ev as EventTableEntity);
-        var entityGroups = entities.GroupBy(ent => ent.PartitionKey);
-        foreach (var group in entityGroups)
+        public async Task<PagedResult<IEvent>> GetManyByOrganizationActingUserAsync(Guid organizationId, Guid actingUserId,
+            DateTime startDate, DateTime endDate, PageOptions pageOptions)
         {
-            var groupEntities = group.ToList();
-            if (groupEntities.Count == 1)
+            return await GetManyAsync($"OrganizationId={organizationId}",
+                $"ActingUserId={actingUserId}__Date={{0}}", startDate, endDate, pageOptions);
+        }
+
+        public async Task<PagedResult<IEvent>> GetManyByProviderAsync(Guid providerId,
+            DateTime startDate, DateTime endDate, PageOptions pageOptions)
+        {
+            return await GetManyAsync($"ProviderId={providerId}", "Date={0}", startDate, endDate, pageOptions);
+        }
+
+        public async Task<PagedResult<IEvent>> GetManyByProviderActingUserAsync(Guid providerId, Guid actingUserId,
+            DateTime startDate, DateTime endDate, PageOptions pageOptions)
+        {
+            return await GetManyAsync($"ProviderId={providerId}",
+                $"ActingUserId={actingUserId}__Date={{0}}", startDate, endDate, pageOptions);
+        }
+
+        public async Task<PagedResult<IEvent>> GetManyByCipherAsync(Cipher cipher, DateTime startDate, DateTime endDate,
+            PageOptions pageOptions)
+        {
+            var partitionKey = cipher.OrganizationId.HasValue ?
+                $"OrganizationId={cipher.OrganizationId}" : $"UserId={cipher.UserId}";
+            return await GetManyAsync(partitionKey, $"CipherId={cipher.Id}__Date={{0}}", startDate, endDate, pageOptions);
+        }
+
+        public async Task CreateAsync(IEvent e)
+        {
+            if (!(e is EventTableEntity entity))
             {
-                await CreateEntityAsync(groupEntities.First());
-                continue;
+                throw new ArgumentException(nameof(e));
             }
 
-            // A batch insert can only contain 100 entities at a time
-            var iterations = groupEntities.Count / 100;
-            for (var i = 0; i <= iterations; i++)
+            await CreateEntityAsync(entity);
+        }
+
+        public async Task CreateManyAsync(IEnumerable<IEvent> e)
+        {
+            if (!e?.Any() ?? true)
             {
-                var batch = new TableBatchOperation();
-                var batchEntities = groupEntities.Skip(i * 100).Take(100);
-                if (!batchEntities.Any())
+                return;
+            }
+
+            if (!e.Skip(1).Any())
+            {
+                await CreateAsync(e.First());
+                return;
+            }
+
+            var entities = e.Where(ev => ev is EventTableEntity).Select(ev => ev as EventTableEntity);
+            var entityGroups = entities.GroupBy(ent => ent.PartitionKey);
+            foreach (var group in entityGroups)
+            {
+                var groupEntities = group.ToList();
+                if (groupEntities.Count == 1)
                 {
-                    break;
+                    await CreateEntityAsync(groupEntities.First());
+                    continue;
                 }
 
-                foreach (var entity in batchEntities)
+                // A batch insert can only contain 100 entities at a time
+                var iterations = groupEntities.Count / 100;
+                for (var i = 0; i <= iterations; i++)
                 {
-                    batch.InsertOrReplace(entity);
-                }
+                    var batch = new TableBatchOperation();
+                    var batchEntities = groupEntities.Skip(i * 100).Take(100);
+                    if (!batchEntities.Any())
+                    {
+                        break;
+                    }
 
-                await _table.ExecuteBatchAsync(batch);
+                    foreach (var entity in batchEntities)
+                    {
+                        batch.InsertOrReplace(entity);
+                    }
+
+                    await _table.ExecuteBatchAsync(batch);
+                }
             }
         }
-    }
 
-    public async Task CreateEntityAsync(ITableEntity entity)
-    {
-        await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
-    }
-
-    public async Task<PagedResult<IEvent>> GetManyAsync(string partitionKey, string rowKey,
-        DateTime startDate, DateTime endDate, PageOptions pageOptions)
-    {
-        var start = CoreHelpers.DateTimeToTableStorageKey(startDate);
-        var end = CoreHelpers.DateTimeToTableStorageKey(endDate);
-        var filter = MakeFilter(partitionKey, string.Format(rowKey, start), string.Format(rowKey, end));
-
-        var query = new TableQuery<EventTableEntity>().Where(filter).Take(pageOptions.PageSize);
-        var result = new PagedResult<IEvent>();
-        var continuationToken = DeserializeContinuationToken(pageOptions?.ContinuationToken);
-
-        var queryResults = await _table.ExecuteQuerySegmentedAsync(query, continuationToken);
-        result.ContinuationToken = SerializeContinuationToken(queryResults.ContinuationToken);
-        result.Data.AddRange(queryResults.Results);
-
-        return result;
-    }
-
-    private string MakeFilter(string partitionKey, string rowStart, string rowEnd)
-    {
-        var rowFilter = TableQuery.CombineFilters(
-            TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, $"{rowStart}`"),
-            TableOperators.And,
-            TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, $"{rowEnd}_"));
-
-        return TableQuery.CombineFilters(
-            TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey),
-            TableOperators.And,
-            rowFilter);
-    }
-
-    private string SerializeContinuationToken(TableContinuationToken token)
-    {
-        if (token == null)
+        public async Task CreateEntityAsync(ITableEntity entity)
         {
-            return null;
+            await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
         }
 
-        return string.Format("{0}__{1}__{2}__{3}", (int)token.TargetLocation, token.NextTableName,
-            token.NextPartitionKey, token.NextRowKey);
-    }
-
-    private TableContinuationToken DeserializeContinuationToken(string token)
-    {
-        if (string.IsNullOrWhiteSpace(token))
+        public async Task<PagedResult<IEvent>> GetManyAsync(string partitionKey, string rowKey,
+            DateTime startDate, DateTime endDate, PageOptions pageOptions)
         {
-            return null;
+            var start = CoreHelpers.DateTimeToTableStorageKey(startDate);
+            var end = CoreHelpers.DateTimeToTableStorageKey(endDate);
+            var filter = MakeFilter(partitionKey, string.Format(rowKey, start), string.Format(rowKey, end));
+
+            var query = new TableQuery<EventTableEntity>().Where(filter).Take(pageOptions.PageSize);
+            var result = new PagedResult<IEvent>();
+            var continuationToken = DeserializeContinuationToken(pageOptions?.ContinuationToken);
+
+            var queryResults = await _table.ExecuteQuerySegmentedAsync(query, continuationToken);
+            result.ContinuationToken = SerializeContinuationToken(queryResults.ContinuationToken);
+            result.Data.AddRange(queryResults.Results);
+
+            return result;
         }
 
-        var tokenParts = token.Split(new string[] { "__" }, StringSplitOptions.None);
-        if (tokenParts.Length < 4 || !Enum.TryParse(tokenParts[0], out StorageLocation tLoc))
+        private string MakeFilter(string partitionKey, string rowStart, string rowEnd)
         {
-            return null;
+            var rowFilter = TableQuery.CombineFilters(
+                TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, $"{rowStart}`"),
+                TableOperators.And,
+                TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, $"{rowEnd}_"));
+
+            return TableQuery.CombineFilters(
+                TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey),
+                TableOperators.And,
+                rowFilter);
         }
 
-        return new TableContinuationToken
+        private string SerializeContinuationToken(TableContinuationToken token)
         {
-            TargetLocation = tLoc,
-            NextTableName = string.IsNullOrWhiteSpace(tokenParts[1]) ? null : tokenParts[1],
-            NextPartitionKey = string.IsNullOrWhiteSpace(tokenParts[2]) ? null : tokenParts[2],
-            NextRowKey = string.IsNullOrWhiteSpace(tokenParts[3]) ? null : tokenParts[3]
-        };
+            if (token == null)
+            {
+                return null;
+            }
+
+            return string.Format("{0}__{1}__{2}__{3}", (int)token.TargetLocation, token.NextTableName,
+                token.NextPartitionKey, token.NextRowKey);
+        }
+
+        private TableContinuationToken DeserializeContinuationToken(string token)
+        {
+            if (string.IsNullOrWhiteSpace(token))
+            {
+                return null;
+            }
+
+            var tokenParts = token.Split(new string[] { "__" }, StringSplitOptions.None);
+            if (tokenParts.Length < 4 || !Enum.TryParse(tokenParts[0], out StorageLocation tLoc))
+            {
+                return null;
+            }
+
+            return new TableContinuationToken
+            {
+                TargetLocation = tLoc,
+                NextTableName = string.IsNullOrWhiteSpace(tokenParts[1]) ? null : tokenParts[1],
+                NextPartitionKey = string.IsNullOrWhiteSpace(tokenParts[2]) ? null : tokenParts[2],
+                NextRowKey = string.IsNullOrWhiteSpace(tokenParts[3]) ? null : tokenParts[3]
+            };
+        }
     }
 }

src/Core/Repositories/TableStorage/InstallationDeviceRepository.cs

@@ -3,82 +3,83 @@ using Bit.Core.Models.Data;
 using Bit.Core.Settings;
 using Microsoft.Azure.Cosmos.Table;
 
-namespace Bit.Core.Repositories.TableStorage;
-
-public class InstallationDeviceRepository : IInstallationDeviceRepository
+namespace Bit.Core.Repositories.TableStorage
 {
-    private readonly CloudTable _table;
-
-    public InstallationDeviceRepository(GlobalSettings globalSettings)
-        : this(globalSettings.Events.ConnectionString)
-    { }
-
-    public InstallationDeviceRepository(string storageConnectionString)
+    public class InstallationDeviceRepository : IInstallationDeviceRepository
     {
-        var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
-        var tableClient = storageAccount.CreateCloudTableClient();
-        _table = tableClient.GetTableReference("installationdevice");
-    }
+        private readonly CloudTable _table;
 
-    public async Task UpsertAsync(InstallationDeviceEntity entity)
-    {
-        await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
-    }
+        public InstallationDeviceRepository(GlobalSettings globalSettings)
+            : this(globalSettings.Events.ConnectionString)
+        { }
 
-    public async Task UpsertManyAsync(IList<InstallationDeviceEntity> entities)
-    {
-        if (!entities?.Any() ?? true)
+        public InstallationDeviceRepository(string storageConnectionString)
         {
-            return;
+            var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
+            var tableClient = storageAccount.CreateCloudTableClient();
+            _table = tableClient.GetTableReference("installationdevice");
         }
 
-        if (entities.Count == 1)
+        public async Task UpsertAsync(InstallationDeviceEntity entity)
         {
-            await UpsertAsync(entities.First());
-            return;
+            await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
         }
 
-        var entityGroups = entities.GroupBy(ent => ent.PartitionKey);
-        foreach (var group in entityGroups)
+        public async Task UpsertManyAsync(IList<InstallationDeviceEntity> entities)
         {
-            var groupEntities = group.ToList();
-            if (groupEntities.Count == 1)
+            if (!entities?.Any() ?? true)
             {
-                await UpsertAsync(groupEntities.First());
-                continue;
+                return;
             }
 
-            // A batch insert can only contain 100 entities at a time
-            var iterations = groupEntities.Count / 100;
-            for (var i = 0; i <= iterations; i++)
+            if (entities.Count == 1)
             {
-                var batch = new TableBatchOperation();
-                var batchEntities = groupEntities.Skip(i * 100).Take(100);
-                if (!batchEntities.Any())
+                await UpsertAsync(entities.First());
+                return;
+            }
+
+            var entityGroups = entities.GroupBy(ent => ent.PartitionKey);
+            foreach (var group in entityGroups)
+            {
+                var groupEntities = group.ToList();
+                if (groupEntities.Count == 1)
                 {
-                    break;
+                    await UpsertAsync(groupEntities.First());
+                    continue;
                 }
 
-                foreach (var entity in batchEntities)
+                // A batch insert can only contain 100 entities at a time
+                var iterations = groupEntities.Count / 100;
+                for (var i = 0; i <= iterations; i++)
                 {
-                    batch.InsertOrReplace(entity);
-                }
+                    var batch = new TableBatchOperation();
+                    var batchEntities = groupEntities.Skip(i * 100).Take(100);
+                    if (!batchEntities.Any())
+                    {
+                        break;
+                    }
 
-                await _table.ExecuteBatchAsync(batch);
+                    foreach (var entity in batchEntities)
+                    {
+                        batch.InsertOrReplace(entity);
+                    }
+
+                    await _table.ExecuteBatchAsync(batch);
+                }
             }
         }
-    }
 
-    public async Task DeleteAsync(InstallationDeviceEntity entity)
-    {
-        try
+        public async Task DeleteAsync(InstallationDeviceEntity entity)
         {
-            entity.ETag = "*";
-            await _table.ExecuteAsync(TableOperation.Delete(entity));
-        }
-        catch (StorageException e) when (e.RequestInformation.HttpStatusCode != (int)HttpStatusCode.NotFound)
-        {
-            throw;
+            try
+            {
+                entity.ETag = "*";
+                await _table.ExecuteAsync(TableOperation.Delete(entity));
+            }
+            catch (StorageException e) when (e.RequestInformation.HttpStatusCode != (int)HttpStatusCode.NotFound)
+            {
+                throw;
+            }
         }
     }
 }

src/Core/Repositories/TableStorage/MetaDataRepository.cs

@@ -3,91 +3,92 @@ using Bit.Core.Models.Data;
 using Bit.Core.Settings;
 using Microsoft.Azure.Cosmos.Table;
 
-namespace Bit.Core.Repositories.TableStorage;
-
-public class MetaDataRepository : IMetaDataRepository
+namespace Bit.Core.Repositories.TableStorage
 {
-    private readonly CloudTable _table;
-
-    public MetaDataRepository(GlobalSettings globalSettings)
-        : this(globalSettings.Events.ConnectionString)
-    { }
-
-    public MetaDataRepository(string storageConnectionString)
+    public class MetaDataRepository : IMetaDataRepository
     {
-        var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
-        var tableClient = storageAccount.CreateCloudTableClient();
-        _table = tableClient.GetTableReference("metadata");
-    }
+        private readonly CloudTable _table;
 
-    public async Task<IDictionary<string, string>> GetAsync(string objectName, string id)
-    {
-        var query = new TableQuery<DictionaryEntity>().Where(
-            TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{objectName}_{id}"));
-        var queryResults = await _table.ExecuteQuerySegmentedAsync(query, null);
-        return queryResults.Results.FirstOrDefault()?.ToDictionary(d => d.Key, d => d.Value.StringValue);
-    }
+        public MetaDataRepository(GlobalSettings globalSettings)
+            : this(globalSettings.Events.ConnectionString)
+        { }
 
-    public async Task<string> GetAsync(string objectName, string id, string prop)
-    {
-        var dict = await GetAsync(objectName, id);
-        if (dict != null && dict.ContainsKey(prop))
+        public MetaDataRepository(string storageConnectionString)
         {
-            return dict[prop];
+            var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
+            var tableClient = storageAccount.CreateCloudTableClient();
+            _table = tableClient.GetTableReference("metadata");
         }
-        return null;
-    }
 
-    public async Task UpsertAsync(string objectName, string id, KeyValuePair<string, string> keyValuePair)
-    {
-        var query = new TableQuery<DictionaryEntity>().Where(
-            TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{objectName}_{id}"));
-        var queryResults = await _table.ExecuteQuerySegmentedAsync(query, null);
-        var entity = queryResults.Results.FirstOrDefault();
-        if (entity == null)
+        public async Task<IDictionary<string, string>> GetAsync(string objectName, string id)
         {
-            entity = new DictionaryEntity
+            var query = new TableQuery<DictionaryEntity>().Where(
+                TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{objectName}_{id}"));
+            var queryResults = await _table.ExecuteQuerySegmentedAsync(query, null);
+            return queryResults.Results.FirstOrDefault()?.ToDictionary(d => d.Key, d => d.Value.StringValue);
+        }
+
+        public async Task<string> GetAsync(string objectName, string id, string prop)
+        {
+            var dict = await GetAsync(objectName, id);
+            if (dict != null && dict.ContainsKey(prop))
+            {
+                return dict[prop];
+            }
+            return null;
+        }
+
+        public async Task UpsertAsync(string objectName, string id, KeyValuePair<string, string> keyValuePair)
+        {
+            var query = new TableQuery<DictionaryEntity>().Where(
+                TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, $"{objectName}_{id}"));
+            var queryResults = await _table.ExecuteQuerySegmentedAsync(query, null);
+            var entity = queryResults.Results.FirstOrDefault();
+            if (entity == null)
+            {
+                entity = new DictionaryEntity
+                {
+                    PartitionKey = $"{objectName}_{id}",
+                    RowKey = string.Empty
+                };
+            }
+            if (entity.ContainsKey(keyValuePair.Key))
+            {
+                entity.Remove(keyValuePair.Key);
+            }
+            entity.Add(keyValuePair.Key, keyValuePair.Value);
+            await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
+        }
+
+        public async Task UpsertAsync(string objectName, string id, IDictionary<string, string> dict)
+        {
+            var entity = new DictionaryEntity
             {
                 PartitionKey = $"{objectName}_{id}",
                 RowKey = string.Empty
             };
-        }
-        if (entity.ContainsKey(keyValuePair.Key))
-        {
-            entity.Remove(keyValuePair.Key);
-        }
-        entity.Add(keyValuePair.Key, keyValuePair.Value);
-        await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
-    }
-
-    public async Task UpsertAsync(string objectName, string id, IDictionary<string, string> dict)
-    {
-        var entity = new DictionaryEntity
-        {
-            PartitionKey = $"{objectName}_{id}",
-            RowKey = string.Empty
-        };
-        foreach (var item in dict)
-        {
-            entity.Add(item.Key, item.Value);
-        }
-        await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
-    }
-
-    public async Task DeleteAsync(string objectName, string id)
-    {
-        try
-        {
-            await _table.ExecuteAsync(TableOperation.Delete(new DictionaryEntity
+            foreach (var item in dict)
             {
-                PartitionKey = $"{objectName}_{id}",
-                RowKey = string.Empty,
-                ETag = "*"
-            }));
+                entity.Add(item.Key, item.Value);
+            }
+            await _table.ExecuteAsync(TableOperation.InsertOrReplace(entity));
         }
-        catch (StorageException e) when (e.RequestInformation.HttpStatusCode != (int)HttpStatusCode.NotFound)
+
+        public async Task DeleteAsync(string objectName, string id)
         {
-            throw;
+            try
+            {
+                await _table.ExecuteAsync(TableOperation.Delete(new DictionaryEntity
+                {
+                    PartitionKey = $"{objectName}_{id}",
+                    RowKey = string.Empty,
+                    ETag = "*"
+                }));
+            }
+            catch (StorageException e) when (e.RequestInformation.HttpStatusCode != (int)HttpStatusCode.NotFound)
+            {
+                throw;
+            }
         }
     }
 }