New and Fresh Private + Public Proxies Lists Everyday!
Get and Download New Proxies from NewProxyLists.com
I have created a complete React+Node app. I want to make it Seo friendly. I have done the meta and title tags (internal seo) using Helmet but I don’t exactly know how to make it available to google for indexing (It shows blank pages in Seo tools). I read about it and came across SSR but I don’t know how to perform it on existing React app. Can someone please guide me on this?
Thanks.
Device Management is quite hard to achieve so we’ve seen the rise of many SaaS, from big providers and small startup, which automate the deploy of edge services onto IoT devices fleet. Some of them rely on containerization (and Docker is pushing towards a top level support on ARM archs) some other else act in a “serverless fashion” which means that let you load some script in some language and then copy it through your fleet
Basically what you can do is
It’s clear that this is the safest choice since you have to do nothing but some benchmark and then integrate your pipeline. But as with all cloud services, they come with their costs and their constraint
Yes, I’m not crazy. We know config management tools (Ansible, Terraform etc) since we use them to provision hundreds of cloud VMs, but there is not so much difference between a cloud VM and a linux device accessible through SSH and VPN. You just have to make sure that you are using a tool that is scalable enough and has the needed resiliency to work over unreliable channels. Saltstack dose this job quite good, it uses ZeroMQ as event bus and have small footprint agents. You can define your desired state through versioned files and change them accordingly to requirements, or take control of some devices for some specific maintenance tasks. Pay attention on managing all Ops aspects (security, scalability, availability) that are the major burden that this solution carries to you project
If you have a very simple use case, you wouldn’t be eager to pay cloud bills or to manage large scale configuration application for High Avaliability and so on…. You are able to communicate with your devices in a bidirectional way, you could write some platform service able to send events to the edge whenever a config update is available. Then the edge send back some tracking event to understand whether you should retry on some unavaliable device, rollback the deployment or perform some deployment strategy such as canary. But this worth only with the simplest scenario, because building a full fledged management solution takes a huge effort and distract your team for the real valuable activities
Hovering, or simply moving the mouse is normally a purely passive action, and doesn’t typically get treated as decisively as other user input (except, perhaps, for detecting inactivity). Hovering is an exploratory action, and should be guarded as a safe way for the user to gain additional contextual information, and peruse their environment before taking actions.
You may think that changing focus is not really affecting much and is easily fixable, but it now means that the user’s hover action is no longer “safe”. Their typically harmless explorations now have consequences.
Both on the web and in desktop applications, hover actions do not permanently change the state of the system. For example, a menu that expands on hover is expected to collapse when the mouse leaves. This norm reinforces the idea that a hover action is only a “shadow” that only temporarily modifies its surroundings.
This feature will break the user’s expectations for hover actions, so it should be an opt-in feature, or at least one that is explained at the start. I see the value in providing the feature so long as it fits the user’s workflow, so empower them to utilize it if they wish.
As an additional note, your example of the alarm application breaking the users expectation by capturing focus is justified (in my opinion) because it’s time-sensitive. Its core purpose is to capture the users attention at a certain time, so the intrusion is actually beneficial.
I am trying to control my SONY android TV with my Pixel using Android TV Remote control.
Everything works fine except the Keyboard.
When I type on the virtual keyboard provided in the app, the typed letters don’t appear on the screen.
Only the enter control keys like back and enter seem to have an effect on the TV but not the alpha numeric keys.
Need some help figuring this out.
I am not an Android developer, but one of the apps I use is now saying “Unfortunately … has stopped.”
I would like to look at the system logs to help figure out why, but all I can find is references to logcat and it would be a lot more convenient if I didn’t have to download Android Studio just to do this one thing.
Is there a way to get the logs without using Android Studio?
I am using SQL server for my mobile app but when doing beta testing, my app said it cannot connect to the database and when i check the report of my app, it says the error
android.database.sqlite.SQLiteException: no such table: server_preferences (code 1): , while compiling: SELECT * FROM server_preferences WHERE (name = ?) arrow_right_alt
It seems to be working on my android emulator but when i publish in play store, it gives me this error. Please help!
I have observed some people fumble with a mouse. They seem unable to synchronize clicking the buttons and sliding the mouse consistently, to where they drag things when they only meant to click on them. Or in trying to use drag-and-drop, they inadvertently drop too soon because they can’t keep their finger on the mouse button for the whole travel. Or they have trouble aiming the mouse while keeping the button pressed.
The web application is a simple toolbar. Think stickers, like gold stars for favorites, or thumbs-down for disfavor, or a red X for deletion. I want users to be able to apply those stickers from a “toolbar” on the edge, to objects on a web page. Drag-and-drop works for this.
For less dextrous users I envision what I’m calling click-and-drop. Instead of dragging with the mouse button depressed the whole time, it proceeds like this: one full click (mousedown + mouseup) on the toolbar “picks up” the icon. Now the mouse-cursor is replaced by the icon while the mouse moves, possibly with a grabbing hand next to it. A second full click at the destination “drops” the icon and the mouse-cursor goes back to what it was. Is there a name for this already? Maybe that action is more like dipping a paintbrush in a watercolor well, rather than a tool-belt.
Would this click-and-drop alternative be helpful for a good portion of dexterity-challenged web users? Are there better alternatives?
Without muddying this question too much, I was further thinking this alternative might transport to mobile or pad devices. Touch the toolbar, the icon hovers say in the upper right corner, pan to the destination, tap the destination once to “drop” the icon. I bring this up mainly for the consideration of consistency across devices. Though perhaps an entirely different scheme is better for the multi-touch world.
I have an app whose sole purpose is to seed data files and add the data to different CSVs which are zipped and exported by the user. My application controller is filled with lines that all look like this:
def export_tips
@appointments = Appointment.order('service_id')
send_data @appointments.to_csv_tips, filename: 'tips.csv'
end
def export_ticketpayments
@appointments = Appointment.order('service_id')
send_data @appointments.to_csv_ticketpayments, filename: 'ticketspaymentitems.csv'
end
def export_batchmanifest
@batchmanifests = Batchmanifest.all
send_data @batchmanifests.to_csv_batchmanifest, filename: "batch_manifest-#{Date.today}.csv"
end
def export_pets
@clients = Client.all
send_data @clients.to_csv_pets, filename: 'pets.csv'
end
def export_clients
@clients = Client.all
send_data @clients.to_csv_clients, filename: 'clients.csv'
end
I have it in the application controller because I used it in multiple different areas including creating single CSV exports and creating complex zip files with multiple zips and CSVs inside.
Some things that I have tried to cleanup the code include:
My application record is just as bad with repeated lines simply meant to export the CSVs:
def self.to_csv_appointments
attributes = %w(appointment_id location_id employee_id client_id child_id notes
has_specific_employee start_time end_time)
CSV.generate(headers: true) do |csv|
csv << attributes
all.each do |appointment|
csv << attributes.map { |attr| appointment.send(attr) }
end
end
end
def self.to_csv_appointmentservices
attributes = %w(appointment_id service_id price duration)
CSV.generate(headers: true) do |csv|
csv << attributes
all.each do |appointment|
csv << attributes.map { |attr| appointment.send(attr) }
end
end
end
def self.to_csv_tickets
attributes = %w(ticket_id location_id client_id ticket_status employee_id
employee_id start_time)
headers = %w(ticket_id location_id client_id status employee_id
closed_by_employee_id closed_at)
CSV.generate(headers: true) do |csv|
csv << headers
all.each do |appointment|
csv << attributes.map { |attr| appointment.send(attr) }
end
end
end
For the application record, I have tried similar methods as those listed for the application controller, but to no avail. Again, I use the code in application record instead of in the individual model files because I need to access these in multiple parts of the site.
The code from the application controller is used mostly in the static controller and buttons on the view files. I need the ability to create the file sets, as listed below, but also allow the user to export just one CSV.
Examples from static controller to built the zip files:
def create_appointments_zip
file_stream = Zip::OutputStream.write_buffer do |zip|
@appointments = Appointment.order('service_id')
zip.put_next_entry "appointment_manifest.csv"; zip << File.binread("#{Rails.root}/app/assets/csvs/appointment_manifest.csv")
zip.put_next_entry "appointments.csv"; zip << @appointments.to_csv_appointments
zip.put_next_entry "appointment_services.csv"; zip << @appointments.to_csv_appointmentservices
zip.put_next_entry "appointment_statuses.csv"; zip << @appointments.to_csv_appointmentstatuses
end
file_stream.rewind
File.open("#{Rails.root}/app/assets/csvs/appointments.zip", 'wb') do |file|
file.write(file_stream.read)
end
end
def export_salonset
create_appointments_zip
create_tickets_zip
create_inventory_zip
create_memberships_zip
file_stream = Zip::OutputStream.write_buffer do |zip|
@saloncategories = Saloncategory.all
@salonservices = Salonservice.all
@clients = Client.all
@locations = Location.all
@salonpricings = Salonpricing.all
@staffs = Staff.order("location_id")
zip.put_next_entry "batch_manifest.csv"; zip << File.binread("#{Rails.root}/app/assets/csvs/batch_manifest_simple_salon.csv")
zip.put_next_entry "categories.csv"; zip << @saloncategories.to_csv_saloncategories
zip.put_next_entry "clients.csv"; zip << @clients.to_csv_clients
zip.put_next_entry "employees.csv"; zip << @staffs.to_csv_staff
zip.put_next_entry "locations.csv"; zip << @locations.to_csv_locations
zip.put_next_entry "pricings.csv"; zip << @salonpricings.to_csv_pricings
zip.put_next_entry "services.csv"; zip << @salonservices.to_csv_salonservices
zip.put_next_entry "appointments.zip"; zip << File.binread("#{Rails.root}/app/assets/csvs/appointments.zip")
zip.put_next_entry "inventories.zip"; zip << File.binread("#{Rails.root}/app/assets/csvs/inventories.zip")
zip.put_next_entry "tickets.zip"; zip << File.binread("#{Rails.root}/app/assets/csvs/tickets.zip")
zip.put_next_entry "addonmappings.csv"; zip << File.binread("#{Rails.root}/app/assets/csvs/addonmappings.csv")
end
file_stream.rewind
respond_to do |format|
format.zip do
send_data file_stream.read, filename: "salon_set.zip"
end
end
file_stream.rewind
File.open("#{Rails.root}/app/assets/csvs/salon_set.zip", 'wb') do |file|
file.write(file_stream.read)
end
end
Link to my repository, if that is helpful
https://github.com/atayl16/data-wizard/blob/master/app/controllers/application_controller.rb
https://github.com/atayl16/data-wizard/blob/master/app/models/application_record.rb
I know there must be a better way than writing these same lines over and over. The code works, my site works (amazingly), but I would be embarrassed for any seasoned developer to see the repository without laughing. Any help is appreciated!
Hello, I am Vanessa Chole , I have been working with Vertexplus Technologies in Canada location from the past 3 Years which provides mobile app development, Salesforce integration, and IT services, with amazing job experience of Website Developer, where I keen to get lots of opportunities to serve clients while working for multiple industries worldwide.
I just created my first GTK+ 3 app with Python using PyGObject. It is very nice to be able to make GTK applications using Python, as I love that language. I’m not completely sure if the way I designed the code is the most conventional and efficient way, so would like some people with more experience to take a look at it.
It’s a very simple app that can temporarily disable the automatic screen lock when your screensaver kicks in. Sometimes when I am watching a movie with my partner and we pause it to get some food, my screensaver kicks in and the computer is locked and I need to re-enter my password again. This is a bit annoying sometimes, so I made this little tool that temporarily disables the screen lock and enables it again after some time, so that my computer isn’t left insecure.
Here’s the code:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gio, GLib
class ScreenLockDisableWindow(Gtk.Window):
def __init__(self):
super().__init__(title="Screen lock disable")
self.screensaver_settings = Gio.Settings('org.gnome.desktop.screensaver')
self.initial_lock_enabled = self.screensaver_settings.get_boolean('lock-enabled')
self.main_ui_stack = Gtk.Stack()
self.quantity_input = Gtk.SpinButton.new_with_range(min=1, max=60, step=1)
self.unit_radio_minutes = Gtk.RadioButton.new_with_label_from_widget(None, "minutes")
self.unit_radio_hours = Gtk.RadioButton.new_with_label_from_widget(self.unit_radio_minutes, "hours")
self.time_left_label = Gtk.Label()
self.seconds_left = 0
self.set_border_width(25)
self.add(self.main_ui)
def start(self):
self.show_all()
self.reinit_main_ui_stack()
self.connect('destroy', self.exit)
Gtk.main()
def exit(self, app):
self.screensaver_settings.set_boolean('lock-enabled', self.initial_lock_enabled)
Gtk.main_quit()
@property
def main_ui(self):
self.main_ui_stack.add_named(self.screen_lock_ui, 'main')
self.main_ui_stack.add_named(self.timer_ui, 'timer')
self.main_ui_stack.add_named(self.already_disabled_ui, 'already_disabled')
return self.main_ui_stack
def reinit_main_ui_stack(self):
if self.seconds_left > 0:
self.main_ui_stack.set_visible_child_name('timer')
elif not self.screensaver_settings.get_boolean('lock-enabled'):
self.main_ui_stack.set_visible_child_name('already_disabled')
else:
self.main_ui_stack.set_visible_child_name('main')
@property
def screen_lock_ui(self):
header_label = Gtk.Label(halign=Gtk.Align.START)
header_label.set_markup('<big><b>Screen lock</b></big>')
description_label = Gtk.Label(
halign=Gtk.Align.START,
label="Disable the screen lock for:"
)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.add(header_label)
box.add(description_label)
box.add(self.time_picker)
box.add(self.start_button)
return box
@property
def time_picker(self):
self.quantity_input.props.value = 1
radio_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
radio_box.add(self.unit_radio_minutes)
radio_box.add(self.unit_radio_hours)
box = Gtk.Box()
box.add(self.quantity_input)
box.add(radio_box)
return box
@property
def start_button(self):
button = Gtk.Button.new_with_label("Start")
button.connect('clicked', self.on_start_button_click)
return button
def on_start_button_click(self, button):
self.screensaver_settings.set_boolean('lock-enabled', False)
quantity = int(self.quantity_input.get_text())
if self.unit_radio_hours.get_active():
minutes = 60 * quantity
else:
minutes = quantity
self.seconds_left = minutes * 60
self.update_time_left_label()
self.reinit_main_ui_stack()
GLib.timeout_add_seconds(1, self.update_seconds_left)
def update_seconds_left(self):
self.seconds_left -= 1
self.update_time_left_label()
self.update_lock_enabled()
return self.seconds_left > 0
def update_lock_enabled(self):
if self.seconds_left < 1:
self.screensaver_settings.set_boolean('lock-enabled', True)
self.reinit_main_ui_stack()
def update_time_left_label(self):
self.time_left_label.set_text(f"{self.seconds_left} seconds")
@property
def timer_ui(self):
header_label = Gtk.Label()
header_label.set_markup("<big><b>Screen lock disabled</b></big>")
message_label = Gtk.Label("Enabling screen lock again after:")
enable_now_button = Gtk.Button.new_with_label("Enable now")
enable_now_button.connect('clicked', self.on_enable_now_button_click)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.add(header_label)
box.add(message_label)
box.add(self.time_left_label)
box.add(enable_now_button)
return box
def on_enable_now_button_click(self, button):
self.seconds_left = 0
self.update_lock_enabled()
@property
def already_disabled_ui(self):
return Gtk.Label(
halign=Gtk.Align.START,
label="The screen lock is already disabled"
)
ScreenLockDisableWindow().start()
Some things I’m a bit confused about:
Gtk.main() and Gtk.main_quit() inside my window class. Not sure if this makes sense. If there are multiple window classes, how would GTK know which window to show?Gtk.Stack widget to switch between views in the app. Is this the way to go, or would you normally use hide() and show() on the widgets? Seems to me that’s more cumbersome. Also I noticed that hide(), show() and the Gtk.Stack.set_visible_child_name() methods don’t seem to work in __init__() but do work in a callback function, from a button click for example. That’s why I put the reinit_main_ui_stack() method in the start() method that is called after __init__().render() method that re-renders the complete content of the component when it is called again, so you can easily set a new state, which re-renders the component, and in the render function you can have different content rendered with a different state. I guess that’s not the way it is done in GTK+.