public void Can_save_userRepository()
{
var username = Any.Name("user");
var user = new UserEntity
{
Id = Guid.NewGuid(),
Username = username,
Email = Any.Email(username)
};
var repo = new RepositoryEntity()
{
Id = Guid.NewGuid(),
Challenge = Any.Name(),
Name = Any.Name(),
UserId = user.Id
};
user.Repositories.Add(repo);
_users.Save(user);
var loadedUser = _users.Get(user.Id);
Assert.NotEmpty(loadedUser.Repositories);
var loadedRepo = loadedUser.Repositories[0];
Assert.Equal(repo.Name, loadedRepo.Name);
}
public override bool IsEqual(RepositoryEntity other)
{
if (other is Tweet)
{
var otherTweet = other as Tweet;
if (this.StatusID == otherTweet.StatusID)
{
return(true);
}
/*
* Here we want to compute the text as fast as possible
* to do this we compare the precomputed letter hashes
* if we mis we return as soon as possible.
*/
else if (this.WordLetterPairHash.Length == otherTweet.WordLetterPairHash.Length)
{
for (int i = 0; i < this.WordLetterPairHash.Length; i++)
{
if (this.WordLetterPairHash[i] != otherTweet.WordLetterPairHash[i])
{
return(false);
}
}
return(true);
}
}
return(false);
}
public UserBusiness(RepositoryEntity repository,
System.Net.Http.HttpClient httpClient,
string systemId)
{
_repository = repository;
_userApi = new UserApi(httpClient);
_systemId = systemId;
}
public void Update(RepositoryEntity entity)
{
string sql = "update cms_repository set repository_name = @RepositoryName, repository_type_id = @RepositoryTypeId, gitlab_project_fullname = @GitlabProjectFullname, data_status = @DataStatus, description = @Description where id = @Id;";
using (var sqliteConn = connectionProvider.GetConnection())
{
sqliteConn.Execute(sql, new { id = entity.Id, RepositoryName = entity.RepositoryName, RepositoryTypeId = entity.RepositoryTypeId, GitlabProjectFullname = entity.GitlabProjectFullname, DataStatus = entity.DataStatus, Description = entity.Description });
}
}
public void Create(RepositoryEntity entity)
{
string sql = "insert into cms_repository(repository_name, repository_type_id, gitlab_project_fullname, data_status, description) values (@RepositoryName, @RepositoryTypeId, @GitlabProjectFullname, @DataStatus, @Description);";
using (var sqliteConn = connectionProvider.GetConnection())
{
sqliteConn.Execute(sql, new { RepositoryName = entity.RepositoryName, RepositoryTypeId = entity.RepositoryTypeId, GitlabProjectFullname = entity.GitlabProjectFullname, DataStatus = entity.DataStatus, Description = entity.Description });
}
}
/// <summary>
/// Builds the replacements table for tokens and values based on the given repository.
/// </summary>
/// <param name="repository">The repository.</param>
/// <returns>A dictionary of tokens and values to replace the tokens.</returns>
private static IDictionary <string, string> BuildReplacementsTable(RepositoryEntity repository)
{
IDictionary <string, string> result = new Dictionary <string, string>();
result.Add("${REPO_FOLDER}", repository.LocationPath);
result.Add("${WIN_FOLDER}", Environment.SystemDirectory);
return(result);
}
public RepositoryVo toMoreVo(RepositoryEntity entity)
{
RepositoryVo vo = toVo(entity);
List <TheMetaRepositoryTypeEntity> theMetaRepositoryTypeEntityList = theMetaRepositoryTypeMeta.GetEntityList();
vo.RepositoryTypeId = theMetaRepositoryTypeConvertor.getMoreVoList(theMetaRepositoryTypeEntityList, entity.RepositoryTypeId);
return(vo);
}
public void TestInsert()
{
PrEntity prEntity = new PrEntity(3, "http://test");
RepositoryEntity repositoryEntity = new RepositoryEntity("test", "test", new[] { prEntity });
UserEntity userEntity = new UserEntity(_testGuid, new List <RepositoryEntity> {
repositoryEntity
});
var insertedEntity = _context.InsertOrMergeEntityAsync(userEntity).Result;
}
public ActionResult Delete(int id)
{
var almProd = new RepositoryEntity<ProductoAlmacen, ProductoAlmacenViewModel>(ctx);
almProd.Borrar(o => o.idAlmacen.Equals(id));
repo.Borrar(new AlmacenViewModel() {ID = id});
return RedirectToAction("Index");
}
public RepositoryEntity toEntity(RepositoryCreateRequest request)
{
RepositoryEntity entity = new RepositoryEntity();
entity.RepositoryName = request.RepositoryName;
entity.RepositoryTypeId = request.RepositoryTypeId != null ? request.RepositoryTypeId.Value : 0;
entity.GitlabProjectFullname = request.GitlabProjectFullname;
entity.DataStatus = request.DataStatus != null ? request.DataStatus.Value : 0;
entity.Description = request.Description;
return(entity);
}
public override bool IsEqual(RepositoryEntity other)
{
if (other is TweetGroup)
{
var otherTweet = other as TweetGroup;
return(this.StatusID == otherTweet.StatusID);
}
else
{
return(false);
}
}
public override bool IsEqual(RepositoryEntity other)
{
if (other is Tweep)
{
var otherTweep = other as Tweep;
return(this.User.Identifier.UserID == otherTweep.User.Identifier.UserID);
}
else
{
return(false);
}
}
/// <summary>
/// 将entity转换为vo。不包括来自元数据的属性
/// </summary>
private RepositoryVo toVo(RepositoryEntity entity)
{
RepositoryVo vo = new RepositoryVo();
vo.Id = entity.Id;
vo.RepositoryName = entity.RepositoryName;
vo.GitlabProjectFullname = entity.GitlabProjectFullname;
vo.DataStatus = entity.DataStatus;
vo.Description = entity.Description;
return(vo);
}
public void TestInsert()
{
PrEntity prEntity = new PrEntity(Constants.PR_ID, Constants.URL);
RepositoryEntity repositoryEntity = new RepositoryEntity(Constants.TEST_OWNER, Constants.TEST_REPO_NAME, new List <PrEntity> {
prEntity
});
UserEntity userEntity = new UserEntity(Constants.USERNAME, new List <RepositoryEntity> {
repositoryEntity
});
var insertedEntity = _context.InsertOrMergeEntityAsync(userEntity).Result;
}
private void UploadBlob(CloudBlockBlob blob, RepositoryEntity obj)
{
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream))
{
writer.Write(Serialize(obj));
writer.Flush();
stream.Seek(0, 0);
blob.UploadFromStream(stream);
}
}
}
public async Task <RepositoryEntity> Create(RepositoryEntity entity)
{
var validationResult = await Validator.ValidateAsync(entity);
if (!validationResult.IsValid)
{
throw new ValidationException("Le repository n'est pas valide", validationResult.Errors);
}
var storageEntity = _mapper.Map <RepositoryStorageEntity>(entity);
await _service.Create(storageEntity);
return(_mapper.Map <RepositoryEntity>(storageEntity));
}
/// <summary>
/// Loads this instance.
/// </summary>
public void Load()
{
this.__data = new Data();
this.__gedcomFileContent = ReadGedcomFileContents(this.__filePath);
//Split on "0 @" to get an array of Individuals, Families, Notes, Source, Repository, Object (File)
string[] records = this.__gedcomFileContent.Replace("0 @", "\u0646@").Split('\u0646');
foreach (var record in records)
{
if (record.StartsWith("@") && !record.StartsWith("@SUBM@ SUBM"))
{
//The GEDCOM file is structured one row per element. Split the record into elements.
var elements = record.Replace("\r\n", "\r").Split('\r');
RecordTypes recordType = (RecordTypes)Enum.Parse(typeof(RecordTypes), elements[0].Replace(" ", "").Split('@')[2]);
//Check what type of record we are working with.
switch (recordType)
{
case RecordTypes.INDI:
__data.Individuals.Add(PersonEntity.Create(elements));
break;
case RecordTypes.FAM:
__data.Families.Add(FamilyEntity.Create(elements));
break;
case RecordTypes.NOTE:
__data.Notes.Add(NoteEntity.Create(elements));
break;
case RecordTypes.OBJE:
__data.Objects.Add(FileEntity.Create(elements));
break;
case RecordTypes.REPO:
__data.Repositories.Add(RepositoryEntity.Create(elements));
break;
case RecordTypes.SOUR:
__data.Sources.Add(SourceEntity.Create(elements));
break;
}
}
}
}
private async Task <RepositoriesServiceModel> CreateOrUpdateRepository(RepositoryEntity repository)
{
try
{
var result = await _repositoriesService.SaveRepository(repository, UserInfo.UserName, UserInfo.Ip, UserInfo.UserEmail, IS_PRODUCTION);
return(result);
}
catch (Exception ex)
{
_log.Error(ex, context: new { repository });
return(new RepositoriesServiceModel {
Result = UpdateSettingsStatus.InternalError
});
}
}
public void Setup()
{
_username = "******";
_prEntity = new PrEntity(3, "http://test");
RepositoryEntity repository = new RepositoryEntity("test", "test", new List <PrEntity> {
_prEntity
});
_userEntity = new UserEntity(_username, new List <RepositoryEntity> {
repository
});
_user = (User)_userEntity;
_tableContext = new Mock <ITableContext>(MockBehavior.Strict);
_sut = new UserRepository(_tableContext.Object);
}
private static void UploadBlob(CloudBlockBlob blob, RepositoryEntity obj)
{
using (var streamCompressed = new MemoryStream())
{
using (var gzip = new GZipStream(streamCompressed, CompressionMode.Compress))
{
var data = Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(obj));
gzip.Write(data, 0, data.Length);
gzip.Flush();
gzip.Close();
using (var streamOut = new MemoryStream(streamCompressed.ToArray()))
{
blob.UploadFromStream(streamOut);
}
}
}
}
public static async Task <(bool success, string error)> InsertRepositoryEntity(RepositoryResource resource, CloudTable table, ILogger log)
{
log.LogInformation($"");
try
{
var newEntity = new RepositoryEntity(resource.Owner, resource.Name);
newEntity.Subscribers.Add(resource.Subscriber);
var insertOperation = TableOperation.Insert(newEntity);
await table.ExecuteAsync(insertOperation);
}
catch (StorageException sex)
{
return(false, sex.RequestInformation.ExtendedErrorInformation.ErrorMessage);
}
catch (Exception ex)
{
return(false, ex.Message);
}
return(true, "");
}
public RepositoryUpdateResponse Update([FromBody] RepositoryUpdateRequest request)
{
RepositoryUpdateResponse response = new RepositoryUpdateResponse();
if (request.Id == 0 || request.Id < 0)
{
response.Status = -1;
return(response);
}
RepositoryEntity entity = repositoryRepository.GetById(request.Id);
if (entity == null)
{
response.Status = 404;
return(response);
}
repositoryRepository.Update(repositoryConvertor.toEntity(request, entity));
response.Status = 1;
return(response);
}
public RepositoryItemResponse Item([FromBody] RepositoryItemRequest request)
{
RepositoryItemResponse response = new RepositoryItemResponse();
if (request.Id <= 0)
{
response.Status = -1;
return(response);
}
RepositoryEntity entity = repositoryRepository.GetById(request.Id);
if (entity == null)
{
response.Status = 404;
return(response);
}
response.Item = repositoryConvertor.toLessVo(entity);
response.Status = 1;
return(response);
}
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new DotNetConfDbContext(
serviceProvider.GetRequiredService <DbContextOptions <DotNetConfDbContext> >()))
{
// Look for any board games.
if (context.Users.Any())
{
return; // Data was already seeded
}
for (int i = 1; i < 5; i++)
{
var tempUser = new UserEntity();
tempUser.Name = "User" + i;
tempUser.Username = "******" + i;
tempUser.Company = "Blabla";
tempUser.Bio = $"Hi my name {tempUser.Name} and work {tempUser.Company}";
tempUser.Add();
context.Users.Add(tempUser);
}
for (int i = 1; i < 5; i++)
{
var tempRepository = new RepositoryEntity();
tempRepository.Name = "Repo" + i;
tempRepository.Description = "Description";
tempRepository.IsFork = false;
tempRepository.IsPrivate = true;
tempRepository.UserId = 1;
tempRepository.Add();
context.Repositories.Add(tempRepository);
}
context.SaveChanges();
var test = context.Repositories.Include(x => x.User).ToList();
}
}
public override bool IsEqual(RepositoryEntity other)
{
return(this.UniqueKey == other.UniqueKey);
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='repository'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ApiRepositoryModel> ApiApiRepositoryPostAsync(this ISettingsServiceV2API operations, RepositoryEntity repository = default(RepositoryEntity), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ApiApiRepositoryPostWithHttpMessagesAsync(repository, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='repository'>
/// </param>
public static ApiRepositoryModel ApiApiRepositoryPost(this ISettingsServiceV2API operations, RepositoryEntity repository = default(RepositoryEntity))
{
return(operations.ApiApiRepositoryPostAsync(repository).GetAwaiter().GetResult());
}
public override bool IsEqual(RepositoryEntity other)
{
if (other is TweetGroup)
{
var otherTweet = other as TweetGroup;
return this.StatusID == otherTweet.StatusID;
}
else
return false;
}
public ProductoController()
{
var ctx = new TiendaEntities();
repo = new RepositoryEntity<Producto, ProductoViewModel>(ctx);
}
private async Task <RepositoriesServiceModel> UpdateRepositoryAsync(
IRepository repository,
string userName,
string userIp,
string userEmail,
bool isProduction)
{
var repositoryEntity = await _repositoriesRepository.GetAsync(repository.RowKey);
if (repositoryEntity == null)
{
return new RepositoriesServiceModel {
Result = UpdateSettingsStatus.NotFound
}
}
;
repository.GitUrl = repositoryEntity.GitUrl;
repository.Tag = repositoryEntity.Tag;
//check if type if github or bitbucket. since we have only github and bitbucket I am checking url for github.com
var type = repository.GitUrl.Contains(GITHUB_URL) ? SourceControlTypes.Github : SourceControlTypes.Bitbucket;
//get gitUrl for raw json format
var settingsGitUrl = GitServices.GitServices.GenerateRepositorySettingsGitUrl(repository.GitUrl, type, repository.Branch);
var name = GitServices.GitServices.GetGitRepositoryName(repository.GitUrl, type);
string fileFullName = FILENAME;
fileFullName += type == SourceControlTypes.Github ? "git_" : "bb_";
fileFullName += name + "_" + repository.Branch;
fileFullName += repository.Tag == null ? FILE_FORMAT : $"_{repository.Tag}{FILE_FORMAT}";
repositoryEntity = new RepositoryEntity
{
RowKey = Guid.NewGuid().ToString(),
GitUrl = repository.GitUrl,
Branch = repository.Branch,
FileName = fileFullName,
UserName = userName,
Name = name,
OriginalName = name,
Tag = repository.Tag
};
var last = await _repositoriesUpdateHistoryRepository.GetAsync(repository.RowKey);
repositoryEntity.ConnectionUrl = _repositoryFileInfoControllerAction + last.InitialCommit + "/"
+ (!string.IsNullOrWhiteSpace(repositoryEntity.Tag) ? repositoryEntity.Tag + "/" : string.Empty) + name;
//get json from generated gitUrl
var settingsResult = GitServices.GitServices.DownloadSettingsFileFromGit(
_log,
settingsGitUrl,
type,
_appSettings.BitBucketSettings?.BitbucketEmail,
_appSettings.BitBucketSettings?.BitbucketPassword);
if (!settingsResult.Success)
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.GitDownloadError,
Message = "Couldn't download settings file from git",
Data = settingsResult.Message,
}
}
;
string settingsYaml = settingsResult.Data.ToString();
var settings = settingsYaml.GetSettingsDataFromYaml();
if (!settings.Success)
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.YamlProcessingError,
Message = "Couldn't get settings data from yaml",
Data = settings.Message,
}
}
;
var settingsJson = (settings.Data as DataFromYaml)?.Json;
// update key values
var placeholders = (settings.Data as DataFromYaml)?.Placeholders;
var keyRepoName = !string.IsNullOrEmpty(repositoryEntity?.Tag) ? repositoryEntity?.Tag + "-" + repositoryEntity?.OriginalName : repositoryEntity?.OriginalName;
var keyValues = await InitKeyValuesAsync(
repositoryEntity,
placeholders,
repository.Tag,
keyRepoName,
false);
//no need to update if files are the same
var existingBlob = await GetFileData(fileFullName);
bool isDuplicated;
if (existingBlob == settingsJson)
{
var oldKeyValues = await _keyValuesRepository.GetKeyValuesAsync(x => x.RepositoryNames != null && x.RepositoryNames.Contains(keyRepoName));
if (oldKeyValues.Count() != keyValues.Count)
{
isDuplicated = false;
}
else
{
var changesCount = 0;
foreach (var item in keyValues)
{
var oldItem = oldKeyValues.FirstOrDefault(x => x.RowKey == item.RowKey);
var areTypesEqual = oldItem != null && oldItem.Types == null && item.Types == null ||
(oldItem.Types != null && item.Types != null && !oldItem.Types.Except(item.Types).Any() && !item.Types.Except(oldItem.Types).Any());
if (oldItem == null || !areTypesEqual)
{
changesCount++;
}
}
isDuplicated = changesCount == 0;
}
}
else
{
isDuplicated = false;
}
if (isDuplicated)
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.HasDuplicated
}
}
;
//Adding data to history repository
await AddToHistoryRepository(repositoryEntity, settingsJson, repository.RowKey, userName : userName, userIp : userIp);
//delete repository to add updated one
await _repositoriesRepository.RemoveRepositoryAsync(repository.RowKey);
// if updating file, we must not create new name for it
await _repositoryDataRepository.UpdateBlobAsync(settingsJson, userName, userIp, fileFullName);
await _repositoriesRepository.SaveRepositoryAsync(repositoryEntity);
var repositoriesModel = await GetPaginatedRepositories();
var repositories = repositoriesModel.Data as PaginatedList <IRepository>;
//await _keyValuesRepository.UpdateKeyValueAsync(keyValues);
await SaveKeyValuesAsync(keyValues, userEmail, userIp, isProduction);
existingBlob = existingBlob.ReleaseFromComments();
settingsJson = settingsJson.ReleaseFromComments();
//If Update remove checking for placeholders change if any deleted fix RepositoryNames for that
var lastPlaceholders = existingBlob.PlaceholderList();
for (int i = 0; i < lastPlaceholders.Count; i++)
{
foreach (var item in keyValues)
{
if (lastPlaceholders[i].RowKey != null &&
lastPlaceholders[i].RowKey == (string.IsNullOrEmpty(repository.Tag) ? item.RowKey : item.RowKey.SubstringFromString(item.Tag + "-")))
{
lastPlaceholders.Remove(lastPlaceholders[i]);
--i;
break;
}
}
}
if (lastPlaceholders.Count > 0)
{
var keyValuesToUpdate = new List <IKeyValueEntity>();
foreach (var lastItem in lastPlaceholders)
{
var keyValueToUpdate = await _keyValuesRepository.GetKeyValueAsync(string.IsNullOrEmpty(repository.Tag)
?lastItem.RowKey
: repository.Tag + "-" + lastItem.RowKey);
if (keyValueToUpdate != null)
{
var tempRepoNames = keyValueToUpdate.RepositoryNames?.ToList();
tempRepoNames?.Remove(keyRepoName);
keyValueToUpdate.RepositoryNames = tempRepoNames != null && tempRepoNames.Count > 0 ? tempRepoNames.ToArray() : null;
keyValuesToUpdate.Add(keyValueToUpdate);
}
}
await _keyValuesRepository.UpdateKeyValueAsync(keyValuesToUpdate);
}
return(new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.Ok,
Json = JsonConvert.SerializeObject(repositories),
Data = new
{
Last = existingBlob,
Current = settingsJson,
Oldid = repository.RowKey,
Newid = repositoryEntity.RowKey,
repositories.PageIndex,
repositories.TotalPages
}
});
}
}
}
public AlmacenController()
{
var ctx = new TiendaEntities();
repo = new RepositoryEntity<Almacen, AlmacenViewModel>(ctx);
}
public void SetUp()
{
_testEntity = Mother.CreateTestEntity();
_testRepositoryEntity = new RepositoryEntity<TestEntity>(_testEntity);
}
private static void UploadBlob(CloudBlockBlob blob, RepositoryEntity obj)
{
using (var streamCompressed = new MemoryStream())
{
using (var gzip = new GZipStream(streamCompressed, CompressionMode.Compress))
{
var data = Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(obj));
gzip.Write(data, 0, data.Length);
gzip.Flush();
gzip.Close();
using (var streamOut = new MemoryStream(streamCompressed.ToArray()))
{
blob.UploadFromStream(streamOut);
}
}
}
}
public void SetUp()
{
_testEntity = Mother.CreateTestEntity();
_testRepositoryEntity = new RepositoryEntity <TestEntity>(_testEntity);
}
private async Task <RepositoriesServiceModel> CreateRepositoryAsync(
IRepository repository,
string userName,
string userIp,
string userEmail,
bool isProduction)
{
if (string.IsNullOrWhiteSpace(repository.GitUrl))
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.InvalidInput,
Message = "Url can't be empty",
}
}
;
repository.GitUrl = repository.GitUrl?.Trim();
//check if type if github or bitbucket. since we have only github and bitbucket I am checking url for github.com
var type = repository.GitUrl.Contains(GITHUB_URL) ? SourceControlTypes.Github : SourceControlTypes.Bitbucket;
//get gitUrl for raw json format
var settingsGitUrl = GitServices.GitServices.GenerateRepositorySettingsGitUrl(repository.GitUrl, type, repository.Branch);
var repositoryExistedItems = await _repositoriesRepository.GetAllAsync();
IRepository noTagRepo = null;
foreach (var item in repositoryExistedItems)
{
if (GitServices.GitServices.GenerateRepositorySettingsGitUrl(item.GitUrl, type, item.Branch) != settingsGitUrl)
{
continue;
}
if (string.IsNullOrWhiteSpace(item.Tag))
{
noTagRepo = item;
}
if (item.Tag == repository.Tag)
{
return new RepositoriesServiceModel {
Result = UpdateSettingsStatus.AlreadyExists
}
}
;
}
if (!string.IsNullOrWhiteSpace(repository.Tag))
{
if (noTagRepo == null)
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.InvalidInput,
Message = "Please, first create main repo without tag."
}
}
;
var whiteSpaceRegex = new Regex(@"\s");
var tagMaximumLength = 20;
if (whiteSpaceRegex.IsMatch(repository.Tag) || repository.Tag.Length > tagMaximumLength)
{
return new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.InvalidInput,
Message = "Tag includes whitespace characters or it is too long (max length is 20 characters)"
}
}
;
}
var name = GitServices.GitServices.GetGitRepositoryName(repository.GitUrl, type);
string fileFullName = FILENAME;
fileFullName += (type == SourceControlTypes.Github) ? "git_" : "bb_";
fileFullName += name + "_" + repository.Branch;
fileFullName += (repository.Tag == null) ? FILE_FORMAT : "_" + repository.Tag + FILE_FORMAT;
IRepository repositoryEntity = new RepositoryEntity
{
RowKey = Guid.NewGuid().ToString(),
GitUrl = repository.GitUrl,
Branch = repository.Branch,
FileName = fileFullName,
UserName = userName,
Name = name,
OriginalName = name,
Tag = repository.Tag
};
repositoryEntity.ConnectionUrl = _repositoryFileInfoControllerAction + repositoryEntity.RowKey + "/"
+ (!string.IsNullOrWhiteSpace(repositoryEntity.Tag) ? repositoryEntity.Tag + "/" : string.Empty) + name;
//get json from generated gitUrl
var settingsResult = GitServices.GitServices.DownloadSettingsFileFromGit(
_log,
settingsGitUrl,
type,
_appSettings.BitBucketSettings?.BitbucketEmail,
_appSettings.BitBucketSettings?.BitbucketPassword);
if (!settingsResult.Success)
{
_log.Warning($"Couldn't download settings file from git: {settingsResult.Message}");
return(new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.GitDownloadError,
Message = "Couldn't download settings file from git",
});
}
string settingsYaml = settingsResult.Data.ToString();
var settings = settingsYaml.GetSettingsDataFromYaml();
if (!settings.Success)
{
_log.Warning($"Couldn't get settings data from yaml: {settings.Message}");
return(new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.YamlProcessingError,
Message = "Couldn't get settings data from yaml",
});
}
var settingsJson = (settings.Data as DataFromYaml)?.Json;
//Adding data to history repository
await AddToHistoryRepository(repositoryEntity, settingsJson, userName : userName, userIp : userIp);
// if updating file, we must not create new name for it
await _repositoryDataRepository.UpdateBlobAsync(settingsJson, userName, userIp, fileFullName);
await _repositoriesRepository.SaveRepositoryAsync(repositoryEntity);
// update key values
var placeholders = (settings.Data as DataFromYaml)?.Placeholders;
var keyRepoName = !string.IsNullOrEmpty(repositoryEntity.Tag) ? repositoryEntity.Tag + "-" + repositoryEntity.OriginalName : repositoryEntity.OriginalName;
var keyValues = await InitKeyValuesAsync(
repositoryEntity,
placeholders,
repository.Tag,
keyRepoName,
true);
await SaveKeyValuesAsync(keyValues, userEmail, userIp, isProduction);
var repositoriesModel = await GetPaginatedRepositories();
var repositories = repositoriesModel.Data as PaginatedList <IRepository>;
return(new RepositoriesServiceModel
{
Result = UpdateSettingsStatus.Ok,
Json = JsonConvert.SerializeObject(repositories),
Data = new
{
repositories.PageIndex,
repositories.TotalPages
}
});
}
public override bool IsEqual(RepositoryEntity other)
{
return this.UniqueKey == other.UniqueKey;
}
public CompanyBusiness(RepositoryEntity repository) : base(repository)
{
}
public RepositoryDB(RepositoryEntity <ID, T> config)
{
this.config = config;
con = ConnectDb.getConnection();
}
