def gravatar_url(email, size=150):
default = "https://picsum.photos/{}.jpg".format(size)
g = Gravatar(email)
gravatar_url = g.get_image(size=size,
default=default,
filetype_extension=True)
return gravatar_url
def gravatar(user):
email = user.email.lower()
default = 'mm'
size = 256
g = Gravatar(email)
url = g.get_image()
return url
def to_dict(self):
g = Gravatar(self.email)
return {
"email": self.email,
"name": self.name,
"avatar_url": g.get_image()
}
def _receive(self):
"""
Downloads a Gravatar image. May raise an HTTPError.
"""
g = Gravatar(self._email)
response = urlopen(g.get_image(size=self._resolution, default="404", use_ssl=True))
return response
def tournamentMatchesJson(request, pk):
matches = Match.objects.filter(tournament=pk).order_by('-tournament_round', 'pair_no')
data = list(matches.values(
'tournament_round',
'pair_no',
'winner',
'participant_zero__user__first_name',
'participant_zero__user__last_name',
'participant_zero__user__email',
'participant_one__user__first_name',
'participant_one__user__last_name',
'participant_one__user__email'
))
for entry in data:
email = entry['participant_zero__user__email']
if email is not None:
entry['participant_zero__user__gravatar'] = Gravatar(email).get_image(size=80, default='retro')
else:
entry['participant_zero__user__gravatar'] = ''
del entry['participant_zero__user__email'] # Don't send email addresses to users
email = entry['participant_one__user__email']
if email is not None:
entry['participant_one__user__gravatar'] = Gravatar(email).get_image(size=80, default='retro')
else:
entry['participant_one__user__gravatar'] = ''
del entry['participant_one__user__email']
return JsonResponse(data, safe=False)
def create(self, validated_data):
g = Gravatar(validated_data['email'])
gravatar = g.get_image(size=120, default='retro', use_ssl=True)
user = CustomUser.objects.create_user(validated_data['username'],
validated_data['email'],
validated_data['password'],
gravatar=gravatar)
return user
def profile():
g = Gravatar("*****@*****.**")
return render_template(
'profile.html',
gravatar=g.get_image(
size=40,
default=request.url_root +
url_for('static', filename='assets/img/default-avatar.png')))
def avatar_url(self):
if self.has_avatar:
config = get_config()
if config.AVATAR_STORAGE == 'local':
return f'/users/{self.id}/avatar'
return self.get_storage_blob().public_url
# otherwise return a gravatar url
av = Gravatar(self.email)
return av.get_image(size=200,
default=DEFAULT_AV_URL,
filetype_extension=True,
use_ssl=True)
def post(self, request, *args, **kwargs):
"""Method for updating your profile."""
me = get_object_or_404(CustomUser, id=request.user.id)
if 'refreshAvatar' in request.data:
g = Gravatar(me.email)
me.gravatar = g.get_image(size=120, default='retro', use_ssl=True)
for key in request.data:
setattr(me, key, request.data[key])
me.save()
serializer = ProfileSerializer(me).data
return Response(serializer)
def get_avatar(backend, response, user, *args, **kwargs):
if backend.name == "facebook":
try:
if not response.get("picture").get("data").get("is_silhouette"):
user.userprofile.avatar["facebook"] = (
response.get("picture").get("data").get("url"))
except AttributeError:
pass
elif backend.name == "google-oauth2" and response.get("picture"):
user.userprofile.avatar["google-oauth2"] = response["picture"][:-6]
url = Gravatar(sanitize_email(user.email)).get_image(size=500,
use_ssl=True,
default="404")
try:
resp = requests.get(url)
resp.raise_for_status()
user.userprofile.avatar["gravatar"] = url
if not user.userprofile.avatar.get("provider", None):
user.userprofile.avatar["provider"] = "gravatar"
except requests.exceptions.HTTPError:
pass
if not user.userprofile.avatar.get("provider", None) and backend.name in [
"facebook",
"google-oauth2",
]:
user.userprofile.avatar["provider"] = backend.name
user.save()
def post(self, request):
try:
body = json.loads(request.body)
slug = body['slug']
username = body['username']
email = body['email']
website = body['website']
content = body['comment']
ip, browser, os, _ = get_client_info(request)
except (KeyError, json.JSONDecodeError):
logger.warning('param invalid|%s', request.body.decode('utf-8'))
return ParamInvalidResponse()
try:
article = Article.objects.get(slug=slug)
except Article.DoesNotExist:
logger.warning('article not exist|%s', slug)
return ObjectNotExistResponse()
comment = Comment.objects.create(article=article,
username=username,
email=email,
avatar=Gravatar(email).get_image(),
website=website,
content=content,
publish_dt=datetime.now(),
ipv4=ip,
browser=browser,
os=os)
logger.info('add comment|%s|%s|%s', article.slug, article.title,
comment.username)
return SuccessResponse()
def fetch_avatar(email):
g = Gravatar(email)
url = g.get_image(size=100)
response = urllib2.urlopen(url)
f = open("/tmp/tmp.png", "wb")
f.write(response.read())
f.close()
img = Magick.Image("/tmp/tmp.png")
img.magick('XBM')
img.write("/tmp/out.xbm")
f = open("/tmp/out.xbm", "rt")
content = f.read()
f.close()
return xbm_to_base64(content)
def settings(identificator):
if identificator != session.get("id") and not session.get("is_admin"):
return redirect("/404")
else:
user = User.query.filter_by(id=identificator).first()
form = SettingsForm()
if request.method == "POST":
if form.validate_on_submit():
if "@" not in request.form["email"]:
form.email.errors.append("Введите реальную почту!")
elif request.form.get("email") != "":
user.email = request.form["email"]
user.avatar_path = Gravatar(request.form['email']) \
.get_image(248)
if request.form.get("password") != "":
m = hashlib.md5()
m.update((request.form["password"]).encode('UTF-8'))
user.password_hash = m.hexdigest()
if request.form.get("name") != "":
user.name = request.form["name"]
if request.form.get("surname") != "":
user.surname = request.form["surname"]
if request.form.get("about_me") != "":
user.about_me = request.form["about_me"]
if request.form.get("date") != "":
user.date = parser.parse(request.form['date'])
db.session.commit()
return redirect(f"/user/id{identificator}")
return render_template("settings.html",
username=user.username,
api_key=user.api_key,
session=session,
form=form,
who=user.name + " " + user.surname)
def populate_user_profile_from_ldap(sender,
user=None,
ldap_user=None,
**kwargs): # pragma: no cover
user.save() # Create the user which will create the profile as well
try:
profile = user.userprofile # Check if profile really exist
except UserProfile.DoesNotExist:
profile = UserProfile.objects.create(
user=user) # Create profile if it does not exist
# Get attributes from ldap
bucket = {"phone_number": ldap_user.attrs.get("telephoneNumber")}
# Check each key if it has value add to profile
for key, value in bucket.items():
if value:
setattr(user.userprofile, key, value[0])
# Set profile picture from Gravatar
if user.email:
url = Gravatar(sanitize_email(user.email)).get_image(size=500,
use_ssl=True,
default="404")
try:
resp = requests.get(url)
resp.raise_for_status()
profile.avatar["gravatar"] = url
if not profile.avatar.get("provider", None):
profile.avatar["provider"] = "gravatar"
except requests.exceptions.HTTPError:
pass
profile.save() # Save the profile modifications
def to_json(self):
gravatar = Gravatar(self.user.email)
src = gravatar.get_image()
return {
'id':
self.id,
'username':
self.username,
'gravatar':
src,
'contents':
self.contents,
'childs': [child.to_json() for child in self.childs],
'created':
None if self.created is None else
self.created.strftime('%Y%m%dT%H%M%S%z'),
}
def userinfo(request, pk):
response_json_data = {}
try:
user = Admin.objects.get(id=pk)
response_json_data['nickname'] = user.nickname
response_json_data['email'] = user.email
response_json_data['type'] = user.usertype
response_json_data['image'] = ""
if user.email is not None:
image = Gravatar(user.email)
response_json_data['image'] = image.get_image()
if user.usertype == 2:
info = Student.objects.get(student_id=pk)
response_json_data['name'] = info.name
response_json_data['id'] = info.student_id
response_json_data['classroom'] = info.classroom.name
response_json_data['classroom_id'] = info.classroom_id
response_json_data['department_name'] = info.department.name
response_json_data['department_id'] = info.department.department_id
response_json_data['sex'] = info.sex
response_json_data['age'] = info.age
response_json_data['person_id'] = info.person_id
response_json_data['phone_num'] = info.phone_num
elif user.usertype == 1:
info = Teacher.objects.get(teacher_id=pk)
response_json_data['id'] = info.teacher_id
response_json_data['department_id'] = info.department_id
response_json_data['age'] = info.age
response_json_data['name'] = info.name
response_json_data['department_name'] = info.department.name
response_json_data['department_id'] = info.department.department_id
response_json_data['address'] = info.address
response_json_data['sex'] = info.sex
response_json_data['person_id'] = info.person_id
response_json_data['phone_num'] = info.phone_num
response_json_data["code"] = 200
response_json_data["msg"] = "获取成功"
return JsonResponse(response_json_data)
except ObjectDoesNotExist:
response_json_data["code"] = 404
response_json_data["msg"] = "用户不存在"
return JsonResponse(response_json_data)
def gravatar(email: str) -> str: # pylint: disable=unused-variable
default = url_for("static",
filename="image/digibot_profile_40.png",
_external=True)
if not email:
return default
gravatar: Gravatar = Gravatar(email)
return gravatar.get_image(size=40, default="retro")
class GravatarProfileTestCase(unittest.TestCase):
"""Test case for the Gravatar class and the get_profile method."""
def setUp(self):
self.g = Gravatar('*****@*****.**')
def test_without_params(self):
"""Test a get_profile with default parameters."""
profile_url = 'http://www.gravatar.com/0bc83cb571cd1c50ba6f3e8a78ef1346'
result = self.g.get_profile()
self.assertEqual(profile_url, result)
def getDiscuss(request):
discuss = Discuss.objects.all().order_by('-time')
response_json_data = {
'code': 200,
'msg': '请求成功',
'num': discuss.count(),
'result': [],
}
for i in discuss:
try:
user = Admin.objects.get(id=i.student.student_id)
if user.email is not None:
image = Gravatar(user.email)
else:
image = "",
response_json_data['result'].append({
'discuss_id':
i.discuss_id,
'username':
i.student.name,
'img':
image.get_image(),
'class':
i.student.classroom.name,
'like_num':
i.like_num,
'text':
i.text,
'time':
i.time.strftime("%Y-%m-%d %H:%I:%S"),
})
except ObjectDoesNotExist:
response_json_data['result'].append({
'discuss_id': i.discuss_id,
'username': i.student.name,
'img': '',
'class': i.student.classroom.name,
'like_num': i.like_num,
'text': i.text,
'time': i.time,
})
return JsonResponse(response_json_data)
class GravatarProfileTestCase(unittest.TestCase):
"""Test case for the Gravatar class and the get_profile method."""
def setUp(self):
self.g = Gravatar('*****@*****.**')
def test_without_params(self):
"""Test a get_profile with default parameters."""
profile_url = 'http://www.gravatar.com/0bc83cb571cd1c50ba6f3e8a78ef1346'
result = self.g.get_profile()
self.assertEqual(profile_url, result)
def create_user(data):
try:
session['uid'] = str(uuid.uuid4())
username = data['username']
email = data['email']
avatar = Gravatar(email.lower()).get_image(size=500)
password = generate_password_hash(data['password'])
session_user = session['uid']
article = User(username=username, email=email, password=password, session=session_user, avatar=avatar)
db.session.add(article)
db.session.commit()
return True
except:
return False
def _create_user(self, email, password, **extra_fields):
"""
Creates and saves a User with the given email,and password.
"""
if not email:
raise ValueError('The given email must be set')
try:
user = self.model(email=email,
avatar_url=Gravatar(email).get_image(),
**extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
except:
raise
def get_gravatar_image(email):
'''
输入email 判断这个邮箱是否有头像
有就保存 没有就返回 默认头像
'''
# 判断数据库有没有这个邮箱 有就直接用
emails = class_comment.query_email(email=email)
if len(emails) > 0:
if emails[-1].vcardurl != 'default_img':
return emails[-1].vcardurl
imgpath = os.path.join(config.cwd, 'app', 'static', 'img', 'gravatar')
g = Gravatar(email)
r = requests.get(g.get_image(default="404"))
if r.status_code == 404:
return "default_img"
else:
i_type = r.headers.get('Content-Type', '')[-3:].lower()
if i_type not in ['jpg', 'png']:
i_type = 'jpg'
count = len(os.listdir(imgpath))
filename = ''
while filename == '':
count += 1
imgname = '{}.{}'.format(count, i_type)
target_filename = os.path.join(imgpath, imgname)
if os.path.isfile(target_filename):
continue
else:
filename = target_filename
break
with open(filename, 'wb') as f:
f.write(r.content)
result = url_for('static', filename='img/gravatar/{}'.format(imgname))
return result
def register():
if session.get("username", None) is not None:
return redirect("/feed")
form = RegisterForm()
if request.method == "POST":
if form.validate_on_submit():
if request.form['password'] != request.form['retype_password']:
form.password.errors.append("Пароли не совпадают!")
elif " " in request.form["username"]:
form.username.errors.append(
"В логине не должно быть пробелов!")
elif "@" not in request.form["email"]:
form.email.errors.append("Введите реальную почту!")
elif User.query.filter_by(
username=request.form['username']).first() is not None:
form.username.errors.append("Уже зарегестрирован!")
else:
try:
m = hashlib.md5()
m.update((request.form['password']).encode('UTF-8'))
m1 = hashlib.md5()
m1.update((request.form['username'] +
request.form["password"][2:5]).encode("UTF-8"))
avatar = Gravatar(request.form['email']).get_image(248)
new_user = User(username=request.form['username'],
name=request.form['name'],
about_me=request.form['about_me'],
surname=request.form['surname'],
email=request.form['email'],
avatar_path=avatar,
password_hash=m.hexdigest(),
date=parser.parse(request.form['date']),
api_key=m1.hexdigest())
db.session.add(new_user)
db.session.commit()
user = User.query.filter_by(
username=new_user.username).first()
session['id'] = user.id
session['username'] = user.username
session['api_key'] = user.api_key
session['is_admin'] = user.is_admin
return redirect("/feed")
except Exception as e:
print(e)
form.username.errors.append("Ошибка при создании профиля!")
return render_template("register.html", session=session, form=form)
class User(UserMixin, db.Model):
"""User database class
Args:
UserMixin : Flask-Login Mixin
db : Database Model Base Class
"""
__tablename__ = 'messusers'
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=True)
email = db.Column(db.String(100), unique=True, nullable=False)
name = db.Column(db.String(100), unique=False, nullable=False)
avatar = db.Column(db.Text,
nullable=False,
default=Gravatar(str(email)).get_image())
balance = db.Column(db.Float, nullable=True, default=0.0)
total_balance = db.Column(db.Float, nullable=True, default=0.0)
password = db.Column(db.Text, nullable=True, unique=False)
admin = db.Column(db.Boolean, nullable=False, unique=False, default=False)
def refresh_gravatar():
print("refresh_gravatar")
gravatar_url = Gravatar(self.user.email).get_image()
if 'http://' in gravatar_url:
gravatar_url = 'https://{}'.format(gravatar_url[7:])
response = requests.get(gravatar_url)
img = Image.open(BytesIO(response.content))
# filename example: 'www.gravatar.com-avatar-f976af5e922e17a4.png'
filename = '{}.{}'.format(gravatar_url[8:].replace('/', '-'),
img.format.lower())
try:
final = UploadedPictureHandler().generate_everything(
BytesIO(response.content),
'gravatar/',
thumbnail_dimensions=(60, 60),
uploaded_filename=filename)
with transaction.atomic():
self.gravatar = GravatarFile.objects.create(
description='gravatar',
filename_original=gravatar_url,
file_field=final)
self.save()
except IOError:
pass
def avatar(self):
"""Retorna a partir do endereço de e-mail, um avatar
configurado no Gravatar ou um dos avatares padrão deles."""
g = Gravatar(self.email)
return g.get_image(default='identicon')
def gravatar_url(email, size=40):
return Gravatar(email).get_image(size=size, default='retro')
def gravatar_url(email, **kwargs):
return Gravatar(email).get_image(use_ssl=True, **kwargs)
class GravatarImageTestCase(unittest.TestCase):
"""Test case for the Gravatar class and the get_image method."""
def setUp(self):
self.g = Gravatar('*****@*****.**')
def test_without_params(self):
"""Test a get_image with default parameters."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346'
result = self.g.get_image()
self.assertEqual(image_url, result)
def test_image_size(self):
"""Test image size parameter."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?size=24'
result = self.g.get_image(size=24)
self.assertEqual(image_url, result)
def test_invalid_image_size(self):
"""Test an invalid image size value."""
self.assertRaises(ValueError, self.g.get_image, size=0)
self.assertRaises(ValueError, self.g.get_image, size=2049)
def test_filetype_extension(self):
"""Test filetype_extension parameter."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346.jpg'
result = self.g.get_image(filetype_extension=True)
self.assertEqual(image_url, result)
def test_default(self):
"""Test default parameter."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?default=monsterid'
result = self.g.get_image(default='monsterid')
self.assertEqual(image_url, result)
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?default=http%3A%2F%2Fexample.com%2Fimages%2Favatar.jpg'
result = self.g.get_image(default='http://example.com/images/avatar.jpg')
self.assertEqual(image_url, result)
invalid_default_url = 'ftp://example.com/images/avatar.php?key=value'
self.assertRaises(ValueError, self.g.get_image, default=invalid_default_url)
def test_forcedefault(self):
"""Test forcedefault parameter."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?forcedefault=y'
result = self.g.get_image(force_default=True)
self.assertEqual(image_url, result)
def test_use_ssl(self):
"""Test use_ssl parameter."""
image_url = 'https://secure.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346'
result = self.g.get_image(use_ssl=True)
self.assertEqual(image_url, result)
def test_rating(self):
"""Test the rating parameter."""
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?rating=g'
result = self.g.get_image(rating='g')
self.assertEqual(image_url, result)
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?rating=pg'
result = self.g.get_image(rating='pg')
self.assertEqual(image_url, result)
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?rating=r'
result = self.g.get_image(rating='r')
self.assertEqual(image_url, result)
image_url = 'http://www.gravatar.com/avatar/0bc83cb571cd1c50ba6f3e8a78ef1346?rating=x'
result = self.g.get_image(rating='x')
self.assertEqual(image_url, result)
self.assertRaises(ValueError, self.g.get_image, rating='invalid')
def gravatar_url(self):
from libgravatar import Gravatar
email = (self.email)
g = Gravatar(email)
return g.get_image()
def setUp(self):
self.g = Gravatar('*****@*****.**')
def gravatar_url(value):
g = Gravatar(value)
return g.get_image(size=72)
def gravatar(email, size=40):
'''Get commenter's avatar from Gravatar service via API (depends on libgravatar)'''
g = Gravatar(email)
return g.get_image(size, "mm")
def avatar(self):
return Gravatar(self.email).get_image()
