public static (Project project, Repo repo) ImportProject(User me, string originId)
{
var externalRepo = GetClient().Repository.Get(Convert.ToInt64(originId)).Result;
User creator = null;
if (me != null)
{
var token = me.ServiceAccessToken(ServiceType.GitHub);
if (token.origin_user_id == "")
{
GitHubUserUtils.UpdateOriginUserId(me);
}
var originUserId = token.origin_user_id;
creator = externalRepo.Owner.Id == Convert.ToInt64(originUserId) ? me : null;
}
Repo repository = RepoRepository.CreateAndGet(
me, externalRepo.Name, externalRepo.HtmlUrl, RepoServiceType.GitHub, externalRepo.Id.ToString()
);
var project = ProjectRepository.FindOrCreate(repository.title, creator, repository);
if (externalRepo.Description != null)
{
project.UpdateCol("description", externalRepo.Description);
}
return(project, repository);
}
public CliResult Execute()
{
Output("Type creator login:"******"User not found");
return(new CliResult(CliExitCode.NotFound, StrOutput));
}
Output("Type repo title:");
var repoTitle = Console.ReadLine();
Output("Type repo url:");
var repoUrl = Console.ReadLine();
// TODO: get service type
var repo = RepoRepository.CreateAndGet(user, repoTitle, repoUrl, RepoServiceType.GitHub);
Output("Type project name:");
var projectName = Console.ReadLine();
var project = ProjectRepository.FindOrCreate(projectName, user, repo);
Output("Created project:");
Output(new ProjectTransformer().Transform(project).ToString());
return(new CliResult(CliExitCode.Ok, StrOutput));
}
public void Create_DataCorrect_RepoCreated()
{
var user = UserFaker.Create();
var browser = new Browser(new DefaultNancyBootstrapper());
var repoTitle = "testRepo" + Rand.SmallInt();
var result = browser.Post("/api/v1/repository/create", with => {
with.HttpRequest();
with.Query("api_token", Jwt.FromUserId(user.id));
with.Query("title", repoTitle);
with.Query("repo_url", "randomUrl" + Rand.SmallInt());
with.Query("service_type", RepoServiceType.GitHub.ToString());
}).Result;
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
var json = JObject.Parse(result.Body.AsString());
var guid = json["data"]["repository"].Value <string>("guid") ?? "";
var createdRepository = RepoRepository.FindByGuid(guid);
Assert.NotNull(createdRepository);
Assert.AreEqual(repoTitle, createdRepository.title);
Assert.AreEqual(
user.guid, json["data"]["repository"]["creator"].Value <string>("guid") ?? ""
);
}
public static RepoModel Create()
{
return(RepoRepository.CreateAndGet(
UserFaker.Create(),
"randomTitle_" + Rand.SmallInt(),
"repoUrl_" + Rand.SmallInt(),
RepoServiceType.GitHub
));
}
public RepoController()
{
Get("/api/v1/repository/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("repo_guid", "repositories", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
return(HttpResponse.Item("repository", new RepoTransformer().Transform(
RepoRepository.FindByGuid((string)Request.Query["repo_guid"])
)));
});
Get("/api/v1/repository/meta/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("repo_guid", "repositories", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var sponsorLinks = new JObject();
var repo = RepoRepository.FindByGuid((string)Request.Query["repo_guid"]);
if (repo.service_type == RepoServiceType.GitHub)
{
try {
var splitUrl = repo.repo_url.Split("/");
var response = new HttpClient().GetAsync(
$"https://raw.githubusercontent.com/{splitUrl[3]}/{splitUrl[4]}/master/.github/FUNDING.yml"
).Result.Content.ReadAsStringAsync().Result;
var yamlObject = (Dictionary <object, object>) new DeserializerBuilder().Build()
.Deserialize(new StringReader(response));
sponsorLinks["github"] = yamlObject["github"]?.ToString();
sponsorLinks["patreon"] = yamlObject["patreon"]?.ToString();
sponsorLinks["open_collective"] = yamlObject["open_collective"]?.ToString();
}
catch (Exception e) {
SentrySdk.CaptureException(e);
}
}
return(HttpResponse.Data(new JObject()
{
["repository"] = new RepoTransformer().Transform(repo)
["meta"] = new JObject()
{
["sponsor_links"] = sponsorLinks
}
}));
});
}
public void Find_DataCorrect_GotServiceTypeCorrect()
{
var user = UserFaker.Create();
var repo = RepoRepository.CreateAndGet(
user, "some_title_" + Rand.SmallInt(), "random_url_" + Rand.SmallInt(), RepoServiceType.GitLab
);
repo = repo.Refresh();
Assert.AreEqual(RepoServiceType.GitLab, repo.service_type);
}
public static (Project project, Repo repo) ImportProject(User me, string originId)
{
var tokenModel = me.ServiceAccessToken(ServiceType.GitLab);
var client = new GitLabClient(tokenModel.access_token);
client.SetAuthorizedUser();
if (tokenModel.origin_user_id == "")
{
GitLabUserUtils.UpdateOriginUserId(me);
}
var gitLabProject = GitlabApi.GetPublicProject(originId);
if (gitLabProject == null)
{
return(null, null);
}
Repo repository = RepoRepository.CreateAndGet(
me,
gitLabProject.Value <string>("name"),
gitLabProject.Value <string>("web_url"),
RepoServiceType.GitLab,
gitLabProject.Value <string>("id")
);
var originUserId = tokenModel.origin_user_id;
User creator = null;
var projectUsers = GitlabApi.GetProjectUsers(originId);
foreach (var projectUser in projectUsers.Children())
{
if (originUserId == projectUser.Value <string>("id"))
{
creator = me;
break;
}
}
var project = ProjectRepository.FindOrCreate(repository.title, creator, repository);
project.UpdateCol("description", gitLabProject.Value <string>("description"));
return(project, repository);
}
public void Delete_DataCorrect_RepositoryDeleted()
{
var browser = new Browser(new DefaultNancyBootstrapper());
var repo = RepoFaker.Create();
var result = browser.Delete("/api/v1/repository/delete", with => {
with.HttpRequest();
with.Query("api_token", Jwt.FromUserId(UserFaker.Create().id));
with.Query("repo_guid", repo.guid);
}).Result;
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
var json = JObject.Parse(result.Body.AsString());
Assert.AreEqual(repo.guid, json["data"]["repository"].Value <string>("guid"));
Assert.IsNull(RepoRepository.FindByGuid(repo.guid));
}
public Repo Refresh() => RepoRepository.Find(id);
// TODO: add support for GitLab
public PublicImportController()
{
Post("/api/v1/repository/submit/post", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "url" }),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var url = GetRequestStr("url");
Uri parsedUrl;
try {
parsedUrl = new Uri(url);
}
catch (Exception e) {
return(HttpResponse.Error(HttpStatusCode.UnprocessableEntity, "Invalid url"));
}
string host = parsedUrl.Host;
if (
!(new[] { "github.com" }.Contains(host)) || parsedUrl.Segments.Length < 3
)
{
return(HttpResponse.Error(HttpStatusCode.UnprocessableEntity, "Invalid hostname"));
}
RepoServiceType serviceType = host == "github.com" ? RepoServiceType.GitHub : RepoServiceType.GitLab;
(DL.Model.Project.Project project, DL.Model.Repo.Repo repo)result = (null, null);
if (serviceType == RepoServiceType.GitHub)
{
var githubClient = GitHubApi.Client();
Repository repo;
try {
repo = githubClient.Repository.Get(
parsedUrl.Segments[1].Replace("/", ""),
parsedUrl.Segments[2].Replace("/", "")
).Result;
}
catch (Exception e) {
return(HttpResponse.Error(HttpStatusCode.NotFound, "GitHub repository does not exist"));
}
var existingRepo = RepoRepository.Find(repo.Id.ToString(), serviceType);
if (existingRepo != null)
{
return(HttpResponse.Error(HttpStatusCode.UnprocessableEntity, "Project is already imported",
new JObject()
{
["project"] = new ProjectTransformer().Transform(existingRepo.Project()),
}));
}
result = GitHubRepositoriesUtils.ImportProject(null, repo.Id.ToString());
}
return(HttpResponse.Data(new JObject()
{
["project"] = new ProjectTransformer().Transform(result.project),
["repository"] = new RepoTransformer().Transform(result.repo)
}));
});
public RepoCrudController()
{
Post("/api/v1/repository/create", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "title", "repo_url", "service_type" }),
new ShouldBeCorrectEnumValue("service_type", typeof(RepoServiceType)),
new ShouldNotExistInTable("repo_url", "repositories")
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var repository = RepoRepository.CreateAndGet(
me, (string)Request.Query["title"], (string)Request.Query["repo_url"],
(RepoServiceType)GetRequestEnum("service_type", typeof(RepoServiceType))
);
return(HttpResponse.Item(
"repository", new RepoTransformer().Transform(repository), HttpStatusCode.Created
));
});
Patch("/api/v1/repository/edit", _ => {
var rules = new List <IValidatorRule>()
{
new ExistsInTable("repo_guid", "repositories", "guid")
};
if (Request.Query["repo_url"])
{
rules.Add(new ShouldNotExistInTable("repo_url", "repositories"));
}
var errors = ValidationProcessor.Process(Request, rules);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var repo = RepoRepository.FindByGuid((string)Request.Query["repo_guid"]);
repo = RepoRepository.UpdateAndRefresh(repo, new JObject()
{
["title"] = (string)Request.Query["title"],
["repo_url"] = (string)Request.Query["repo_url"]
});
return(HttpResponse.Item("repository", new RepoTransformer().Transform(repo)));
});
Delete("/api/v1/repository/delete", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ExistsInTable("repo_guid", "repositories", "guid"),
});
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var repo = RepoRepository.FindByGuid((string)Request.Query["repo_guid"]);
repo.Delete();
return(HttpResponse.Item("repository", new RepoTransformer().Transform(repo)));
});
}
public Repo.Repo Repository() => RepoRepository.Find(repository_id);
public ImportRepoController()
{
Post("/api/v1/repository/import", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "service_type", "origin_id" }),
new ShouldBeCorrectEnumValue("service_type", typeof(RepoServiceType))
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var originId = GetRequestStr("origin_id");
RepoServiceType serviceType =
(RepoServiceType)GetRequestEnum("service_type", typeof(RepoServiceType));
var existingRepo = RepoRepository.Find(originId, serviceType);
if (existingRepo != null)
{
return(HttpResponse.Error(HttpStatusCode.UnprocessableEntity, "Project is already imported",
new JObject()
{
["project"] = new ProjectTransformer().Transform(existingRepo.Project()),
}));
}
if (serviceType == RepoServiceType.GitHub && !GitHubRepositoriesUtils.IfRepoExists(originId))
{
return(HttpResponse.Error(
HttpStatusCode.NotFound, "GitHub repository with this id does not exist"
));
}
if (serviceType == RepoServiceType.GitLab && !GitlabApi.IfRepoExists(originId))
{
return(HttpResponse.Error(
HttpStatusCode.NotFound, "GitLab repository with this id does not exist"
));
}
var me = UserRepository.Find(CurrentRequest.UserId);
(ProjectModel project, DL.Model.Repo.Repo repo)result = (null, null);
switch (serviceType)
{
case RepoServiceType.GitHub:
result = GitHubRepositoriesUtils.ImportProject(me, originId);
break;
case RepoServiceType.GitLab:
result = GitLabRepositoriesUtils.ImportProject(me, originId);
break;
}
if (result.project == null || result.repo == null)
{
return(HttpResponse.Error(HttpStatusCode.BadRequest, "Cannot import target project"));
}
return(HttpResponse.Data(new JObject()
{
["project"] = new ProjectTransformer().Transform(result.project),
["repository"] = new RepoTransformer().Transform(result.repo)
}));
});
