David RENÉ / hayamiki

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

read hayamiki_lib/types/hayamiki.anubis
read tools/basis.anubis
read tools/streams.anubis
read system/string.anubis
read fields.anubis
read columns.anubis
read html.anubis
  
define List(String)
/** 
 */
  _generate_type
  (
    List(HK_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is hk_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,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, display),
  since model is hk_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 HK_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(HK_Model_Column) columns,
    List(String)          so_far
  )=
  if columns is
  {
    []        then reverse(so_far),
    [h . t ]  then
      since h is hk_column(name, col_type, _, _),
      _generate_get_default(t, [ to_Anubis_default(col_type) . so_far])
  }.
public define Maybe(One)
  generate_get_default
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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(HK_Model_Column) columns,
    List(String)          so_far,
    Int                   closure
  )=
  if columns is
  {
    []        then (reverse(so_far), closure),
    [h . t ]  then
      since h is hk_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,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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\npublic define Maybe("+type_name+")\n"+
     "  extract_"+type_name+"_from_web_arg\n"+
     "  (\n"+
     "    List(Web_arg) lwa,\n"+
     "    String __prefix__\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_"+type_name+"_from_web_arg "+type_name); failure,
    success(_)  then  success(unique)
  }.

public define Maybe(One)
  generate_extract_db_cursor
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, display),
  since model is hk_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"+
     "public 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,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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"+
     "public 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(", ", enclose("\\\"",to_List_String(columns, true)))+" FROM "+name+";\", [], \"get_all_"+name+"\") is\n"+
     "  {\n"+
     "    error(_)         then [],\n"+
     "    ok(_, cursor, _) then _get_all_"+name+"(cursor, [])\n"+
     "  }.\n"+
     "\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_all_with_clause
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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, 
     //SQL query
     "public define List("+type_name+")\n"+
     "  get_all_"+name+"_by_clause\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    String           clause\n"+
     "  )=\n"+
     "  if sql_query_timeout(db, \"SELECT "+join(", ", enclose("\\\"",to_List_String(columns, true)))+" FROM "+name+" WHERE \"+clause+\";\", [], \"get_all_"+name+"_by_clause\") 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,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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(", ", enclose("\\\"",to_List_String(columns, true)))+" 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_get_one_with_clause
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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+"_by_clause\n"+
     "  (\n"+
     "    SQLite3DataBase  db,\n"+
     "    String           clause\n"+
     "  )=\n"+
     "  if sql_query_timeout(db, \"SELECT "+join(", ", enclose("\\\"",to_List_String(columns, true)))+" FROM "+name+" WHERE \"+clause+\";\", [], \"get_"+name+"_by_clause\") is\n"+
     "  {\n"+
     "    error(_)         then failure,\n"+
     "    ok(_, cursor, _) then extract_"+name+"(cursor)\n"+
     "  }.\n"      
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_one_by_clause "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_update
  (
    Stream          stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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"+
     "      if 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)\") is { \n"+
     "                 error(sql_error)\n"+
     "                   then logError(debug_log, db_error(sql_error, \"update_"+name+"\")), ok(_, _, _) then unique }\n"+
     "  }.\n\n"+
     "public define Maybe(One)\n"+
     "  update_"+name+"\n"+
     "  (\n"+
     "    SQLite3DataBase db,\n"+
     "    List(Web_arg)   lwa\n"+
     "  )=\n"+
     "  if extract_"+type_name+"_from_web_arg(lwa, \"\") is\n"+
     "  {\n"+
     "    failure         then logError(debug_log, \"update_"+name+" extract_"+type_name+"_from_web_arg is failure\"); 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,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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_selector
  (
    Stream    stream,
    HK_Table  table
  )=
  since table is hk_table(name, short_name, model, _),
  since model is hk_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"+
    "define List((List(CoreAttrs), WebArgValue, String))\n"+
    "  _get_selector_"+name+"\n"+
    "  (\n"+
    "    SQLite3DataBase             db,\n"+
    "    List("+type_name+")         list,\n"+
    "    List((List(CoreAttrs), WebArgValue, String))  so_far\n"+
    "  )=\n"+
    "  if list is\n"+
    "  {\n"+
    "    []        then  reverse(so_far),\n"+
    "    [ h . t ] then \n"+
    "      if h.id is \n"+
    "      {\n"+
    "        none      then [],\n"+
    "        db_id(id) then _get_selector_"+name+"(db, t, [([], wav(to_String(id)), get_"+name+"_show_string(db, id)) . so_far])\n"+
    "      }\n"+
    "  }.\n\n"+
    "public define List((List(CoreAttrs), WebArgValue, String))\n"+
    "  get_selector_"+name+"\n"+
    "  (\n"+
    "    SQLite3DataBase  db,\n"+
    "  )=\n"+
    "  _get_selector_"+name+"(db, get_all_"+name+"(db), [])."
     ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_show_string "+type_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
/* Generate 

*/
  generate_VT_view
  (
    Stream        stream, //stream file where to write
    HK_Table      table,  //
    HK_List_View  list_view   //list view to generate
  )=
  since table   is hk_table(table_name, short_name, model, display),
  since model   is hk_model( columns, _),
  //since display is db_display(list_view, list_edit),
  
  with type_name =  to_upper(table_name, 1), //make the first character to upper case and be an Anubis Type.
  with view_name =  if list_view is
                    {
                      list_view_all               then  "default",
                      list_view(view_name, _, _)  then  view_name
                    },
  with current_list_view = if list_view is
                            {
                              list_view_all         then to_List_String(columns, false),
                              list_view(_, cols, _) then cols
                            },
  //generate the type of the table that contain all components 
  if write_string(stream, 
   "\n\n"+
   //SQL query
   "define VT_view\n"+
   "  _get_viewable_"+table_name+"_"+view_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_header([\n"+
   // view row header
   make_list_view_header(current_list_view, "                      ")+"\n"+
   "                     ]),\n"+
   "      vt_view(\""+table_name+"\", \""+view_name+"\", header, reverse(so_far)),\n"+
   "    [ h . t ] then\n"+
   "      with entry = vt_view_row(to_Int(h.id), [\n"+
   // view row
   make_list_view_row(table, "h", "                      ", list_view)+"\n"+
   "        ]),\n"+
   "      _get_viewable_"+table_name+"_"+view_name+"(db, t, [entry . so_far])\n"+
   "  }.\n\n"+
   "public define VT_view\n"+
   "  get_viewable_"+table_name+"_"+view_name+"\n"+
   "  (\n"+
   "    SQLite3DataBase  db\n"+
   "  )=\n"+
   "  _get_viewable_"+table_name+"_"+view_name+"(db, get_all_"+table_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 

*/
  _generate_VT_view
  (
    Stream              stream,     //stream file where to write
    HK_Table            table,      //
    List(HK_List_View)  list_view,  //list view to generate
    Bool                has_default //set to true if a default view was encountered.
  )=
  if list_view is
  { 
    []          then
      //if default view was not generated, we force to generate it
      if has_default = false then
        generate_VT_view(stream, table, list_view_all)
      else  
        success(unique),
    [view . t]  then
      if generate_VT_view(stream, table, view) is 
      {
        failure     then failure,
        success(_)  then 
          with new_has_default = if has_default = true then //already true, no need to go further
                                  true
                                 else
                                  if view is
                                  {
                                    list_view_all               then  true, //list_view_all is default view
                                    list_view(view_name, _, _)  then    
                                      //if not we search for view named 'default'
                                      if view_name = "default" then true else false
                                  },
          _generate_VT_view(stream, table, t, new_has_default)
      }
  }.

public define String
/* Generate 

*/
  _generate_get_viewable_if_else
  (
    String              table_name,      //
    List(HK_List_View)  list_view,  //list view to generate
    String              so_far
  )=
  if list_view is
  { 
    []          then
      so_far +
      "\n"+
      "    _get_viewable_"+table_name+"_default(db, get_all_"+table_name+"(db), [])\n",
    [view . t]  then
      with view_name =  if view is
                        {
                          list_view_all              then  "default",
                          list_view(view_name, _, _) then  view_name
                        },
      _generate_get_viewable_if_else( table_name, t,
        so_far +
        "  if view = \""+view_name+"\" then\n"+
        "    _get_viewable_"+table_name+"_"+view_name+"(db, get_all_"+table_name+"(db), [])\n"+
        "  else"
        )
  }.
  
public define Maybe(One)
/* Generate 

*/
  generate_get_viewable
  (
    Stream              stream,     //stream file where to write
    HK_Table            table,      //
    List(HK_List_View)  list_view   //list view to generate
  )=
  since table   is hk_table(table_name, short_name, model, display),
  if write_string(stream, 
    "public define VT_view\n"+
    "  get_viewable_"+table_name+"\n"+
    "  (\n"+
    "    SQLite3DataBase  db,\n"+
    "    String           view\n"+
    "  )=\n"+
    _generate_get_viewable_if_else(table_name, list_view, "")+
    ".\n"
   ) is                                                           //end of the function
  {
    failure     then  println("can't write generate_get_viewable "+table_name); failure,
    success(_)  then  success(unique)
  }.
  
public define Maybe(One)
  generate_VT_all_view
  (
    Stream    stream,
    HK_Table  table
  )=
  since table   is hk_table(name, short_name, model, display),
  since model   is hk_model( columns, _),
  since display is hk_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.
  if _generate_VT_view(stream, table, list_view, false) is   //list view to generate
  {
    failure     then  failure,
    success(_)  then  generate_get_viewable(stream, table, list_view)
  }.
  
  
 public define Maybe(One)
  generate_VT_edit
  (
    Stream    stream,
    HK_Table  table
  )=
  since table   is hk_table(name, short_name, model, display),
  since model   is hk_model( columns, _),
  since display is hk_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)
  }.