async Task <Repository> FindRepositoryToSubmitPullRequestFrom(string owner, string name)
{
var repository = await Wrap.RateLimiting(client, c => c.Repository.Get(owner, name));
if (repository.Permissions.Push)
{
return(repository);
}
var request = new RepositoryRequest()
{
Type = RepositoryType.Owner
};
var ownedRepos = await Wrap.RateLimiting(client, c => c.Repository.GetAllForCurrent(request, new ApiOptions()
{
PageSize = 100
}));
var forks = ownedRepos.Where(r => r.Fork);
var matchingNames = forks.Where(r => r.Name == name);
var foundFork = matchingNames.FirstOrDefault();
// TODO: foundFork.Parent is null, and that might be a problem down the track
if (foundFork != null)
{
return(foundFork);
}
return(await Wrap.RateLimiting(client, c => c.Repository.Forks.Create(owner, name, new NewRepositoryFork())));
}
public void ContainsSetValues()
{
var request = new RepositoryRequest
{
Type = RepositoryType.All,
Sort = RepositorySort.FullName,
Direction = SortDirection.Ascending
};
var parameters = request.ToParametersDictionary();
Assert.Equal(3, parameters.Count);
Assert.Equal("all", parameters["type"]);
Assert.Equal("full_name", parameters["sort"]);
Assert.Equal("asc", parameters["direction"]);
request = new RepositoryRequest
{
Affiliation = RepositoryAffiliation.All,
Visibility = RepositoryRequestVisibility.Public
};
parameters = request.ToParametersDictionary();
Assert.Equal(2, parameters.Count);
Assert.Equal("owner, collaborator, organization_member", parameters["affiliation"]);
Assert.Equal("public", parameters["visibility"]);
}
public static async Task <IReadOnlyList <Repository> > GetRepoList(string token, string scope)
{
GitHubClient client = GetClient(token);
RepositoryRequest rr = new RepositoryRequest {
Affiliation = RepositoryAffiliation.Owner
};
switch (scope)
{
case "public":
rr.Visibility = RepositoryVisibility.Public;
break;
case "private":
rr.Visibility = RepositoryVisibility.Private;
break;
default:
rr.Visibility = RepositoryVisibility.All;
break;
}
IReadOnlyList <Repository> repos = await client.Repository.GetAllForCurrent(rr);
return(repos);
}
public void ContainsSetValues()
{
var request = new RepositoryRequest
{
Type = RepositoryType.All,
Sort = RepositorySort.FullName,
Direction = SortDirection.Ascending
};
var parameters = request.ToParametersDictionary();
Assert.Equal(3, parameters.Count);
Assert.Equal("all", parameters["type"]);
Assert.Equal("full_name", parameters["sort"]);
Assert.Equal("asc", parameters["direction"]);
request = new RepositoryRequest
{
Affiliation = RepositoryAffiliation.All,
Visibility = RepositoryVisibility.Public
};
parameters = request.ToParametersDictionary();
Assert.Equal(2, parameters.Count);
Assert.Equal("owner, collaborator, organization_member", parameters["affiliation"]);
Assert.Equal("public", parameters["visibility"]);
}
public async Task <IEnumerable <FileModel> > Get(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
var request = new RepositoryRequest
{
Type = RepositoryType.Owner,
Sort = RepositorySort.Updated
};
var repositories = await _gitHub.Repository.GetAllForCurrent(request).ConfigureAwait(false);
return(repositories.Select(repo => new FileModel
{
IsFolder = true,
Modified = repo.CreatedAt.UtcDateTime,
Name = repo.Name,
Path = repo.Name,
Size = repo.Size
}));
}
var details = GetRepositoryNameAndFilePath(path);
var contents = await _gitHub.Repository.Content
.GetAllContents(_currentUserName, details.Repository, details.Path)
.ConfigureAwait(false);
return(contents.Select(file => new FileModel
{
Name = file.Name,
IsFolder = file.Type == "dir",
Path = Path.Combine(details.Repository, file.Path),
Size = file.Size
}));
}
public async Task <GitContributor[]> GetContributorsRepository(RepositoryRequest requestRepository)
{
if (!requestRepository.IsNull() && !requestRepository.loginOwner.IsNullOrEmpty() && !requestRepository.nameRepository.IsNullOrEmpty())
{
try
{
var request = new HttpRequestMessage(HttpMethod.Get, string.Format(_uriGetContributorsRepository, requestRepository.loginOwner, requestRepository.nameRepository));
var response = await _clientFactory.CreateClient("github").SendAsync(request);
if (response.IsSuccessStatusCode)
{
using var responseStream = await response.Content.ReadAsStreamAsync();
return(await JsonSerializer.DeserializeAsync <GitContributor[]>(responseStream));
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw ex;
}
}
else
{
throw new ArgumentNullException("Owner e Nome do Repositório");
}
}
public IQueryable<ManufacturerType> Get(RepositoryRequest<ManufacturerType> request)
{
return new EnumerableQuery<ManufacturerType>(new[]
{
new ManufacturerType
{
Id = 1,
Name = "Basic Factory",
HasFixedQueueSize = true,
SupportsParallelManufacturing = true,
QueueSize = 3,
ProductTypes = new Collection<ProductType>
{
new ProductType
{
Id = 1,
ManufacturerTypeId = 1,
Name = "Metal",
TimeToManufacture = 1
},
new ProductType
{
Id = 2,
ManufacturerTypeId = 1,
Name = "Wood",
TimeToManufacture = 3
}
}
}
});
}
/// <summary>
/// Retrieves every <see cref="Repository"/> that belongs to the current user.
/// </summary>
/// <param name="request">Search parameters to filter results on</param>
/// <param name="options">Options for changing the API response</param>
/// <exception cref="AuthorizationException">Thrown if the client is not authenticated.</exception>
/// <returns>A <see cref="IReadOnlyPagedCollection{Repository}"/> of <see cref="Repository"/>.</returns>
public IObservable <Repository> GetAllForCurrent(RepositoryRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, "request");
Ensure.ArgumentNotNull(options, "options");
return(_connection.GetAndFlattenAllPages <Repository>(ApiUrls.Repositories(), request.ToParametersDictionary()));
}
/// <summary>
/// Retrieves every <see cref="Repository"/> that belongs to the current user.
/// </summary>
/// <param name="request">Search parameters to filter results on</param>
/// <param name="options">Options for changing the API response</param>
/// <exception cref="AuthorizationException">Thrown if the client is not authenticated.</exception>
/// <returns>A <see cref="IReadOnlyPagedCollection{Repository}"/> of <see cref="Repository"/>.</returns>
public IObservable <Repository> GetAllForCurrent(RepositoryRequest request, ApiOptions options)
{
Ensure.ArgumentNotNull(request, nameof(request));
Ensure.ArgumentNotNull(options, nameof(options));
return(_connection.GetAndFlattenAllPages <Repository>(ApiUrls.Repositories(), request.ToParametersDictionary(), AcceptHeaders.LicensesApiPreview));
}
public void DoesNotReturnValuesForDefaultRequest()
{
var request = new RepositoryRequest();
var parameters = request.ToParametersDictionary();
Assert.Empty(parameters);
}
public void DoesNotReturnValuesForDefaultRequest()
{
var request = new RepositoryRequest();
var parameters = request.ToParametersDictionary();
Assert.Empty(parameters);
}
public IObservable<Repository> GetUserRepositories(RepositoryType repositoryType)
{
var request = new RepositoryRequest
{
Type = repositoryType,
Direction = SortDirection.Ascending,
Sort = RepositorySort.FullName
};
return gitHubClient.Repository.GetAllForCurrent(request);
}
private Task <IReadOnlyList <Repository> > GetRepositories()
{
var request = new RepositoryRequest
{
Type = RepositoryType.Owner,
Sort = RepositorySort.Updated
};
return(_gitHub.Repository.GetAllForCurrent(request));
}
public RepositoryResponse Save(RepositoryRequest <TKey, TEntity> request)
{
if (string.IsNullOrWhiteSpace(request.Guid)
||
!ReposityEntityFactory.Items.ContainsKey(request.Guid)
)
{
throw new Exception("Error: requestGuid is null or is not exists! ");
}
return(this.Save(request, ReposityEntityFactory.Items[request.Guid]));
}
public RepositoryResponse Save(RepositoryRequest <TKey, TEntity> request, ReposityEntity re)
{
RepositoryResponse result = new RepositoryResponse();
int cnt = 0;
int failcnt = 0;
foreach (var e in request.CreateEntities)
{
try
{
cnt += SQLHelper.ExecuteNonQuery(re.OwnerService, re.CreateEntity, e.GetSQLParams());
}
catch (Exception ex)
{
failcnt++;
result.CreateMessage.Add(e.GetKey().ToString(), ex.Message);
}
}
foreach (var e in request.UpdateEntities)
{
try
{
cnt += SQLHelper.ExecuteNonQuery(re.OwnerService, re.UpdateEntity, e.GetSQLParams());
}
catch (Exception ex)
{
failcnt++;
result.UpdateMessage.Add(e.GetKey().ToString(), ex.Message);
}
}
foreach (var e in request.RemoveEntities)
{
try
{
cnt += SQLHelper.ExecuteNonQuery(re.OwnerService, re.RemoveEntity, e.GetSQLParams());
}
catch (Exception ex)
{
failcnt++;
result.RemoveMessage.Add(e.ToString(), ex.Message);
}
}
result.ResultState = failcnt == 0;
return(result);
}
public async Task <Model.ResultPage> GetRepos([FromQuery] int?pageSize = null,
[FromQuery] int?pageNo = null)
{
RepositoryRequest req = new RepositoryRequest();
var repos = await _githubCli.Repository.GetAllForCurrent(Utils.ApiOptions(pageSize, pageNo));
//Utils.Save2File("01_repo_getrepos.json", repos);
return(Utils.ToResult(repos.Select(r => new
{
name = r.FullName,
description = r.Description,
updated = r.UpdatedAt,
id = r.Id
}), pageNo));
}
public void CanFilterByType()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.All
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d => d["type"] == "all"));
}
public void CanFilterByVisibility()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Visibility = RepositoryVisibility.Private
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["visibility"] == "private"));
}
public CityUpdateResponse UpdateCity(CityUpdateRequest request)
{
if (request.City.CurrentCityStorage != null)
UpdateCityStorage(request.City.CurrentCityStorage);
var repoRequest = new RepositoryRequest<BuildingUpgrade>
{
Expression = GetBuildingUpgradeExpression()
};
var result = _cityUpdateUnitOfWork.BuildingUpgradeRepository.Get(repoRequest);
foreach (var dUpgrade in result)
{
if (request.City.BuildingUpgrades.Any(x=>x.Id == dUpgrade.Id))
continue;
dUpgrade.Completed = true;
}
foreach (var upgrade in request.City.BuildingUpgrades)
{
var domainUpgrade = result.FirstOrDefault(x=> x.Id==upgrade.Id);
if (domainUpgrade == null)
{
domainUpgrade = Mapper.Map<BuildingUpgrade>(upgrade);
_cityUpdateUnitOfWork.BuildingUpgradeRepository.Add(domainUpgrade);
}
else
{
var changedUpgrade = Mapper.Map<BuildingUpgrade>(upgrade);
_cityUpdateUnitOfWork.EntityContext.SetValues(domainUpgrade, changedUpgrade);
}
if (domainUpgrade.Products == null)
domainUpgrade.Products = new List<Product>();
DataCollectionMapper.MapCollection(upgrade.Products.Select(Mapper.Map<Product>).ToList(), domainUpgrade.Products, new CollectionMapperOptions
{
Context = _cityUpdateUnitOfWork.EntityContext
});
}
_cityUpdateUnitOfWork.Commit();
return new CityUpdateResponse();
}
public async Task CanChangeSortDirection()
{
var github = Helper.GetAuthenticatedClient();
var request = new RepositoryRequest
{
Direction = SortDirection.Ascending
};
var reposAscending = await github.Repository.GetAllForCurrent(request);
request.Direction = SortDirection.Ascending;
var reposDescending = await github.Repository.GetAllForCurrent(request);
Assert.NotEmpty(reposAscending);
Assert.NotEmpty(reposDescending);
Assert.NotEqual(reposAscending, reposDescending);
}
public async Task CanSortResults()
{
var github = Helper.GetAuthenticatedClient();
var request = new RepositoryRequest
{
Sort = RepositorySort.Created
};
var reposByCreated = await github.Repository.GetAllForCurrent(request);
request.Sort = RepositorySort.FullName;
var reposByFullName = await github.Repository.GetAllForCurrent(request);
Assert.NotEmpty(reposByCreated);
Assert.NotEmpty(reposByFullName);
Assert.NotEqual(reposByCreated, reposByFullName);
}
public void CanFilterBySort()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.Private,
Sort = RepositorySort.FullName
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["type"] == "private" && d["sort"] == "full_name"));
}
public void CanFilterByAffiliation()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Affiliation = RepositoryAffiliation.Owner,
Sort = RepositorySort.FullName
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["affiliation"] == "owner" && d["sort"] == "full_name"));
}
public async Task CanFilterByType()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.All
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d => d["type"] == "all"),
"application/vnd.github.drax-preview+json",
Args.ApiOptions);
}
public async Task <IActionResult> GetContributorsByRepository([FromQuery] RepositoryRequest requestRepository)
{
try
{
var result = await _service.GetContributorsRepository(requestRepository).ConfigureAwait(false);
if (!result.IsNull())
{
return(Ok(result));
}
else
{
return(NotFound(new { }));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void CanFilterBySortDirection()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.Member,
Sort = RepositorySort.Updated,
Direction = SortDirection.Ascending
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["type"] == "member" && d["sort"] == "updated" && d["direction"] == "asc"));
}
// GET: RepositorioController/Details/5
public async Task <ActionResult <GitRepositoryView> > Details(RepositoryRequest requestRepository)
{
if (ModelState.IsValid)
{
var request = new HttpRequestMessage(HttpMethod.Get, string.Format(_uriGetRepositoryByOwnerAndRepository, requestRepository.nameRepository, requestRepository.loginOwner));
var response = await _clientFactory.CreateClient("apiGitIntegration").SendAsync(request).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
using var responseStream = await response.Content.ReadAsStreamAsync();
return(View(await JsonSerializer.DeserializeAsync <GitRepositoryView>(responseStream)));
}
else
{
return(View());
}
}
return(View());
}
public async Task CanFilterByAffiliation()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Affiliation = RepositoryAffiliation.Owner,
Sort = RepositorySort.FullName
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["affiliation"] == "owner" && d["sort"] == "full_name"),
"application/vnd.github.drax-preview+json",
Args.ApiOptions);
}
public async Task CanFilterBySortDirection()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.Member,
Sort = RepositorySort.Updated,
Direction = SortDirection.Ascending
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll <Repository>(
Arg.Is <Uri>(u => u.ToString() == "user/repos"),
Arg.Is <Dictionary <string, string> >(d =>
d["type"] == "member" && d["sort"] == "updated" && d["direction"] == "asc"),
"application/vnd.github.drax-preview+json",
Args.ApiOptions);
}
public async Task <IEnumerable <GitsteemRepo> > GetRepos()
{
GitHubClient client = CreateAuthorizedClient();
var currentUser = await client.User.Current();
var request = new RepositoryRequest
{
Type = RepositoryType.Owner
};
var repos = await client.Repository.GetAllForCurrent(request);
var issuesRequest = new IssueRequest
{
Filter = IssueFilter.All,
State = ItemStateFilter.All
};
var issues = await client.Issue.GetAllForCurrent(issuesRequest);
var mappedIssues = issues.Select(i => new GitsteemIssue
{
Id = i.Id,
RepoName = i.Repository.Name,
RepoId = i.Repository.Id,
Title = i.Title,
State = i.State.StringValue
});
return(repos.Select(r => new GitsteemRepo
{
Issues = mappedIssues.Where(i => i.RepoId == r.Id).ToArray(),
Name = r.Name,
Id = r.Id,
IsPosted = false
}));
}
public RepositoryResponse Save(RepositoryRequest <UserKey, User> request)
{
return(new Repository <UserKey, User>().Save(request, SRRDBMS.ReposityEntityFactory.Items[Flag]));
}
/// <summary>
/// Retrieves every <see cref="Repository"/> that belongs to the current user.
/// </summary>
/// <remarks>
/// The default page size on GitHub.com is 30.
/// </remarks>
/// <param name="request">Search parameters to filter results on</param>
/// <exception cref="AuthorizationException">Thrown if the client is not authenticated.</exception>
/// <returns>A <see cref="IReadOnlyPagedCollection{Repository}"/> of <see cref="Repository"/>.</returns>
public IObservable<Repository> GetAllForCurrent(RepositoryRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<Repository>(ApiUrls.Repositories(), request.ToParametersDictionary());
}
public async Task CanFilterByType()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.All
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll<Repository>(
Arg.Is<Uri>(u => u.ToString() == "user/repos"),
Arg.Is<Dictionary<string, string>>(d => d["type"] == "all"),
Args.ApiOptions);
}
public void CanFilterBySort()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.Private,
Sort = RepositorySort.FullName
};
client.GetAllForCurrent(request);
connection.Received()
.GetAll<Repository>(
Arg.Is<Uri>(u => u.ToString() == "user/repos"),
Arg.Is<Dictionary<string, string>>(d =>
d["type"] == "private" && d["sort"] == "full_name"));
}
public IQueryable<ManufacturerType> Get(RepositoryRequest<ManufacturerType> request)
{
return _context.ManufacturerTypes.Where(request.Expression);
}
public async Task CanFilterBySortDirection()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Type = RepositoryType.Member,
Sort = RepositorySort.Updated,
Direction = SortDirection.Ascending
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll<Repository>(
Arg.Is<Uri>(u => u.ToString() == "user/repos"),
Arg.Is<Dictionary<string, string>>(d =>
d["type"] == "member" && d["sort"] == "updated" && d["direction"] == "asc"),
Args.ApiOptions);
}
public async Task CanFilterByAffiliation()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Affiliation = RepositoryAffiliation.Owner,
Sort = RepositorySort.FullName
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll<Repository>(
Arg.Is<Uri>(u => u.ToString() == "user/repos"),
Arg.Is<Dictionary<string, string>>(d =>
d["affiliation"] == "owner" && d["sort"] == "full_name"),
Args.ApiOptions);
}
public RequestController()
{
_repoRequest = new RepositoryRequest();
}
public IQueryable<ProductType> Get(RepositoryRequest<ProductType> request)
{
throw new NotImplementedException();
}
/// <summary>
/// Retrieves every <see cref="Repository"/> that belongs to the current user.
/// </summary>
/// <remarks>
/// The default page size on GitHub.com is 30.
/// </remarks>
/// <param name="request">Search parameters to filter results on</param>
/// <exception cref="AuthorizationException">Thrown if the client is not authenticated.</exception>
/// <returns>A <see cref="IReadOnlyPagedCollection{Repository}"/> of <see cref="Repository"/>.</returns>
public IObservable <Repository> GetAllForCurrent(RepositoryRequest request)
{
Ensure.ArgumentNotNull(request, nameof(request));
return(GetAllForCurrent(request, ApiOptions.None));
}
/// <summary>
/// Retrieves every <see cref="Repository"/> that belongs to the current user.
/// </summary>
/// <remarks>
/// The default page size on GitHub.com is 30.
/// </remarks>
/// <param name="request">Search parameters to filter results on</param>
/// <exception cref="AuthorizationException">Thrown if the client is not authenticated.</exception>
/// <returns>A <see cref="IReadOnlyPagedCollection{Repository}"/> of <see cref="Repository"/>.</returns>
public IObservable<Repository> GetAllForCurrent(RepositoryRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return GetAllForCurrent(request, ApiOptions.None);
}
public async Task CanFilterByVisibility()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var request = new RepositoryRequest
{
Visibility = RepositoryVisibility.Private
};
await client.GetAllForCurrent(request);
connection.Received()
.GetAll<Repository>(
Arg.Is<Uri>(u => u.ToString() == "user/repos"),
Arg.Is<Dictionary<string, string>>(d =>
d["visibility"] == "private"),
Args.ApiOptions);
}
private void UpdateCityStorage(CityStorage currentCityStorage)
{
var reporequest = new RepositoryRequest<Product>
{
Expression = GetCityStorageExpression()
};
var storageProductsResponse = _cityUpdateUnitOfWork
.ProductRepository
.Get(reporequest);
foreach (var product in currentCityStorage.CurrentInventory)
{
var cityStorageProduct = storageProductsResponse
.FirstOrDefault(x=>x.ProductTypeId == product.ProductTypeId);
if (cityStorageProduct == null)
{
cityStorageProduct = new Product
{
// ReSharper disable once PossibleInvalidOperationException
ProductTypeId = product.ProductTypeId.Value,
IsCityStorage = true
};
_cityUpdateUnitOfWork.ProductRepository.Add(cityStorageProduct);
}
cityStorageProduct.Quantity = product.Quantity ?? 0;
}
}
