Cara pengajuan kepemilikan kartu kredit Bank

Kepemilikan kartu kredit saat ini sudah tidak dapat lagi dihindari terutama untuk mereka yang bekerja dan berbisnis menggunakan teknologi berbasis teknologi informasi komputer, kebutuhan kartu kredit mulai dari membayar tagihan server, cloud hosting hingga membayar berbagai layanan online dan offline banyak yang mensyaratkan penggunaan kartu kredit sebagai sarana pembayaran yang disarankan (atau kadang satu-satunya layanan pembayaran yang ditawarkan).

Mungkin beberapa orang belum faham bagaimana cara mengajukan kepemilikan kartu kredit ke Bank yang ada di Indonesia, cara termudah untuk mendapatkan kepemilikan kartu kredit adalah dengan menghubingi marketing kartu kredit yang telah berpengalaman untuk mengurus pengajuan kartu kredit dan tentunya dapat membantu anda dalam menyiapkan berbagai persayaratan dan juga memberikan anda masukan bagaimana dan apa yang harus dikatakan kepada surveyor kartu-kredit bila nanti mereka menelpon maupun mendatangi kantor dan rumah anda.

Berikut persyaratan dan informasi umum yang diminta oleh Bank dalam mengajukan kepemilikan kartu-kredit oleh karyawan:

  • KTP
  • NPWP
  • No HP yang aktif
  • No Kantor
  • No Keluarga yang tidak serumah
  • Nama lengkap Ibu kandung
  • Pendidikan terakhir
  • Status kepemilikan rumah
  • Alamat tempat tinggal (Alamat bila berbeda sesuai KTP)
  • Lama menempati rumah tersebut
  • Alamat Kantor
  • No Telp Kantor
  • Slip Gaji Tiga bulan terakhir
  • Posisi di perusahaan
  • Lama bekerja diperusahaan (Biasanya min 2 tahun)

Tips Pengajuan kartu kredit

  • Untuk no keluarga yang tidak serumah pastikan mereka diberitahu bila akan dihubungi oleh Bank terkait pengajuan Kartu kredit anda.
  • Pastikan anda sudah bekerja minimun lebih dari 2 tahun untuk kantor current company.
  • Gaji diatas 4 Juta.
  • Selalu ada orang dirumah dan di kantor supaya ada yang menjawab pertanyaan-pertanyaan surveyor kartu kredit yang datang ke rumah maupun untuk menjawab telepon.

 

 

Bank Tempat Penukaran Uang ke Pecahan Kecil Recehan untuk Lebaran

Saat mendekati lebaran biasanya tempat penukaran uang recehan ramai dipenuhi masyarakat yang ingin menukarkan uangnya ke pecahan kecil misalnya pecahan 1000, 2000, 5000, 10000, nah opsi yang paling mudah adalah dengan menggunakan jasa penukaran uang dipinggir jalan, hanya saja penukaran uang recehan dipinggir jalan tentunya tentunya uang yang kita tukarkan bukan senilai yang kita berikan, misal uang 100rb paling kalo di tukar hanya cair 90rb atau 95rb saja.

pernukaran uang

 

Kebetulah hari ini saya juga berniat menukarkan uang ke nominal kecil/receh setelah melakukan googling dan tanya sana sini akhirnya saya tahu bahwa Bank BI sudah menunjuk beberapa Bank untuk melayani penukaran uang ke nominal kecil

Nah supaya lebih irit dan tidak kehilangan sejumlah nilai uang saat di tukarkan ada baiknya kita pergi ke Bank saja untuk menukarkan uang kita dengan uang recehan, adapun bank-bank umum yang melayani penukaran uang pecahan kecil / receh adalah sebagai berikut:

Menukarkan uang di Bank Umum

  • Bank Mestika,
  • Bank BCA,
  • Bank Mandiri,
  • Bank Sumut,
  • Bank BNI,
  • Bank Mega,
  • Bank BRI,
  • Bank Permata,
  • Bank Danamon,
  • Bank CIMB Niaga,
  • Bank Mandiri Syariah,
  • Bank BRI Syariah,
  • Bank BNI Syariah,
  • Bank Maybank,
  • Bank Muamalat.

Menukarkan Uang di BPR, Selain 15 bank umum itu, BI juga bekerja sama dengan 14 Bank Perkreditan Rakyat (BPR) untuk melayani penukaran uang pecahan kecil kebutuhan Ramadan dan Lebaran. Ke 14 BPR itu yakni :

  • BPR Disky Surya Jaya,
  • BPR Duta Paramarta,
  • BPR Guna Rakyat,
  • BPR Hombar Makmur,
  • BPR Karyabhakti Ugahari,
  • BPR Laksana Abadi Sunggal,
  • BPR Mitra Sumber Makmur,
  • BPR Milala, BPR NBP13,
  • BPR NBP18,
  • BPR NBP22,
  • BPR NBP25,
  • BPR Prima Madani,
  • BPR Prima Tata Patumbak.

Maksimum penukaran uang per-hari:

“Tiap-tiap masyarakat per harinya dapat menukarkan uang pecahan kecil dengan nilai Rp.3.250.000,”

Demikian Bank-bank umum dan BPR yang bisa digunakan sebagai pilihan kita menukarkan uang, semoga bermanfaat dan selamat berpuasa…

Golang: Collection of structs

This post intended to be my personal note regarding struct collection (map with structs inside):

Link: https://play.golang.org/p/Tj3cpLu-mu

package main

import (
	"fmt"
)

type Animalia struct {
	fart bool
}

type Person struct {
	Animalia // Embedding as extend replacement
	Name, Address string
}

func (p Person) print() {
	if p.Animalia.fart {
		fmt.Println(p.Name, p.Address)
	}
}

type Human interface {
	print()
}

func humanCheck(h Human) {
}

func main() {
	person := Person{
		Animalia{
			true,
		},
		"Yusuf",
		"Jalan No.90",
	}

	person.print()

	// Collection
	people := map[int]Person{
		1: { Animalia{true}, "jhoni", "Jl. Kehidupan no.90"},
		2: { Animalia{true}, "Rhey", "Jl. Kehidupan no.99"},
		3: { Animalia{true}, "Rhona", "Jl. Girang no.77"},
	}

	for _, person := range people {
		humanCheck(person)
		person.print()
	}
}

Output

structoutput1.png

Menambahkan Rekening tujuan dan Transfer Uang Tunai dengan CIMB Clicks

Dibawah ini adalah cara untuk transfer dari CIMB Niaga ke bank lain atau ke sesama bank CIMB Niaga :

1.login
Login ke Akun CIMB Clicks anda
2.pilihRekeningTujuan
Pilih menu transfer

 

3. pilih rekening
Pilih rekening sumber dan tujuan
5.transferInfo
Biarkan apa adanya dan next
6.transferInfo
Masukan MPin anda yang dikirim ke hp via sms lalu submit

8.resendMpin

10.success
Informasi transaksi
11.menuAddNewAccountDestination
bila belum ada no rkening tujuan maka daftarkan dulu dengan klik “Favorites account Transfer”
12.1.To Other CIMB Niaga Accounts - Rekening Ponsel
Favorites account Transfer untuk sesama CIMB Niaga
12.2.To Other CIMB Niaga Accounts - Rekening Ponsel
Menambah Tujuan rekening sesama CIMB Niaga

13.0.tambahFavoriteAcoount

13.1.addFavBankLain
List Favorites account Transfer untuk beda bank / selain cimb niaga
13.2.addFavBankLain.png
Tambahkan No rekening tujuan dan Pilih Bank nya

16.saatLogoutadanotifikasi berhasil

22.tutorialLogin
cek manual tentang login di sini

Google App Engine: Setting up GAE Local Development Server

In this blog post I’m going to show you about install and setting up Google Cloud SDK in Local computer environment for Go / Golang web development, my current computer runs Ubuntu 14.04 as primary os but I’m quite sure that the following steps run on the latest Ubuntu as well.

Requirements :

  1. Ubuntu 14.04 or later
  2. Python 2.7.x or later
  3. Java 1.7 or later
  4. Git

Let’s start the journey :

Download Google Cloud SDK
Download Google Cloud SDK
Extract Google Cloud SDK to local folder
Extract Google Cloud SDK to local folder
Install Google Cloud SDK to local system
Install Google Cloud SDK to local system
Choose yes to improve Google Cloud SDK
Choose yes to improve Google Cloud SDK
Update environment variables / bashrc path
Update environment variables / bashrc path
Update environment variables / bashrc path
Update environment variables / bashrc path
Restart / Reload Bash
Restart / Reload Bash
GCLOUD Init and Login
GCLOUD Init and Login
GCLOUD Init and Login to browser
GCLOUD Init and Login to browser
GCLOUD Init and Login to browser
GCLOUD Init and Login to browser
GCLOUD Init and Login to browser
GCLOUD Init and Login to browser
Give Permission
Give Permission
Give Permission
Give Permission

22.WebLoggedIn

Terminal Logged in
Terminal Logged in
Select Project
Select Project
Check Development App Server
Check Development App Server
Generate ssh Public Key
Generate ssh Public Key
SSH Public Key
SSH Public Key
GitLab Settting
Gitlab Setting
GitLab Settting
GitLab Settting
GitLab SSH Pub key
GitLab SSH Pub key
Install GIT
Install GIT
Clone Code From Repository
Clone Code From Repository
Run development server
Run development server
Runs application
Runs application
Local Web Application
Local Web Application
Admin Server
Admin Server

Golang: Undertanding Basic of Concurrence Programming in the easiest way

In this blog post I’m gonna show you an easy example regarding basic concurrency in Golang programming, it will be an easy step-by-step approach to avoid misapprehend to the example (sample).

What is concurrency?

Concurrency is the composition of independently executing computations.

Concurrency is a way to structure software, particularly as a way to write clean code that interacts well with the real world.

It is not parallelism.

Rob Pike, Google

https://talks.golang.org/2012/concurrency.slide#6

Step 1:

package main

import (
	"fmt"
	"time"
)

func sayHello() {
	for x := 0; x < 10; x++ {
		fmt.Println("Hello ", x)
	}
}

func main() {
	start := time.Now()
	fmt.Println("Start at: ", start)
	fmt.Println("------------------------------------------------------")

	go sayHello()

	fmt.Println("------------------------------------------------------")
	fmt.Println("End at: ", time.Now())
	fmt.Println("Done at: ", time.Now().Sub(start))
}

Output:

basic1

In this  step we do not have output to be printed on the screen from sayHello() because the main process ends before the goroutine being executed. Golang program execution begins by initializing the main package and then invoking the function main. When the function main returns, the program exits. It does not wait for other (non-main) goroutines to complete.

A goroutine is a lightweight thread managed by the Go runtime.

Step 2

func main() {
	start := time.Now()
	fmt.Println("Start at: ", start)
	fmt.Println("------------------------------------------------------")

	go sayHello()

	time.Sleep(time.Second)

	fmt.Println("------------------------------------------------------")
	fmt.Println("End at: ", time.Now())
	fmt.Println("Done at: ", time.Now().Sub(start))
}

Output:

Basic2delay

The example above uses delay to make main function (process) waits the goroutine through 1 second before ends, 1 second is more than enough for Golang to print out all the lines on the screen. for the next step I’m gonna add  delay to the loop inside the sayHello() function so it will takes 9 seconds to be finished (and keep 1 second delay in the main function), let’s see what will take place.

Step 3

func sayHello() {
	for x := 0; x < 10; x++ {
		fmt.Println("Hello ", x)
		time.Sleep(time.Second)
	}
}

func main() {
	start := time.Now()
	fmt.Println("Start at: ", start)
	fmt.Println("------------------------------------------------------")

	go sayHello()

	time.Sleep(time.Second)

	fmt.Println("------------------------------------------------------")
	fmt.Println("End at: ", time.Now())
	fmt.Println("Done at: ", time.Now().Sub(start))
}

Output:

Basic3

Each loop waits for 1 second after printed the text, so in 1 minute it adequate to print 2 lines.

Step 4 Make main function wait goroutine to be done before it ends

We can make main function to wait all goroutines to be done before end it’s process without using primitive delay (time.Sleep(time.Second)) function.

package main

import (
	"fmt"
	"time"
	"sync"
)

func sayHello(wg *sync.WaitGroup) {
	for x := 0; x < 10; x++ {
		fmt.Println("Hello ", x)
		time.Sleep(time.Second)

		if x == 8 {
			wg.Done()
		}

	}
}

func main() {
	var wg sync.WaitGroup

	start := time.Now()
	fmt.Println("Start at: ", start)
	fmt.Println("------------------------------------------------------")

	wg.Add(1)
	go sayHello(&wg)

	wg.Wait()

	fmt.Println("------------------------------------------------------")
	fmt.Println("End at: ", time.Now())
	fmt.Println("Done at: ", time.Now().Sub(start))
}

Output:

basic5

Please pay attention to these lines:

var wg sync.WaitGroup
wg.Add(1) // Should be called before goroutine call
wg.Done()
wg.Wait()

Step 5 Go channel

Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine (ch<-) and receive those values into another goroutine (<-ch).

I don’t want to talk much about channel to avoid confusion, instead I will just show you several behavior of channel.

Receive operation <-ch in the main

package main

import (
	"fmt"
)

func sayHello(msg chan string) {

	msg <- "Hello Lorem ipsum1!"
	msg <- "Hello Lorem ipsum2!"
	msg <- "Hello Lorem ipsum3!"
	close(msg)
}

func main() {
	msg := make(chan string)

	go sayHello(msg)

	for value := range(msg) {
		fmt.Println(value);
	}

	// Or you could just uncomment following lines (but comments 'for' lines first)
	// fmt.Println("1:", <-msg)
	// fmt.Println("2:", <-msg)
	// fmt.Println("3:", <-msg)
	// fmt.Println("4:", <-msg) // empty or error if you did't close(msg)
}

Output:

channelx1

package main

import (
      "fmt"
)

func sayHello(msg chan string) {
      says := "Says: "
      for x := 0; x < 10; x++ {
          says += fmt.Sprintf("Hello-%d ,", x)
          fmt.Println("ok")
      }   

      msg <- says
}

func main() {
      msg := make(chan string)
      go sayHello(msg)
      fmt.Println(<-msg)
}

Output:

channel1

Receive operation (<-msg) in main() is a blocking operation, so the program won’t continue until a value is available.

Receive operation <-ch from goroutine to be printed by function

package main

import (
	"fmt"
)

func sayHello(msg chan string) {

	msg <- "hello world"

}

func printHello2(msg string) {
	fmt.Println(msg)

}

func main() {

	msg := make(chan string)

	go sayHello(msg)

	printHello2(<-msg)

}

Output:

exited1

Select

package main

import (
	"fmt"
	"time"
)

func main() {

	// For our example we'll select across two channels.
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		time.Sleep(time.Second * 1)
		c1 <- "one"
	}()

	go func() {
		time.Sleep(time.Second * 2)
		c2 <- "two"
	}()

	for {

		select {
		case msg1, ok := <-c1:
			if ok {
				fmt.Println("received", msg1)
			}
		case msg2, ok := <-c2:
			if ok {
				fmt.Println("received", msg2)
			}
		case <-time.After(3000 * time.Millisecond):
			fmt.Printf("Timed out!")
			return
		}

	}
}

Output:

timeout

The select statement lets a goroutine wait on multiple communication operations.

A select blocks until one of its cases can run, then it executes that case. It chooses one at random if multiple are ready.

Golang: Simple File Upload Using Go Languange

As a web programming language Go has capability to handle file upload from browser html form, in this post I will show you simple File Upload using Golang web programming.

  1. Create HTML Form upload src/webupload/upload.gtpl
    <html>
      <head>
             <title>Test Upload a File</title>
      </head>
      <body>
    <form enctype="multipart/form-data" action="http://127.0.0.1:9090/upload" method="post">
              {{/* 1. File input */}}
              <input type="file" name="uploadfile" />
    
              {{/* 2. Submit button */}}
              <input type="submit" value="upload file" />
          </form>
    
      </body>
      </html>
    
    

    1. GO Form
    *ignore unused token input
  2. Create go code to handle file upload src/webupload/upload.go
  3. package main
    
    import (
    	"crypto/md5"
    	"fmt"
    	"html/template"
    	"io"
    	"net/http"
    	"os"
    	"strconv"
    	"time"
    )
    
    func upload(w http.ResponseWriter, r *http.Request) {
    
    	if r.Method == "GET" {
    		// GET
    		t, _ := template.ParseFiles("upload.gtpl")
    
    		t.Execute(w, nil)
    
    	} else if r.Method == "POST" {
    		// Post
    		file, handler, err := r.FormFile("uploadfile")
    		if err != nil {
    			fmt.Println(err)
    			return
    		}
    		defer file.Close()
    
    		fmt.Fprintf(w, "%v", handler.Header)
    		f, err := os.OpenFile("./test/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
    		if err != nil {
    			fmt.Println(err)
    			return
    		}
    		defer f.Close()
    
    		io.Copy(f, file)
    
    	} else {
    		fmt.Println("Unknown HTTP " + r.Method + "  Method")
    	}
    }
    
    func main() {
    	http.HandleFunc("/upload", upload)
    	http.ListenAndServe(":9090", nil) // setting listening port
    }
    
    
  4. Create new folder for upload destination src/webupload/testfolder
  5. that’s all

Golang: The easy example of Go deferred function

Deferred function means that the function call is deferred after/until the surrounding function   done / returns.

Here is the basic and easy sample of defer uses in Golang (code):


package main

import "fmt"

var (
	a = 10
	b = 2
	c = 0
)

func multiply(aa int, bb int, c *int) {
	*c = aa * bb
	fmt.Printf("2. value of c: %v ", *c) // Print pointer value
}

func main() {
	defer multiply(a, b, &c) // Will be executed after main() finished

	fmt.Printf("1. value of c: %d \n", c)

}

Output:

1. value of c: 0 
2. value of c: 20 
Program exited.

Another Example about defer


package main

import "fmt"

func main() {
	defer fmt.Println("1")
	defer fmt.Println("2")
	defer fmt.Println("3")
	defer fmt.Println("4")
}

Output:

4
3
2
1

Deferred function calls are executed in Last In First Out order after the surrounding function returns.