def upgrade(self, request, pk):
del pk # unused
service = self.get_object()
if not service.next_invoice_date:
raise APIBadRequest(
detail=_('Unpaid service cannot be upgraded/downgraded'))
ser = ServiceUpgOptionsSerializer(data=request.data,
context={'service': service})
ser.is_valid(raise_exception=True)
configurable_options = ser.validated_data.get('configurable_options')
confirmation = ser.validated_data.get('confirm', False)
upgrade_summary = ServiceManager.estimate_new_service_cycle_cost(
service=service,
product=ser.validated_data['product'],
cycle=ser.validated_data['cycle'],
start_date=utcnow(),
configurable_options=configurable_options)
if confirmation:
order_metadata = OrderMetadata.from_request(request).to_json()
invoice = ServiceManager.create_service_upgrade_order(
user=request.user,
client=request.user.clients.first(),
service=service,
product=ser.validated_data['product'],
cycle=ser.validated_data['cycle'],
start_date=utcnow(),
configurable_options=configurable_options,
metadata=order_metadata)
return Response({'invoice': invoice.pk})
else:
return Response(upgrade_summary)
class Todo(models.Model):
todo_text = models.CharField(max_length=200)
publish_time = models.DateTimeField(default=utcnow())
update_time = models.DateTimeField(default=utcnow())
def __str__(self):
return self.todo_text
def test_bad_txn_period(self):
obj = models.Contact.objects.current().get(_master=JohnMaster)
obj._txn_end_date = utcnow()
time.sleep(.1)
obj._txn_start_date = utcnow()
with self.assertRaises(IntegrityError):
obj.save()
def test_bad_txn_period(self):
obj = models.Contact.objects.current().get(_master=JohnMaster)
obj._txn_end_date = utcnow()
time.sleep(.1)
obj._txn_start_date = utcnow()
with self.assertRaises(IntegrityError):
obj.save()
def update_time(request):
if request.user.username:
print request.user.username
u = request.user.profile
print u.last_accessed
print utcnow()
u.last_accessed = utcnow()
u.is_chat_user = True
u.save()
print u.last_accessed
return HttpResponse('updated')
return HttpResponse('who are you?')
def update_time(request):
if request.user.username:
print request.user.username
u = request.user.profile
print u.last_accessed
print utcnow()
u.last_accessed = utcnow()
u.is_chat_user = True
u.save()
print u.last_accessed
return HttpResponse('updated')
return HttpResponse('who are you?')
def handle_queued_events():
"""Runs from a thread and processes events as soon as they are available"""
messages = 0
last_count = utcnow()
while True:
event_data = p_queue.get()
# count received messages but with a delay of 5s
now = utcnow()
messages = messages + 1
delta = now - last_count
delta = delta.total_seconds()
if delta > 5:
last_count = now
sum_updated_messages(new_count=messages, last_updated=last_count)
messages = 0
logging_keywords = getattr(
settings, 'OPENSTACK_EVENT_NOTIFICATIONS_LOGGING_KEYWORDS', [])
if len(logging_keywords):
metadata = event_data.get('metadata', {})
payload = event_data.get('payload', {})
for keyword in logging_keywords:
if keyword in event_data['event_type']:
with open('/var/log/fleio/os_event_notifications.txt',
'a') as log_file:
log_file.write(
'{} - {} - Message type: {} - Region: {} - Resource id: {}\n'
.format(
metadata.get('timestamp', 'Missing timestamp'),
event_data['event_type'],
event_data['message_type'],
event_data['region'],
_get_os_resource_id_from_payload(
payload=payload),
))
break
try:
if event_data['message_type'] == 'info':
handle_infos(event_data['event_type'], event_data['metadata'],
event_data['payload'], event_data['region'])
elif event_data['message_type'] == 'error':
handle_errors(event_data['event_type'], event_data['metadata'],
event_data['payload'], event_data['region'])
except db.utils.OperationalError:
db.close_old_connections()
except Exception as e:
LOG.exception('Handle exception {}'.format(e))
finally:
p_queue.task_done()
def set_terminated(self, cancellation_request_id=None):
self.status = ServiceStatus.terminated
self.terminated_at = utcnow()
self.updated_at = self.terminated_at
self.save(update_fields=['status', 'updated_at', 'terminated_at'])
if cancellation_request_id:
try:
cr = CancellationRequest.objects.get(
id=cancellation_request_id)
except CancellationRequest.DoesNotExist:
pass
else:
cr.completed_at = utcnow()
cr.save(update_fields=['completed_at'])
def has_password_confirmed(self, request):
elapsed_time_since_last_login = utcnow() - request.user.last_login
if elapsed_time_since_last_login < timedelta(
minutes=getattr(settings, 'ALLOW_CHANGING_SFA_AFTER_LOGIN_MINUTES', 5)
):
return Response({'allowed': True}) # if user logged in earlier than 2 mins he is allowed
if 'sfa_manager' in request.session:
allowed_at = datetime.strptime(request.session['sfa_manager']['allowed_at'], '%B %d %Y - %H:%M:%S')
allowed_at = allowed_at.replace(tzinfo=pytz.utc)
elapsed_time_since_last_allowed = utcnow() - allowed_at
if elapsed_time_since_last_allowed > timedelta(minutes=REMEMBER_PASSWORD_CONFIRM_MINUTES):
return Response({'allowed': False})
return Response({'allowed': request.session['sfa_manager']['allowed']})
return Response({'allowed': False})
def send_invitation(self, request=None, baseurl=None):
"""Create and send an email with an invitation link
Either `request` (a HttpRequest`) or a `baseurl` is needed to generate
an absolute uri for the invitation link.
"""
# Ensure that template and subject is set
if None in (self.template_name, self.email_subject_template):
raise NotImplemented
# Create an absolute uri to the invitation accept view
link = self.get_absolute_accept_url()
if request is not None:
link = request.build_absolute_uri(link)
elif baseurl is not None:
link = baseurl + link
context = self.get_context_data(link=link)
subject = render_to_string(self.email_subject_template, context)
subject = ''.join(subject.splitlines()) # Ensure single line
message = render_to_string(self.template_name, context)
to_address = self.email_address
sent = send_mail(subject,
message,
FROM_EMAIL, [to_address],
fail_silently=False)
self.sent = utcnow()
self.save()
return sent
def login(request):
if request.user.username and request.user.profile.is_chat_user:
return HttpResponseRedirect(reverse("index"))
context = {"error": ""}
if request.method == "POST":
username = request.POST.get("username", "") # return '' if no username
password = request.POST.get("password", "")
user = auth.authenticate(username=username, password=password)
if user is None:
if username is None or password is None:
context["error"] = " You must specify username and password"
return render(request, "djangoChat/login.html", context)
if User.objects.filter(username=username).count() != 0:
context["error"] = " Username already exists. please choose another one"
return render(request, "djangoChat/login.html", context)
User.objects.create_user(username=username, password=password)
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
cu = request.user.profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
clear_messages()
return HttpResponseRedirect(reverse("index"))
else:
context["error"] = " wrong credentials try again"
return render(request, "djangoChat/login.html", context)
context.update(csrf(request))
return render(request, "djangoChat/login.html", context)
def sync_hypervisors(self):
del self # unused
now = utcnow()
timestamp = now.isoformat()
deletion_timestamp = (now - timedelta(hours=1)).isoformat()
hh = HypervisorSyncHandler()
version_to_delete = hh.get_version(deletion_timestamp)
all_regions = sync_regions(auth_cache=AUTH_CACHE)
try:
for region in all_regions:
for hypervisor in Hypervisors(
api_session=IdentityAdminApi().session).get_hypervisors(
region=region.id):
hh.create_or_update(data=hypervisor,
region=region.id,
timestamp=timestamp)
# delete hypervisors that were not synced in a version represented by a time less than one hour ago
delete_filter = {
'{}__lt'.format(hh.version_field): version_to_delete,
'region': region.id
}
Hypervisor.objects.filter(**delete_filter).delete()
except Exception as e:
LOG.error(str(e))
return
def create_service_for_item(item):
try:
if not validate_services_limit():
raise APIBadRequest(
_('Failed to create service, please contact support'), )
with transaction.atomic():
service = Service.objects.create(client=item.order.client,
display_name=item.name,
product=item.product,
cycle=item.cycle,
status=ServiceStatus.pending,
next_due_date=utcnow(),
plugin_data=item.plugin_data,
domain_name=item.domain_name)
for config_option in item.configurable_options.all():
service.configurable_options.create(
option=config_option.option,
option_value=config_option.option_value,
quantity=config_option.quantity,
has_price=config_option.has_price,
taxable=config_option.taxable,
price=config_option.price,
unit_price=config_option.unit_price,
setup_fee=config_option.setup_fee)
billing_module = module_factory.get_module_instance(
service=service)
if not billing_module.initialize(service=service):
raise BillingError(_('Failed to initialize service'))
except BillingError:
# failed to initialize service
# TODO: see what action should we take here
pass
else:
item.service = service
item.save(update_fields=['service'])
def monitoring(self, connection, bot, position=0):
sz = 0
log("Monitoring started").write()
while connection.connected:
percentage = int(position + self.dict[bot]["received_bytes"]) / int(self.dict[bot]["size"]) * 100
completed = int(position + self.dict[bot]["received_bytes"])
speed = (self.dict[bot]["received_bytes"]-sz)
if speed != 0:
tm = (int(self.dict[bot]["size"])-int(self.dict[bot]["received_bytes"])-position) / speed
else:
tm = 99999
eta = utcnow() + datetime.timedelta(seconds=tm)
speed = int(speed/1024)
(self.dict[bot]["down"].status, self.dict[bot]["down"].progress, self.dict[bot]["down"].completed,
self.dict[bot]["down"].eta, self.dict[bot]["down"].timeleft)= 'Downloading...', percentage, completed, eta, tm
#workaround for occasionnal empty packages
if speed:
self.dict[bot]["down"].speed = speed
self.dict[bot]["down"].save()
sz = self.dict[bot]["received_bytes"]
if percentage >=100:
self.DCCconnections_dict[bot].disconnect()
return ""
time.sleep(1)
log("Monitoring stoped").write()
def index(request):
# if request.user.username and request.user.chat_profile.is_chat_user:
# --------
# ---> don't need to use their chat login, will use plain phantastes login decorator
# --------
cu = request.user.chat_profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
# intial chat json data
r = Message.objects.order_by('-time')[:20]
res = []
for msgs in reversed(r):
res.append({
'id': msgs.id,
'user': msgs.user,
'msg': msgs.message,
'time': msgs.time.strftime('%I:%M:%S %p').lstrip('0'),
'gravatar': msgs.gravatar
})
data = json.dumps(res)
# end json
context = {'data': mark_safe(data)}
return render(request, 'djangoChat/index.html', context)
def get_logged_chat_users(request):
""" get logged chat users """
logged_chat_users = ChatUser.objects.filter(chat_logged_in=True)
# check if user has left chat room and log him out (45 seconds)
for user in logged_chat_users:
elapsed = utcnow() - user.last_accessed
if elapsed > datetime.timedelta(seconds=45):
user.chat_logged_in = False
user.save()
# check logged users again
logged_chat_users = ChatUser.objects.filter(chat_logged_in=True)
print "after check time and update"
users_list = []
for i in logged_chat_users:
users_list.append({
'username': i.username,
'gravatar':i.gravatar_url,
'id':i.u_id
})
data = json.dumps(users_list)
return HttpResponse(data, content_type="application/json")
def process(self, c, e, resume=False):
#"When receiving a file with DCC, accept it"
downloads_dir = directory()
bot = e.source.nick
try:
connection = self.dcc_connect(self.ip, self.port, "raw")
except irc.client.DCCConnectionError as e:
log('Couldn\'t connect to DCC peer: %s' % e).write()
self.dict[bot]["hist"].status, self.dict[bot]["hist"].time = "Peer connection error", utcnow()
self.dict[bot]["hist"].save()
views.manage_queue(self.dict[bot]["down"])
return ""
if resume:
self.dict[bot]["file"] = open(os.path.join(downloads_dir, self.dict[bot]["filename"]), 'ab')
self.dict[bot]["down"].filename, self.dict[bot]["down"].status = (
self.dict[bot]["filename"], "Resuming download...")
log('Resuming download of %s' % self.dict[bot]["filename"]).write()
else:
self.dict[bot]["file"] = open(os.path.join(downloads_dir, self.dict[bot]["filename"]), 'wb')
self.dict[bot]["down"].filename, self.dict[bot]["down"].status, self.dict[bot]["down"].sizeraw = (
self.dict[bot]["filename"], "Starting download...", self.dict[bot]["size"])
log('Starting download of %s' % self.dict[bot]["filename"]).write()
self.DCCconnections_dict[bot] = connection
self.dict[bot]["hist"].time = utcnow()
self.dict[bot]["down"].save()
t = threading.Timer(0, monitoring, [self, connection, bot, int(self.dict[bot]["position"])])
t.start()
s=threading.Timer(0, self.retry_pack, [connection, bot])
s.daemon=True
s.start()
def login(request):
if request.user.username and request.user.profile.is_app_user:
return HttpResponseRedirect(reverse('index'))
context = {'error': ''}
# get the fields
if request.method == 'POST':
username = request.POST.get('username', '') #return '' if no username
password = request.POST.get('pass', '')
# authenticate the user
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
cu = request.user.profile
cu.is_app_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = 'Wrong username and/or password. Try again.'
return render(request, 'health_search_application/login.html',
context)
context.update(csrf(request))
return render(request, 'health_search_application/login.html', context)
def make_fiscal(self):
if self.is_fiscal:
# invoice is already fiscal - do nothing
return
billing_settings = self.client.billing_settings
with transaction.atomic():
invoice_number = billing_settings.select_for_update(
'next_paid_invoice_number')
billing_settings.next_paid_invoice_number += 1
billing_settings.save(update_fields=['next_paid_invoice_number'])
date_time_now = utcnow()
self.is_fiscal = True
self.fiscal_date = date_time_now
self.fiscal_due_date = date_time_now
number_context = {
'number': invoice_number,
'year': date_time_now.year,
'month': date_time_now.month,
'day': date_time_now.day
}
try:
self.number = Template(
billing_settings.next_paid_invoice_number_format).render(
Context(number_context))
except TemplateSyntaxError as e:
LOG.error('ERROR settings invoice {} number: {}'.format(
self.id, e))
return self.save(update_fields=[
'is_fiscal', 'fiscal_date', 'fiscal_due_date', 'number'
])
def login(request):
if request.user.username and request.user.profile.is_chat_user:
return HttpResponseRedirect(reverse("index"))
context = {"error": ""}
if request.method == "POST":
username = request.POST.get("username", "") # retunr '' if no username
password = request.POST.get("password", "")
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
cu = request.user.profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse("index"))
else:
context["error"] = " wrong credentials try again"
return render(request, "djangoChat/login.html", context)
context.update(csrf(request))
return render(request, "djangoChat/login.html", context)
def login(request):
if request.user.username and request.user.profile.is_chat_user:
return HttpResponseRedirect(reverse('index'))
context = {'error':''}
if request.method == 'POST':
username = request.POST.get('username','') #retunr '' if no username
password = request.POST.get('password','')
user = auth.authenticate(username=username,password=password)
if user is not None:
auth.login(request,user)
cu = request.user.profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = ' wrong credentials try again'
return render(request,'djangoChat/login.html',context)
context.update(csrf(request))
return render(request,'djangoChat/login.html',context)
def run(self, *args, **kwargs):
operation_params = json.loads(self.db_operation.params)
region = operation_params.get('region')
if not region:
return self.abort_operation()
nc = nova_client(
api_session=IdentityAdminApi(request_session=AUTH_CACHE).session,
region_name=region)
try:
instance = nc.servers.get(
server={'id': self.db_operation.primary_object_id})
except (Exception, NotFound):
instance = None
if not instance:
resource_usage_log = ResourceUsageLog.objects.filter(
resource_uuid=self.db_operation.primary_object_id).order_by(
'start').last()
if not resource_usage_log:
return self.abort_operation()
if not resource_usage_log.end:
timestamp = utcnow().isoformat()
LOG.info(
'Instance delete operation successfully set the resource usage log end date'
)
resource_usage_log.end = timestamp
resource_usage_log.save()
return self.mark_as_completed()
else:
LOG.info(
'Instance related resource usage log was already ended by OS messages'
)
return self.mark_as_completed()
def login(request):
if request.user.username and request.user.profile.is_chat_user:
return HttpResponseRedirect(reverse('index'))
context = {'error': ''}
if request.method == 'POST':
username = request.POST.get('username', '') # return '' if no username
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is None:
if username is None or password is None:
context['error'] = ' You must specify username and password'
return render(request, 'djangoChat/login.html', context)
if User.objects.filter(username=username).count() != 0:
context[
'error'] = ' Username already exists. please choose another one'
return render(request, 'djangoChat/login.html', context)
User.objects.create_user(username=username, password=password)
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
cu = request.user.profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
clear_messages()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = ' wrong credentials try again'
return render(request, 'djangoChat/login.html', context)
context.update(csrf(request))
return render(request, 'djangoChat/login.html', context)
def logged_chat_users(request):
u = ChatUser.objects.filter(is_chat_user=True)
for k in u:
print k.username
for j in u:
elapsed = utcnow() - j.last_accessed
if elapsed > datetime.timedelta(seconds=45):
print elapsed
j.is_chat_user = False
j.save()
uu = ChatUser.objects.filter(is_chat_user=True)
print "after check time and update"
for k in uu:
print k.username
d = []
for i in uu:
d.append({
'username': i.username,
'gravatar': i.gravatar_url,
'id': i.userID
})
data = json.dumps(d)
return HttpResponse(data, content_type="application/json")
def test_insert_billy_bob(self):
obj = models.Contact(name=u"Billy Bob", is_organization=False)
obj.save_during(utcnow(), TIME_CURRENT)
master = MasterObject.objects.get(pk=obj.master.pk)
self.assertEqual(1, master.get_all().count())
self.assertEqual(obj, master.get_current())
def format_monitor(download_object):
"""
internal purpose only, not a view
"""
monitor = serializers.serialize('json', [download_object,])
monitor = json.loads(monitor)[0]
#prepare data
del monitor['model']
#monitor['fields']['attempts'] = Resume_Backup.objects.latest("id").attempts
monitor['fields']['id'] = download_object.id
if download_object.eta:
if localtime(download_object.eta).date() == utcnow().date():
monitor['fields']['eta'] = localtime(download_object.eta).time().strftime('%H:%M:%S')
else:
monitor['fields']['eta'] = localtime(download_object.eta).strftime('%d %b %H:%M:%S')
if download_object.timeleft:
if download_object.timeleft > 3600:
monitor['fields']['timeleft'] = time.strftime('%H h %M min %S sec', time.gmtime(download_object.timeleft))
elif download_object.timeleft > 60:
monitor['fields']['timeleft'] = time.strftime('%M min %S sec', time.gmtime(download_object.timeleft))
else:
monitor['fields']['timeleft'] = time.strftime('%S sec', time.gmtime(download_object.timeleft))
if download_object.completed:
if download_object.completed/(1024**2) >= 1000:
monitor['fields']['completed'] = format_number(download_object.completed, "GB")
else:
monitor['fields']['completed'] = format_number(download_object.completed)
if download_object.sizeraw:
if download_object.sizeraw/(1024**2) >= 1000:
monitor['fields']['size'] = format_number(download_object.sizeraw, "GB")
else:
monitor['fields']['size'] = format_number(download_object.sizeraw)
return monitor
def upload_monitoring(self, connection, upload):
sz = 0
log("Monitoring started").write()
start = time.time()
while connection.connected:
if self.bytesSent != sz:
end = time.time()
percentage = int(self.position + self.bytesSent) / int(self.size) * 100
completed = int(self.position + self.bytesSent)
elapsed = end-start
speed = int((self.bytesSent-sz)/elapsed)
if speed != 0:
tm = (int(self.size)-int(self.bytesSent)-self.position) / speed
else:
tm = 99999
eta = utcnow() + datetime.timedelta(seconds=tm)
speed = int(speed/1024)
upload.status, upload.progress, upload.completed, upload.eta, upload.timeleft = 'Uploading...', percentage, completed, eta, tm
#workaround for occasionnal empty packages
if speed:
upload.speed = speed
upload.save()
sz = self.bytesSent
start = time.time()
if percentage >=100:
self.reactor.disconnect_all()
return ""
time.sleep(1)
log("Monitoring stoped").write()
def test_insert_billy_bob(self):
obj = models.Contact(name=u"Billy Bob", is_organization=False)
obj.save_during(utcnow(), TIME_CURRENT)
master = MasterObject.objects.get(pk=obj.master.pk)
self.assertEqual(1, master.get_all().count())
self.assertEqual(obj, master.get_current())
def login(request):
""" performs login """
context = {'error':''}
# if user is already logged into chat
if request.user.username and request.user.profile.chat_logged_in:
return HttpResponseRedirect(reverse('index'))
if request.method == 'POST':
username = request.POST.get('username', '') #return '' if no username
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
chat_user = request.user.profile
chat_user.chat_logged_in = True
chat_user.last_accessed = utcnow()
chat_user.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = ' wrong credentials try again'
return render(request, 'djangoChat/login.html', context)
context.update(csrf(request))
return render(request, 'djangoChat/login.html', context)
def cluster_summary(cluster, condition):
results_map = {
'mean': cache.get(_CLUSTER_MEAN_SQL),
'sum': cache.get(_CLUSTER_SUM_SQL)
}
points = {}
for func, results in results_map.items():
for result in results:
if len(result) > 0:
key = result.keys()[0][0].replace('node', 'cluster')
df = pd.DataFrame(list(result.get_points()))
data = df[df['host'].isin(condition)]['value']
val = getattr(data.fillna(0), func)() if not data.empty else 0
points.update({key: float(val)})
now = utcnow()
points['cluster_mem_ratio'] = \
points['cluster_mem'] / points['cluster_mem_total'] * 100.0 \
if points.get('cluster_mem_total', 0) != 0 and \
'cluster_mem' in points \
else 0.0
cache.set([{
'measurement': measurement,
'tags': {
'host': cluster,
},
'time': now,
'fields': {
'value': float(value),
}
} for measurement, value in points.items()])
def login(request):
if request.user.username and request.user.profile.is_chat_user:
return HttpResponseRedirect(reverse('index'))
context = {'error': ''}
if request.method == 'POST':
username = request.POST.get('username', '') #retunr '' if no username
password = request.POST.get('password', '')
user = auth.authenticate(username=username, password=password)
if user is not None:
auth.login(request, user)
cu = request.user.profile
cu.is_chat_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = ' wrong credentials try again'
return render(request, 'djangoChat/login.html', context)
context.update(csrf(request))
return render(request, 'djangoChat/login.html', context)
def build_ipn_response(params):
now = utcnow().strftime('%Y%m%d%H%M%S')
params = params.decode('utf-8')
params = urllib.parse.unquote_plus(params)
params = params.split('&')
hash_string = ''
hash_fields = ['IPN_PID[]', 'IPN_PNAME[]', 'IPN_DATE']
already_collected_hash_fields = {}
for param in params:
to_append = param.split('=')
key = to_append[0]
value = to_append[1] if to_append[1] else None
if key in hash_fields and already_collected_hash_fields.get(
key, None) is None:
hash_string = '{}{}{}'.format(
hash_string,
len(value),
value,
)
already_collected_hash_fields[key] = True
hash_string = '{}{}{}'.format(hash_string, len(now), now)
response_hash = hmac.new(conf.secret_key, hash_string.encode('utf-8'),
hashlib.md5).hexdigest().encode('utf-8')
return '<EPAYMENT>{}|{}</EPAYMENT>'.format(
now, str(response_hash, encoding='utf-8'))
def _generate_ghosts_log(resource_name, parent_stat):
model = RESOURCE_MAP.get(resource_name)
now = utcnow()
date_dir_name = '{}-{}-{}'.format(now.year, now.month, now.day)
date_dir_path = '{}/{}'.format(GHOST_RESOURCES_DIR, date_dir_name)
if not os.path.exists(date_dir_path):
os.mkdir(date_dir_path)
stats = os.stat(date_dir_path)
if stats.st_uid != parent_stat.st_uid:
os.chown(date_dir_path, parent_stat.st_uid, parent_stat.st_gid)
with open('{}/{}'.format(date_dir_path, resource_name), 'w') as log_file:
resource_usage_logs = ResourceUsageLog.objects.filter(
resource_type=resource_name, end=None)
total_count = 0
for resource_usage_log in resource_usage_logs:
try:
model.objects.get(id=resource_usage_log.resource_uuid)
except model.DoesNotExist:
log_file.write(
'Not found resource with uuid: {} in db, but it has a resource usage log '
'that has no end date.\n'.format(
resource_usage_log.resource_uuid))
total_count = total_count + 1
log_file.write('TOTAL: {}\n'.format(total_count))
return '{}/{}'.format(date_dir_path, resource_name)
def run():
os_admin_api = IdentityAdminApi()
for client in Client.objects.all(): # type: Client
try:
LOG.debug('Cleaning up for client {}'.format(client))
if not client.first_project:
LOG.debug('Skipping client without project ...')
continue
openstack_settings = OpenstackSettings.for_client(client=client)
if openstack_settings.auto_cleanup_images:
max_create_date = utcnow() - timedelta(
days=openstack_settings.auto_cleanup_number_of_days)
images_to_cleanup = Image.objects.filter(
disk_format__in=openstack_settings.
auto_cleanup_image_types,
created_at__lte=max_create_date,
project=client.first_project,
).all()
for image in images_to_cleanup:
os_api = Images(api_session=os_admin_api.session)
os_image = os_api.get(image=image)
# TODO: implement protected image deletion
if not image.protected:
os_image.delete()
except Exception as e:
LOG.exception('Error processing client {} - {}'.format(client, e))
def login(request):
if request.user.username and request.user.profile.is_app_user:
return HttpResponseRedirect(reverse('index'))
context = {'error':''}
# get the fields
if request.method == 'POST':
username = request.POST.get('username','') #return '' if no username
password = request.POST.get('pass','')
# authenticate the user
user = auth.authenticate(username=username,password=password)
if user is not None:
auth.login(request,user)
cu = request.user.profile
cu.is_app_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error'] = 'Wrong username and/or password. Try again.'
return render(request,'health_search_application/login.html',context)
context.update(csrf(request))
return render(request,'health_search_application/login.html',context)
def handle(self, *args, **options):
def tweet_not_posted(status):
return status.id is None
#twitter api exponential backoff, max 10 second delay, try for 2 mins
@retry(wait_exponential_multiplier=1000,
wait_exponential_max=10000,
stop_max_attempt_number=12,
retry_on_result=tweet_not_posted)
def post_tweet(data, image_url=None):
if image_url:
fn, headers = urllib.urlretrieve(image_url)
data['filename'] = fn
status = twitter_api.update_with_media(**data)
else:
status = twitter_api.update_status(**data)
return status
if options['tweet_order']:
try:
tweet = Tweet.objects.get(tweet_sent=False,
order=options['tweet_order'])
except Tweet.DoesNotExist:
print "tweet order", options[
'tweet_order'], ' does not exist, or was already sent'
else:
tweet = Tweet.objects.filter(
tweet_sent=False).order_by('order')[options['skip']]
data = {'status': tweet.text_replace_placeholder()}
if DoNotSend.objects.filter(
fatal_encounter=tweet.fatal_encounter).count():
print "do not send", tweet.fatal_encounter
tweet.delete()
sys.exit(-1)
if options['geocode']:
print "geocoding",
tweet.location_id = twitter_geocode(tweet.fatal_encounter.city,
tweet.fatal_encounter.state)
data['place_id'] = tweet.location_id
print "done"
try:
print "posting", data,
status = post_tweet(data, tweet.share_image_url)
print "done"
tweet.tweet_sent_at = utcnow()
tweet.tweet_sent = True
tweet.tweet_id = status.id
tweet.save()
sys.exit(0)
except tweepy.error.TweepError, e:
print e
mail_admins(
'Tweepy error', """Error posting %s
%s
""" % (data, e))
sys.exit(-1)
def get_active_tos(self, request, *args, **kwargs):
del request, args, kwargs # unused
latest_version_tos = TermsOfService.objects.filter(
draft=False).order_by('-version').first()
if not latest_version_tos:
return Response({'tos_data': None})
try:
tos_agreement = TermsOfServiceAgreement.objects.get_or_create(
terms_of_service=latest_version_tos,
user=self.request.user,
)[0] # type: TermsOfServiceAgreement
except Exception as e:
raise APIBadRequest(str(e))
remind_later_button_available = True
if tos_settings.forbid_access_after:
forbid_after_datetime = datetime.datetime.strptime(
tos_settings.forbid_access_after, '%Y-%m-%d %H:%M:%S')
forbid_after_datetime = forbid_after_datetime.replace(
tzinfo=pytz.utc)
if utcnow() > forbid_after_datetime:
remind_later_button_available = False
return Response({
'tos_data': {
'agreement_id': tos_agreement.id,
'title': tos_agreement.terms_of_service.title,
'version': tos_agreement.terms_of_service.version,
'content': tos_agreement.terms_of_service.content,
'agreed': tos_agreement.agreed,
'remind_later_button_available': remind_later_button_available,
}
})
def delete(self, as_of=None, using=None):
"""
Invalidate self
Write new row with valid_end_date set
"""
now = utcnow()
if as_of is None:
as_of = now
if self.valid_end_date != TIME_CURRENT:
raise IntegrityError('Cannot delete non-current object')
# Refetch data so we don't update any fields
old_self = self._original()
old_self._txn_end_date = now
# invalidate previous row
old_self.save(using=using, update_fields=['_txn_end_date',])
# Save new row with valid end date
old_self.pk = None
old_self._txn_start_date = now
old_self._txn_end_date = TIME_CURRENT
old_self._valid_end_date = as_of
# save change
old_self.save(using=using)
return old_self
def get_previous_due_date(self, next_due_date=None):
"""
Get previous due date based on current assigned cycle.
DO NOTE: this does not work correctly if the cycle is changed before the next due date.
"""
if not self.cycle:
# FIXME(tomo): Free product
return utcnow()
elif self.cycle.cycle == CyclePeriods.onetime:
return self.next_due_date
elif self.cycle.cycle == CyclePeriods.hour:
return self.next_due_date - datetime.timedelta(
hours=float(self.cycle.cycle_multiplier))
elif self.cycle.cycle == CyclePeriods.year:
try:
return self.next_due_date.replace(
year=(self.next_due_date.year -
self.cycle.cycle_multiplier))
except ValueError:
years_diff = (datetime.datetime(
self.next_due_date.year - self.cycle.cycle_multiplier, 1,
1) - datetime.datetime(self.next_due_date.year, 1, 1))
return self.next_due_date - years_diff
elif self.cycle.cycle == CyclePeriods.month:
if next_due_date:
nd = next_due_date
else:
nd = self.next_due_date
if not nd:
# FIXME(tomo): next_due_date may be None
nd = utcnow()
quantity = self.cycle.cycle_multiplier
new_year = nd.year + int(nd.month - quantity - 1) // 12
# (int(start_date.month + quantity - 1) % 12) + 1
if nd.month > quantity:
new_month = nd.month - quantity
else:
new_month = (int(nd.month - quantity - 1) % 12) + 1
try:
return nd.replace(year=new_year, month=new_month)
except ValueError:
# It means that the new month was shorter than the current causing to have an invalid day.
# Skip to the first day of the following month.
# (i.e. Jan 31 + 1 month = Feb 31, invalid day so skip to Mar 1)
return nd.replace(year=new_year, month=new_month + 1, day=1)
else:
return self.next_due_date
def create_template(published=None):
published = utcnow() if published else None
t = Template.objects.create(title='test template', published=published)
s = Section.objects.create(template=t, title='test section')
q = BooleanQuestion.objects.create(section=s, obligatory=True)
CannedAnswer.objects.create(question=q, choice='Yes')
CannedAnswer.objects.create(question=q, choice='No')
return t
def save(self,
as_of=None,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
""" if as_of is provided, self.valid_start_date is set to it.
if self.valid_start_date is undefined, it is set to now.
"""
now = utcnow()
if self.pk and update_fields and tuple(update_fields) != (
'_txn_end_date', ):
raise IntegrityError(
'Attempted re-save of {} object, pk: {}'.format(
self.__class__.__name__, self.pk))
# _valid_start_date resolves in this order:
# as_of (overide), self.valid_start_date (existing value), now() (default)
if as_of is not None:
self._valid_start_date = as_of
if self.valid_start_date is None:
self._valid_start_date = now
if self.txn_end_date != TIME_CURRENT and self.txn_end_date > now:
raise IntegrityError(
'txn_end_date date {} may not be in the future'.format(
self.txn_end_date))
if self.valid_start_date > self.valid_end_date:
raise IntegrityError(
'valid_start_date date {} must precede valid_end_date {}'.
format(self.valid_start_date, self.valid_end_date))
# _txn_start_date is None before first save
if self.txn_start_date and self.txn_start_date > self.txn_end_date:
raise IntegrityError(
'txn_start_date date {} must precede txn_end_date {}'.format(
self.txn_start_date, self.txn_end_date))
if self.txn_start_date is None and self.txn_end_date != TIME_CURRENT:
raise IntegrityError(
'txn_end_date {} must be TIME_CURRENT for new transactions'.
format(self.txn_end_date))
# Create a new master object if we don't have one already
if self.master is None:
new_master = MasterObject(
content_type=ContentType.objects.get_for_model(self))
new_master.save()
self._master = new_master
# TODO: why save_base and not super().save() (used to be)
super(BitemporalModelBase, self).save(using=using,
force_insert=force_insert,
force_update=force_update,
update_fields=update_fields)
def update_time(request):
""" update last accessed time of user """
if request.user.username:
user = request.user.profile
user.last_accessed = utcnow()
user.chat_logged_in = True
user.save()
return HttpResponse('updated')
return HttpResponse('who are you?')
def update_time(request):
if request.user.username:
u = request.user.profile
u.last_accessed = utcnow()
u.is_chat_user = True
u.save()
return HttpResponse("updated")
return HttpResponse("who are you?")
def on_dcc_disconnect(self, connection, event, bot=""):
for key, value in self.DCCconnections_dict.items():
if value == connection:
bot = key
break
try:
self.dict[bot]["file"].close()
except:
bot = bot
if self.dict[bot]["stop"]:
return ""
if self.dict[bot]["cancel"] == False:
(self.dict[bot]["down"].status, self.dict[bot]["down"].progress, self.dict[bot]["down"].speed,
self.dict[bot]["down"].progress, self.dict[bot]["down"].eta) = "Extracting...", None, None, None, None
self.dict[bot]["down"].save()
tot = self.dict[bot]["received_bytes"]+self.dict[bot]["position"]
log("Received file (%d bytes)." % tot ).write()
log("Size (%d bytes)." % int(self.dict[bot]["size"]) ).write()
percdone = tot/int(self.dict[bot]["size"])
duration = (utcnow() - self.dict[bot]["hist"].time)
average = int(self.dict[bot]["size"])/1024/duration.total_seconds()
(self.dict[bot]["hist"].filename, self.dict[bot]["hist"].status, self.dict[bot]["hist"].average,
self.dict[bot]["hist"].duration, self.dict[bot]["hist"].time, self.dict[bot]["hist"].sizeraw) = (self.dict[bot]["filename"],
"Downloaded", round(average, 0), duration, utcnow(), self.dict[bot]["size"])
self.dict[bot]["hist"].save()
if os.path.exists(os.path.join(directory(), self.dict[bot]["filename"])):
#added to prevent extracting incomplete files (internet connection interrupted)
if percdone > 99/100:
untar(os.path.join(directory(), self.dict[bot]["filename"]),
self.dict[bot]["filename"], self.dict[bot]["down"], self.dict[bot]["hist"])
return ""
self.dict[bot]["down"].status = "Error during file transfer"
self.dict[bot]["down"].save()
self.dict[bot]["hist"].status, self.dict[bot]["hist"].time = "Error during file transfer", utcnow()
self.dict[bot]["hist"].save()
log("Error during file transfer. Completed percentage: %d" % int(percdone*100) ).write()
print ("2")
views.manage_queue(self.dict[bot]["down"])
return ""
else:
self.dict[bot]["cancel"] = False
views.manage_queue(self.dict[bot]["down"])
return ""
def chat_api(request):
if request.method == 'POST':
###Oauth system:userid for username
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(request.session.get('key'), request.session.get('secret'))
api = tweepy.API(auth_handler=auth)
###Update user
if request.user.username:
u = request.user.profile
u.last_accessed = utcnow()
u.is_chat_user = True
u.save()
###Makes json
#d = json.loads(request.body)
msg = request.POST['msg']
#msg = d.get('msg')
if len(msg) > 120:
print "error to much word"
return 0
######################################
#形態素解析による不明なコメント除去
######################################
word=msg
node = tagger.parseToNode(word.encode('utf-8'))
while(node):
if node.feature.split(",")[0] == "名詞" or node.feature.split(",")[0] == "動詞":
for checks in find:
if node.surface == checks:
#print "Bad Word",node.surface
return 0;
node = node.next
######################################
u = api.get_user(request.user.username)
user= u.screen_name
#print 'user',user
m = Message(user=user,message=msg)
m.save()
#res = {'id':m.id,'msg':m.message,'user':m.user,'time':m.time.strftime('%I:%M:%S %p').lstrip('0')}
#data = json.dumps(res)
try:
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(request.session.get('key'), request.session.get('secret'))
api = tweepy.API(auth_handler=auth)
""" test get tweet"""
api.update_status(status=m.message+" "+"#spicetest")
#count=count+1
except tweepy.TweepError,e:
p = re.compile('^\[{u\'message\': u\'(.+)\', u\'code\': (\d+)}\]$')
m = p.match(e.reason)
if m:
message = m.group(1)
code = m.group(2)
#return HttpResponse(data,content_type="application/json")
return HttpResponse("Sended")
def test_delete_john_doe(self):
obj = models.Contact.objects.current().get(_master=JohnMaster)
then = utcnow()
time.sleep(.1)
obj = obj.delete()
with self.assertRaises(models.Contact.DoesNotExist):
obj = models.Contact.objects.current().get(_master=JohnMaster)
self.assertGreater(obj.txn_start_date, then)
self.assertGreater(obj.valid_end_date, then)
def save(self, *args, **kwargs):
self.updated = utcnow()
if not self.id and not self.slug:
self.slug = slugify(self.name)
i = 0
while True:
try:
return super(Gauge, self).save(*args, **kwargs)
except IntegrityError:
i += 1
self.slug = "%s-%d" % (self.slug, i)
return super(Gauge, self).save(*args, **kwargs)
def run(self, wait=False):
self.state = 'Q'
self.qtime = utcnow()
self.save()
from . import queue
queue.run(which=self)
if wait is True:
time.sleep(.5)
for _ in range(3):
time.sleep(.5)
if self.state == 'D':
break
def db_metric_task(num=1, **kwargs):
"""This is a task to add a metric item"""
if getattr(settings, 'DEBUG'):
log.setLevel(logging.DEBUG)
created = kwargs.pop('created', utcnow())
if isinstance(created, basestring):
try:
created = dateutil.parser.parse(created).replace(tzinfo=pytz.utc)
except:
log.error("Unable to parse date from {}".format(created))
created=utcnow()
try:
met, _ = Metric.objects.get_or_create(**kwargs)
MetricItem.objects.create(metric=met, num=num, created=created)
except IntegrityError:
met, _ = Metric.objects.get(**kwargs)
MetricItem.objects.create(metric=met, num=num, created=created)
except Exception as err:
issue = "Unable to complete task!! {} - kwargs: {}".format(err, kwargs)
log.exception(issue)
raise
def test_dump_json_expired_date(self):
with open(settings.CECA_PASS_PASSWORD_PATH, 'w') as f:
s = '{"version": "0", "data": {"pv": {"passv": {"password": \
"hello", "expire": "%s"}}}}' % \
(utcnow()-timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%SZ')
cipher = Cipher()
f.write(
json.dumps(cipher.encode_aes(s),
default=json_encode_datetime))
self.assertEqual(get_password('pv', 'passv'), None)
def amend(self, as_of=None, using=None):
"""
Invalidate self
Write old data with valid_end set
write new data
"""
now = utcnow()
if as_of is None:
as_of = now
if self.txn_end_date != TIME_CURRENT:
#Raise error, must change an active row
raise IntegrityError('[{}] pk: {} is not an active row'.format(
self.__class__.__name__, self.pk))
if as_of > self.valid_end_date:
raise IntegrityError('as_of date {} must precede valid_end_date {}'.format(
as_of, self.valid_end_date))
old_self = self._original()
if old_self.valid_start_date != self.valid_start_date:
raise IntegrityError('You may not change valid_start_date in an update or amend, use save_during')
if self.valid_end_date != old_self.valid_end_date:
raise IntegrityError('You may not change valid_end_date in an update or amend, use save_during')
# Optimized for replacing a single row
# invalidate previous row
old_self._txn_end_date = now
old_self.save(using=using, update_fields=['_txn_end_date',])
# If valid_start == as_of, don't save a new row that covers no time
# This was an update
if old_self.valid_start_date != as_of :
# Save new row with updated valid end date
old_self.pk = None
old_self._txn_start_date = now
old_self._txn_end_date = TIME_CURRENT
old_self._valid_end_date = as_of
# save change
old_self.save(using=using)
# Save self as new row
self.pk = None
self._txn_start_date = now
self._txn_end_date = TIME_CURRENT
self._valid_start_date = as_of
self.save(using=using)
def handle(self, *args, **options):
def tweet_not_posted(status):
return status.id is None
#twitter api exponential backoff, max 10 second delay, try for 2 mins
@retry(wait_exponential_multiplier=1000, wait_exponential_max=10000, stop_max_attempt_number=12, retry_on_result=tweet_not_posted)
def post_tweet(data, image_url=None):
if image_url:
fn, headers = urllib.urlretrieve(image_url)
data['filename'] = fn
status = twitter_api.update_with_media(**data)
else:
status = twitter_api.update_status(**data)
return status
if options['tweet_order']:
try:
tweet = Tweet.objects.get(tweet_sent=False, order=options['tweet_order'])
except Tweet.DoesNotExist:
print "tweet order",options['tweet_order'],' does not exist, or was already sent'
else:
tweet = Tweet.objects.filter(tweet_sent=False).order_by('order')[options['skip']]
data = {'status': tweet.text_replace_placeholder()}
if DoNotSend.objects.filter(fatal_encounter=tweet.fatal_encounter).count():
print "do not send",tweet.fatal_encounter
tweet.delete()
sys.exit(-1)
if options['geocode']:
print "geocoding",
tweet.location_id = twitter_geocode(tweet.fatal_encounter.city, tweet.fatal_encounter.state)
data['place_id'] = tweet.location_id
print "done"
try:
print "posting",data,
status = post_tweet(data, tweet.share_image_url)
print "done"
tweet.tweet_sent_at = utcnow()
tweet.tweet_sent = True
tweet.tweet_id = status.id
tweet.save()
sys.exit(0)
except tweepy.error.TweepError,e:
print e
mail_admins('Tweepy error',
"""Error posting %s
%s
""" % (data, e))
sys.exit(-1)
def prep_history(download_object):
"""
internal purpose only, not a view
"""
raw = serializers.serialize('json', Download_History.objects.filter(pk=download_object.id))
raw = json.loads(raw)
raw = raw[0]
try:
if localtime(download_object.time).date() == utcnow().date():
raw['fields']['time'] = localtime(download_object.time).time().strftime('%H:%M:%S')
elif localtime(download_object.time).year == utcnow().year:
raw['fields']['time'] = localtime(download_object.time).strftime('%d %b %H:%M:%S')
else:
raw['fields']['time'] = localtime(download_object.time).strftime('%Y %d %b %H:%M:%S')
except :
#time == None, do nothing
pass
try:
s = download_object.duration.total_seconds()
if s < 60:
raw['fields']['duration'] = str(int(s)) + 's'
elif s < 3600:
raw['fields']['duration'] = str(int(s/60)) + 'm' + str(int(s%60)) + 's'
else:
raw['fields']['duration'] = str(int(s/3600)) + 'h' + str(int(s%3600/60)) + 'm' + str(int(s%3600%60)) + 's'
except :
#duration == None, do nothing
pass
del raw['model']
try:
if download_object.sizeraw/(1024**2) >= 1000:
raw['fields']['size'] = format_number(download_object.sizeraw, "GB")
else:
raw['fields']['size'] = format_number(download_object.sizeraw)
except :
#duration == None, do nothing
pass
return raw
def dump_to_bash():
passwords = Password.objects.filter(Q(expire=False) |
(Q(expire=True) & Q(datetime_expire__gte=utcnow())))
data = u''
for p in passwords:
data += u'export {0}={1}\n'.format(p.env_name, p.password)
if not os.path.exists(os.path.dirname(settings.CECA_PASS_BASH_PATH)):
os.makedirs(os.path.dirname(settings.CECA_PASS_BASH_PATH))
with open(settings.CECA_PASS_BASH_PATH, 'w') as f:
os.chmod(settings.CECA_PASS_BASH_PATH, 400)
f.write(data)
def get_callback(request):
'''
Callback
'''
# Example using callback (web app)
verifier = request.GET.get('oauth_verifier')
oauth_token = request.GET.get('oauth_token')
# Let's say this is a web app, so we need to re-build the auth handler first...
auth_get = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth_get.set_access_token(oauth_token, verifier)
auth_get.request_token = request.session.get('request_token')
try:
auth_get.get_access_token(verifier)
except tweepy.TweepError:
print 'Error! Failed to get access token.'
return HttpResponseRedirect(reverse('index'))
#get access token
request.session['key'] = auth_get.access_token
request.session['secret'] = auth_get.access_token_secret
#get user_id
user_id = int(tweepy.API(auth_get).me().id_str)
print "auth_username"+auth_get.get_username()
#authentication DataBase!!:
user=auth.authenticate(username=user_id, password=auth_get.access_token)
if user is None:
print "go to index"
user = User.objects.create_user(username=user_id, password=auth_get.access_token)
#user.userID=user_id
user.username=user_id#auth_get.get_username()
user.access_token = auth_get.access_token
user.access_token_secret = auth_get.access_token_secret
user.save()
#user = User.objects.get(username=user_id)
user.backend = 'django.contrib.auth.backends.ModelBackend'
engine = importlib.import_module(settings.SESSION_ENGINE)
request.session = engine.SessionStore()
user=auth.authenticate(username=user_id, password=auth_get.access_token)
auth.login(request,user)
cu = request.user.profile
cu.is_chat_user = True
#time
cu.last_accessed = utcnow()
cu.save()
request.session['key'] = auth_get.access_token
request.session['secret'] = auth_get.access_token_secret
return HttpResponseRedirect(reverse('index'))
def _run(self):
self.clean_dir()
if not os.path.exists(self.basedir):
os.mkdir(self.basedir)
# Initialize
cda = algs.get(self.name)
g = self.ds.get_networkx()
self.state = 'R'
self.save()
# Do actual running
self.rtime = utcnow()
start_time = time.time()
cd = cda(g, dir=self.basedir, verbosity=-10, **self.options_dict)
self.dtime = utcnow()
self.runtime = time.time() - start_time
# Process results
self.save_results(cd.results)
self.state = 'D'
self.save()
data = { }
data['results'] = cd.results
data['stdout'] = None
return data
def signup(request):
context = {}
if request.method == 'POST':
# get all the fields
username = request.POST.get('username','')
fname = request.POST.get('firstname','')
lname = request.POST.get('lastname','')
password = request.POST.get('pass','')
email = request.POST.get('email','')
# if the user exists, pick another username
if username!="" and User.objects.filter(username=username).exists():
context['user_error']="Please, pick another username."
return render(request,'health_search_application/signup.html',context)
# if there is a registered user with the same email, pick another email
if username!="" and User.objects.filter(email=email).exists():
context['email_error']="Please, pick another email."
return render(request,'health_search_application/signup.html',context)
if email!="" and validateEmail(email)==False:
context['email_error']="Please, use a valid email."
return render(request,'health_search_application/signup.html',context)
# if everything is filled and unique as well as valid, create the user
if username!="" and password!="" and email!="" and validateEmail(email) and len(username)<=10 and 3<=len(password)<=14 and \
not User.objects.filter(username=username).exists() and not User.objects.filter(email=email).exists():
user = User.objects.create_user(username,email,password)
user = auth.authenticate(username=username,password=password)
user.first_name=fname
user.last_name=lname
user.save()
if user is not None:
auth.login(request,user)
cu = request.user.profile
cu.is_app_user = True
cu.last_accessed = utcnow()
cu.save()
return HttpResponseRedirect(reverse('index'))
else:
context['error']="Please, fill in all the details."
return render(request,'health_search_application/signup.html',context)
context.update(csrf(request))
return render(request,'health_search_application/signup.html',context)
