David RENÉ / hayamiki

/*
 * Created by PyramIDE.
 * User: フランスのトトロ 
 * Date: 31/12/2015
 * Time: 16:18
 * © Calexium 
 */

read calexium_lib/database/model/db_model.anubis
read tools/basis.anubis
read tools/streams.anubis
read system/string.anubis

  
define List(String)
/** 
 */
  _generate_type
  (
    List(DB_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is db_column(name, col_type, _, _),
      _generate_type(t, [ "    "+fill(to_Anubis_type(col_type), 12) + " " + name . so_far])
  }.

public define Maybe(One)
  generate_type
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, display),
  since model is db_model(columns, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the db_table that contain all components 
  if write_string(stream, 
     "\n\npublic type "+type_name+":\n  "+name+"\n  (\n"+   //head of the type declaration
     join(",\n",_generate_type(columns, []))+               //all components of the type
     "\n  ).\n") is                                         //end of declaration
  {
    failure     then  println("can't write type "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
define List(String)
/** 
 */
  _generate_get_default
  (
    List(DB_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is db_column(name, col_type, _, _),
      _generate_get_default(t, [ to_Anubis_default(col_type) . so_far])
  }.
public define Maybe(One)
  generate_get_default
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model(columns, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\ndefine "+type_name+"\n  get_default_"+name+" =\n  "+name+"("+   //head of the definition
     join(", ",_generate_get_default(columns, []))+                       //all components of the type
     ").\n") is                                                           //end of the function
  {
    failure     then  println("can't write get_default "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
define (List(String), Int)
/** 
 */
  _generate_extract_web_arg
  (
    List(DB_Model_Column) columns,
    List(String)          so_far,
    Int                   closure
  )=
  if columns is
  {
    []        then (reverse(so_far), closure),
    [h . t ]  then
      since h is db_column(name, col_type, _, _),
      with result =  from_web_arg(col_type, name),
      //If the field is not editable no need to get it from the web
      if result = "" then
        _generate_extract_web_arg(t, so_far, closure)
      else 
        if start_with(result, "with") then
          _generate_extract_web_arg(t, [ "  "+result . so_far], closure)
        else
          with line = "  if "+fill(result, 45)+" is {failure then failure, "+fill("success("+name+")",25)+" then",
          _generate_extract_web_arg(t, [ line . so_far], closure+1)
  }.
  
public define Maybe(One)
  generate_extract_web_arg
  (
    Stream          stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model(columns, _),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  since _generate_extract_web_arg(columns, [], 0) is ((List(String))list_of_web_arg, (Int) nb_closure),
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\ndefine Maybe("+type_name+")\n  extract_from_web_arg\n  (\n    List(Web_arg) lwa\n  )=\n"+   //head of the definition
     to_String(list_of_web_arg)+                       //all editable components of the type
     "    success(\n"+generate_constructor(name, columns, "      ")+")\n"+         //generate type construction with values got from web arg
     "  "+fill(nb_closure, '}')+          //add close } according to number of web arg 
     ".\n") is                                         //end of the function
  {
    failure     then  println("can't write extract_from_web_arg "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_extract_db_cursor
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, display),
  since model is db_model(columns, _),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     "define Maybe("+type_name+")\n"+
     "  extract_"+name+"\n"+
     "  (\n"+
     "    One -> SQLite3Row table_cursor\n"+
     "  ) =\n"+
     "  if table_cursor(unique) is\n"+
     "  {\n"+
     "    error(sql_error)  then println(db_error(sql_error, \"extract_"+name+"\")); failure,\n"+
     "    no_more_row       then failure,\n"+
     "    row(cursor)       then\n"+ 
     "      success(\n"+generate_constructor_from_cursor(name, "cursor", columns, "        ")+")\n"+         //generate type construction with values got from web arg
     "  }.\n") is                                                           //end of the function
  {
    failure     then  println("can't write generate_extract_db_cursor "+type_name); failure,
    success(_)  then  success(unique)
  }.


public define Maybe(One)
  generate_get_all
  (
    Stream          stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model(columns, _),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     "define List("+type_name+")\n"+
     "  _get_all_"+name+"\n"+
     "  (\n"+
     "    One -> SQLite3Row table_cursor,\n"+
     "    List("+type_name+") so_far\n"+
     "  ) =\n"+
     "  if extract_"+name+"(table_cursor) is\n"+
     "  {\n"+
     "    failure       then reverse(so_far),\n"+
     "    success(data) then _get_all_"+name+"(table_cursor, [data . so_far])\n"+
     "  }.\n"+
     "\n\n"+
     //SQL query
     "public define List("+type_name+")\n"+
     "  get_all_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "  )=\n"+
     "  if sql_query_timeout(db, \"SELECT "+join(", ", components(columns, []))+" FROM "+name+";\", [], \"get_all_"+name+"\") is\n"+
     "  {\n"+
     "    error(_)         then [],\n"+
     "    ok(_, cursor, _) then _get_all_"+name+"(cursor, [])\n"+
     "  }.\n" 
     
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_all "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_get_one
  (
    Stream          stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model(columns, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define Maybe("+type_name+")\n"+
     "  get_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    String           idx\n"+
     "  )=\n"+
     "  if sql_query_timeout(db, \"SELECT "+join(", ", components(columns, []))+" FROM "+name+" WHERE id=\"+idx+\";\", [], \"get_"+name+"\") is\n"+
     "  {\n"+
     "    error(_)         then failure,\n"+
     "    ok(_, cursor, _) then extract_"+name+"(cursor)\n"+
     "  }.\n\n"+
     //SQL query
     "public define Maybe("+type_name+")\n"+
     "  get_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    Int              idx\n"+
     "  )=\n"+
     "  get_"+name+"(db, to_decimal(idx))."      
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_one "+type_name); failure,
    success(_)  then  success(unique)
  }.
  

public define Maybe(One)
  generate_update
  (
    Stream          stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model( columns, _),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define One\n"+
     "  update_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    "+type_name+"    "+name+"\n"+
     "  )=\n"+
     "  if "+name+".id is\n"+
     "  {\n"+
     //INSERT SQL query
     "    none then\n"+
     "      forget(sql_query_timeout(db,\n"+
     "             \"INSERT INTO "+name+"\n"+
     insert_values(columns, "             ")+";\",\n"+
     generate_Bind_list(columns, name, "             ", true)+",\n"+
     "             \"update_"+name+" (INSERT)\")),\n"+
     //UPDATE SQL query
     "    db_id(idx) then\n"+
     "      forget(sql_query_timeout(db,\n"+
     "             \"UPDATE "+name+" SET\n"+
     update_values(columns, "             ")+"\n"+
     "             WHERE id = \"+idx+\";\",\n"+
     generate_Bind_list(columns, name, "             ", false)+",\n"+
     "             \"update_"+name+" (UPDATE)\"))\n"+
     "  }.\n\n"+
     "public define Maybe(One)\n"+
     "  update_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase db,\n"+
     "    List(Web_arg)   lwa\n"+
     "  )=\n"+
     "  if extract_from_web_arg(lwa) is\n"+
     "  {\n"+
     "    failure         then failure,\n"+
     "    success("+name+")  then success(update_"+name+"(db, "+name+"))\n"+
     "  }.\n\n"
  
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_update "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_show_string
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, _),
  since model is db_model( columns, show_string),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
     "\n\n"+
     //SQL query
     "public define String\n"+
     "  get_"+name+"_show_string\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    Int              idx\n"+
     "  )=\n"+
     "  if get_"+name+"(db, idx) is\n"+
     "  {\n"+
     "    failure      then default_select,\n"+
     "    success(obj) then "+show_string+"\n"+
     "  }."
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_update "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_VT_view
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, display),
  since model is db_model( columns, _),
  since display is db_display(list_view, list_edit),
  
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
   "\n\n"+
   //SQL query
   "define VT_view\n"+
   "  _get_viewable_"+name+"\n"+
   "  (\n"+
   "    SQLite3DataBase      db,\n"+
   "    List("+type_name+")  list,\n"+
   "    List(VT_view_row) so_far\n"+
   "  )=\n"+
   "  if list is\n"+
   "  {\n"+
   "    []        then\n"+
   "      with header = vt_view_row([\n"+
   // view row header
   make_list_view_header(list_view, "                      ")+"\n"+
   "                     ]),\n"+
   "      vt_view(\""+name+"\", header, reverse(so_far)),\n"+
   "    [ h . t ] then\n"+
   "      with entry = vt_view_row([\n"+
   // view row
   make_list_view_row(model, list_view, "h", "                      ")+"\n"+
   "        ]),\n"+
   "      _get_viewable_"+name+"(db, t, [entry . so_far])\n"+
   "  }.\n\n"+
   "public define VT_view\n"+
   "  get_viewable_"+name+"\n"+
   "  (\n"+
   "    SQLite3DataBase  db\n"+
   "  )=\n"+
   "  _get_viewable_"+name+"(db, get_all_"+name+"(db), []).\n\n"
   ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_VT_view "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_VT_edit
  (
    Stream    stream,
    DB_Table  table
  )=
  since table is db_table(name, model, display),
  since model is db_model( columns, _),
  since display is db_display(list_view, list_edit),
  with type_name = to_upper(name, 1), //make the first character to upper case to able to be a Anubis Type.
  
  //generate the type of the table that contain all components 
  if write_string(stream, 
   "\n ********** EDITABLE VIEWs ***************\n"+
   //SQL query
   "define VT_edit\n"+
   "  _get_editable_"+name+"\n"+
   "  (\n"+
   "   "+type_name+"  "+name+",\n"+
   "    SQLite3DataBase      db\n"+
   "  )=\n"+
   "  with edit_entries = (List(VT_edit_entry))\n"+
   "                      [\n"+
   edit_entries(columns, name, "                      ", [])+"\n"+
   "                      ],\n"+
   "      vt_edit(\""+name+"\", edit_entries).\n\n"+

   "public define VT_edit\n"+
   "  get_editable_"+name+"\n"+
   "  (\n"+
   "    SQLite3DataBase  db,\n"+
   "    VT_action        action\n"+
   "  )=\n"+
   "  with "+name+" = if action is\n"+
   "  {\n"+
   "    new_entry       then get_default_"+name+"\n"+
   "    edit_entry(idx) then\n"+
   "      if get_"+name+"(db, idx) is\n"+
   "      {\n"+
   "        failure       then get_default_"+name+",\n"+
   "        success(data) then data\n"+
   "      }\n"+
   "  },\n"+
   "  _get_editable_"+name+"("+name+", db).\n\n"
   ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_VT_edit "+type_name); failure,
    success(_)  then  success(unique)
  }.