Forem: Linuxander

Wipe Windows Directory

Linuxander — Fri, 25 Dec 2020 01:00:49 +0000

I am currently working on some wipe+backup project in free time, and during my tests I've created this small demo program. It start with double-click, and clean all files in directory with 9 overwrites.

Source is taken from AFINUS, And compiled with OCRA gem, for fun, but could be useful for fast/secure folder clean.

WinWiper

Github

Download

Rails bitcoin prodavnica - deo II

Linuxander — Mon, 14 Dec 2020 11:59:16 +0000

Part II of "Shopping Cart with Bitcoin payout" tutorial in Serbian language. I will create a full application with tutorial in English for Hackathon. I will also add nested-attributes for order-payment and more checkout options.

U prvom delu tutoriala napravili smo korisnike, proizvode, i korpu. U ovom delu kreiracemo porudzbine iz korpe, i procesuirati uplatu na bitcoin adresu.

Porudzbine

Nastavljamo sa scaffold-om, kao i u prvom delu:

rails g scaffold order cart_id:integer, user_id:integer, full_price:decimal, cart_price:decimal, shipping_price:decimal, country, address, canceled:boolean, complete:boolean, status, token

Nakon toga otvorite OrdersController i dodajte sledeci kod:

class OrdersController < ApplicationController

  before_action :authenticate_user!
  before_action :set_cart,  only: [:create]
  before_action :set_order, only: [:show, :destroy, :delivered]


  def index
    @orders = current_user.orders.recent.last(30)
  end

  def show
  end

  def new
    @order = current_user.orders.build
  end

  def create

    country = params[:order][:country]  ||= current_user.country
    address = params[:order][:address]  ||= current_user.address

    unless cart_empty?

      @order = current_user.orders.build(order_params)
      @order.construct_from_cart(current_cart, country, address)

      if @order.save; @cart.destroy
        redirect_to @order, notice: "Order: #{@order.address} has been created. Charity donation: $#{@order.charity_fee}."
      else
        redirect_to @cart, notice: "An error ocurred with your order!"
      end

    else
      redirect_to products_path, notice: "Your Cart is empty."
    end
  end

  def destroy
    if @payment.status == 'unpaid'
      @payment.cancel! and @order.cancel!
      redirect_to orders_path, notice: "Order #{@order.token} has been canceled!"
    else
      redirect_to @order, notice: "Order can't be canceled at this step!"
    end
  end

  def delivered
    if @payment.status == 'complete'; @order.finalize!
      redirect_to @order, notice: "Order: #{@order.token} has been delivered!"
    else
      redirect_to @order, notice: "Please finalize your payment before marking order as delivered."
    end
  end


  private

  def set_order
    @order   = current_user.orders.find(params[:id])
    @payment = Payment.find_by(order_id: @order.id)
  end

  def cart_empty?
    current_cart.cart_items.count < 1
  end

  def order_params
    params.require(:order).permit(:cart_id, :user_id, :full_price, :cart_price, :shipping_price, :site_fee, :country, :address, :description, :canceled, :complete, :status, :token)
  end

end

Metod create koristi :construct_from_cart, metod koji smo definisali u modelu. Otvoride model Order i dodajte sledece:

class Order < ApplicationRecord

  belongs_to :user
  has_one    :cart
  has_many   :payments, dependent: :destroy

  scope      :recent, -> { order created_at: :desc }

  validates  :user_id, :cart_id, :full_price, :country, :address, :token, :status, presence: true


  def construct_from_cart(cart, country, address)
    self.cart_id        = cart.id
    self.token          = cart.token
    self.cart_price     = cart.total_price
    self.shipping_price = get_shipping_price(country)
    self.country        = country
    self.address        = address
    self.status         = 'created'
    self.description    = desc = ""

    current_cart.cart_items.each do |item|
      desc << "#{item.quantity} x #{item.product.title}; "
    end
  end

  def get_shipping_price(country)
    ShippingPrice.for(country)
  end

  def site_fee
    #define your site fee as ENV variable
  end

  def full_price
    self.cart_price + self.site_fee + self.shipping_price
  end

  def cancel!
    self.canceled = true
  end

  def finalize!
    self.complete = true
  end

end

Ovde smo napravili metod koji smo koristili u kontroleru, koji popunjava tabelu Orders uz pomoc zadatih podataka.
Podaci neophodni za kreiranje porudzbine su korpa, drzava i adresa. Kod je prilicno samo-objasnjavajuci, sto je jedna
od dobrih odlika Ruby-ja.

Ono sto nije je objasnjeno je odakle dolazi Shipping#price metod? U folderu concerns u modelima, gde smo definisali
nasu korpu (shopping_cart.rb), sada kreirajte novi dokument i nazovite ga shipping_price.rb. U njega dodajte sledeci kod:

module ShippingPrice

  COUNTRIES = %w{ SERBIA GREECE RUSSIA EUROPE WORLDWIDE }

  private

  def self.for(country)

    case country
      when 'SERBIA'    then 5
      when 'GREECE'    then 15
      when 'RUSSIA'    then 30
      when 'EUROPE'    then 20
      when 'WORLDWIDE' then 35
    end    

  end
end

Ovde imamo definisan modul koji koristimo u porudzbinama, ShippingPrice.for(country), kao i kolekciju COUNTRIES
koju koristimo da odredimo cene za odredene zemlje. Kolekciju countries cemo takodje koristiti u views (.html.erb) fajlovima kao izor drzave.
Za sve ovo postoji mnogo bolji nacin, ali zeleo sam da to uradim brzo i jednostavno, bez svih drzava, dodatnih tabela itd... Na kraju nam ostaju migracije:

class CreateOrders < ActiveRecord::Migration[6.0]
  def change
    create_table :orders do |t|
      t.integer  :user_id, null:false, foreign_key: true
      t.integer  :cart_id
      t.string   :country
      t.text     :address
      t.text     :description
      t.decimal  :cart_price
      t.decimal  :shipping_price
      t.decimal  :full_price
      t.decimal  :site_fee
      t.string   :token
      t.string   :status
      t.boolean  :canceled
      t.boolean  :complete

      t.timestamps
    end
  end
end

Sada kada su nam porudzbne funkcionalne, predjmo na placanje, kako bi smo popunili @payments variable u porudzbinama.

Procesuiranje Porudzbine

Napravite novi scaffold za uplate, odnsno procesuiranje istih:

rails g scaffold payment price:decimal, order_id:integer, cart_id:integer, user_id:integer, address, public_key, balance:decimal, index:integer, token, canceled:boolean, complete:boolean, status

Otvorite PaymentsController i promenite kod da izgleda ovako:

class PaymentsController < ApplicationController

  include Bitcoin

  before_action :authenticate_user!
  before_action :get_payments, except: [:create]
  before_action :set_status,   only:   [:index]
  before_action :set_payment,  only:   [:show, :destroy]


  def index
    @payments = @user_payments.recent.last(30)
  end

  def show
  end

  def new
    @payment = current_user.payments.build
  end

  def create

    generate_payment_address!
    @order   = Order.find(params[:order_id])
    @payment = current_user.payments.build(payment_params)
    @payment.construct_from_order(@order, @index, @bip32, @address)

    if @payment.save
      redirect_to @payment, notice: "To finalize order, send $#{@payment.price} to address: #{@payment.address}"
    elsif @order
      redirect_to @order, notice: "An error ocurred while creating payment. Please try again."
    else
      redirect_to root_path, notice: "An error ocurred - wrong Order ID."
    end
  end

  def destroy
    if @payment.status == 'unpaid' 
      @payment.cancel! and @order.cancel!
      redirect_to payments_url, notice: "Payment for Order: #{@order.token} was successfully canceled."
    else
      redirect_to @payment, notice: "Order can't be stopped at this step!"
    end
  end


  private

  def get_payments
    @user_payments = Payment.where(user_id: current_user.id, canceled: false).find_each
  end

  def set_payment
    @payment = @user_payments.find(params[:id])
    @order   = orders.find(@payment.order_id)
    @payment.update! unless @payment.complete or @payment.canceled
  end

  def set_status
    payments = @user_payments.recent.last(5)
    payments.each { |p| p.update! unless (p.complete or p.canceled) }
  end

  def generate_payment_address!
    payment  =  Payment.last
    payment  ?  index = payment.index  :  index = 0
    wallet   =  generate_new_address_from(index)
    @index   =  wallet.index
    @bip32   =  wallet.to_bip32
    @address =  wallet.to_address
  end

  def payment_params
    params.require(:payment).permit(:user_id, :order_id, :price, :balance, :public_key, :address, :index,
                                    :status,  :canceled, :complete, :token)
  end

end

Ovde smo uradili metod :generate_payment_address da kreira novu adresu za svaku uplatu. Za to smo takodje koristili concerns u modelima, i napravili novi bip32.rb.

module Bip32

  private

  #   key should be defined as ENV config variable!
  KEY = 'xpub6AvUGrnEpfvJJFCTd6q****************************cfBUbeUEgNYCCP4omxULbNaRr'
  API = BlockCypher::Api.new

  def generate_new_address_from(index)
    wallet = initialize_wallet_node!
    depth  = wallet.depth
    path   = "M/#{depth}/#{index += 1}"
    pubkey = wallet.node_for_path path
    return pubkey if pubkey
  end

  def initialize_wallet_node!
    MoneyTree::Node.from_bip32(KEY)
  end

  def get_address_data(address)
    balance = API.address_balance(address)
    return balance if balance
  end

  def payment_success?(address, price)
    data = get_address_data(address)
    data ? coins = data[:balance] : coins = 0
    return true unless coins < price
  end

end

Sada promenite Vas Payment model:

class Payment < ApplicationRecord

  belongs_to :order
  belongs_to :user

  scope     :recent, -> { payment created_at: :desc }

  validates :order_id, :user_id, :price, :address, :index, :public_key, :status, :balance, presence: true


  def update!

    bip32 = Bip32.get_address_data(self.address)
    data  = JSON.parse(bip32)

    unless data.nil?

      balance    = data[:balance]
      no_balance = data[:unconfirmed_balance]

      if no_balance == payment.price
        update_status('waiting payment', 'waiting confirmations')

      elsif no_balance > 0 and balance == 0
        update_status('waiting payment', 'processing payment') unless no_balance == payment.price

      elsif balance > 0 and balance < payment.price
        update_status('processing payment', 'underpaid')

      elsif balance == payment.price or balance > payment.price
        update_status('waiting delivery', 'complete') and finalize!
      end
    end
  end

  def construct_from_order(order, index, bip32, address)
    self.user_id    = order.user_id
    self.order_id   = order.id
    self.token      = order.token
    self.price      = order.full_price
    self.index      = index
    self.public_key = bip32
    self.address    = address
  end

  def update_status(order_status, payment_status)
    new = Order.find(self.order_id)
    new.status  = order_status
    self.status = payment_status
  end

  def cancel!
    self.canceled == true
  end

  def finalize!
    self.complete == true
  end

end

Ovo je skoro identicno porudzbinama, i takodje je sve samo-objasnjavajuce. Popunite migracije i izvrsite rails db:migrate:

class CreatePayments < ActiveRecord::Migration[6.0]
  def change
    create_table :payments do |t|
      t.integer :order_id,  foreign_key: true
      t.integer :user_id,   foreign_key: true
      t.integer :cart_id
      t.decimal :price
      t.decimal :balance,   null: false, default: 0
      t.string  :public_key
      t.string  :address
      t.integer :index
      t.string  :status,    null: false, default: 'unpaid'
      t.boolean :canceled
      t.boolean :complete

      t.timestamps
    end
  end
end

Sada imamo dodate porudzbine i uplate za njih. Obzirom da koristimo samo jedan nacin uplate, @payment.cancel! automatski prekida i porudzbinu.

U trecem delu cemo uraditi izgled i rute, iako je vecina njih dodato automatski uz scaffold, treba ih delimicno izmeniti. Osim toga treba izmeniti ApplicationController, is jos nekoliko stvari koje cu opisati u trecem delu. Sve u svemu, potpuno funkcionalna prodavnica, uz mogucnost lakog ubacivanja Stripe-a ili nekog drugog payout sistema.

How to sort numbers in ruby

Linuxander — Sun, 13 Dec 2020 23:22:57 +0000

This is a simple module to sort numbers from lower to higher:

module Sort

  def numbers(array)
    n = array.length - 1
    x = 0
    while x <= n - 1
      first = x
      y = x + 1
      while y <= n
        first = y if array[y] < array[first]
        y += 1
      end
      array[x], array[first] = array[first], array[x] unless x = first
      x += 1
    end
  end

end

Now you can use this module like this:

  nums = [14,2,290,13,54,254,66,72,918,90]

  puts "Numbers to sort: #{nums}"

  data = Sort.numbers(nums)
  puts "Sorted numbers: #{data.inspect}"

  x_data = data.shuffle
  puts "Shuffled numbers: #{x_data.inspect}"

  y_data = Sort.numbers(x_data)
  puts "Sorted again: #{y_data.inspect}"

Scrap web-shop to database

Linuxander — Sun, 13 Dec 2020 22:52:51 +0000

Web scrapping is important and needed in all spheres of IT. One of good use-cases is to create a drop-shipping website, and to populate database with items from some shop. This is even better if you work with digital items, so you don't care about item-delivery. You just have to put some provision, and to give something to the users that will make them use your site (create quality content, add forum, chat, scrap some news about your products and show them in news feed...).

I will create Ruby script to scrap data from Delije Butik as sample shop. You can implement this as rake task on heroku, to scrap items every hour and update database if something changed.

First install all gems that we will use:

gem install nokogiri rest-client sequel colorize

Now create a new document and call it scrap.rb. As always on start add shebang and require all gems:

#!/usr/bin/env ruby

require nokogiri
require rest-client
require sequel
require colorize

Now we can start... I will use sequel to connect to database and populate scrapped data. Rest-Client is used to make request with website, and Nokogiri to actually scrap our data. At the end, gem Colorize is used to make our output in terminal look nice.


  DB  = Sequel.sqlite('db/development.sqlite3')
  URL = 'https://delijebutik.com/shop'

  def open_page(url)
    html  = RestClient.get(url)
    @page = Nokogiri::HTML(html)
    @data = @page.search('div.thunk-product')
  end

Now open the web-page you want to scrap, to find all div names you need. So go open inspector (right click + inspect element) and find main field that contain all others. So we don't need header and all body, we need item name, price, photo, description etc... In this case, field is <div class="thunk-product">:

Now create new method that will actually scrap all those data and populate database:



  table = DB[:products]

  @data.each do |x|

    title   = x.search('div.thunk-product-content > h2').text          rescue  title   = nil
    price   = x.search('div.thunk-product-content > span > span').text rescue  price   = nil
    photo   = x.search('div.thunk-product-image > img')[0]['src']      rescue  photo   = nil
    photoH  = x.search('div.thunk-product-image > img')[1]['src']      rescue  photoH  = nil
    link    = x.search('> a')[0]['href']                               rescue  link    = nil

  unless table.where(title: title, price: price, link: link).all.count > 0

    table.insert(
      title:      title,
      price:      price,
      photo:      photo,
      photoH:     photoH,
      link:       link,
      created_at: Time.now,
      updated_at: Time.now )

    puts 'Naziv:     ' + title.yellow.bold
    puts 'Cena:      ' + price.green.bold
    puts 'Slika:     ' + photo.red
    puts 'Link:      ' + link.yellow

    60.times { print '='.white }; puts ''
  else

    puts "Product: #{title} has been skipped!"
  end end

So how we found all other fields? After we found main field div.thunk-product, we look at other fields against main. Take a look at code or go to the website and look at page source:

So it was easy, but what what about pages? We will find total number of pages, and define counter as zero. Then we will scrap one page, increase counter for 1, then scrap again... until we reach total number of pages:


  @c = 0
  open_page(URL)

  @data       = @page.search('div.thunk-product')
  last_number = @page.search("a.page-numbers")[5].text

  @last_page_number = last_number.to_i
  @last_page_number.times do
    @c +=1
    puts "\n Scrapping page [" + "#{@c}".red.bold + "]\n" + "\n" 
    open_page("#{URL}/page/#{@c}") and scrap!
    puts "\nFinished scrapping [".white + "#{@last_page_number}".red.bold + "] pages!\n\n"
  end

And that's it! You have a web-scrapper for your new e-commerce app! I used sqlite3, but you can use whatever DB fit your needs. Full code look like this, and in my case it was in lib folder of rails app, for manual execution:
ruby lib/scrap.rb

Edit:
Added if response code = 200, to check is web-page available:

#!/usr/bin/env ruby

require 'nokogiri'
require 'sequel'
require 'rest-client'
require 'colorize'


class DelijeShop

  DB  = Sequel.sqlite('db/development.sqlite3')
  URL = "https://delijebutik.com/shop"

  def initialize

    @c = 0
    open_page(URL)

    if @html.code == 200

      @data       = @page.search('div.thunk-product')
      last_number = @page.search("a.page-numbers")[5].text

      @last_page_number = last_number.to_i
      @last_page_number.times do
        @c +=1
        puts "\n Scrapping page [" + "#{@c}".red.bold + "]\n" + "\n" 
        open_page("#{URL}/page/#{@c}") and scrap! and sleep(3)
      end
      puts "\nFinished scrapping [".white + "#{@last_page_number}".red.bold + "] pages!\n\n"

    else
      raise "Connection error, code #{@html.code} returned"
    end
  end

  def open_page(url)
    @html = RestClient.get(url)
    @page = Nokogiri::HTML(html)
    @data = @page.search('div.thunk-product')
  end

  def scrap!

    table = DB[:products]

    @data.each do |x|

      title   = x.search('div.thunk-product-content > h2').text          rescue  title   = nil
      price   = x.search('div.thunk-product-content > span > span').text rescue  price   = nil
      photo   = x.search('div.thunk-product-image > img')[0]['src']      rescue  photo   = nil
      photoH  = x.search('div.thunk-product-image > img')[1]['src']      rescue  photoH  = nil
      link    = x.search('> a')[0]['href']                               rescue  link    = nil

    unless table.where(title: title, price: price, link: link).all.count > 0

      table.insert(
        title:      title,
        price:      price,
        photo:      photo,
        photoH:     photoH,
        link:       link,
        created_at: Time.now,
        updated_at: Time.now )

      puts 'Naziv:     ' + title.yellow.bold
      puts 'Cena:      ' + price.green.bold
      puts 'Slika:     ' + photo.red
      puts 'Link:      ' + link.yellow

      60.times { print '='.white }; puts ''
    else

      puts "Product: #{title} has been skipped!"
    end end
  end

end    # end_of_class


  puts "\n" + 'Scrapping Delije Shop Products List ...'.yellow

  50.times { print '-'.yellow }; puts '' and DelijeShop.new

Fisher-Yates shuffle algorithm with Ruby

Linuxander — Sat, 12 Dec 2020 19:52:23 +0000

The simplest shuffle algorithm, Fisher-Yates, is widely used and easy to implement. I personally used it to create a card game in Sinatra:

# Fisher-Yates Shuffle Algorithm

module FisherYates

  def self.shuffle(numbers)
    n = numbers.length
    while n > 0 
      x = rand(n-=1)
      numbers[x], numbers[n] = numbers[n], numbers[x]
    end
    return numbers
  end

end

So let's imagine you want to use it in your Rails app, you could do something like this:

  def initialize(numbers)
    shuffle = FisherYates.shuffle(numbers)
    return shuffle.inspect
  end

If you want to test this script from shell, add this after FisherYates, and save as shuffle.rb. Add numbers as arguments, or just execute script to shuffle defined numbers from array:

  @numbers = [1,2,3,4,5,6,7,8,9,10,12,13,14]

  if ARGV.empty?
    puts FisherYates.shuffle(@numbers).inspect
  else
    puts FisherYates.shuffle(ARGV).inspect
  end

Without inspect you would get each number in separated line, but with inspect we receive array of numbers printed in terminal.

Create bootable USB from terminal

Linuxander — Sat, 12 Dec 2020 11:46:50 +0000

This is for linux beginners, simple how-to create bootable usb from terminal. DD command takes input and duplicate it, and it's exactly what we need.

Serbian Translate:
Tutorial za linux pocetnike, kako napraviti butabilni USB iz terminala. Koristeci DD komandu, koja pravi duplikat zeljenog fajla.

1. Full Command Explained

$ sudo dd if=Ubuntu.iso of=/dev/sdb bs=8M status=progress && sync

sudo - give you root access
dd - command to duplicate disk
if - name of file you want to write
of - name of USB device
bs - size of bytes to write at a time
status - show status progress during duplication
sync - synchronize writes

2. Fill Device With Zero (optional)

If you have some damaged fields on USB, fill it with zero first:

sudo dd if=/dev/zero of=/dev/sdb bs=8M status=progress && sync

zero - will delete everything on USB, including partitions
Run dd zero BEFORE you write file to USB
If you need to make a new partition, take a look at FDISK tutorial

3. Make Process Automatic (for future use)

Symlink script in /bin/ folder to make it available within the system

ln -s /path/to/writeusb.sh /bin/writeusb

Change download folder to any folder you want

#!/bin/bash

#  Check Root User

  if [ $(id -u) != "0" ]; then
    echo -e "$W"" You must have root access to run this script!\n"$RS" "
    sleep 1
    exit
  fi


#  Banner

  echo -e -----------------------------------
  echo -e    Write USB Script
  echo -e -----------------------------------


#  Define Functions

  function list_usb_devices() {
    lsblk -l | grep sd
}

  function clean_usb() {
    sudo dd if=/dev/zero of=$DEV bs=8M status=progress && sync
}

  function write_usb() {
    sudo dd if=$NAME of=$DEV bs=8M status=progress && sync
}

#  Define Working Directory

  DIR=~/Downloads
  cd "$DIR"
  #DEV="/dev/sdb"   # To define USB device name

#  Start Script

  echo -e "Please find USB device name (example: /dev/sdb)"
    list_usb_devices

  echo -e -n "Please enter USB device name: "
    read DEV        # remove this lines if you hardcoded usb device name   

  clear && sleep 1

  echo -e "Your USB device name is: "$DEV" "
  echo -e "Your Working Folder Is: "$DIR" "

  echo -e -n "Enter a name of file to write: "
    read NAME

  echo -e -n "Do you want to fill USB with zero? (y/n): "
    read ANSWZERO

      if [ "$ANSWZERO" == "y" ] || [ "$ANSWZERO" == "Y" ]; then

        echo -e -n "Do you want to write USB after zero-ing? (y/n): "
          read AFTZERO

        if [ "$AFTZERO" == "y" ] || [ "$AFTZERO" == "Y" ]; then
          clean_usb;
          write_usb && echo -e "Process Finished!"
        else
          clean_usb && echo -e "Process Finished!"
        fi

      else
        echo -e -n "Do you want to write file to USB? (y/n): "
          read WRITE

        if [ "$WRITE" == "y" ] || [ "$WRITE" == "Y" ]; then
          write_usb && echo -e "Process Finished!"
        fi
      fi

Receive Bitcoin from BIP32 in Rails 6

Linuxander — Fri, 11 Dec 2020 21:20:56 +0000

To implement Bitcoin in Rails 6 to receive payment without private keys and full-node, MoneyTree gem is perfect solution. Allow creation of Master Public Key on offline device, and creation of different address for each payment from MPK on production server. Here is a simple implementation of this:

module Bip32

  private

  #   key should be defined as ENV config variable!
  KEY = 'xpub6AvUGrnEpfvJJFCTd6qEYfMaxry******************qV9cfBUbeUEgNYCCP4omxULbNaRr'
  API = BlockCypher::Api.new

  def initialize_wallet_node!
    MoneyTree::Node.from_bip32(KEY)
  end

  def generate_new_pubkey(index)
    wallet = initialize_wallet_node!
    depth  = wallet.depth
    path   = "M/#{depth}/#{index += 1}"
    pubkey = wallet.node_for_path path
    return pubkey if pubkey
  end

  def get_address_data(address)
    balance = API.address_balance(address)
    return balance if balance
  end

  def payment_success?(address, price)
    data = get_address_data(address)
    data ? coins = data[:balance] : coins = 0
    return true unless coins < price
  end

end

#  HOW TO USE
#
#  If you have :transactions table with :index column, you could do something like this:
#
#
#  data  = Transaction.last                  =>  Find last transaction index or use 0
#  data ? index = data.index : index = 0
#  
#  wallet   = generate_new_pubkey(index)     =>  Generate new public-key from MPK
#  @address = wallet.to_address              =>  Generate address from public key
#  @index   = wallet.to_index
#
#  bitcoin    = get_address_data(@address)   =>  Get address data from BlockCypher
#  address    = JSON.parse(bitcoin)
#    balance  = address[:balance]
#    conf_tx  = address[:n_tx]
#    uncon_tx = address[:unconfirmed_n_tx]
#    uncon_bl = address[:unconfirmed_balance]
#
#
#  or to finalize current order:
#
#  Transaction.finalize! if payment_success?(@address, @transaction.price)

In production MPK should be defined as ENV variable.
For checking transaction data I used BlockCypher api, the fastest method :address_balance. It returns JSON data with confirmed and unconfirmed balance and number of transactions. It's enough to check is order ready for shipping or not.

Rails Bitcoin Prodavnica - deo I

Linuxander — Fri, 11 Dec 2020 13:19:00 +0000

This is tutorial in Serbian language, creating simple shop with Rails 6 and Bitcoin, without JavaScript (or to not depends on JavaScript).

Prvi u seriji od 3 tutoriala u kojima cemo napraviti kompletnu prodavnicu, bez funkcija koje necemo koristiti, bez online wallet-a, privatnih kljuceva. Siguran i jednostavan nacin, koristeci BIP32 Master Public Key. Podrazumeva se osnovno znanje Ruby on Rails i MVC.

U prvom delu napravicemo novu aplikaciju, korisnike, proizvode i kopru. U drugom delu porudzbine i placanje, i u trecem delu izgled sajta, pagination, i priprema za production env.

Nova aplikacija

Kreiraj novu rails aplikaciju (istraziti rails new komandu, kao i --no-javascript i --api opcije).

rails new example-shop

Otvorite Gemfile i u njega dodajte sledece:

gem 'devise'
gem 'bulma'

Ovo ce instalirati gemove za autentikaciju (devise) i za stil (bulma).
Nakon toga kucajte bundle install za instaliranje gemova.

Novi Korisnik

rails g devise:install
rails g devise user
rails g controller registrations

Ovo ce integrisati devise u vasu aplikaciju, dodati model i tabelu :users,
i napraviti novi kontroler za registracije. Otvorite Registrations Controller:

class RegistrationsController < Devise::RegistrationsController

 private

 def sign_up_params
  params.require(:user).permit(:name, :address, :country, :email, :password, :password_confirmation)
 end

 def account_update_params
  params.require(:user).permit(:name, :address, :country, :email, :password, :password_confirmation, :current_password)
 end

end

Registrations Controller proizilazi iz Devise::Registrations, pa u njemu menjamo params, da bi smo
dodali nova polja (:name, :address, :country). Nakon toga napravite novu migraciju:

rails g migration add_fields_to_users

class AddFieldsToUsers < ActiveRecord::Migration[6.0]

  def change
    add_column :users, :name,    :string, null: false, default: ""
    add_column :users, :country, :string, null: false, default: ""
    add_column :users, :address, :text
  end

end

Za kraj izvrsite komandu rails db:migrate.

Otvoride model User i dodajte sledece:

class User < ApplicationRecord

  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable

  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  validates :name,    length: { maximum:  16, too_long: "%{count} chars is maximum for User name."}
  validates :country, length: { maximum:  20, too_long: "%{count} chars is maximum for User country."}
  validates :address, length: { maximum:  75, too_long: "%{count} chars is maximum for User address."}

  has_many :products

end

Provera da li je neko polje validno moze da se definise u modelu ili direktno u DB (migrations).
Ako je polje obavezno za sve, definisemo null: false, ali nekad je polje obavezno za jednu grupu
korisnika, dok za drugu nije. Zato sve provere treba definisati u modelu.

Dodati Proizvode

Rails scaffold automatski napravi model, kontroler, kao i views.

rails g scaffold product title description:text photo price:decimal user_id:integer published:boolean

Otvorite ProductsController i promenite kod da izgleda ovako:

class ProductsController < ApplicationController


  before_action :authenticate_user!, except: [:show, :index]
  before_action :set_product,        only:   [:show, :update, :destroy, :edit]


  def index
    @products = Product.all
  end

  def show
  end

  def new
    @product = current_user.products.build
  end

  def edit
  end


  def create
    @product = current_user.products.build(product_params)
    if @product.save
      redirect_to @product, notice: "Product #{@product.title} has been created."
    else
      render :new
    end
  end


  def update
    if @product.update(product_params)
      redirect_to @product, notice: "Product #{@product.title} has been updated."
    else
      render :edit
    end
  end

  def destroy
    @product.published = false if @product.user_id == current_user.id
    redirect_to root_path, notice: 'Product was successfully destroyed.'
  end


  private

  def set_product
    @product = Product.find(params[:id])
  end

  def product_params
    params.require(:product).permit(:title, :price, :description, :photo, :user_id, :published)
  end

end

Promenite model Product da izleda:

class Product < ApplicationRecord

  belongs_to :user

  validates :title, :price, :description, :photo, :user_id, :published, presence: true
  validates :price,         length: { maximum:    7 }
  validates :title,         length: { maximum:  140, too_long: "Title is too long! [%{count}] chars is maximum."}
  validates :description,   length: { maximum: 1000, too_long: "Description is too long! [%{count}] chars is maximum."}

end

Na kraju migracije:

class CreateProducts < ActiveRecord::Migration[6.0]
  def change
    create_table :products do |t|
      t.string  :title,       null: false, default: ""
      t.decimal :price,       null: false, default: 0
      t.text    :description
      t.string  :photo
      t.boolean :published,   null:false, default: true

      t.timestamps
    end
  end
end

Izvrsite rails db:migrate i kreirali ste Products za vasu aplikaciju!

Shopping Cart

Shopping Cart je nezaobilazni deo svake prodavnice. Za to su nam potrebni
Cart i CartItem. Ponovo koristimo scaffold, i pocinjemo sa Cart modelom.

rails g scaffold cart

Otvorite CartsController i neka izgleda ovako:

class CartsController < ApplicationController

  rescue_from   ActiveRecord::RecordNotFound, with: :invalid_cart

  before_action :set_cart, except: [:create, :new]


  def index
    @carts = list_cart_products
  end

  def new
    @cart = current_user.carts.build
  end

  def create
    @cart = current_user.carts.build(cart_params)
    if @cart.save
      redirect_to @cart
    else
      render :new
    end
  end

  def destroy
    if current_cart.id == session[:cart_id]
      @cart.destroy
      session[:cart_id] = session[:token] = nil
      set_cart and redirect_to root_url, notice: 'Your cart is empty!'
    end
  end


  private

  def list_cart_products
    CartItem.where(cart_id: session[:cart_id]).all
  end

  def invalid_cart
    logger.error "Attempt to access invalid cart with ID: #{params[:id]}"
    redirect_to root_path, notice: "Cart doesn't exist!"
  end

  def cart_params
    params.require(:cart).permit(:token)
  end

end

Kako bi odrzali korpu i za korisnike koji nisu registrovani, koristimo :sessions.
Takodje koristimo i :token, koji ce kasnije sluziti za friendly-id gem kao rute,
i svaki model verifikuje token (cart, order, payment)

Sada otvorite Cart model i dodajte sledece:

class Cart < ApplicationRecord

  has_many  :cart_items, dependent: :destroy

  validates :token, presence: true


  def add(product)
    cart_item = cart_items.find_by(product_id: product.id)
    cart_item ? cart_item.quantity += 1 : cart_item = cart_items.build(product_id: product.id)
  end


  def total_price
    cart_items.to_a.sum { |item| item.total_price }
  end

end

Otvorite concerns u folderu models i napravite shopping_cart.rb.
U njega dodajte sledece:

module ShoppingCart

  private

  def set_cart
    begin
      @cart = Cart.find(session[:cart_id])
    rescue    ActiveRecord::RecordNotFound
      @cart = Cart.create(token: generate_token)
      session[:token]   = @cart.token
      session[:cart_id] = @cart.id
    end
  end

  def generate_token
    SecureRandom.urlsafe_base64
  end

end

Otvorite ApplicationController i dodajte sledece:

class ApplicationController < ActionController::Base

  protect_from_forgery with: :exception

  include ShoppingCart

  before_action :set_cart
  helper        :all

  def current_cart
    Cart.find(session[:cart_id])
  end

end

Sada napravite CartItem, ponovo uz pomoc scaffold-a:

rails g scaffold cart_item

Otvorite CartItems Controller i dodajte sledece:

class CartItemsController < ApplicationController

  before_action :set_cart
  before_action :set_cart_item, except: [:index, :create]

  def index
    @cart_item = CartItem.find_by(cart_id: session[:cart_id])
  end

  def show
    @cart_item = CartItem.find(params[:id])
  end

  def new
    @cart_item = CartItem.new
  end

  def create

    @product              = Product.find(params[:product_id])
    @cart_item            = @cart.add(@product)
    @cart_item.product_id = @product.id

    if @cart_item.save
      redirect_to carts_path, notice: "#{@cart_item.product.title} added to cart for $#{@cart_item.total_price}"
    else
      render :new
    end
  end


  def destroy
    if @cart_item.cart_id == @cart.id
      @cart.destroy
      set_cart and redirect_to @cart, notice: "#{@cart_item.product.title} has been removed from cart!"
    end
  end


  private

  def set_cart_item
    @cart_item = CartItem.find_by(id: params[:id], cart_id: @cart.id)
  end

  def cart_item_params
    params.require(:cart_item).permit(:product_id, :cart_id, :quantity, :total_price)
  end

end

Sada otvorite model CartItem i dodajte:

class CartItem < ApplicationRecord

  belongs_to :cart
  belongs_to :product

  def total_price
    product.price.to_i * quantity.to_i
  end

end

I to je sve za prvi deo! Sada imamo potpuno funkcionalne korisnike, proizvode i korpu.
U drugom delu dodacemo porudzbine i placanje Bitcoinom, kao i izgled sajta koristeci bulmu ili bootstrap, po vasem izboru.

Ostavite wordpress i woo-commerce, korstite Ruby on Rails za online prodavnicu.

=> Procitajte Deo II