def all_persons(request, page):
if request.user.is_authenticated:
try:
user = Person.objects.get(username = request.user.username)
except:
user = Person(username = request.user.username, name = request.user.first_name)
user.save()
else:
user = None
persons = Person.objects.all() # Get all persons
paginate = Paginator(persons, 3)
context = {
'persons': paginate.page(page),
'current_url': str('/user/all/%3Fpage=1/').replace('/', '%2F'),
}
mskf.add_notification_availability_to_context(request, context)
mskf.add_authenticated_user_to_context(request, context)
return render(request, 'all_persons.html', context)
def regist(request):
if request.method == 'POST':
try:
name = request.POST['name']
start = request.POST['start']
end = request.POST['end']
except Exception as e:
return HttpResponseBadRequest()
if len(name) >= 10:
return _response_json({'code' : 1, 'message' : u'이름은 10자 이하여야 합니다.'})
if len(name) == 0:
return _response_json({'code' : 2, 'message' : u'이름을 입력해주세요.'})
try:
start_dt = datetime.strptime(start, '%Y-%m-%d')
end_dt = datetime.strptime(end, '%Y-%m-%d')
cur_dt = datetime.now()
except Exception as e:
return _response_json({'code' : 3, 'message' : u'날짜 형식이 잘못되었습니다.'})
if start_dt >= end_dt:
return _response_json({'code' : 4, 'message' : u'시작일이 종료일보다 빠릅니다.'})
if cur_dt >= end_dt:
return _response_json({'code' : 5, 'message' : u'이미 지나간 이벤트입니다.'})
if cur_dt <= start_dt:
return _response_json({'code' : 6, 'message' : u'아직 시작되지 않은 이벤트입니다.'})
if (end_dt - start_dt).total_seconds() > (100 * 3600 * 24 * 365):
return _response_json({'code' : 7, 'message' : u'너무 긴 이벤트입니다.'})
if u' ' in name:
return _response_json({'code' : 8, 'message' : u'이름에 공백이 들어갈 수 없습니다.'})
p = Person(name = name, start_date = start_dt, end_date = end_dt)
p.save()
return _response_json({'code' : 0, 'message' : u'등록 성공!'})
else:
return HttpResponseBadRequest()
def handle(self, *args, **options):
f = open(os.path.join(BASE_DIR, 'data.txt'), 'r+')
for line in f:
line_dict = parse_line(line)
if line_dict is not None:
person = Person(name=line_dict['name'], phone_one=line_dict['phone_one'], phone_two=line_dict['phone_two'])
person.save()
def persons_list(request):
if request.method == 'GET':
persons = Person.objects.all()
persons = [p.to_json() for p in persons]
return JsonResponse(persons, safe=False)
elif request.method == 'POST':
data = json.loads(request.body)
persons = Person(FullName=data['FullName'])
persons = Person(Gender=data['Gender'])
persons.save()
return JsonResponse(persons.to_json())
def create_persons(hypo_list):
"""Create a person for each hypostasis in list."""
hypostases_to_update = []
print("Making")
for h in hypo_list:
instance = h.non_empty_instance
new_person = Person(last_name=instance.last_name,
first_name=instance.first_name,
middle_name=instance.middle_name,
birth_date=instance.date_birth)
new_person.save()
h.person = new_person
hypostases_to_update.append(h)
print(h.id)
print("Saving")
bulk_update(hypostases_to_update, update_fields=['person'])
def index(request):
if request.user.is_authenticated:
# If user has Person model
try:
# Load the user's person model
user = Person.objects.get(username=request.user.username)
# If user doesnt has Person model
except:
# Create a new Person model for user
user = Person(
username=request.user.username,
name=request.user.first_name)
user.save()
# Redirect user to "wellcome" page
return HttpResponseRedirect('/wellcome/')
# Redirect user to index's first page
return HttpResponseRedirect('%3Fpage=1/')
def post(self, request):
form = ContactForm(request.POST)
if(form.is_valid()):
email = form.cleaned_data['received_email']
name = form.cleaned_data['received_from']
try:
person = Person.objects.get(email=email)
except Person.DoesNotExist:
person = Person(name=name, email=email)
person.save()
contact = form.save()
contact.person = person
contact.save()
if(self.lang == 'pt-br'):
succes = 'Obrigado por entrar em contato! ;)'
else:
succes = 'Thank you for reaching out! ;)'
messages.success(request, succes)
form = ContactForm()
context = {'form': form}
return render(request, 'contact.html', context)
else:
if(self.lang == 'pt-br'):
error = 'Não foi possível registrar seu contato, por favor mantenha em mente que todos os campos são' \
' obrigatórios.'
else:
error = "It wasn't possible to register your contact, please make note that all fields are required."
messages.error(request, error)
context = {'form': form}
return render(request, 'contact.html', context)
def signup(request):
# If form method == POST
if request.method == 'POST':
form = SignUpForm(request.POST) # Get Form
# If form valid
if form.is_valid():
username = form.cleaned_data['username'] # Read username
# Create a user with form data
user = form.save(commit=False)
user.backend = 'django.contrib.auth.backends.ModelBackend'
user.save()
# Create a Person model for user
person = Person(username=username, name=username)
person.save()
# Login current user
login(request, user)
# Redirect user to "wellcome" page
return HttpResponseRedirect('/wellcome/')
# If form method == GET
else:
form = SignUpForm() # Give form to user
context = {
'form': form,
}
# Add authenticated user and it's new notifications to context
mskf.add_notification_availability_to_context(request, context)
mskf.add_authenticated_user_to_context(request, context)
# Show "signup" page template to user
return render(request, 'registration/signup.html', context)
def customer_register(request):
if request.method == 'POST':
username = request.POST['username']
first_name = request.POST['first_name']
last_name = request.POST['last_name']
address = request.POST['address']
email = request.POST['email']
password1 = request.POST['password1']
password2 = request.POST['password2']
if password1 == password2:
if User.objects.filter(username=username).exists():
messages.info(request, "username already exists")
return redirect("/register")
elif User.objects.filter(email=email).exists():
messages.info(request, "email already exists")
return redirect("/register")
else:
person = Person(username=username,
address=address,
is_seller=False,
Purchased_products=[],
favourite_products=[])
person.save()
customer = Customer(username=username,
rated_products=[],
commented_products=[])
customer.save()
user = User.objects.create_user(username=username,
email=email,
password=password1,
first_name=first_name,
last_name=last_name)
user.save()
messages.info(
request, "user created you just need to check your email")
#send mail ro verify
file = open('my_dute_to_save.key', 'rb')
key = file.read()
f = Fernet(key)
random_code = random.random()
random_code2 = 'hgjkghjkhg'
random_code = f.encrypt(str(random_code).encode()) + f.encrypt(
str(random_code2).encode())
new_mail_verification = mail_verification(
user_name=username,
message_code=str(random_code),
is_autonticated=False)
new_mail_verification.save()
message_to_send = f"http://127.0.0.1:8000/verification/{str(random_code)}"
print(message_to_send)
send_mail(email, message_to_send)
new_cart = Cart(user_id=User.objects.get(username=username).id,
products=[])
new_cart.save()
#messages.info(request,"user created you just need to Login")
else:
messages.info(request, "Password doesnt match")
return redirect("/register")
return redirect('/')
else:
return render(request, 'customer-register.html')
def main(argv):
np.save("stop", np.array([0])) # required to stop from host
cur_dir = pathlib.Path.cwd()
if len(argv) != 0:
if argv[0] == "cam":
cap = cv2.VideoCapture(0)
elif argv[0] == "screen":
screen_width, screen_height = pyautogui.size()
cap = None
mon = {
'top': 0,
'left': 0,
'width': screen_width,
'height': screen_height
}
sct = mss()
else:
cap = cv2.VideoCapture("wws.mp4")
else:
cap = cv2.VideoCapture("wws.mp4")
emotion_lut = {
0: 'anger',
1: 'disgust',
2: 'fear',
3: 'happy',
4: 'neutral',
5: 'sadness',
6: 'surprised'
}
model = tflite.Interpreter("tfmodels/model_optimized.tflite")
model.allocate_tensors()
inputs = model.get_input_details()[0]
outputs = model.get_output_details()[0]
# Using HaarCascade classifier
face_detect = cv2.CascadeClassifier(
'./haarcascade_frontalface_default.xml')
scene_mood = [[] for i in range(7)]
face_id = 0 # is the primary key in Person Table of our DataBase
num_frames = 0 # counts the frames
while True:
face_number_in_frame = 0 # counts the number of faces in each frame
model_results = [[] for i in range(7)]
face_detected = False
if argv[0] == "screen":
image = np.array(sct.grab(mon))
image = np.delete(image, obj=3, axis=2)
success_reading = True
else:
success_reading, image = cap.read()
num_frames += 1
if success_reading:
img_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# detect faces in our gray picture
faces = face_detect.detectMultiScale(img_gray,
scaleFactor=1.3,
minNeighbors=5)
for (x, y, w, h) in faces:
face_number_in_frame += 1
face_id += 1
face_detected = True
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2)
top_prediction, top_probability, all_model_results = predict_emotion(
model, inputs, outputs, image, x, y, w, h, emotion_lut)
to_display = top_prediction + ' ' + str(
int(top_probability * 100))
cv2.putText(image, to_display, (x, y - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2,
cv2.LINE_AA)
timestamp = timezone.localtime(timezone.now()).time()
cv2.imwrite(
str(cur_dir) + "/main/pics/" + str(face_id) + "_" +
str(top_prediction) + "_" + str(timestamp) + ".jpg",
image[y:y + h, x:x + w])
person = Person(
person_id=face_id,
person_number_in_last_frame=face_number_in_frame,
person_frame=num_frames,
person_emotion=top_prediction,
person_last_seen=timezone.localtime(timezone.now()),
person_prediction_prob=str(top_probability * 100)[:4])
person.person_thumbnail = str(face_id) + "_" + str(
top_prediction) + "_" + str(timestamp) + ".jpg"
person.save()
# model_results contains all the results from the model in this frame
# this allows to do averages if multiple faces have more than one prediction higher than 0
for emotion, probability in zip(
np.arange(7), list(all_model_results.values())):
model_results[emotion].append(probability)
# adding the predictions to database
ai_prediction = AIPrediction(
person=person,
anger=round(all_model_results["anger"], 2),
disgust=round(all_model_results["disgust"], 2),
fear=round(all_model_results["fear"], 2),
happy=round(all_model_results["happy"], 2),
neutral=round(all_model_results["neutral"], 2),
sadness=round(all_model_results["sadness"], 2),
surprised=round(all_model_results["surprised"], 2))
ai_prediction.plot = "hist" + str(face_id) + ".jpg"
ai_prediction.save()
plot_histogram(face_id, all_model_results, ai_prediction)
# print(model_results)
if face_detected:
for i in range(len(scene_mood)):
scene_mood[i].append(np.average(model_results[i]))
else:
for i in range(len(scene_mood)):
scene_mood[i].append(None)
plot_emotion_probabilities(emotion_lut, scene_mood, num_frames)
# print(scene_mood)
cv2.imshow("Faces & Emotions", image)
key = cv2.waitKey(1) & 0xFF
stop = np.load("stop.npy")
if key == ord("q") or stop[0] == 1:
cv2.destroyAllWindows()
break
if cap is not None:
cap.release()
movie.poster_path = info['poster_path'] or ''
movie.backdrop_path = info['backdrop_path'] or ''
movie.runtime = info['runtime'] or ''
movie.user = request.user
movie.save()
except Exception, e:
print movie.id, movie.title, str(e)
# movie cast add
for p in credits['cast'] or []:
try:
person = Person()
person.id = p['id']
person.name = p['name'] or ''
person.profile_path = p['profile_path'] or ''
person.save()
except Exception, e:
print movie.id, movie.title, str(e)
order = p['order'] or 0
try:
movie_cast = MovieCast(person=person, movie=movie, order=order)
movie_cast.save()
except Exception, e:
print movie.id, movie.title, str(e)
# get imdb rating and votes
if movie.imdb_id:
url = 'http://www.omdbapi.com/?i=%s&plot=short&r=json' % movie.imdb_id
try:
def database_add_new_visitor(request):
constraint = helpers.constraint(request, "POST");
data = constraint.safe({
"contact_number": False,
"department": False,
"first_name": True,
"last_name": True,
"middle_name": False,
"gender": True,
"purpose": False,
"type": True,
"contact_number2": False,
"document_type": False,
"document_from": False
});
of_user = UserProfile.objects.get(user=request.user.id);
person_params = {
"first_name": data['first_name'],
"last_name": data['last_name'],
"middle_name": data['middle_name'],
"gender": data['gender'],
"added_by": of_user
};
if data['contact_number']:
person_params['contact_number'] = data['contact_number'];
pass;
if data['department']:
person_params['department'] = Department.objects.get(id=data['department']);
of_person = Person(**person_params);
of_person.full_clean();
of_person.clean();
of_person.save();
log_details_params = {
"person_visitor": of_person,
"contact_number":data['contact_number2'],
"added_by" : of_user
};
if data['document_type']:
log_details_params['document_type'] = Document_type.objects.get(id=data['document_type']);
if data['document_from']:
log_details_params['document_from'] = Department.objects.get(id=data['document_from']);
of_log_details = Log_details(**log_details_params);
of_log_details.full_clean();
of_log_details.clean();
of_log_details.save();
of_log = Log(
type=data['type'],
purpose=data['purpose'],
details=of_log_details,
added_by=of_user
);
try:
of_log.full_clean();
of_log.clean();
of_log.save();
except e :
of_log_details.delete();
raise Exception(e);
pass;
return render(request, "ajax_temp/after_added_new_log.html", {
'log': of_log,
"obj_log" : Log,
"log_details_person" : of_log.details.person_visitor
});
# Initialize database
# MeetUp
from main.models import Location, Person, Event, UserEventData
from django.utils import timezone
from datetime import datetime
import pytz
# Create some locations
# Andy's House
l1 = Location(latitude=40.451891, longtitude=-79.950388)
l1.save()
# Create some users
u1 = Person(first_name='Andy',
last_name='Wang',
email='*****@*****.**',
phone='(412)478-2331',
sign_up_time=timezone.now(),
location=l1,
location_last_updated=timezone.now())
u1.save()
# Create some events
# e1 = Event(name='MeetUp meeting',
# time=datetime(2014, 7, 27, 14, 00, 00, 00 pytz.EST),
# location_name='Gates 7th floor',
# location=Location(latitude=40.444046, logntitude=-79.944414),
# )