def create_repository():
repository = Repository(
name="TestRepository",
manager="DSpace",
endpoint="http://dstools.hpsrepository.asu.edu/rest/")
repository.save()
return repository
def test_create_remove(self):
# Create a repo
repo = Repository.objects.create(
name='myrepo', owner=User.objects.get(username='******'))
self.assertIsNotNone(repo)
# Remove repo
Repository.delete(repo)
def test_repository_save_new_one_works():
r = Repository()
bk = Book('NEWTITLE', 'NEWDESCRIPTION', 'NEWISBN')
r.store(bk)
maybe_bk = r.find_one('NEWISBN')
assert_is_not_none(maybe_bk)
assert_equals(maybe_bk.isbn, 'NEWISBN')
assert_equals(maybe_bk.title, 'NEWTITLE')
def create_repository(*args):
user = flask_login.current_user
form = NewRepoForm()
if form.validate_on_submit():
repo = Repository(name=form.name.data, )
repo.save()
user.owned_repositories.connect(repo)
return redirect(url_for("index"))
return render_template("repo_create.html", form=form)
def repository_to_obj(repo, owner):
return Repository(fullname=repo.full_name,
name=repo.name,
last_commit_date=get_lastest_commit_date(repo),
last_commit_sha=get_lastest_commit_sha(repo),
owner=owner,
github_obj=repo)
def setUp(self):
if self.base:
self.repo = self.base.repo
self.user = self.base
else:
self.repo = Repository()
self.user = self.repo.users[user_to_test]
def add_repository_route():
try:
data = request.get_json()
if data is None:
return error_response('Invalid data')
repository_name = data.get('repository_name')
if repository_name is None or len(repository_name) == 0:
return error_response('Invalid repository name supplied')
for repo in current_user.repositories:
if repo.repo_name == repository_name:
return error_response(
'Repository with that name already exist in your account')
repository = Repository(repo_name=repository_name)
current_user.repositories.append(repository)
safe_makedir(UPLOAD_DIR, current_user.username, repository_name)
db.session.add(repository)
db.session.add(current_user)
db.session.commit()
url = '{url}{username}/{repo}{ext}'.format(
url=url_for('auth.auth_route', _external=True),
username=current_user.username,
repo=repository.repo_name,
ext=EXT)
return success_response(url)
except BadRequest:
return error_response('Bad request')
except Exception as e:
print(e)
return error_response(
'Unable to add repository, check the data and try again')
def add_repository_route():
try:
data = request.get_json()
if data is None:
return respond_back(ERROR, 'Invalid data')
repository_name = data.get('repository_name')
if repository_name is None or len(repository_name) == 0:
return respond_back(ERROR, 'Invalid repository name supplied')
for repo in current_user.repositories:
if repo.repo_name == repository_name:
return respond_back(ERROR, 'Repository with that name already exist in your account')
repository = Repository(repo_name=repository_name)
current_user.repositories.append(repository)
safe_makedir(UPLOAD_DIR, current_user.username, repository_name)
db.session.add(repository)
db.session.add(current_user)
db.session.commit()
return respond_back(SUCCESS, 'Successful')
except BadRequest:
return respond_back(ERROR, 'Bad request')
except Exception as e:
print e
return respond_back(ERROR, 'Unable to add repository, check the data and try again')
def home(request):
repositories = [{'name': 'requests'}]
repos = Repository.category().instance.all()
return render(request, "home.html",
{'title': 'Home',
'repositories': repos
})
def check_availability(self, date_in_s, date_out_s):
date_in = parse_date_or_not(date_in_s)
date_out = parse_date_or_not(date_out_s)
rooms = Repository.Instance().find_free_rooms_in_dates(
date_in, date_out)
return ([date_in, date_out], rooms)
def setUp(self):
if self.base:
self.repo = self.base.user.repo
self.user = self.base.user
self.project = self.base
else:
self.repo = Repository()
self.user = self.repo.users[user_to_test]
self.project = self.user.projects[project_to_test]
def test_repository_find_empty():
r = Repository()
bk = Book('TITLE', 'DESCRIPTION', 'ISBN')
r.store(bk)
bk = Book('TITLE2', 'DESCRIPTION2', 'ISBN2')
r.store(bk)
bk = Book('TITLE3', 'DESCRIPTION3', 'ISBN3')
r.store(bk)
books = r.find()
assert_equals(len(books), 3)
def worker_authors(request):
r = Repository.get(db.Key(request.POST["repo"]))
logging.info("processing repository: %s" % r.name)
base_url = "http://github.com/%s/%s" % (r.owner.name, r.name)
url = base_url + "/network_meta"
logging.info(" downloading network_meta from: %s" % url)
try:
s = urllib2.urlopen(url).read()
except urllib2.HTTPError:
logging.info("Probably bad repo, skipping.")
return HttpResponse("Probably bad repo, skipping.\n")
logging.info(" network_meta loaded")
try:
data = simplejson.loads(s)
except ValueError:
logging.info("Probably bad repo, skipping.")
return HttpResponse("Probably bad repo, skipping.\n")
logging.info(" network_meta parsed")
dates = data["dates"]
nethash = data["nethash"]
url = "%s/network_data_chunk?nethash=%s&start=0&end=%d" % (base_url,
nethash, len(dates)-1)
logging.info(" downloading commits from: %s" % url)
s = urllib2.urlopen(url).read()
logging.info(" parsing commits...")
data = simplejson.loads(s, encoding="latin-1")
logging.info(" processing authors...")
commits = data["commits"]
m = [(x["author"], x["id"]) for x in commits]
m = dict(m)
logging.info(m)
authors = m.keys()
authors = list(set(authors))
authors.sort()
logging.info(authors)
queue = get_github_queue()
for author in authors:
q = User.gql("WHERE name = :1", author)
u = q.get()
if u is None:
u = User(name=author, email="None")
u.save()
task = taskqueue.Task(url="/hooks/worker/user_email/",
params={'user': u.key(),
'r_user_id': r.owner.name,
'r_repository': r.name,
'r_sha': m[u.name]
})
queue.add(task)
q = Author.gql("WHERE user = :1 AND repo = :2", u, r)
a = q.get()
if a is None:
a = Author(repo=r, user=u)
a.save()
logging.info(" done.")
return HttpResponse("OK\n")
def __init__(self, request):
super(ReservationView, self).__init__(request)
self.repository = Repository.Instance()
self.rooms = self.repository.rooms
self.data = {
'rooms': self.rooms,
'date_from_check': '',
'date_to_check': '',
}
def create_repository_and_owner(repository, name, email):
if email == "None":
q = User.gql("WHERE name = :1", name)
else:
q = User.gql("WHERE email = :1", email)
u = q.get()
if u is None:
u = User(name=name, email=email)
u.save()
q = Repository.gql("WHERE name = :1 AND owner = :2", repository, u)
r = q.get()
if r is None:
r = Repository(name=repository, owner=u)
r.save()
queue = get_github_queue()
task = taskqueue.Task(url="/hooks/worker/authors/",
params={'repo': r.key()})
queue.add(task)
return r, u
def pull(self, key, watcher, service): api = apiFactory(service.api, service.params, TIMEOUT_API) if api is None: return 0; count = 0; for k, post in api.read(key, watcher.params): db.session.add(Repository(key=k, watcher_id = watcher.id, create = post['create'], text_raw = post['text_raw'], text = post['text'], add = datetime.utcnow())) count += 1 return count
def link_repository(self, pull_request, vsts_info, graph):
'''
links a git repository to a pull request
'''
repo_id = vsts_info["repository"]["id"]
repo = Repository.select(graph, repo_id).first()
if repo is not None:
pull_request.ForRepository.add(repo)
else:
print(
"could not find repositry for pull request we have a problem.")
def repo(request, repo):
r = Repository.get(db.Key(repo))
repo_url = "http://github.com/%s/%s" % (r.owner.name, r.name)
updates = RepoUpdate.gql("WHERE repo = :1", r)
authors = Author.gql("WHERE repo = :1", r)
a = []
for author in authors:
u = author.user
a.append({"name": u.name, "email": u.email, "key": u.key(),
"gravatar_url": get_gravatar_url(u.email)})
return render_to_response("hooks/repo.html", {'repo': r,
'repo_url': repo_url, 'updates': updates, 'authors': a})
class TestGetJARS(unittest.TestCase):
def setUp(self):
self.repository = Repository(
name='TestRepository',
manager='JARS',
endpoint='http://localhost:8002',
)
self.repository.save()
self.user = User(
username = '******',
password = '******',
)
self.user.save()
self.client = Client(
user=self.user,
name="TestUser",
url="http://asdf.com",
client_type=0,
redirect_uri="http://fdsa.com",
client_id = 'fdasasdfasdf',
client_secret = 'asdflkjhlkjasdlfjkhasjlksjldkjf',
)
self.client.save()
def test_get(self):
kwargs = {
'token': '050814a54ac5c81b990140c3c43278031d391676',
}
text = get(self.client, self.repository, jars_uri, **kwargs)
self.assertIsInstance(text, Text)
text.content.delete()
def tearDown(self):
self.client.delete()
self.user.delete()
self.repository.delete()
def update_db(self, repository=None):
db = self.application.db
owner = self.get_body_argument('repo_owner', default=None)
repo = self.get_body_argument('repo_name', default=None)
board = self.get_body_argument('board_id', default=None)
new_list = self.get_body_argument('list_id', default=None)
if repository is None:
repository = Repository(owner=owner,
repo=repo,
board=board,
new_list=new_list)
else:
repository.owner = owner
repository.repo = repo
repository.board = board
repository.new_list = new_list
db.add(repository)
db.commit() # TODO error checking
self.redirect(self.application.reverse_url('repo_edit', repository.id))
def test_repository_update_works():
r = Repository()
bk = Book('TITLE', 'DESCRIPTION', 'ISBN')
r.store(bk)
bk = r.find_one('ISBN')
bk.title = 'NEWTITLE'
bk.isbn = 'NEWISBN'
r.store(bk)
maybe_bk = r.find_one('ISBN')
assert_is_none(maybe_bk)
maybe_bk = r.find_one('NEWISBN')
assert_is_not_none(maybe_bk)
assert_equals(maybe_bk.isbn, 'NEWISBN')
assert_equals(maybe_bk.title, 'NEWTITLE')
def repos_for_org(self):
def format_datetime(dt):
# Remove milliseconds 2018-02-20T06:44:35.461Z
return dt.split(".")[0] + "Z"
data = []
url = f"{self.base_url}groups/{self.organisation}/projects?per_page=100"
response = requests.get(url)
if response.status_code == 404:
return {}
response.raise_for_status()
data.extend(response.json())
repos = defaultdict(list)
for repository in data:
repo = {}
repo["nom"] = repository["path"]
repo["organisation_nom"] = self.organisation
repo["plateforme"] = "GitLab"
repo["repertoire_url"] = repository["web_url"]
repo["description"] = repository["description"]
repo["est_fork"] = None
repo["est_archive"] = repository["archived"]
repo["date_creation"] = format_datetime(repository["created_at"])
repo["derniere_mise_a_jour"] = format_datetime(
repository["last_activity_at"]
)
# derniere_modification really ought to be the equivalent of GitHub pushed_at but GitLab does not expose such information for now
repo["derniere_modification"] = format_datetime(
repository["last_activity_at"]
)
repo["page_accueil"] = None
repo["nombre_stars"] = repository["star_count"]
repo["nombre_forks"] = repository["forks_count"]
repo["licence"] = None
try:
repo["nombre_issues_ouvertes"] = repository["open_issues_count"]
except KeyError:
# Is it appropriate? Issues can be disabled, always leading to 0 issues
repo["nombre_issues_ouvertes"] = 0
repo["langage"] = None
repo["topics"] = ",".join(repository["tag_list"])
repo.update(self.swh_attributes(repo))
for k, v in Repository(**repo).to_dict_list().items():
repos[k].extend(v)
return repos
def crawl(self, project_name):
"""
Gets Repositories for a given project
"""
url = (
"%s/DefaultCollection/%s/_apis/git/repositories?api-version=%s" %
(self.instance, project_name, self.api_version))
data = self.vsts.make_request(url)
for r in data["value"]:
graph = GraphBuilder().GetNewGraph()
#print(r["id"])
repo = Repository()
repo.Id = r.get("id")
repo.Name = r.get("name")
repo.Url = r.get("url")
raw_proj = r.get("project")
proj = Project()
proj.Id = raw_proj.get("id")
proj.Name = raw_proj.get("name")
proj.Url = raw_proj.get("url")
repo_proj = Project.select(graph, proj.Id)
'''todo: may not need to do this.'''
if repo_proj is not None:
proj_tx = graph.begin()
proj_tx.create(proj)
proj_tx.commit()
repo.BelongsTo.add(proj)
print("Adding Repo: ")
print(repo.Name)
transaction = graph.begin()
transaction.merge(repo)
transaction.graph.push(repo)
print("Finished mapping repos")
class TestGetWWW(unittest.TestCase): def setUp(self): self.repository = Repository( name='TestRepository', manager='WWW', endpoint='', ) self.repository.save() self.user = User( username = '******', password = '******', ) self.user.save() self.client = Client( user=self.user, name="TestUser", url="http://asdf.com", client_type=0, redirect_uri="http://fdsa.com", client_id = 'fdasasdfasdf', client_secret = 'asdflkjhlkjasdlfjkhasjlksjldkjf', ) self.client.save() def test_get(self): text = get(self.client, self.repository, wikiURL) self.assertIsInstance(text, Text) text.content.delete() def tearDown(self): self.client.delete() self.user.delete() self.repository.delete()
async def add_repository(self, ctx, github_link: str):
github_link = github_link.replace(".git", "").lower()
github_search = self.github_regex.search(github_link)
if github_search is None or len(github_link) > 1000:
return await ctx.send("This is not a valid github repository url!")
github_parsed = github_search.group(2)
if github_parsed in self.github_repository_verification_queue:
return await ctx.send("This repository is already in the queue!")
if self.bot.db_session.query(Repository).get(
github_parsed) is not None:
return await ctx.send("This repository has already been added!")
if self.bot.db_session.query(User).get(ctx.author.id) is None:
return await ctx.send(
"You need to start first! Use `!start <github username>` to start!"
)
response = await self.bot.http_session.get(github_link)
if response.status != 200:
return await ctx.send("This repository does not exist!")
embed = discord.Embed(
title="New repository",
description=
f"**Url**: {github_link}\n**Extracted**: {github_parsed}",
color=0x55CC33)
await ctx.send(
"Your repository has been put in queue for verification!")
self.github_repository_verification_queue.append(github_link)
mod_result = await self.utils.mod_poll(embed)
self.github_repository_verification_queue.remove(github_link)
if mod_result:
self.bot.db_session.add(
Repository(repository=github_parsed,
submitter_id=ctx.author.id))
self.bot.db_session.commit()
try:
await ctx.author.send(
f"The repository you submitted (`{github_parsed}`) got accepted!"
)
except discord.Forbidden:
pass
else:
try:
await ctx.author.send(
f"The repository you submitted (`{github_parsed}`) got denied!"
)
except discord.Forbidden:
pass
def get_repos(self, org):
try:
repos = self.gh.repos.list_by_org(org.username).all()
for repo in repos:
if not repo.fork:
r = Repository.query.filter_by(gh_id=repo.id).first()
if r is None:
r = Repository()
r.organization = org
r.gh_id = repo.id
r.name = repo.name
r.description = repo.description
r.forks = repo.forks
r.watchers = repo.watchers
r.size = repo.size
r.open_issues = repo.open_issues
db.session.add(r)
db.session.commit()
except:
print 'error ' + org.name
def add_specific_repos(g: Github, session: Any,
fullnames: List[str]) -> Iterator[Repository]:
for fullname in fullnames:
repo = (session.query(Repository).filter(
Repository.id == fullname).one_or_none())
if repo is None:
grepo = g.get_repo(fullname)
repo = Repository(
id=grepo.full_name,
owner=grepo.owner.login,
name=grepo.name,
description=grepo.description,
search_method='custom',
)
yield repo
def repositories(self):
public_repos_q = Repository.all().filter("is_public = ", True)
public_repos = {}
for r in public_repos_q:
public_repos[r.name] = r
owned_repos = {}
viewable_repos = {}
user = utils.get_current_user()
if not user:
return (owned_repos, viewable_repos, public_repos)
for r in Repository.all().filter("contributers = ", user.key()):
viewable_repos[r.name] = r
if r.name in public_repos:
del public_repos[r.name]
for r in Repository.all().filter("viewers = ", user.key()):
viewable_repos[r.name] = r
if r.name in public_repos:
del public_repos[r.name]
for r in Repository.all().filter("owner = ", user):
owned_repos[r.name] = r
for repos_dict in [public_repos, viewable_repos]:
if r.name in repos_dict:
del repos_dict[r.name]
return (owned_repos, viewable_repos, public_repos)
def home():
g = Github("7330eb02f7b1b9201b850262ff6e2b84c48685d2")
user = g.get_user()
repo = g.get_user().get_repos()
l = []
for r in repo:
l.append(r.name)
try:
details = Repository(username=user.login, repos=l)
db.session.add(details)
db.session.commit()
det = Repository.query.all()
return jsonify([e.serialize() for e in det])
# return "Repos added. Repo id : {}, User : {} ".format(details.id, user.login)
except Exception as e:
return (str(e))
def repos_for_org(self):
data = []
base_url = self.url("orgs/" + self.organisation +
"/repos?per_page=100")
response = requests.get(base_url, headers=self.github_headers())
if response.status_code == 404:
return {}
response.raise_for_status()
data.extend(response.json())
while "next" in response.links:
url = response.links["next"]["url"]
response = requests.get(url, headers=self.github_headers())
data.extend(response.json())
repos = defaultdict(list)
for repository in data:
repo = {}
repo["nom"] = repository["name"]
repo["organisation_nom"] = repository["owner"]["login"]
repo["plateforme"] = "GitHub"
repo["repertoire_url"] = repository["html_url"]
repo["description"] = repository["description"]
repo["est_fork"] = repository["fork"]
repo["est_archive"] = repository["archived"]
repo["date_creation"] = repository["created_at"]
repo["derniere_mise_a_jour"] = repository["updated_at"]
repo["derniere_modification"] = repository["pushed_at"]
repo["page_accueil"] = repository["homepage"]
repo["nombre_stars"] = repository["stargazers_count"]
repo["nombre_forks"] = repository["forks_count"]
try:
repo["licence"] = self.clean_license(
repository["license"]["name"])
except Exception:
repo["licence"] = None
repo["nombre_issues_ouvertes"] = repository["open_issues"]
repo["langage"] = repository["language"]
repo["topics"] = ",".join(repository["topics"])
repo.update(self.swh_attributes(repo))
for k, v in Repository(**repo).to_dict_list().items():
repos[k].extend(v)
return repos
def test_nonmember_cannot_editor_private_repo(self):
user = User(username="******",
password="******",
display_name="Display Name",
email="*****@*****.**")
org = Organization(name="org", display_name="Organization")
Repository(organization=org,
name="repo",
display_name="A Repository",
is_public=False)
self.session.add(user)
self.session.commit()
self.assertFalse(
RepositoryUserMapManager.is_editable(self.session, "username",
"org", "repo"))
def dispatch(self, repo_name):
r = Repository.get_by_key_name(utils.gen_repokeyname(repo_name))
if r:
app = hgapp(repo_name)
app.request = self.request
app.response = self.response
code = app.check_perm(self.request.method)
if code != HTTP_OK:
return code
if self.request.method == "GET":
app.get()
elif self.request.method == "POST":
app.post()
else:
return HTTP_METHOD_NOT_ALLOWED
return code
self.response.out.write("Not found")
return HTTP_NOT_FOUND
def test_repo_editor_can_editor_private_repo(self):
user = User(username="******",
password="******",
display_name="Display Name",
email="*****@*****.**")
org = Organization(name="org", display_name="Organization")
OrganizationUserMap(organization=org, user=user, role_shortname='M')
repo = Repository(organization=org,
name="repo",
display_name="A Repository",
is_public=False)
RepositoryUserMap(repository=repo, user=user, role_shortname='E')
self.session.add(user)
self.session.commit()
self.assertTrue(
RepositoryUserMapManager.is_editable(self.session, "username",
"org", "repo"))
def create_repository():
try:
data = request.get_json(silent=True)
user = db.get_user_by_token(request.headers["token"])
if user == None:
return jsonify({"error": "The token is not correct"}), 200
if db.get_repositories_by_user_and_name(user.id,
data["repoName"]) != None:
return jsonify({"error":
"You have a repo with the same name"}), 200
db.add(
Repository(user.id, data["repoName"], data["repoDesc"],
data["private"]))
if GIT:
git.create_repository(user.username, data["repoName"],
data["private"])
return jsonify({"success": "true"}), 200
except:
abort(500)
def _add_repository(url):
identity_file = current_user.generated_identity_file
if identity_file is None:
return UnifiedResponse(
result='fail',
details="Current user doesn't have generated identity file"
)
validation = validate_repository(url, identity_file, current_user.email)
if validation.result == 'ok':
repo = Repository(user_id=current_user.id,
url=url,
identity_file=identity_file)
try:
db_session.add(repo)
current_user.active_repository_id = repo.id
current_user.generated_identity_file = None
db_session.commit()
response = UnifiedResponse(
result='ok',
details=''
)
except SQLAlchemyError:
db_session.rollback()
response = UnifiedResponse(
result='fail',
details='Failed to save the repository into database'
)
else:
response = UnifiedResponse(
result='fail',
details=['Failed to validate the url:'] + process_details(validation.details)
)
response.update(dict(
repositories=user_repositories(current_user)
))
return response
def get_interesting_repos(g: Github, session: Any) -> List[Repository]:
repos: List[Repository] = []
grepos = g.search_repositories(query='stars:>250 forks:>50',
sort='stars',
order='desc')
records = zip(grepos, fy.repeat('most_stars'))
grepos = g.search_repositories(query='forks:>5 topic:kaggle-competition',
sort='stars',
order='desc')
records = fy.concat(records, zip(grepos, fy.repeat('kaggle')))
grepos = g.search_repositories(query='forks:>5 topic:tensorflow-model',
sort='stars',
order='desc')
records = fy.concat(records, zip(grepos, fy.repeat('tensorflow-model')))
grepos = g.search_repositories(
query='cookiecutterdatascience in:readme forks:>5 stars:>0 fork:true',
sort='stars',
order='desc')
records = fy.concat(records,
zip(grepos, fy.repeat('cookiecutterdatascience')))
for grepo, search_method in tqdm(records):
repo = (session.query(Repository).filter(
Repository.id == grepo.full_name).one_or_none())
if repo is None:
repo = Repository(
id=grepo.full_name,
owner=grepo.owner.login,
name=grepo.name,
description=grepo.description,
search_method=search_method,
)
repos.append(repo)
return repos
def issues_repos(request, boardid):
boards = Board.objects.filter(pk=boardid)
if len(boards) == 0:
ret = HttpResponseRedirect('/issueview/board/show/')
add_never_cache_headers(ret)
return ret
if boards[0].user != request.user and len(
ReadPermissions.objects.filter(
username=request.user.username).filter(board=boards[0])) == 0:
ret = HttpResponseRedirect("/issueview/board/show/")
add_never_cache_headers(ret)
return ret
board = boards[0].board
if request.method == "GET":
filtstring = request.GET.get("filter", "")
repos = Repository.objects.filter(board=boards[0])
form = Repoform()
ret = render(
request, "issueview/repos.html", {
"board": boards[0],
"form": form,
"repos": repos,
"filtstring": filtstring
})
add_never_cache_headers(ret)
return ret
form = Repoform(request.POST)
filtstring = request.POST.get("filter", "")
if form.is_valid():
newrepo = Repository()
newrepo.repository = form.cleaned_data["repository"]
newrepo.board = boards[0]
newrepo.save()
form = Repoform()
repos = Repository.objects.filter(board=boards[0])
ret = render(request, "issueview/repos.html", {
"board": boards[0],
"form": form,
"repos": repos,
"filtstring": filtstring
})
add_never_cache_headers(ret)
return ret
def setUp(self): self.repository = Repository( name='TestRepository', manager='JARS', endpoint='http://localhost:8002', ) self.repository.save() self.user = User( username = '******', password = '******', ) self.user.save() self.client = Client( user=self.user, name="TestUser", url="http://asdf.com", client_type=0, redirect_uri="http://fdsa.com", client_id = 'fdasasdfasdf', client_secret = 'asdflkjhlkjasdlfjkhasjlksjldkjf', ) self.client.save()
def repo_dict_to_obj(repo_dict):
return Repository(fullname=repo_dict['fullname'],
name=repo_dict['name'],
last_commit_date=repo_dict['lastCommitDate'],
last_commit_sha=repo_dict['lastCommitSha'],
owner=repo_dict['owner'])
def test_create_remove(self):
# Create a repo
repo = Repository.objects.create(name='myrepo', owner=User.objects.get(username='******'))
self.assertIsNotNone(repo)
# Remove repo
Repository.delete(repo)
def create_repository():
repository = Repository(name="TestRepository",
manager="DSpace",
endpoint="http://dstools.hpsrepository.asu.edu/rest/")
repository.save()
return repository
def test_instantiation(self):
new_repo = Repository()
def load_repo(self, data, **kwargs):
return Repository(**data)
def __init__(self, request):
super(BillView, self).__init__(request)
self.repository = Repository.Instance()
def test_repository_find_one_fails():
r = Repository()
maybe_bk = r.find_one('NOTAREALISBN')
assert_is_none(maybe_bk)
def test_repository_find_nonempty():
r = Repository()
books = r.find()
assert_equals(len(books), 0)
def get_stat(request):
if request.method == 'POST':
get_sort_by = request.POST['sort_by']
get_date_created = request.POST['date_created']
get_number = int(request.POST['number'])
repositories_in_database = Repository.objects.all()
names_in_database = [repository.name for repository in repositories_in_database]
repositories = search_repositories(number=get_number,
created_after=get_date_created,
sort_by=get_sort_by
)
out = []
for repository in repositories:
if repository["name"] in names_in_database:
repository_from_database = Repository.objects.get(name=repository["name"])
out.append({
"name": repository_from_database.name,
"url": repository_from_database.url,
"stars": repository_from_database.stars,
"stars_per_day": repository_from_database.stars_per_day,
"contributors": repository_from_database.contributors,
"contributors_per_day": repository_from_database.contributors_per_day,
"commits": repository_from_database.commits,
"commits_per_day": repository_from_database.commits_per_day,
})
else:
repository_from_api = get_repository_stat(repo_owner=repository["owner"],
repo_name=repository["name"],
repo_created_at=repository["created"]
)
out.append({
"name": repository["name"],
"url": repository["url"],
"stars": repository["stars"],
"stars_per_day": repository["stars_per_day"],
"contributors": repository_from_api["contributors"],
"contributors_per_day": repository_from_api["contributors_per_day"],
"commits": repository_from_api["commits"],
"commits_per_day": repository_from_api["commits_per_day"],
})
r = Repository(name=repository["name"],
owner=repository["owner"],
url=repository["url"],
created=datetime(repository["created"][0], repository["created"][1], repository["created"][2]),
updated=datetime(repository["updated"][0], repository["updated"][1], repository["updated"][2]),
stars=repository["stars"],
stars_per_day=repository["stars_per_day"],
contributors=repository_from_api["contributors"],
contributors_per_day=repository_from_api["contributors_per_day"],
commits=repository_from_api["commits"],
commits_per_day=repository_from_api["commits_per_day"]
)
r.save()
stars = {
'label': 'Stars',
'data': [],
'units': "Stars"
}
stars_per_day = {
'label': 'Stars per day',
'data': [],
'units': "Stars/day"
}
contributors = {
'label': 'Contributors',
'data': [],
'units': "Contributors"
}
contributors_per_day = {
'label': 'Contributors per day',
'data': [],
'units': "Contributors/day"
}
commits = {
'label': 'Commits',
'data': [],
'units': "Commits"
}
commits_per_day = {
'label': 'Commits per day',
'data': [],
'units': "Commits/day"
}
for repository in out:
stars["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["stars"],
})
stars_per_day["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["stars_per_day"],
})
contributors["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["contributors"],
})
contributors_per_day["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["contributors_per_day"],
})
commits["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["commits"],
})
commits_per_day["data"].append({
"name": repository["name"],
"url": repository["url"],
"value": repository["commits_per_day"],
})
response_data = [stars, stars_per_day, contributors, contributors_per_day, commits, commits_per_day]
return HttpResponse(
json.dumps(response_data),
content_type='application/json'
)
else:
return HttpResponse(
json.dumps({'error': 'something wrong'}),
content_type='application/json'
)
def spider_repos():
gh = Github(settings.GITHUB_TOKEN)
for repo in gh.get_organization('ministryofjustice').get_repos():
try:
r = Repository.objects.get(name=repo.name)
except Repository.DoesNotExist:
r = Repository()
r.name = repo.name
r.created = set_timezone(repo.created_at)
r.description = repo.description
r.url = repo.html_url
r.updated = set_timezone(repo.updated_at)
r.private = repo.private
r.contributors = repo.get_contributors().totalCount or 0
r.save()
print '\nSaving', r.name
r.add_language_usages(repo.get_languages())
record_gem_dependencies(repo, r)
r.has_tests = check_for_tests(repo, r)
r.save()
def __init__(self, request):
super(CheckInOutView, self).__init__(request)
self.repository = Repository.Instance()
def setUp(self):
if self.base:
self.repo = base
else:
self.repo = Repository()
def repo_delete(request, repo):
r = Repository.get(db.Key(repo))
r.delete()
return HttpResponseRedirect(reverse('hooks.views.repos'))
