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 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 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)