Oracle CRM On Demand Documentation Library: JavaScript Code Addition for the od

Oracle CRM On Demand Desktop Administration Guide > Code Listing for Updates to the Customization Package from Version 2.0 >

JavaScript Code Addition for the od_helpers.js File

Insert the following JavaScript code after the first line of the file, as described in Step 8:

include("form_helpers.js", "form_helpers");

var allow_includesubbooks =
{
// "Account": true
};

         helpers.for_each(session.find_items("Book", session.empty_criteria), function(item)
         {
            var has_no_parent = session.find_item("Book", session.create_expression("Value", "eq", item.ParentBookId)) == null;
            if(!in_tree[item.Value] && has_no_parent)
               add_node(item);
         });
      }
   };

   function get_current_user_userbook(ctx)
   {
      var defaults = helpers.get_defaults(ctx.session);
      return defaults != null ? defaults.PrimaryPositionId : "";
   }
}

function book_can_contain_data(ctx, id)
{
   var book = ctx.session.find_item("Book", ctx.session.create_expression("Value", "eq", id)),
      result = true;
   if(book != null)
      result = book.CanContainDataFlag;
   return result;
}

function book_is_userbook(ctx, id)
{
var user = ctx.session.find_item("User", ctx.session.create_expression("PrimaryPositionId", "eq", id));
return user != null;
}

edit.value = label;
}
}

         // Build mode selector options
         cbx_mode.items.clear();
         cbx_mode.items.start_adding();
         cbx_mode.items.add("team", ctx.session.res_string("cbx_record_set_team"));
         if (book_available || current_type_settings.BookId != null)
            cbx_mode.items.add("book", ctx.session.res_string("cbx_record_set_book"));
         if (book_available && book_processor.default_book_exists(rs_type) || is_default_book_selected(current_type_settings, rs_type.default_book))
            cbx_mode.items.add("default_book", ctx.session.res_string("cbx_record_set_default_book"));
         cbx_mode.items.finish_adding();

         // Retrieve cached book selector (or create a new one if not found)
         var books = book_processor.get_available_books();
         var bs = cached_bs_controllers[rs_type.type_id];
         if (bs) {
            bs.update_options({type: rs_type, books: books});
         } else {
                  var bs_options =
               {
               ctrl_edit: edit_book,
               ctrl_btn: btn_book_select,
               type: rs_type,
               books: books,
               allow_include_subbooks: book_processor.allow_include_subbooks(rs_type.type_id)
            };
            bs = new cp_book_selector(ctx, bs_options);
            ctx.events.connect(bs, "on_changed", set_option_selected);
            cached_bs_controllers[rs_type.type_id] = bs;
            ctx.events.connect(cbx_mode, "changed", function(){on_mode_changed(cbx_mode.value)});
         }

         // Fill controls with initial values
         prefill_type(current_type_settings);

   /**
   Enables/disables "Save" button based on detected changes and performed validations.
   @type Function
   */
   function validate_changes() {
      var enable_save_btn = true;
      var changes_found = false;
      // Detect changes
      if (saved_item_snapshot.length != current_item.length) {
         changes_found = true;
      } else {
         for (var i in current_item) {
            var current_item_options = current_item[i];
            var saved_item_snapshot_options = saved_item_snapshot[i];
            if (saved_item_snapshot_options.BookId != current_item_options.BookId || saved_item_snapshot_options.IncludeSubBooks != current_item_options.IncludeSubBooks) {
               changes_found = true;
               break;
            }
         }
      }

      if (!changes_found) {
         enable_save_btn = false;
      } else {
         // Run validations
         for (var i in current_item) {
            if (current_item[i].BookId === predefined_options.no_book_selected.BookId) {
               enable_save_btn = false;
               break;
            }
         }
      }
      // Enable/disable "Save" button
      form.btn_save1.enabled = enable_save_btn;
   }

   /**
   Builds a snapshot of current_item, which can later be used as saved item snapshot for detecting changes.
   @type Function
   */
   function rebuild_saved_item_snapshot() {
      var data_source = book_processor.get_data_source();
      var columns = data_source.columns.toArray();
      saved_item_snapshot = [];
      for (var key in current_item) {
         var snapshot_item = {};
         for (var i in columns)
            snapshot_item[columns[i]] = current_item[key][columns[i]];
         saved_item_snapshot.push(snapshot_item);
      }
   }
}

function book_of_business_processor(ctx, options) {
   options = options || {};

   var available_books, user_default_book, user_has_books;
   var record_set_types = [];
   var default_books = [];
   var data_source, connector = options.connector || null;
   var disconnectable = {};
   var book_predefined_options =
   {
      "team": {BookId: "", IncludeSubBooks: false},
      "no_book_selected": {BookId: null, IncludeSubBooks: null}
   };

   this.save_default_books_if_empty = function(on_after_saved_fn, on_save_failed_fn)
{
      var on_books_retrieved = function (retrieved_books) {
         save(retrieved_books, on_after_saved_fn);
      };
      this.retrieve_saved_or_default_books(on_books_retrieved, on_save_failed_fn);
   };

   this.retrieve_saved_or_default_books = function(on_books_retrieved_fn, on_err_fn)
{
      // Saving default visibility modes
      if (!connector)
         ctx.application.connector.async_get_remote_connector(0, form_helpers.disconnectable_handler(on_connector_ready, disconnectable));
      else
         on_connector_ready(connector);

      function on_connector_ready(c, err) {
         if (err) {
            ctx.ui.message_box(ctx.ui.app_window, err.message, ctx.session.res_string("books_retrieve_failed_title"), 0x10); // MB_OK | MB_ICONERROR
            if (on_err_fn)
               on_err_fn(err);
            return;
         }

         // Reset variables
         var saved_item = [];
         var default_prefilling = [];
         record_set_types = [];
         default_books = [];
         available_books = [];
         user_default_book = null;
         data_source = null;

         // Cache connector
         connector = c;

         // Retrieve remotely available books list and default books per type for current user
         create_data_source("Book", function(book_ds) {
            available_books = retrieve_books_picklist_from_datasource(book_ds);
            var books_count = 0;
            for (var _ in available_books) { books_count++; }
            user_has_books = books_count > 0;
            create_data_source("BookDefaults", function(BookDefaults_ds) {
               default_books = retrieve_books_picklist_from_datasource(BookDefaults_ds);
               on_books_ready();
            });
         });

         function on_books_ready()
         {
            // Configure list of supported types
            for (var type_id in default_books)
               record_set_types.push({type_id: type_id, sort_order: parseInt(default_books[type_id]["OrderNumber"])});
            record_set_types.sort(function(a, b){ return a.sort_order - b.sort_order; });

            // Get global default book
            create_data_source("::Defaults", function(defaults_ds) {
               // If no items found, proceed
               if (defaults_ds.record_count == 0) {
                  configure_default_books();
               } else {
                  var ds_item = defaults_ds.get_item_id(0);
                  connector.async_get_item("::Defaults", ds_item, function(){}, form_helpers.disconnectable_handler(function(defaults, err) {
                     if (err == null && defaults.DefaultBookName != "" && defaults.DefaultBookName != "All+") {
                        for (var id in available_books) {
                           if (available_books[id].Label == defaults.DefaultBookName) {
                              user_default_book = id;
                              break;
                           }
                        }
                     }
                     configure_default_books();
                  }, disconnectable));
               }

               function configure_default_books() {
                  helpers.for_each2(record_set_types, function(rs_type){
                     // If default book per type is not available set to global default book if available
                     if (default_books[rs_type.type_id].BookId == null && user_default_book != null) {
                        default_books[rs_type.type_id].BookId = user_default_book;
                        default_books[rs_type.type_id].IncludeSubBooks = !available_books[user_default_book].CanContainDataFlag && allow_include_subbooks(rs_type.type_id);
                     }
                     // Check if books of business are enabled
                     rs_type.books_enabled = default_books[rs_type.type_id] != null;
                     // Lookup default book for type if books enabled
                     if (rs_type.books_enabled)
                        rs_type.default_book = default_books[rs_type.type_id];

                     // Default prefilling
                     var book_available = rs_type.books_enabled && user_has_books;
                     var def_book_exists = default_book_exists(rs_type);
                     var prefill_default_book = book_available && def_book_exists;
                     apply_to_type(rs_type.type_id, function(item){
                        item.BookId = prefill_default_book ? rs_type.default_book.BookId : book_predefined_options.team.BookId;
                        item.IncludeSubBooks = prefill_default_book ? rs_type.default_book.IncludeSubBooks : book_predefined_options.team.IncludeSubBooks;
                     }, default_prefilling);
                  });

                  // Get saved item if found
                  create_data_source("Book.Type.Association", function(ds) {
                     // Make datasource global for future use
                     data_source = ds;
                     // If no saved items found, consider this is a first run and proceed next
                     if (data_source.record_count > 0) {
                        // Process found items
                        var items_processed = 0;
                        for (var i=0; i<data_source.record_count; i++) {
                           var ds_item = data_source.get_item_id(i);
                           connector.async_get_item("Book.Type.Association", ds_item, function(){}, form_helpers.disconnectable_handler(function(retrieved_item, err) {
                              if (err == null)
                                 saved_item.push(retrieved_item);
                              items_processed++;

                              // If all items retrieved
                              if (items_processed == data_source.record_count)
                                 configure_default_item();
                           }, disconnectable));
                        }
                     } else {
                        configure_default_item();
                     }

                     // Compiles default visibility modes list
                     function configure_default_item() {
                        helpers.for_each2(record_set_types, function(rs_type){
                           // Trying to find saved mode
                           var item_found = false;
                           for (var key in saved_item) {
                              if (saved_item[key].TypeName == rs_type.type_id) {
                                 item_found = true;
                                 break;
                              }
                           }
                           // set to default mode if not found
                           if (!item_found)
                              apply_to_type(rs_type.type_id, function(item){
                                 for (var key in default_prefilling) {
                                    if (default_prefilling[key].TypeName == item.TypeName) {
                                       item.BookId = default_prefilling[key].BookId;
                                       item.IncludeSubBooks = default_prefilling[key].IncludeSubBooks;
                                       break;
                                    }
                                 }
                              }, saved_item);
                        });

                        on_books_retrieved_fn(saved_item);
                     }
                  });
               }
            });
         }

         function retrieve_books_picklist_from_datasource(ds) {
            var result = {};
            var count = ds.record_count;
            var _columns = ds.columns.toArray();
            var columns = {};
            for (var i=0; i < _columns.length; i++) {
               columns[_columns[i]] = i;
            }
            for (var i=0; i < count; i++) {
               var row = ds.get_item_fields(i).toArray();
               result[get_value(row)] = get_item(row);
            }

            function get_value(row)
            {
               return row[columns["Value"]];
            }
            function get_item(row)
            {
               var item = {};
               helpers.for_each2(_columns, function(fld_name){
                  item[fld_name] = row[columns[fld_name]];
               });
               return item;
            }
            return result;
         }

         function create_data_source(type_id, fn) {
            var ds = connector.create_data_source(type_id);
            ds.on_changed.connect(form_helpers.disconnectable_handler(function() { fn(ds); }, disconnectable));
            ds.enabled = true;
            ds.refresh(100, 600000);
            ds.enabled = false;
         }
      }
   }

   function save(item, on_after_saved_fn) {
      var saved_items_count = 0;
      for (var key in item) {
         connector.async_put_item(item[key], on_progress, form_helpers.disconnectable_handler(on_put_item_complete, disconnectable));
      }
      if (item.length == 0)
         on_after_saved_fn(item);

      function on_progress() {}
      function on_put_item_complete(saved_book) {
         // Synchronize new selected value with local storage
         var user_selected_book = get_ol_storage_rs_book(ctx, saved_book.TypeName) || ctx.session.create_item("Book.Type.Association");
         user_selected_book.TypeName = saved_book.TypeName;
         user_selected_book.BookId = saved_book.BookId;
         user_selected_book.IncludeSubBooks = saved_book.IncludeSubBooks;
         user_selected_book.save();

         saved_items_count++;
         if (saved_items_count == item.length)
            on_after_saved_fn(item);
      }
   }
   this.save = save;

   this.get_types_list = function () {
      return record_set_types;
   }

   this.get_data_source = function () {
      return data_source;
   }

   this.get_connector = function () {
      return connector;
   };

   this.get_available_books = function () {
      return available_books;
   };

   this.user_has_books = function () {
      return user_has_books;
   }

   this.get_predefined_options = function () {
      return book_predefined_options;
   }

   this.abort = function() {
      disconnectable.disabled = true;
   }

   function allow_include_subbooks(type) {
      return allow_includesubbooks[type] || false;
   }
   this.allow_include_subbooks = allow_include_subbooks;

   /**
   Checks whether default book is defined for a type.
   @param type Type name to check default book for
   @returns {Boolean} Does default book exist for a type
   @type Function
   */
   function default_book_exists(type) {
      // Books are disabled
      if (!type.books_enabled)
         return false;
      // No default book
      var book_id = type.default_book.BookId;
      if (book_id == null)
         return false;
      // accessible book && the book that can contain data or with "Include Sub-Items" enabled by administrator
      var book = available_books[book_id];
      if (book != null && (book.CanContainDataFlag || type.default_book.IncludeSubBooks))
         return true;
      // The book that cannot contain data and "Include Sub-Items" for it is disabled by administrator
      return false;
   }
   this.default_book_exists = default_book_exists;

   /**
   Applies a function to a specific type records set option in destination item. if not yet exists, creates "team" records set option for a type (default option).
   @param type_id Records set option type name
   @param {Function} f Function to call over an item
   @param dest Destination object to lookup an item in.
   @type Function
   */
   function apply_to_type(type_id, f, dest) {
      // Try to find item in dest
      var item = null;
      for (var i in dest) {
         if (dest[i].TypeName == type_id) {
            item = dest[i];
            break;
         }
      }
      // Create item if not found
      if (item == null) {
         item = connector.create_item("Book.Type.Association");
         item.TypeName = type_id;
         item.BookId = book_predefined_options.team.BookId;
         item.IncludeSubBooks = book_predefined_options.team.IncludeSubBooks;
         dest.push(item);
      }
      // Apply function
      f(item);
   }
   this.apply_to_type = apply_to_type;
}

function get_ol_storage_rs_book(ctx, type_id) {
   return ctx.session.find_item("Book.Type.Association", ctx.session.create_expression("TypeName", "eq", type_id));
}

Oracle CRM On Demand Desktop Administration Guide, Version 5.2		Copyright © 2017, Oracle and/or its affiliates. All rights reserved. Legal Notices.