How to make existing React app seo friendly?

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.

deployment – How to deploy python microservices app updates?

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

  1. Evaluate these tools (eg. Azure IoT Edge)
  2. Work With some configuration management tool (eg. Saltstack)
  3. Roll you own solution

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

Is it ok for a desktop app to steal the focus when the app’s window is hovered?

Hovering should be a “safe” action

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.

Hovering is not expected to affect the state of the system

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.

Provide the feature only after explaining it, and allow the user to easily disable it

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.

Android TV Remote Control app

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.

logging – As a non-developer, how do I download logs so I can help diagnose why an app is crashing?

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?

applications – Cannot connect to database when publish app in play store

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!

web app – “Click-and-drop” alternative to drag-and-drop, for accessibility (and maybe mobile-web)

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.

beginner – App to seed DB, generate CSVs, and export individually or in complex zip files Rails 5

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:

  • Different variables of this:
    def csv_export (model, filename)
    @model.pluralize = (model.titleize).all
    send_data @model.pluralize.filename, filename: filename
    end
  • Having each one in its own controller (could not access them from different views and other controllers easily)
  • I also tried to figure out how to create my own module, but was unable to do so.

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!

Mobile app development services | NewProxyLists

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.

 

Ubuntu GTK+ 3 desktop app, made with Python library PyGObject

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:

  • I put the 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?
  • I used the 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__().
  • Is there a way to add/remove widgets after initialization? Or re-render a widget so that you can give it new contents? I am coming from web development and am used to libraries like React where you have a 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+.