API tools faq
paste
Guest User

Untitled

a guest
Aug 17th, 2018
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.68 KB | None | 0 0
raw download clone embed print report
  1. package main
  2.  
  3. import (
  4. "database/sql"
  5. "github.com/gin-gonic/gin"
  6. _ "github.com/go-sql-driver/mysql"
  7. "gopkg.in/gorp.v1"
  8. "log"
  9. "strconv"
  10. )
  11.  
  12. type Hewan struct {
  13. Id int64 `db:"Id" json:"id"`
  14. SpesiesHewan string `db:"SpesiesHewan" json:"SpesiesHewan"`
  15. NamaHewan string `db:"NamaHewan" json:"NamaHewan"`
  16. HabitatHewan string `db:"HabitatHewan" json:"HabitatHewan"`
  17. }
  18.  
  19. type Category struct {
  20. CategoryID int64 `db:"CategoryID" json:"CategoryID"`
  21. CategoryName string `db:"CategoryName" json:"CategoryName"`
  22. }
  23. type Product struct {
  24. ProductID int64 `db:"ProductID" json:"ProductID"`
  25. ProductName string `db:"ProductName" json:"ProductName"`
  26. ProductPrice int64 `db:"ProductPrice" json:"ProductPrice"`
  27. CategoryID int64 `db:"CategoryID" json:"CategoryID"`
  28. }
  29.  
  30. var dbmap = InitDb()
  31.  
  32. func InitDb() *gorp.DbMap {
  33. db, err := sql.Open("mysql", "root:@/myapidb")
  34. checkErr(err, "sql.Open failed")
  35. dbmap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
  36. dbmap.AddTableWithName(Hewan{}, "Hewan").SetKeys(true, "Id")
  37. dbmap.AddTableWithName(Product{}, "Product").SetKeys(true, "ProductID")
  38. dbmap.AddTableWithName(Category{}, "Category").SetKeys(true, "CategoryID")
  39. err = dbmap.CreateTablesIfNotExists()
  40. checkErr(err, "Create tables failed")
  41.  
  42. return dbmap
  43. }
  44.  
  45. func checkErr(err error, msg string) {
  46. if err != nil {
  47. log.Fatalln(msg, err)
  48. }
  49. }
  50.  
  51. func Cors() gin.HandlerFunc {
  52. return func(c *gin.Context) {
  53. c.Writer.Header().Add("Access-Control-Allow-Origin", "*")
  54. c.Next()
  55. }
  56. }
  57.  
  58. func main() {
  59. r := gin.Default()
  60. r.Use(Cors())
  61. v1 := r.Group("api/v1")
  62. {
  63. v1.GET("/hewan", GetHewans)
  64. v1.GET("/hewan/:id", GetHewan)
  65. v1.POST("/hewan", PostHewan)
  66. v1.PUT("/hewan/:id", UpdateHewan)
  67. v1.DELETE("/hewan/:id", DeleteHewan)
  68. v1.GET("/product", GetProducts)
  69. v1.GET("/product/:ProductID", GetProduct)
  70. v1.POST("/product", PostProduct)
  71. v1.PUT("/product/:ProductID", UpdateProduct)
  72. v1.DELETE("/product/:ProductID", DeleteProduct)
  73. v1.GET("/category", GetCategories)
  74. v1.GET("/category/:CategoryID", GetCategory)
  75. v1.POST("/category", PostCategory)
  76. v1.PUT("/category/:CategoryID", UpdateCategory)
  77. v1.DELETE("/category/:CategoryID", DeleteCategory)
  78. }
  79. r.Run(":8080")
  80. }
  81.  
  82. func GetCategories(c *gin.Context) {
  83. var category []Category
  84. _, err := dbmap.Select(&category, "SELECT * FROM Category")
  85. if err == nil {
  86. c.JSON(200, category)
  87. } else {
  88. c.JSON(404, gin.H{"error": "Data tidak ditemukan"})
  89. }
  90. }
  91.  
  92. func GetCategory(c *gin.Context) {
  93. catid := c.Params.ByName("CategoryID")
  94. var category Category
  95. err := dbmap.SelectOne(&category, "SELECT * FROM Category WHERE CategoryID=?", catid)
  96. if err == nil {
  97. cateid, _ := strconv.ParseInt(catid, 0, 64)
  98.  
  99. content := &Category{
  100. CategoryID: cateid,
  101. CategoryName: category.CategoryName,
  102. }
  103. c.JSON(200, content)
  104. } else {
  105. c.JSON(404, gin.H{"error": "Data tidak ditemukan"})
  106. }
  107. }
  108.  
  109. func PostCategory(c *gin.Context) {
  110. var category Category
  111. c.Bind(&category)
  112. log.Println(category)
  113.  
  114. if category.CategoryName != "" {
  115. if insert, _ := dbmap.Exec(`INSERT INTO category (CategoryName) VALUES (?)`, category.CategoryName); insert != nil {
  116. category_id, err := insert.LastInsertId()
  117. if err == nil {
  118. content := &Category{
  119. CategoryID: category_id,
  120. CategoryName: category.CategoryName,
  121. }
  122. c.JSON(201, content)
  123. } else {
  124. checkErr(err, "Gagal menambahkan data")
  125. }
  126. }
  127. } else {
  128. c.JSON(400, gin.H{"error": "Atribut kosong, harus diisi"})
  129. }
  130. }
  131.  
  132. func UpdateCategory(c *gin.Context) {
  133. catid := c.Params.ByName("CategoryID")
  134. var category Category
  135. err := dbmap.SelectOne(&category, "SELECT * FROM Category WHERE CategoryID=?", catid)
  136.  
  137. if err == nil {
  138. var catenew Category
  139. c.Bind(&catenew)
  140.  
  141. category_id, _ := strconv.ParseInt(catid, 0, 64)
  142.  
  143. category := Category{
  144. CategoryID: category_id,
  145. CategoryName: catenew.CategoryName,
  146. }
  147. if category.CategoryName != "" {
  148. _, err = dbmap.Update(&category)
  149.  
  150. if err == nil {
  151. c.JSON(200, category)
  152. } else {
  153. checkErr(err, "Gagal mengubah data")
  154. }
  155.  
  156. } else {
  157. c.JSON(400, gin.H{"error": "Atribut harus diisi"})
  158. }
  159. } else {
  160. c.JSON(404, gin.H{"error": "Categori tidak ditemukan"})
  161. }
  162. }
  163.  
  164. func DeleteCategory(c *gin.Context) {
  165. catid := c.Params.ByName("CategoryID")
  166. var category Category
  167. err := dbmap.SelectOne(&category, "SELECT * FROM Category WHERE CategoryID=?", catid)
  168.  
  169. if err == nil {
  170. _, err = dbmap.Delete(&category)
  171.  
  172. if err == nil {
  173. c.JSON(200, gin.H{"id #" + catid: "berhasil dihapus"})
  174. } else {
  175. checkErr(err, "Data tidak berhasil dihapus")
  176. }
  177. } else {
  178. c.JSON(404, gin.H{"error": "Categori tidak ditemukan"})
  179. }
  180. }
  181.  
  182. func GetProducts(c *gin.Context) {
  183. var product []Product
  184. _, err := dbmap.Select(&product, "SELECT * FROM Product")
  185.  
  186. if err == nil {
  187. c.JSON(200, product)
  188. } else {
  189. c.JSON(404, gin.H{"error": "Tidak ada data product di tabel"})
  190. }
  191. }
  192.  
  193. func GetProduct(c *gin.Context) {
  194. productid := c.Params.ByName("ProductID")
  195. var product Product
  196. err := dbmap.SelectOne(&product, "SELECT * FROM Product WHERE ProductID=?", productid)
  197.  
  198. if err == nil {
  199. product_id, _ := strconv.ParseInt(productid, 0, 64)
  200. content := &Product{
  201. ProductID: product_id,
  202. ProductName: product.ProductName,
  203. ProductPrice: product.ProductPrice,
  204. CategoryID: product.CategoryID,
  205. }
  206. c.JSON(200, content)
  207. } else {
  208. c.JSON(404, gin.H{"error": "Data tidak ditemukan"})
  209. }
  210. }
  211.  
  212. func PostProduct(c *gin.Context) {
  213. var product Product
  214. c.Bind(&product)
  215. log.Println(product)
  216. /*categoryid := c.Params.ByName("CategoryID")
  217. productprice := c.Params.ByName("ProductPrice")
  218. category_id, _ := strconv.Itoa(categoryid)
  219. product_price, _ := strconv.Itoa(productprice)*/
  220.  
  221. if product.ProductName != "" && product.ProductPrice != 0 && product.CategoryID != 0 {
  222. if insert, _ := dbmap.Exec(`INSERT INTO Product (ProductName, ProductPrice, CategoryID) VALUES (?, ?, ?)`, product.ProductName, product.ProductPrice, product.CategoryID); insert != nil {
  223. product_id, err := insert.LastInsertId()
  224. if err == nil {
  225. content := &Product{
  226. ProductID: product_id,
  227. ProductName: product.ProductName,
  228. ProductPrice: product.ProductPrice,
  229. CategoryID: product.CategoryID,
  230. }
  231. c.JSON(201, content)
  232. } else {
  233. checkErr(err, "Gagal menambahkan data")
  234. }
  235. }
  236. } else {
  237. c.JSON(400, gin.H{"error": "Atribut kosong, harus diisi / Categori ID tidak sesusai dengan Tabel Category"})
  238. }
  239. }
  240. func UpdateProduct(c *gin.Context) {
  241. productid := c.Params.ByName("ProductID")
  242. var product Product
  243. err := dbmap.SelectOne(&product, "SELECT * FROM Product WHERE ProductID=?", productid)
  244.  
  245. if err == nil {
  246. var productnew Product
  247. c.Bind(&productnew)
  248.  
  249. product_id, _ := strconv.ParseInt(productid, 0, 64)
  250.  
  251. product := Product{
  252. ProductID: product_id,
  253. ProductName: productnew.ProductName,
  254. ProductPrice: productnew.ProductPrice,
  255. CategoryID: productnew.CategoryID,
  256. }
  257. if product.ProductName != "" && product.ProductPrice != 0 && product.CategoryID != 0 {
  258. _, err = dbmap.Update(&product)
  259.  
  260. if err == nil {
  261. c.JSON(200, product)
  262. } else {
  263. checkErr(err, "Gagal mengubah data product")
  264. }
  265.  
  266. } else {
  267. c.JSON(400, gin.H{"error": "Atribut harus diisi"})
  268. }
  269. } else {
  270. c.JSON(404, gin.H{"error": "Product tidak ditemukan"})
  271. }
  272. }
  273. func DeleteProduct(c *gin.Context) {
  274. productid := c.Params.ByName("ProductID")
  275. var product Product
  276. err := dbmap.SelectOne(&product, "SELECT * FROM Product WHERE ProductID=?", productid)
  277.  
  278. if err == nil {
  279. _, err = dbmap.Delete(&product)
  280.  
  281. if err == nil {
  282. c.JSON(200, gin.H{"id #" + productid: "berhasil dihapus"})
  283. } else {
  284. checkErr(err, "Data tidak berhasil dihapus")
  285. }
  286. } else {
  287. c.JSON(404, gin.H{"error": "Produk tidak ditemukan"})
  288. }
  289. }
  290.  
  291. func PostHewan(c *gin.Context) {
  292. var hewan Hewan
  293. c.Bind(&hewan)
  294. log.Println(hewan)
  295.  
  296. if hewan.NamaHewan != "" && hewan.SpesiesHewan != "" && hewan.HabitatHewan != "" {
  297. if insert, _ := dbmap.Exec(`INSERT INTO hewan (SpesiesHewan, NamaHewan, HabitatHewan) VALUES (?, ?, ?)`, hewan.SpesiesHewan, hewan.NamaHewan, hewan.HabitatHewan); insert != nil {
  298. hewan_id, err := insert.LastInsertId()
  299. if err == nil {
  300. content := &Hewan{
  301. Id: hewan_id,
  302. SpesiesHewan: hewan.SpesiesHewan,
  303. NamaHewan: hewan.NamaHewan,
  304. HabitatHewan: hewan.HabitatHewan,
  305. }
  306. c.JSON(201, content)
  307. } else {
  308. checkErr(err, "Gagal menambahkan data")
  309. }
  310. }
  311. } else {
  312. c.JSON(400, gin.H{"error": "Atribut kosong, harus diisi"})
  313. }
  314. /*db := InitDb()
  315. defer db.Close()
  316.  
  317. var hewan Hewan
  318. c.Bind(&hewan)
  319.  
  320. if hewan.SpesiesHewan != "" && hewan.NamaHewan != "" {
  321. db.Create(&hewan)
  322. c.JSON(201, gin.H{"Berhasil": hewan})
  323. } else {
  324. c.JSON(422, gin.H{"Error": "Data kosong"})
  325. }*/
  326. }
  327.  
  328. func GetHewans(c *gin.Context) {
  329. var hewan []Hewan
  330. _, err := dbmap.Select(&hewan, "SELECT * FROM Hewan")
  331.  
  332. if err == nil {
  333. c.JSON(200, hewan)
  334. } else {
  335. c.JSON(404, gin.H{"error": "Tidak ada data hewan di tabel"})
  336. }
  337. /*db := InitDb()
  338. defer db.Close()
  339.  
  340. var hewans []Hewan
  341. db.Find(&hewans)
  342. c.JSON(200, hewans)
  343. */
  344. }
  345.  
  346. func GetHewan(c *gin.Context) {
  347. id := c.Params.ByName("id")
  348. var hewan Hewan
  349. err := dbmap.SelectOne(&hewan, "SELECT * FROM hewan WHERE Id=? LIMIT 1", id)
  350.  
  351. if err == nil {
  352. hewan_id, _ := strconv.ParseInt(id, 0, 64)
  353.  
  354. content := &Hewan{
  355. Id: hewan_id,
  356. SpesiesHewan: hewan.SpesiesHewan,
  357. NamaHewan: hewan.NamaHewan,
  358. HabitatHewan: hewan.HabitatHewan,
  359. }
  360. c.JSON(200, content)
  361. } else {
  362. c.JSON(404, gin.H{"error": "Hewan tidak ditemukan"})
  363. }
  364. /*db := InitDb()
  365. defer db.Close()
  366.  
  367. id := c.Params.ByName("id")
  368. var hewan Hewan
  369. db.First(&hewan, id)
  370.  
  371. if hewan.Id != 0 {
  372. c.JSON(200, hewan)
  373. } else {
  374. c.JSON(404, hewan)
  375. }*/
  376. }
  377. func UpdateHewan(c *gin.Context) {
  378. id := c.Params.ByName("id")
  379. var hewan Hewan
  380. err := dbmap.SelectOne(&hewan, "SELECT * FROM Hewan WHERE Id=?", id)
  381.  
  382. if err == nil {
  383. var hewanbaru Hewan
  384. c.Bind(&hewanbaru)
  385.  
  386. hewan_id, _ := strconv.ParseInt(id, 0, 64)
  387.  
  388. hewan := Hewan{
  389. Id: hewan_id,
  390. SpesiesHewan: hewanbaru.SpesiesHewan,
  391. NamaHewan: hewanbaru.NamaHewan,
  392. HabitatHewan: hewanbaru.HabitatHewan,
  393. }
  394. if hewan.SpesiesHewan != "" && hewan.NamaHewan != "" && hewan.HabitatHewan != "" {
  395. _, err = dbmap.Update(&hewan)
  396.  
  397. if err == nil {
  398. c.JSON(200, hewan)
  399. } else {
  400. checkErr(err, "Gagal mengubah data")
  401. }
  402.  
  403. } else {
  404. c.JSON(400, gin.H{"error": "Atribut harus diisi"})
  405. }
  406. } else {
  407. c.JSON(404, gin.H{"error": "Hewan tidak ditemukan"})
  408. }
  409. }
  410. func DeleteHewan(c *gin.Context) {
  411. id := c.Params.ByName("id")
  412. var hewan Hewan
  413. err := dbmap.SelectOne(&hewan, "SELECT * FROM Hewan WHERE Id=?", id)
  414. if err == nil {
  415. _, err = dbmap.Delete(&hewan)
  416.  
  417. if err == nil {
  418. c.JSON(200, gin.H{"id #" + id: "berhasil dihapus"})
  419. } else {
  420. checkErr(err, "Data tidak berhasil dihapus")
  421. }
  422. } else {
  423. c.JSON(404, gin.H{"error": "Hewan tidak ditemukan"})
  424. }
  425. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!