def new_post(request): #post with images and require page refresh
user = request.user
form = FeedForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = user
is_challenge = request.POST.get('is_challenge') #need to set a post whether its a challenge post or not
is_response = request.POST.get('is_response') #need to set a post whether its a response post or not
response_for_id = request.POST.get('response_for_id') #required to generate notification for the user for whome the challnege was originally
to_user = request.POST.get('to_user') #comes in all response feeds and in challenges where to_user is not left blan as its optional
if response_for_id:
response_for_feed=get_object_or_404(Feed, id=response_for_id)
response_for_user_indirect=response_for_feed.challenge_to_user
if response_for_user_indirect:
to_user_profile_pk_indirect=response_for_user_indirect.profile.pk
to_user_profile_indirect=Profile.objects.get(pk=to_user_profile_pk_indirect)
if to_user:
to_user = get_object_or_404(User, username=to_user)
to_user_profile_pk=to_user.profile.pk
to_user_profile=Profile.objects.get(pk=to_user_profile_pk)
post = request.POST['post']
post = post.strip() #+ str(to_user_profile_pk_indirect)
if len(post) > 0:
instance.post = post[:255]
if is_response:
instance.to_user = to_user
instance.response_for = response_for_id
if is_challenge:
instance.is_challenge = is_challenge
if to_user:
instance.challenge_to_user = to_user
instance.save()
feed=instance
# instance.optimize_image()
if is_challenge == '1':
if to_user:
challengedActivity=Activity(activity_type=Activity.CHALLENGED,
profile=to_user_profile_pk, user=user,
)
challengedActivity.save()
user.profile.notifyChallenged(to_user_profile,feed) # from user to to_user
return redirect('challenge_feeds')
elif is_response == '1':
respondActivity=Activity(activity_type=Activity.RESPOND, profile=to_user_profile_pk, user=user)
respondActivity.save()
user.profile.notifyResponded(to_user_profile,feed)
# if to_user_profile_pk_indirect:
# respondIndirectActivity=Activity(activity_type=Activity.RESPOND_INDIRECT, profile=to_user_profile_pk_indirect, user=user)
# respondIndirectActivity.save()
# user.profile.notifyRespondedIndirect(to_user_profile_indirect,feed)
return redirect('/feeds/response/%s'%(response_for_id))
return redirect('feeds')
def post(self, request):
form = self.form(request.POST)
if form.is_valid():
try:
user_id = request.session.get('userauth', {}).get('user_id')
task_name = request.POST.get('name')
data = {
'name': task_name,
'deadline': request.POST.get('deadline_date'),
'user_id': user_id
}
task_obj = Task(**data)
task_obj.save()
# update activity
activity_dict = {
'user_id': user_id,
'message': 'You created Task, {}'.format(str(task_name))
}
Activity(**activity_dict).save()
messages.success(request, "Task add successfully !")
return redirect('task-list')
except RuntimeWarning:
return redirect('task-list')
return render(request, self.template_name, {'form': form})
def post(self, request):
data = json.loads(request.body.decode())
activityName = data['activityName']
if activityName == '':
return sendError(message='Tienes que agregar una actividad')
if len(activityName) > 100:
return sendError(message='El nombre del curso es demasiado grande')
if 'activityDesc' in data:
activityDesc = data['activityDesc']
else:
activityDesc = ''
newActivity = Activity(name=activityName,
teacher=request.user.teacher,
description=activityDesc)
newActivity.save()
data = {'id': newActivity.id, 'name': newActivity.name}
return sendResponse(data=data,
message='Actividad {} agregada'.format(
data['name']),
code=201)
def alter(self, instance, activity, **kwargs):
# 状態が draft の場合は通知しない
if activity and instance.pub_state == 'draft':
return None
if activity and activity.status == 'updated':
if activity.previous:
# 通知が必要な状態の変更を詳細に記録する
previous = activity.previous.snapshot
is_created = lambda x: (not getattr(previous, x) and getattr(
instance, x))
is_updated = lambda x: (getattr(previous, x) and getattr(
instance, x) and getattr(previous, x) != getattr(
instance, x))
is_deleted = lambda x: (getattr(previous, x) and not getattr(
instance, x))
remarks = []
attributes = (
'title',
'body',
'icon',
'status',
'category',
)
for attribute in attributes:
if is_created(attribute):
remarks.append(attribute + '_created')
elif is_updated(attribute):
remarks.append(attribute + '_updated')
elif is_deleted(attribute):
remarks.append(attribute + '_deleted')
if not remarks:
# 通知が必要な変更ではないため通知しない
return None
activity.remarks = "\n".join(remarks)
elif activity is None:
# m2m_updated
action = kwargs.get('action')
model = kwargs.get('model')
if action not in ('post_add', 'post_remove'):
# 追加/削除以外は通知しない
return None
if action == 'post_add' and instance.members.count() == 1:
# models.join_administratorシグナルによりpost_save処理より以前に
# 作成者参加が行われ project が作成される前に参加者が追加される
# したがって参加者が一人（join_administratorにより追加された直後）
# の場合に飛んできた m2m_signal は無視
return None
# 追加・削除をトラックするActivityを作成
ct = ContentType.objects.get_for_model(instance)
status = 'user_added' if action == 'post_add' else 'user_removed'
activity = Activity(content_type=ct,
object_id=instance.pk,
status=status)
# snapshot を保存
activity.snapshot = instance
# 追加・削除されたユーザーのIDを保存
activity.remarks = " ".join(map(str, kwargs.get('pk_set')))
return activity
def add(request):
name = request.POST.get('name','')
img = request.FILES.get('image','')
order = len(Activity.objects.all())
img.name = name + '.' + img.name.split('.')[-1]
activity = Activity(name=name,order=order,img=img)
activity.save()
return HttpResponseRedirect('/activities/edit/')
def test_saving_and_retrieving_activity(self):
new_activity = Activity()
new_activity.text = 'The new activity'
new_activity.save()
saved_activity = Activity.objects.all()
self.assertEqual(saved_activity.count(), 1)
only_activity = saved_activity[0]
self.assertEqual(only_activity.text, 'The new activity')
def vote(request):
answer_id = request.POST['answer']
answer = Answer.objects.get(pk=answer_id)
vote = request.POST['vote']
user = request.user
activity = Activity.objects.filter(Q(activity_type=Activity.UP_VOTE) | Q(activity_type=Activity.DOWN_VOTE), user=user, answer=answer_id)
if activity:
activity.delete()
if vote in [Activity.UP_VOTE, Activity.DOWN_VOTE]:
activity = Activity(activity_type=vote, user=user, answer=answer_id)
activity.save()
return HttpResponse(answer.calculate_votes())
def like(request):
feed_id = request.POST['feed']
feed = Feed.objects.get(pk=feed_id)
user = request.user
like = Activity.objects.filter(activity_type=Activity.LIKE, feed=feed_id, user=user)
if like:
user.profile.unotify_liked(feed)
like.delete()
else:
like = Activity(activity_type=Activity.LIKE, feed=feed_id, user=user)
like.save()
user.profile.notify_liked(feed)
return HttpResponse(feed.calculate_likes())
def favorite(request):
question_id = request.POST['question']
question = Question.objects.get(pk=question_id)
user = request.user
activity = Activity.objects.filter(activity_type=Activity.FAVORITE, user=user, question=question_id)
if activity:
activity.delete()
user.profile.unotify_favorited(question)
else:
activity = Activity(activity_type=Activity.FAVORITE, user=user, question=question_id)
activity.save()
user.profile.notify_favorited(question)
return HttpResponse(question.calculate_favorites())
def fetchStrava(code, request):
if request.user == '' or request.user == None:
request.user = '******'
access_token = getAccessToken(code)
activites_url = "https://www.strava.com/api/v3/athlete/activities"
header = {'Authorization': 'Bearer ' + access_token}
print("Fill database")
i = 1
while True:
param = {'per_page': 200, 'page': i}
current_activities = Activity.objects.filter(user=request.user)
current_ids = set([i.strava_id for i in current_activities])
print(len(current_activities))
print(len(current_ids))
strava_activities = requests.get(activites_url,
headers=header,
params=param).json()
print("current batch - " + str(len(strava_activities)))
if len(strava_activities) == 0:
break
i += 1
for strava_activity in strava_activities:
if strava_activity["id"] not in current_ids:
activity = Activity()
activity.strava_id = strava_activity["id"]
activity.user = request.user
activity.title = strava_activity["name"]
activity.activity_type = strava_activity["type"]
activity.date = datetime.strptime(
strava_activity['start_date'][2:10], '%y-%m-%d')
activity.timestamp = datetime.timestamp(activity.date)
if strava_activity['has_heartrate']:
activity.heartrate = strava_activity['average_heartrate']
if 'suffer_score' in strava_activity:
activity.suffer = strava_activity['suffer_score']
else:
activity.suffer = 0
else:
activity.heartrate = 0
activity.suffer = 0
activity.distance = strava_activity['distance'] / 1000
activity.moving_time = strava_activity['elapsed_time']
activity.elevation = strava_activity['total_elevation_gain']
activity.speed = strava_activity['average_speed']
if activity.activity_type == "Run" or activity.activity_type == "Ride":
if strava_activity['workout_type'] == None:
activity.workout_type = 'niks'
else:
activity.workout_type = strava_activity['workout_type']
activity.save()
def bulk_upload_activities(request):
path = 'bulk_upload/activities.csv'
with open(path, encoding="latin-1") as f:
reader = csv.reader(f)
for row in reader:
activity = Activity()
activity.name = row[0]
activity.activity_type = row[1]
activity.term = row[2]
activity.location = row[3]
activity.suburb = row[4]
activity.postcode = row[5]
activity.organiser = row[6]
activity.contact_number = row[7]
activity.description = row[8]
activity.activity_date = row[9]
activity.start_date = row[10]
activity.end_date = row[11]
activity.start_time = row[13]
activity.end_time = row[14]
activity.created_by = User.objects.get(username=row[15])
# Image Upload
if row[16] != '':
file_dir = 'bulk_upload/images/' + row[16]
image = open(file_dir, 'rb')
image_file = File(image)
activity.activity_img.save(row[16], image_file)
# Flyer Upload
if row[17] != '':
file_dir = 'bulk_upload/flyers/' + row[17]
flyer = open(file_dir, 'rb')
flyer_file = File(flyer)
activity.flyer.save(row[17], flyer_file)
activity.min_age = row[18]
activity.max_age = row[19]
activity.background = row[20]
activity.living_duration = row[21]
activity.gender = row[22]
if row[23] != '':
activity.cost = row[23]
if row[24] != '':
activity.space = row[24]
activity.cost_choice = row[25]
activity.space_choice = row[26]
activity.save()
f.close()
return HttpResponse("Success uploading activities.")
def new_comment_signal(sender, instance=None, created=False, **kwargs):
if created:
post = instance.post
user = instance.user
post_owner = post.user
if (post.is_paid() and user.is_vet()
and post_owner.vet_reply_notification):
send_notification_message(post_owner.id, vet_commenting_post)
elif post_owner.comments_notification:
send_notification_message(post_owner.id, commenting_post)
activity = Activity(user=user,
action=Activity.COMMENT,
post=post,
comment=instance)
activity.save()
def post_like(request):
post_id = request.POST['post']
post = Post.objects.get(pk=post_id)
user = request.user
like = Activity.objects.filter(activity_type=Activity.LIKE,
post=post_id,
user=user)
if like:
user.profile.unotify_post_liked(post)
like.delete()
else:
like = Activity(activity_type=Activity.LIKE, post=post_id, user=user)
like.save()
user.profile.notify_post_liked(post)
return HttpResponse(post.calculate_likes())
def pubsvn(github):
u = users.objects.get(svn=github)
if Group.objects.filter(name="Commit").exists():
g = Group.objects.get(name="Commit")
else:
Group(name="Commit").save()
g = Group.objects.get(name="Commit")
if Entity.objects.filter(name="Commit", group=g).exists():
en = Entity.objects.get(name="Commit")
else:
Entity(name="Commit", group=g).save()
en = Entity.objects.get(name="Commit")
r = svn.remote.RemoteClient('http://svn.apache.org/repos/asf/')
entries = r.list()
for filename in entries:
r = svn.remote.RemoteClient('http://svn.apache.org/repos/asf/' + filename)
if Project.objects.filter(name=filename).exists():
pr = Project.objects.get(name=filename)
#UserParticipation(user=u, project=pr).save()
else:
p = Project(name=filename, description=filename)
p.save()
pr = Project.objects.get(name=filename)
#UserParticipation(user=u, project=pr)
e = r.list()
for file in e:
if file == "trunk/":
a = svn.remote.RemoteClient('http://svn.apache.org/repos/asf/' + filename + "trunk")
i = 0
for log in a.log_default():
if log[3] == github:
if Measurement.objects.filter(value=log[2]).exists():
continue
else:
i=i+1
Activity(comments="SVN commit " + str(i) + " " + str(filename) +" " + str(github), entity=en).save()
ac = Activity.objects.get(comments="SVN commit " + str(i) + " " + str(filename) +" " + str(github))
Measurement(activity=ac, type="char", name="Type", value="SVN Commit").save()
Measurement(activity=ac, type='char', name="User", value=github).save()
Measurement(activity=ac, type="char", name="Scommit_ID", value=log[2]).save()
if log[1]:
Measurement(activity=ac, type="char", name="Scommit_message", value=log[1]).save()
else:
Measurement(activity=ac, type="char", name="Scommit_message", value="Nothing").save()
return HttpResponse("Done")
def follow(request):
try:
user_id = request.GET['user-id']
to_user = get_object_or_404(User, pk=user_id)
from_user = request.user
following = from_user.profile.get_following()
if to_user not in following:
activity = Activity(from_user=from_user,
to_user=to_user,
activity_type=Activity.FOLLOW)
activity.save()
return HttpResponse()
else:
return HttpResponseBadRequest()
except:
return HttpResponseBadRequest()
def like(request): #创建点赞和撤销点赞
article_id = request.POST['article']
article = Article.objects.get(pk=article_id)
user = request.user
like = Activity.objects.filter(activity_type=Activity.LIKE,
article=article_id,
user=user) #查询该用户是否点过赞
if like: #点过赞的撤销
user.profile.unotify_liked(article)
like.delete()
else: #没有点过赞的点赞
like = Activity(activity_type=Activity.LIKE,
article=article_id,
user=user)
like.save()
user.profile.notify_liked(article)
return HttpResponse(str(
article.calculate_likes())) #返回赞数,ajax用httpresponse，返回数据
def get(self, request, task_id):
user_id = request.session.get('userauth', {}).get('user_id')
try:
task_obj = Task.objects.get(id=task_id, user_id=user_id)
task_name = task_obj.name
task_obj.delete()
messages.success(request, "Task Deleted successfully !")
# update activity
activity_dict = {
'user_id': user_id,
'message': 'You deleted Task, {}'.format(str(task_name))
}
Activity(**activity_dict).save()
except Exception as e:
print(e)
return redirect ('task-list')
def index(request):
results = {}
today = timezone.now()
if request.user.is_staff:
yesterday = today - datetime.timedelta(days=1)
results['yesterday'] = Activity.objects.filter(
activity_date=yesterday.date())
results['today'] = Activity.objects.filter(activity_date=today)
context = {'results': results, 'yesterday': yesterday, 'today': today}
return render(request, 'activities/admin_dashboard.html', context)
else:
results['all'] = Activity.objects.filter(
author__username=request.user.username)
results['today'] = [
item for item in results['all']
if item.activity_date == today.date()
]
results['last_seven_days'] = [item for item in results['all'] \
if (item.activity_date + datetime.timedelta(days=7) > today.date() \
and item.activity_date < today.date())]
if request.method == "POST":
form = ActivityForm(request.POST)
if form.is_valid():
activity = Activity(
author=request.user,
description=form.cleaned_data["description"],
activity_date=form.cleaned_data["activity_date"],
activity_type=form.cleaned_data["activity_type"],
ticket_number=form.cleaned_data["ticket_number"],
hours_worked=form.cleaned_data["hours_worked"],
comment=form.cleaned_data["comment"])
activity.save()
messages.add_message(request, messages.SUCCESS,
"Activity added successfully!")
return redirect(reverse('index'))
else:
form = ActivityForm()
context = {
'name': request.user.username,
'results': results,
'form': form,
'today': today.date()
}
return render(request, "activities/dashboard.html", context)
def review_like(request):
review_id = request.POST['review']
review = Review.objects.get(pk=review_id)
user = request.user
like = Activity.objects.filter(activity_type=Activity.LIKE,
review=review_id,
user=user)
if like:
user.profile.unotify_review_liked(review)
like.delete()
else:
like = Activity(activity_type=Activity.LIKE,
review=review_id,
user=user)
like.save()
user.profile.notify_review_liked(review)
return HttpResponse(review.calculate_likes())
def question_vote(request):
question_id = request.POST['question']
question = Question.objects.get(pk=question_id)
vote = request.POST['vote']
user = request.user
activity = Activity.objects.filter(
Q(activity_type=Activity.UP_VOTE)
| Q(activity_type=Activity.DOWN_VOTE), # noqa: E501
user=user,
question=question_id)
if activity:
activity.delete()
if vote in [Activity.UP_VOTE, Activity.DOWN_VOTE]:
activity = Activity(activity_type=vote,
user=user,
question=question_id)
activity.save()
return HttpResponse(question.calculate_votes())
def post(request): #feeds on profiles
to_user = request.POST.get('to_user')
# profile_pk = request.POST.get('profile_pk')
# last_feed = request.POST.get('last_feed')
to_user = get_object_or_404(User, username=to_user)
to_user_profile_pk = to_user.profile.pk
user = request.user
csrf_token = (csrf(request)['csrf_token'])
feed = Feed()
feed.user = user
feed.to_user = to_user
feed.profile_pk = to_user_profile_pk
# if not to_user:
# feed.profile_pk = profile_pk
# else:
# feed.profile_pk = to_user.profile.pk
# profile_pk = to_user.profile.pk
post = request.POST['post']
post = post.strip()
if len(post) > 0 and to_user:
feed.post = post[:255]
feed.save()
profile = Profile.objects.get(pk=to_user_profile_pk) # to_user_profile
# wrote_on_profile = Activity.objects.filter(activity_type=Activity.WROTE_ON_PROFILE, profile=profile_pk,
# user=user)
wrote_on_profile = Activity(activity_type=Activity.WROTE_ON_PROFILE, profile=to_user_profile_pk, user=user)
wrote_on_profile.save()
user.profile.notify_wrote_on_profile(profile,feed)
html = ''
html = '{0}{1}'.format(html,
render_to_string('feeds/partial_feed_profile.html',
{
'feed': feed,
'user': request.user,
'csrf_token': csrf_token,
}))
else:
html = ''
return HttpResponse(html)
def svna(github,urls):
u = users.objects.get(svn=github)
if Group.objects.filter(name="Commit").exists():
g = Group.objects.get(name="Commit")
else:
Group(name="Commit").save()
g = Group.objects.get(name="Commit")
if Entity.objects.filter(name="Commit", group=g).exists():
en = Entity.objects.get(name="Commit")
else:
Entity(name="Commit", group=g).save()
en = Entity.objects.get(name="Commit")
for url in urls.split(','):
r = svn.remote.RemoteClient(url)
info=r.info()
if Project.objects.filter(name=info['entry_path']).exists():
pr = Project.objects.get(name=info['entry_path'])
#UserParticipation(user=u, project=pr).save()
else:
p = Project(name=info['entry_path'], description=info['entry_path'])
p.save()
pr = Project.objects.get(name=info['entry_path'])
#UserParticipation(user=u, project=pr)
i=0
for log in r.log_default():
if log[3] == github:
if Measurement.objects.filter(value=log[1]).exists():
continue
else:
i = i + 1
Activity(comments="SVN commit " + str(i) + " " + str(info['entry_path']) +" " + str(github), entity=en).save()
ac = Activity.objects.get(comments="SVN commit " + str(i) + " " + str(info['entry_path']) +" " + str(github))
Measurement(activity=ac, type="char", name="Type", value="SVN Commit").save()
Measurement(activity=ac, type='char', name="User", value=github).save()
Measurement(activity=ac, type="char", name="Scommit_ID", value=log[2]).save()
if log[1]:
Measurement(activity=ac, type="char", name="Scommit_message", value=log[1]).save()
else:
Measurement(activity=ac, type="char", name="Scommit_message", value="Nothing").save()
return HttpResponse("Done")
def post(self, request, *args, **kwargs):
user = request.user
form = self.get_form()
if form.is_valid():
vehicle_id = request.POST['vehicle']
form.save()
vehicle = Vehicle.objects.get(pk=vehicle_id)
activity = Activity.objects.filter(activity_type=Activity.BOOK,
user=user, vehicle=vehicle_id)
if activity:
activity.delete()
user.profile.unotify_booked(vehicle)
else:
activity = Activity(activity_type=Activity.BOOK, user=user,
vehicle=vehicle_id)
activity.save()
user.profile.notify_booked(vehicle)
return self.form_valid(form)
else:
return self.form_invalid(form)
def project_add_activity(request, pk):
project = get_object_or_404(models.Project, pk=pk)
activity = Activity(project=project)
if in_list(project.status, '6,7,8'):
messages.error(request,
'Projeto já Em Andamento / Encerrado / Cancelado.')
return redirect(reverse('project:detail', kwargs={'pk': project.pk}))
if not has_group(request.user,
'project_leader') or project.leader != request.user:
messages.error(
request,
'Apenas o Lider do Projeto pode adicionar ima atividade ao projeto.'
)
return redirect(reverse('project:detail', kwargs={'pk': project.pk}))
if request.method == 'POST':
form = forms.NewProjectActivityForm(request.POST, instance=activity)
if form.is_valid():
form.save()
project.status = 1
project.save()
messages.success(request, 'Atividade cadastrada com sucesso.')
else:
messages.error(request,
'Falha ao cadastrar a atividade do projeto.')
return render(request, 'projects/project_add_activity.html',
{'form': form})
return redirect(reverse('project:detail', kwargs={'pk': project.pk}))
else:
form = forms.NewProjectActivityForm(instance=activity)
return render(request, 'projects/project_add_activity.html',
{'form': form})
def create_view(request):
if not request.user.can_create_vote:
return redirect('/activities/list/')
if request.POST:
activity = Activity()
activity.title = request.POST.get('title', '')
activity.vote_num_per_user = request.POST.get('vote_num_per_user', 8)
activity.sponsor = request.user
activity.end_datetime = request.POST.get('end_datetime', None)
activity.save()
images = request.FILES.getlist('option_image', [])
contents = request.POST.getlist('option_content', [])
for image, content in zip(images, contents):
option = Option()
option.image = image
option.content = content
option.activity = activity
option.save()
return redirect('/activities/detail/%s/' % activity.id)
else:
return render(request, 'activities/create.html')
def profile_like(request):
profile_pk = request.POST['profile_pk']
profile = Profile.objects.get(pk=profile_pk)
user = request.user
like = Activity.objects.filter(activity_type=Activity.LIKE_PROFILE, profile=profile_pk,
user=user)
if like:
user.profile.unotify_liked_profile(profile)
print('request user: %s had already liked this user so \
you are gonna be removed from the liker list of this user\
and It should appear Like text on button'
%(request.user.username))
like.delete()
else:
like = Activity(activity_type=Activity.LIKE_PROFILE, profile=profile_pk, user=user)
print('request user: %s had not liked this user so \
you are gonna be added in liker list of this user\
and It should appear UnLike on button'
%(request.user.username))
like.save()
user.profile.notify_liked_profile(profile) # from user to => profile wala_user
return HttpResponse(profile.calculate_likes())
def booking(request):
user = request.user
form = BookingForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
vehicle = Vehicle.objects.get(pk=2)
activity = Activity.objects.filter(activity_type=Activity.BOOK,
user=user, vehicle=2)
if activity:
activity.delete()
user.profile.unotify_booked(vehicle)
else:
activity = Activity(activity_type=Activity.BOOK, user=user,
vehicle=2)
activity.save()
user.profile.notify_booked(vehicle)
return redirect('/')
else:
return HttpResponse('Error')
return render(request, 'booking_form.html', {'form':form} )
def create(self, validated_data):
print('Create activity')
age = validated_data.pop('age')
level = validated_data.pop('level')
time = validated_data.pop('time')
group = validated_data.pop('group')
supervised = validated_data.pop('supervised')
cost = validated_data.pop('cost')
location = validated_data.pop('location')
skills = validated_data.pop('skills')
learning = validated_data.pop('learning')
translations = validated_data.pop('translations')
authors = validated_data.pop('authors')
activity = Activity(**validated_data)
if time:
activity.time = MetadataOption.objects.get_or_create(**time)[0]
if group:
activity.group = MetadataOption.objects.get_or_create(**group)[0]
if supervised:
activity.supervised = MetadataOption.objects.get_or_create(
**supervised)[0]
if cost:
activity.cost = MetadataOption.objects.get_or_create(**cost)[0]
if location:
activity.location = MetadataOption.objects.get_or_create(
**location)[0]
if learning:
activity.learning = MetadataOption.objects.get_or_create(
**learning)[0]
activity.save()
for age_item in age:
activity.age.add(
MetadataOption.objects.get_or_create(**age_item)[0])
for level_item in level:
activity.level.add(
MetadataOption.objects.get_or_create(**level_item)[0])
for skills_item in skills:
activity.skills.add(
MetadataOption.objects.get_or_create(**skills_item)[0])
for author in authors:
author.update(activity=activity)
activity.authors.add(
AuthorInstitution.objects.get_or_create(**author)[0])
activity.save()
for translation in translations:
translation.update(master=activity)
t = ActivityTranslation(**translation)
t.save()
return activity
def git(github):
u = users.objects.get(githubid=github)
root = tkinter.Tk()
root.withdraw()
access = simpledialog.askstring("Accesstoken", "Accesstoken")
if Group.objects.filter(name="Commit").exists():
g = Group.objects.get(name="Commit")
else:
Group(name="Commit").save()
g = Group.objects.get(name="Commit")
if Group.objects.filter(name="Issue").exists():
gi = Group.objects.get(name="Issue")
else:
Group(name="Issue").save()
gi = Group.objects.get(name="Issue")
if Entity.objects.filter(name="Commit", group=g).exists():
e = Entity.objects.get(name="Commit")
else:
Entity(name="Commit", group=g).save()
e = Entity.objects.get(name="Commit")
if Entity.objects.filter(name="Issue", group=gi).exists():
ei = Entity.objects.get(name="Issue")
else:
Entity(name="Issue", group=gi).save()
ei = Entity.objects.get(name="Issue")
for repo in count_user_commits(access):
if Project.objects.filter(name=repo['name']).exists():
pr = Project.objects.get(name=repo['name'])
#UserParticipation(user=u, project=pr).save()
else:
p = Project(name=repo['name'], description=repo['name'])
p.save()
pr = Project.objects.get(name=repo['name'])
#UserParticipation(user=u, project=pr)
r = json.loads(requests.get(repo['commits_url'][:-6]+'?access_token=%s' % access).content)
r1 = json.loads(requests.get(repo['issue_comment_url'][:-9]+'?access_token=%s' % access).content)
for k in range(0, len(r1)):
if Measurement.objects.filter(value=r[i]['id']).exists():
continue
else:
Activity(comments="Git Issue " + str(k) + " " + str(repo['name']), entity=ei).save()
a = Activity.objects.get(comments="Git Issue " + str(i) + " " + str(repo['name']))
Measurement(activity=a, type="char", name="Type", value="Git Issue").save()
Measurement(activity=a, type="char", name="GIssue_ID", value=r[i]['id']).save()
Measurement(activity=a, type="char", name="GIssue_ID", value=r[i]['body']).save()
for i in range(0, len(r)):
if Measurement.objects.filter(value=r[i]['sha']).exists():
continue
else:
Activity(comments="Git commit " + str(i) + " " + str(repo['name']) + " " + str(github), entity=e).save()
a = Activity.objects.get(comments="Git commit " + str(i) + " " + str(repo['name']) +" " + str(github))
rr = requests.get(r[i]['url']+'?access_token=%s' % access)
rr = json.loads(rr.content)
d = rr['stats']['deletions']
l = rr['stats']['additions']
no = len(rr['files'])
date = rr['commit']['committer']['date'].split("T")[0]
t = rr['commit']['committer']['date'].split("T")[1][:-1]
day = datetime.datetime.strptime(date, '%Y-%m-%d').strftime('%A')
if 6 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 12:
time = 1
elif 12 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 18:
time = 2
elif 18 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 24:
time = 3
elif 0 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 6:
time = 4
da = Day(day)
Measurement(activity=a, type="char", name="Type", value="Git Commit").save()
Measurement(activity=a, type='char', name="User", value=github).save()
Measurement(activity=a, type="char", name="Gcommit_ID", value=r[i]['sha']).save()
Measurement(activity=a, type="char", name="Gcommit_deletions", value=d).save()
Measurement(activity=a, type="char", name="Gcommit_addition", value=l).save()
Measurement(activity=a, type="char", name="Gcommit_nooffiles", value=no).save()
Measurement(activity=a, type="char", name="Gcommit_timelabel", value=time).save()
Measurement(activity=a, type="char", name="Gcommit_daylabel", value=da).save()
Measurement(activity=a, type="char", name="Gcommit_message",
value=re.sub('\n', ' ', r[i]['commit']['message']).encode('utf-8', 'ignore')).save()
return HttpResponse("Done")
def bit(github):
root = tkinter.Tk()
root.withdraw()
bitpassword = simpledialog.askstring("Password", "Enter Password", show='*')
headers = {'Content-Type': 'application/json'}
A = bitbuckted_project(github,bitpassword)
u = users.objects.get(bitbucket=github)
if Group.objects.filter(name="Commit").exists():
g = Group.objects.get(name="Commit")
else:
Group(name="Commit").save()
g = Group.objects.get(name="Commit")
if Group.objects.filter(name="Issue").exists():
g1 = Group.objects.get(name="Issue")
else:
Group(name="Issue").save()
g1 = Group.objects.get(name="Issue")
if Entity.objects.filter(name="Commit", group=g).exists():
e = Entity.objects.get(name="Commit")
else:
Entity(name="Commit", group=g).save()
e = Entity.objects.get(name="Commit")
if Entity.objects.filter(name="Issue", group=g1).exists():
e1 = Entity.objects.get(name="Issue")
else:
Entity(name="Issue", group=g1).save()
e1 = Entity.objects.get(name="Issue")
if Activity.objects.filter(comments="BitBucketCommit").exists():
a = Activity.objects.get(comments="BitBucketCommit")
else:
Activity(comments="BitBucketCommit", entity=e).save()
a = Activity.objects.get(comments="BitBucketCommit")
if Activity.objects.filter(comments="BitBucketissue").exists():
a1 = Activity.objects.get(comments="BitBucketissue")
else:
Activity(comments="BitBucketissue", entity=e1).save()
a1 = Activity.objects.get(comments="BitBucketissue")
message = []
count = 0
for i in A:
if Project.objects.filter(name=i).exists():
pr = Project.objects.get(name=i)
#UserParticipation(user=u, project=pr).save()
else:
p = Project(name=i, description=i)
p.save()
pr = Project.objects.get(name=i)
#UserParticipation(user=u, project=pr)
comm, mess, date, br = bitbuckted_commit(github,bitpassword)
r = requests.get("https://api.bitbucket.org/2.0/repositories/%s" % github, auth=(github, bitpassword), headers=headers)
repos = json.loads(r.content)
for m in repos['values']:
r = requests.get("https://api.bitbucket.org/2.0/repositories/" + github + "/" + m['name'],auth=(github, bitpassword), headers=headers )
r = json.loads(r.content)
if r['has_issues']:
r = json.loads(requests.get(r['links']['issues']['href'],auth=(github, bitpassword), headers=headers).content)
for i in r['values']:
if Measurement.objects.filter(value=i['id']).exists():
continue
else:
Measurement(activity=a, type="char", name="BitBucketCommit_ID", value=i['id']).save()
Measurement(activity=a, type="char", name="BitBucketCommit_kind", value=i['kind']).save()
Measurement(activity=a, type="char", name="BitBucketCommit_name", value=i['repository']['name']).save()
Measurement(activity=a, type="char", name="BitBucketCommit_priority", value=i['priority']).save()
Measurement(activity=a, type="char", name="BitBucketCommit_title", value=i['title']).save()
for i in range(len(comm)):
if Measurement.objects.filter(value=comm[i]).exists():
continue
else:
da = date[i].split("T")[0]
t = date[i].split("T")[1].split('+')[0]
da = datetime.datetime.strptime(da, '%Y-%m-%d').strftime('%A')
if 6 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 12:
time = 1
elif 12 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 18:
time = 2
elif 18 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 24:
time = 3
elif 0 <= int(t.split(":")[0]) and int(t.split(":")[0]) < 6:
time = 4
da = Day(da)
Measurement(activity=a, type="char", name="BitBucketCommit_ID", value=comm[i]).save()
Measurement(activity=a, type="char", name="BitBucketCommit_Day", value=da).save()
Measurement(activity=a, type="char", name="BitBucketCommit_Time", value=t).save()
Measurement(activity=a, type="char", name="BitBucketCommit_branch", value=br[i]).save()
Measurement(activity=a, type="char", name="BitBucketCommit_message", value=mess[i]).save()
return HttpResponse(str("Done"))
