def correct_url(request, object_id):
"""修正请求url"""
resolved_url = resolve(request.path_info)
url_name = resolved_url.url_name
url_kwargs = resolved_url.kwargs
if object_id:
# 对于只有object_id没有app_id的 重定向到有app_id的url
modeladmin = view.__self__
try:
obj = modeladmin.model.objects.get(pk=object_id)
except modeladmin.model.DoesNotExist:
return response.HttpResponseBadRequest()
url_kwargs.update(wechat_app_id=obj.app_id, object_id=object_id)
return response.HttpResponseRedirect(reverse("admin:" + url_name,
kwargs=url_kwargs),
status=307)
else:
# 对于没有app_id的listview请求 优先取referrer的app_id
referrer = request.META.get("HTTP_REFERER", "")
path_info = urlparse(referrer).path
try:
app_id = resolve(path_info).kwargs["wechat_app_id"]
except (KeyError, Resolver404):
return response.HttpResponseNotFound()
url_kwargs.update(wechat_app_id=app_id)
resp = response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
resp.status_code = 307
return resp
def updateNewPost(request, profile):
p = Profile.objects.get(username=profile)
try:
profile = instaloader.Profile.from_username(L.context, p.username)
except LoginRequiredException:
L.login("socialanalysiscld", "progettocloud123.")
profile = instaloader.Profile.from_username(L.context, p.username)
p.allPost = profile.mediacount
postFirst = Post.objects.filter(profile_id = p.id).first()
likes = 0
comments = 0
counterpost=0
SINCE = datetime(postFirst.datePost.year, 12, 31)
UNTIL = datetime(postFirst.datePost.year, postFirst.datePost.month, postFirst.datePost.day)
listURI = Post.objects.values_list('uriPost', flat = True).filter(profile_id = p.id)
for post in takewhile(lambda p: p.date > UNTIL, dropwhile(lambda p: p.date > SINCE, profile.get_posts())):
if post.shortcode not in listURI:
likes += post.likes
comments += post.comments
counterpost += 1
uriPost = post.shortcode
bio = post.caption
Post(profile=Profile.objects.get(username=p.username), uriPost=uriPost, bioPost=bio if bio is not None and len(bio) <= 1500 else "No Bio", nLikes=post.likes, nComments=post.comments, datePost=post.date).save()
if counterpost != 0 :
p.totalLikes = p.totalLikes + likes
p.totalComments += comments
p.postContacts += counterpost
p.save()
return response.HttpResponseRedirect(reverse('polls:profile', args=(p.id,)))
def request_material(request):
"""
Controller for handling request_material form
"""
if request.method == 'POST':
course_code = request.POST.get('course_code', "None")
sem = request.POST.get('sem', "None")
year = request.POST.get('year', "None")
type_file = request.POST.get('type_file', "None")
prof = request.POST.get('professor', "None")
other = request.POST.get('other_info', '')
with open(REQUESTS_FILE, 'r') as file:
data = json.load(file)
new_request = {
"course_code": course_code.upper(),
"sem": sem,
"year": year,
"type_file": type_file,
"prof": prof,
"other_info": other
}
if len(data) == 0:
data = []
data.append(new_request)
with open(REQUESTS_FILE, 'w') as file:
json.dump(data, file)
return response.HttpResponseRedirect(reverse('requests'))
else:
profs = json.loads(open("profs.json", "r").read(), object_pairs_hook=OrderedDict)
return render(request, 'books/requestsForm.html', {"profs": profs})
def borrow_book_request(request, pk, id):
book_instance = get_object_or_404(BookInstance, id=id)
if request.method == 'POST':
form = BorrowRequestForm(request.POST)
if form.is_valid():
return_date = form.cleaned_data['return_date']
requester = request.user
requested_book = RequestedBooks(book_id=book_instance,
return_date=return_date,
requester=requester)
requested_book.save()
return response.HttpResponseRedirect(reverse('dashboard'))
else:
proposed_return_date = datetime.date.today() + datetime.timedelta(
weeks=1)
form = BorrowRequestForm(initial={'return_date': proposed_return_date})
context = {
'form': form,
'book_instance': book_instance,
}
return render(request, 'books/book_borrow_request.html', context)
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
# Only proceed if the form is valid
# Get the data out of the form
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
auth_token = form.cleaned_data['auth_token']
token = AuthTokens.objects.get(
human_readable_tkn__exact=auth_token)
if token:
# If the token is valid, aka exists in the lookup table
user = User.objects.create_user(username=username,
password=password,
is_impact=True)
# Delete the old token
token.delete()
# Log the user in
login(request, user)
# Redirect to the login page
return response.HttpResponseRedirect(
reverse_lazy('auth_system-login_portal'))
# Return an error
return render(request, self.template_name, {'form': form})
# If the form is invalid
form.add_error('password1', 'Password too weak')
return render(request, self.template_name, {'form': form})
def decorated_func(request, *args, **kwargs):
app_id = kwargs.pop("wechat_app_id", None)
object_id = kwargs.get("object_id", None)
if not app_id:
resolved_url = resolve(request.path_info)
url_name = resolved_url.url_name
url_kwargs = resolved_url.kwargs
if object_id:
# 对于只有object_id没有app_id的 重定向到有app_id的url
modeladmin = view.__self__
try:
obj = modeladmin.model.objects.get(pk=object_id)
except modeladmin.model.DoesNotExist:
return response.HttpResponseBadRequest()
url_kwargs.update(wechat_app_id=obj.app_id,
object_id=object_id)
return response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
else:
# 对于没有app_id的listview请求 优先取referrer的app_id
referrer = request.META.get("HTTP_REFERER", "")
path_info = urlparse(referrer).path
try:
app_id = resolve(path_info).kwargs["wechat_app_id"]
except (KeyError, Resolver404):
return response.HttpResponseNotFound()
url_kwargs.update(wechat_app_id=app_id)
resp = response.HttpResponseRedirect(
reverse("admin:" + url_name, kwargs=url_kwargs))
resp.status_code = 307
return resp
extra_context = kwargs.pop("extra_context", None) or {}
try:
app = site.wechat_site.app_queryset.get(id=app_id)
except WeChatApp.DoesNotExist:
return response.HttpResponseNotFound()
# 附上app
request.app = app
request.app_id = app_id
# 增加模板context
extra_context.update(wechat_app=app, wechat_app_id=app_id)
kwargs["extra_context"] = extra_context
return view(request, *args, **kwargs)
def form_valid(self, form):
form.save()
messages.add_message(
self.request,
messages.SUCCESS,
_("We sent you an email with instructions to log into your account."),
)
return response.HttpResponseRedirect(self.get_success_url())
def _get_exam_enrollment_form(off_year, request, stud):
learn_unit_enrols = mdl_base.learning_unit_enrollment.find_by_student_and_offer_year(
stud, off_year)
if not learn_unit_enrols:
messages.add_message(
request, messages.WARNING,
_('no_learning_unit_enrollment_found').format(off_year.acronym))
return response.HttpResponseRedirect(reverse('dashboard_home'))
data = exam_enrollment_request.find_by_student(stud)
if data:
try:
data = json.loads(data.document)
except json.JSONDecodeError:
logger.exception("Json data is not valid")
finally:
exam_enrollment_request.pop_document(
data.get('offer_year_acronym'), stud)
if data.get('error_message'):
error_message = _(data.get('error_message')).format(
off_year.acronym)
else:
error_message = data.get('error_message')
return layout.render(
request, 'exam_enrollment_form.html', {
'error_message':
error_message,
'exam_enrollments':
data.get('exam_enrollments'),
'student':
stud,
'current_number_session':
data.get('current_number_session'),
'academic_year':
mdl_base.academic_year.current_academic_year(),
'program':
mdl_base.offer_year.find_by_id(off_year.id),
'request_timeout':
settings.QUEUES.get("QUEUES_TIMEOUT").get(
"EXAM_ENROLLMENT_FORM_RESPONSE")
})
else:
ask_exam_enrollment_form(stud, off_year)
return layout.render(
request, 'exam_enrollment_form.html', {
'exam_enrollments':
"",
'student':
stud,
'current_number_session':
"",
'academic_year':
mdl_base.academic_year.current_academic_year(),
'program':
mdl_base.offer_year.find_by_id(off_year.id),
'request_timeout':
settings.QUEUES.get("QUEUES_TIMEOUT").get(
"EXAM_ENROLLMENT_FORM_RESPONSE")
})
def _process_exam_enrollment_form_submission(off_year, request, stud):
data_to_submit = _exam_enrollment_form_submission_message(off_year, request, stud)
json_data = json.dumps(data_to_submit)
offer_enrol = offer_enrollment.get_by_student_offer(stud, off_year)
if json_data and offer_enrol:
exam_enrollment_submitted.insert_or_update_document(offer_enrol, json_data)
queue_sender.send_message(settings.QUEUES.get('QUEUES_NAME').get('EXAM_ENROLLMENT_FORM_SUBMISSION'), data_to_submit)
messages.add_message(request, messages.SUCCESS, _('exam_enrollment_form_submitted'))
return response.HttpResponseRedirect(reverse('dashboard_home'))
def insertInProfile(request, profile): # aggiungere la data da cui scaricare i post
p = Profile.objects.get(username=profile)
#L = instaloader.Instaloader()
try:
profile = instaloader.Profile.from_username(L.context, p.username)
except LoginRequiredException:
L.login("socialanalysiscld", "progettocloud123.")
profile = instaloader.Profile.from_username(L.context, p.username)
#
#L = instaloader.Instaloader()
#profile = instaloader.Profile.from_username(L.context, p.username)
if p.isPrivate is False:
if profile.is_private:
p.isPrivate = True
p.save()
result = postDates(p)
else:
dateREQ = request.POST.getlist('checkYear') #prendo tutte le date dalla request
date=[]
for dateX in dateREQ:
date.append(dateX)
dates = []
dateDB = p.nDatePostSaved.split(", ")
for dateToInsert in date:
if dateToInsert not in dateDB:
p.nDatePostSaved = p.nDatePostSaved + str(dateToInsert) + ", "
dates.append(dateToInsert)
if len(dates) > 0:
for data in dates:
dataPost = savePost(p.username, data)
if dataPost[2] != 0 :
p.totalLikes = p.totalLikes + dataPost[0]
p.totalComments += dataPost[1]
p.postContacts += dataPost[2]
p.save()
result = postDates(p)
elif p.isPrivate is True:
if profile.is_private:
result = postDates(p)
else:
p.isPrivate=False
result = postDates(p)
p.save()
context = {
'profile' : p,
'dateMancanti': result,
'averangeLikes': round(p.totalLikes/p.postContacts,2) if p.postContacts!=0 else 0,
'averangeComments':round(p.totalComments/p.postContacts, 2) if p.postContacts!=0 else 0,
'engagementProfile': round(float(p.totalLikes + p.totalComments) / (p.followers * p.postContacts),2) if p.postContacts!=0 else 0,
'template' : "post.html",
}
return response.HttpResponseRedirect(reverse('polls:profile', args=(p.id,)))
def customerViewAdd(request):
if request.method == 'POST':
form = customerInputForm(request.POST)
if form.is_valid():
form.save()
return response.HttpResponseRedirect('customers')
else:
form = customerInputForm()
return render(request, 'accounts/customersAdd.html', {'form': form})
def get(self, request, *args, **kwargs):
token = kwargs["token"]
user = authenticate(request, token=token)
if user is None:
raise PermissionDenied
else:
login(self.request, user=user)
# Remove token from the HTTP Referer header
self.request.path.replace(token, INTERNAL_LOGIN_URL_TOKEN)
return response.HttpResponseRedirect(self.get_success_url())
def response_object_tool(self, request, action, obj=None, extra_context=None):
"""Handle an admin object tool"""
rv = action(self, request, obj)
if isinstance(rv, SimpleTemplateResponse):
rv.context_data = rv.context_data or dict()
extra_context and rv.context_data.update(extra_context)
return rv
elif isinstance(rv, response.HttpResponseBase):
return rv
else:
redirect_url = self._get_post_objecttool_url(request)
return response.HttpResponseRedirect(redirect_url)
def updateNuoviCommenti(request, post_id):
limit = 1
ids=list()
postDB = Post.objects.get(id=post_id)
L.login("socialanalysiscld", "progettocloud123.")
try:
post = instaloader.Post.from_shortcode(L.context, postDB.uriPost)
except LoginRequiredException:
L.login("socialanalysiscld", "progettocloud123.")
post = instaloader.Post.from_shortcode(L.context, postDB.uriPost)
all_id_socail = All_Social_Id.objects.values_list('an_id_social', flat=True)
for comment in post.get_comments():
if limit <= 50:
if remove_emoji(comment.text) != '':
if comment.id not in all_id_socail:
if limit <= 50:
All_Social_Id(post=postDB, an_id_social=comment.id).save()
Comments(post=postDB, id_social=comment.id, comment_text=comment.text if len(comment.text) <= 200 else comment.text[:200], owner = comment.owner.username, likesCount = comment.likes_count).save()
ids.append(comment.id)
limit += 1
else:
comm = Comments.objects.get(id_social=comment.id)
if comm.likesCount != comment.likes_count:
comm.likesCount = comment.likes_count
if comm.comment_text != comment.text:
comm.comment_text = comment.text if len(comment.text) <= 200 else comment.text[:200]
ids.append(comment.id)
comm.save()
else:
break
payload = "&ids="+str(ids)
requests.post(FUNCTION_APP+payload)
if postDB.nComments != post.comments:
postDB.nComments = post.comments
if limit > 1:
postDB.nCommentsCount = postDB.nCommentsCount + limit
totPosSentComm = Comments.objects.filter(post_id = postDB.id).exclude(sentiment = "Invalid Lang").aggregate(Sum('positive'))['positive__sum']
totNeutralSentComm = Comments.objects.filter(post_id = postDB.id).exclude(sentiment = "Invalid Lang").aggregate(Sum('neutral'))['neutral__sum']
totNegativeSentComm = Comments.objects.filter(post_id = postDB.id).exclude(sentiment = "Invalid Lang").aggregate(Sum('negative'))['negative__sum']
totDivComm = Comments.objects.filter(post_id = postDB.id).exclude(sentiment = "Invalid Lang").count()
postDB.avgPositiveSentiment = totPosSentComm/totDivComm if totDivComm != 0 and totPosSentComm != None else 0
postDB.avgNeutralSentiment = totNeutralSentComm/totDivComm if totDivComm != 0 and totNeutralSentComm != None else 0
postDB.avgNegativeSentiment = totNegativeSentComm/totDivComm if totDivComm != 0 and totNegativeSentComm != None else 0
if post.likes != postDB.nLikes:
postDB.totalLikes = post.likes
postDB.save()
L.close()
return response.HttpResponseRedirect(reverse('polls:post', args=(postDB.id,)))
def employeeViewAdd(request):
if request.method == 'POST':
form = employeeInputForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.set_password(user.password)
form.save()
return response.HttpResponseRedirect('employee')
else:
print(form.errors)
#return response.HttpResponseRedirect('employee')
else:
form = employeeInputForm()
return render(request, 'accounts/employeeAdd.html', {'form': form})
def navigation(request, navigate_direct_to_form):
try:
stud = mdl_base.student.find_by_user(request.user)
except MultipleObjectsReturned:
return dash_main_view.show_multiple_registration_id_error(request)
current_academic_year = mdl_base.academic_year.starting_academic_year()
student_programs = _get_student_programs(stud, current_academic_year)
if student_programs:
if navigate_direct_to_form and len(student_programs) == 1:
return _get_exam_enrollment_form(student_programs[0], request, stud)
else:
return layout.render(request, 'offer_choice.html', {'programs': student_programs,
'student': stud})
else:
messages.add_message(request, messages.WARNING, _('no_offer_enrollment_found').format(current_academic_year))
return response.HttpResponseRedirect(reverse('dashboard_home'))
def costumerViewEdit(request, pk):
postobj = get_object_or_404(Customer, pk=pk)
if request.method == 'POST':
form = customerInputForm(request.POST or None, instance=postobj)
if form.is_valid():
form.save()
return response.HttpResponseRedirect('/accounts/customers')
else:
e = Customer.objects.get(pk=int(pk))
form = customerInputForm(instance=e)
print(form)
return render(request, 'accounts/customersEdit.html', {
'form': form,
'pk': pk
})
def post(self, request):
form = forms.MakeAPostForm(request.POST, request.FILES)
if form.is_valid():
form.create_post(request.user)
# If its a success
return response.HttpResponseRedirect(
reverse_lazy('posting-made-a-post'))
# An error occured
errors = form.errors.as_data()
form.add_error(None,
"An error occurred during processing of your request")
form.add_error(None, errors)
logging.error(
"Error occurred when processing of a Make a post form, may be irreversable. Error: {}\nForm: {} "
.format(errors, form))
return render(request, 'posting/make_a_post.html', {'form': form})
def index(request):
if not request.user.is_authenticated:
return response.HttpResponseRedirect(
"/admin/login/?next=/log_manager/")
if not request.user.can_access_log_manager and not request.user.is_superuser:
return response.HttpResponseForbidden(
"You are not allowed to access this page.")
requested_resource_bar()
return render(
request, "index.html", {
"http_method_pie": http_method_pie(),
"requested_resources_bar": requested_resource_bar(),
"requests_month_bar": requests_month_bar(),
"status_code_pie": status_code_pie()
})
def _get_exam_enrollment_form(off_year, request, stud):
learn_unit_enrols = mdl_base.learning_unit_enrollment.find_by_student_and_offer_year(stud, off_year)
if not learn_unit_enrols:
messages.add_message(request, messages.WARNING, _('no_learning_unit_enrollment_found').format(off_year.acronym))
return response.HttpResponseRedirect(reverse('dashboard_home'))
if hasattr(settings, 'QUEUES') and settings.QUEUES:
request_timeout = settings.QUEUES.get("QUEUES_TIMEOUT").get("EXAM_ENROLLMENT_FORM_RESPONSE")
else:
request_timeout = settings.DEFAULT_QUEUE_TIMEOUT
fetch_date_limit = timezone.now() - timezone.timedelta(seconds=request_timeout)
exam_enroll_request = exam_enrollment_request.\
get_by_student_and_offer_year_acronym_and_fetch_date(stud, off_year.acronym, fetch_date_limit)
if exam_enroll_request:
try:
data = json.loads(exam_enroll_request.document)
except json.JSONDecodeError:
logger.exception("Json data is not valid")
data = {}
if data.get('error_message'):
error_message = _(data.get('error_message')).format(off_year.acronym)
else:
error_message = data.get('error_message')
return layout.render(request, 'exam_enrollment_form.html',
{'error_message': error_message,
'exam_enrollments': data.get('exam_enrollments'),
'student': stud,
'current_number_session': data.get('current_number_session'),
'academic_year': mdl_base.academic_year.current_academic_year(),
'program': mdl_base.offer_year.find_by_id(off_year.id),
'request_timeout': request_timeout})
else:
ask_exam_enrollment_form(stud, off_year)
return layout.render(request, 'exam_enrollment_form.html',
{'exam_enrollments': "",
'student': stud,
'current_number_session': "",
'academic_year': mdl_base.academic_year.current_academic_year(),
'program': mdl_base.offer_year.find_by_id(off_year.id),
'request_timeout': request_timeout})
def employeeViewEdit(request, pk):
postobj = get_object_or_404(User, pk=pk)
print("*************************************************")
if request.method == 'POST':
form = employeeEditForm(request.POST or None, instance=postobj)
if form.is_valid():
user = form.save(commit=False)
user.set_password(user.password)
form.save()
print(
"-------------------------------------------------------------------------------------------------------------"
)
return response.HttpResponseRedirect('/accounts/employee')
else:
print(form.errors)
else:
e = User.objects.get(pk=int(pk))
form = employeeEditForm(instance=e)
print(form)
return render(request, 'accounts/employeeEdit.html', {
'form': form,
'pk': pk
})
def open(request, slug):
try:
obj = URL.objects.get(slug=slug)
except:
return response.HttpResponseNotFound()
return response.HttpResponseRedirect(obj.original_link, status=301)
def timeout_view(request):
return response.HttpResponseRedirect(reverse('login'))
def home(request
): ##todo add in more data variables to the dictionary hourly_weather
max_wind = Pref.objects.last().max_wind
min_temp = Pref.objects.last().min_temp
def good_to_fly(i, max_wind, min_temp):
why = []
if i.temp > min_temp and (
i.wind_speed < max_wind
) and i.dark == False and i.main != 'Rain' and i.main != 'Snow':
return '', True
else:
if i.temp < min_temp:
why.append('Too Cold,')
if i.wind_speed > max_wind:
why.append('Too Windy,')
if i.dark == True:
why.append('Too Dark,')
if i.main == 'Rain':
why.append("It's Raining")
if i.main == 'Snow':
why.append("It's Snowing")
if len(why) == 0:
why = ''
else:
why = ' '.join(why).strip(',')
return why, False
##### FORM STUFF ##########################
if request.method == 'POST' and 'city' in request.POST:
city_form = SearchCityForm(request.POST)
if city_form.is_valid():
city = request.POST.get(
'city') # name of typed in city could be wrong at this point
c = City(city=city)
d = City.objects.last()
try:
initial_data = main.General(city)
d.delete()
c.save()
return response.HttpResponseRedirect('/')
except:
initial_data = main.General(d.city)
messages.warning(
request,
f'The city you searched for could not be found. Please check your spelling'
)
return response.HttpResponseRedirect('/')
else:
last_search = City.objects.last().city
initial_data = main.General(last_search)
else:
city_form = SearchCityForm()
last_search = City.objects.last().city
initial_data = main.General(last_search)
if request.method == 'POST' and 'max_wind' in request.POST:
pref_form = ChangePreferenceForm(request.POST)
if pref_form.is_valid():
max_wind = int(request.POST.get('max_wind'))
min_temp = int(request.POST.get('min_temp'))
if max_wind > 50 or max_wind < 0:
messages.warning(
request,
'Wind Speed: Please enter a number between 0 and 50')
if min_temp > 40 or min_temp < -20:
messages.warning(
request,
'Minimum Temperature: Please enter a number between -20 and 40'
)
return response.HttpResponseRedirect('/')
if min_temp > 40 or min_temp < -20:
messages.warning(
request,
f'Minimum Temperature: Please enter a number between -20 and 40'
)
if max_wind > 50 or max_wind < 0:
messages.warning(
request,
f'Wind Speed: Please enter a number between 0 and 50')
return response.HttpResponseRedirect('/')
p = Pref(max_wind=max_wind, min_temp=min_temp)
d = Pref.objects.last()
d.delete()
p.save()
messages.success(request, f'Your preferences have been updated')
return response.HttpResponseRedirect('/')
else:
pref_form = ChangePreferenceForm()
weather_data = []
day_list = []
##############################################
for i in initial_data.dates:
dates = {'date': i.lstrip('0')}
day_list.append(dates)
general_data = {}
for i in initial_data.weather_data_list: #todo add i.date (e.g Friday 26th January)to compare to current date
general_data = {
'city': i.city,
'country': i.country,
'sunset': i.sunset,
'sunrise': i.sunrise,
}
hourly_weather = {
'good_to_fly': good_to_fly(i, max_wind, min_temp)[1],
'temperature': i.temp,
'time': i.tf_time,
'wind_speed': i.wind_speed,
'wind_direction': i.cardinal,
'date': i.date.lstrip('0'),
'icon': i.iconname,
'main': i.main,
'why': good_to_fly(i, max_wind, min_temp)[0],
'description': i.description.capitalize(),
'dark': i.dark,
'timezone': i.timezone
}
weather_data.append(hourly_weather)
general_data['timezone'] = weather_data[0]['timezone']
general_data['max_wind'] = max_wind
general_data['min_temp'] = min_temp
context = {
'pref_form': pref_form,
'city_form': city_form,
'weather_data': weather_data,
'day_list': day_list,
'general_data': general_data,
}
return render(request, 'weather/home.html', context)
def insert(request): # aggiungere la data da cui scaricare i post
usernameP = request.POST['name']
dateREQ = request.POST.getlist('checkYear') #prendo tutte le date dalla request
date=[]
lastYear =datetime.now().year
if "ALL" in dateREQ: #controllo se nell'array c'è ALL quindi tutte le date
date = [str(lastYear), str(lastYear-1), str(lastYear-2), str(lastYear-3), str(lastYear-4), str(lastYear-5), str(lastYear-6), str(lastYear-7), str(lastYear-8)] #inizializzo l'array con tutte le date possibili
else:
for dateX in dateREQ:
date.append(dateX)
check = checkIfExistInDB(usernameP) #controllo che l'utente che sto cercando sia già nel Db
if(check == False): # NON C'è
#L = instaloader.Instaloader()
try:
profile = instaloader.Profile.from_username(L.context, usernameP)
except instaloader.ProfileNotExistsException:
context={
'lastest_profile_list' : Profile.objects.order_by('-followers'),
'profilo_non_trovato' : True
}
return render(request, "polls/index.html", context)
q=""
if(profile.is_private is False):
q = Profile(username=profile.username, followees=profile.followees, followers=profile.followers, nDatePostSaved=getStringDate(date), allPost=profile.mediacount, isPrivate=False) #INSERISCO TUTTO CON LA DATA PASSATA DALLA REQUEST
q.save()
dataPost=[]
for data in date:
dataPost = savePost(usernameP, data)
if dataPost[2] != 0 :
q.totalLikes = q.totalLikes + dataPost[0]
q.totalComments += dataPost[1]
q.postContacts += dataPost[2]
q.save()
else:
q = Profile(username=profile.username, followees=profile.followees, followers=profile.followers, allPost=profile.mediacount, isPrivate=True).save() #INSERISCO TUTTO CON LA DATA PASSATA DALLA REQUEST
L.close()
elif(check == True):
p = Profile.objects.get(username=usernameP)
if p.isPrivate : #se quello che prendo dal DB è privato controllo se lo è ancora
#L = instaloader.Instaloader()
profile = instaloader.Profile.from_username(L.context, usernameP)
if profile.is_private is False: #il profilo non è più privato
p.isPrivate = False
dates = []
dateDB = p.nDatePostSaved.split(", ")
for dateToInsert in date:
if dateToInsert not in dateDB:
p.nDatePostSaved = p.nDatePostSaved + str(dateToInsert) + ", "
dates.append(dateToInsert)
print(p.nDatePostSaved)
if len(dates) > 0:
for data in dates:
dataPost = savePost(usernameP, data)
if dataPost[2] != 0 :
p.totalLikes = p.totalLikes + dataPost[0]
p.totalComments += dataPost[1]
p.postContacts += dataPost[2]
p.save()
else:
dates = []
dateDB = p.nDatePostSaved.split(", ")
for dateToInsert in date:
if dateToInsert not in dateDB:
p.nDatePostSaved = p.nDatePostSaved + str(dateToInsert) + ", "
dates.append(dateToInsert)
if len(dates) > 0:
for data in dates:
dataPost = savePost(usernameP, data)
if dataPost[2] != 0 :
p.totalLikes = p.totalLikes + dataPost[0]
p.totalComments += dataPost[1]
p.postContacts += dataPost[2]
p.save()
p.save()
return response.HttpResponseRedirect(reverse('polls:index'))
def form_valid(self, form):
form.save()
return response.HttpResponseRedirect(self.get_success_url())
def delete(request, profile_id):
profile = get_object_or_404(Profile, pk=profile_id)
profile.delete()
return response.HttpResponseRedirect(reverse('polls:index'))
