kablam 0.0.4 → 0.0.8

data/app/assets/javascripts/kablam/forms.js

@@ -0,0 +1,167 @@
+function byId(e){return document.getElementById(e);}
+function newEl(tag){return document.createElement(tag);}
+function newTxt(txt){return document.createTextNode(txt);}
+function hide(e) {
+  var contentId = document.getElementById(e);
+  contentId.style.display = "none";
+}
+//  random hex string generator
+function randHex(len) {
+  var maxlen = 8,
+      min = Math.pow(16,Math.min(len,maxlen)-1)
+      max = Math.pow(16,Math.min(len,maxlen)) - 1,
+      n   = Math.floor( Math.random() * (max-min+1) ) + min,
+      r   = n.toString(16);
+  while ( r.length < len ) {
+     r = r + randHex( len - maxlen );
+  }
+  return r;
+};
+
+function insertAndExecute(id, text) {
+  byId(id).innerHTML = text;
+  var scripts = Array.prototype.slice.call(byId(id).getElementsByTagName("script"));
+  for (var i = 0; i < scripts.length; i++) {
+    if (scripts[i].src != "") {
+      var tag = newEl("script");
+      tag.src = scripts[i].src;
+      document.getElementsByTagName("head")[0].appendChild(tag);
+    }
+    else {
+      eval(scripts[i].innerHTML);
+    }
+  }
+}
+
+function load(target, url) {
+  AjaxRequest.get(
+    {
+      'url':url,
+      'onSuccess':function(req){ insertAndExecute(target, req.responseText); }
+    }
+  );
+}
+
+var W3CDOM = (document.createElement && document.getElementsByTagName);
+
+function initFileUploads(opt) {
+  if (!W3CDOM) return;
+  var fakeFileUpload = document.createElement('div');
+    fakeFileUpload.className = 'kablam_fakefile';
+  var upload_icon = document.createElement('i');
+    upload_icon.className = opt['icon'];
+  var input = document.createElement('input');
+    input.type = "text";
+    input.className = opt['class'];
+
+  fakeFileUpload.appendChild(upload_icon);
+  fakeFileUpload.appendChild(input);
+
+  var x = document.getElementsByClassName('kablam_file');
+  for (var i=0;i<x.length;i++) {
+    if (x[i].type != 'file') continue;
+    if (x[i].parentElement.className != 'kablam_fileinput_init') continue;
+
+    x[i].parentElement.className = 'kablam_fileinputs';
+    var clone = fakeFileUpload.cloneNode(true);
+    x[i].parentElement.appendChild(clone);
+    x[i].relatedElement = clone.getElementsByTagName('input')[0];
+
+    x[i].onchange = x[i].onmouseout = function () {
+      path = this.value
+      path = path.replace( /fakepath\\/, '...' );
+      path = path.replace('C:\\', '');
+      this.relatedElement.value = path;
+    }
+  }
+}
+
+function addInput(id, name, classes){
+  var input_set = document.getElementById(id);
+  var new_set = document.createElement('div');
+    new_set.id = randHex(12);
+    new_set.className = classes['group'];
+
+  var input = document.createElement('input');
+    input.type = "text";
+    input.className = classes['input'];
+    input.name = name;
+  var button = document.createElement('a');
+    button.className = classes['btn'];
+    button.setAttribute("onclick", "event.preventDefault();rmParent(this);");
+  var icon = document.createElement('i');
+    icon.className = classes['icon'];
+
+  button.appendChild(icon);
+  new_set.appendChild(input);
+  new_set.appendChild(button);
+  input_set.appendChild(new_set);
+}
+
+function rmParent(el){
+  el.parentElement.remove();
+}
+
+
+Object.defineProperty(HTMLElement, 'From', {
+    enumerable: false,
+    value: (function (document) {
+        //https://www.measurethat.net/Benchmarks/Show/2149/0/element-creation-speed
+        var rgx = /(\S+)=(["'])(.*?)(?:\2)|(\w+)/g;
+        return function CreateElementFromHTML(html) {
+            html = html.trim();
+            var bodystart = html.indexOf('>') + 1, bodyend = html.lastIndexOf('<');
+            var elemStart = html.substr(0, bodystart);
+            var innerHTML = html.substr(bodystart, bodyend - bodystart);
+            rgx.lastIndex = 0;
+            var elem = document.createElement(rgx.exec(elemStart)[4]);
+            var match; while ((match = rgx.exec(elemStart))) {
+                if (match[1] === undefined) {
+                    elem.setAttribute(match[4], "");
+                } else {
+                    elem.setAttribute(match[1], match[3]);
+                }
+            }
+            elem.innerHTML = innerHTML;
+            return elem;
+        };
+    }(window.document))
+});
+
+
+function submitRemove(form_id){
+  var form = document.getElementById(form_id);
+  form.addEventListener("ajax:success", function(e) {
+    e.preventDefault();
+    form.remove();
+  });
+}
+
+function submitToTop(form_id){
+  var form = document.getElementById(form_id);
+  form.addEventListener("ajax:success", function(e) {
+    e.preventDefault();
+    scrollToTop(500);
+  });
+}
+
+function scrollToTop(scrollDuration) {
+const   scrollHeight = window.scrollY,
+        scrollStep = Math.PI / ( scrollDuration / 15 ),
+        cosParameter = scrollHeight / 2;
+var     scrollCount = 0,
+        scrollMargin,
+        scrollInterval = setInterval( function() {
+            if ( window.scrollY != 0 ) {
+                scrollCount = scrollCount + 1;
+                scrollMargin = cosParameter - cosParameter * Math.cos( scrollCount * scrollStep );
+                window.scrollTo( 0, ( scrollHeight - scrollMargin ) );
+            }
+            else clearInterval(scrollInterval);
+        }, 15 );
+}
+
+function toggle_visibility(id) {
+   var e = document.getElementById(id);
+      e.style.display = 'none';
+}

data/app/assets/javascripts/kablam/messaging.js

@@ -0,0 +1,95 @@
+var scrollPosition;
+document.addEventListener('turbolinks:load', refreshScroll());
+
+function refreshScroll(){
+  if (scrollPosition) {
+    window.scrollTo.apply(window, scrollPosition);
+    scrollPosition = null;
+  }
+}
+
+function TurboRefresh(){
+  scrollPosition = [window.scrollX, window.scrollY];
+  Turbolinks.visit(window.location.toString(), { action: 'replace' });
+}
+
+function Sound(path) {
+  var audio = new Audio(path);
+  audio.play();
+}
+
+function TopDot(dot_id, dot_class="dot bg-officeblue"){
+  var topdotspan = document.getElementById(dot_id);
+  topdotspan.className = dot_class;
+}
+
+
+function RemoveChatsSub(chatid) {
+  var all = App.cable.subscriptions.subscriptions;
+  var all_chats_sub_id = all.map(function (x) {return JSON.parse(x.identifier).id});
+  var index_of_subed_chats = [];
+  all_chats_sub_id.forEach(function(item,index) {
+    if (chatid != undefined) {
+        if (item != undefined && item != chatid) {
+          index_of_subed_chats.push(index);
+      }
+    } else {
+        if (item != undefined) {
+          index_of_subed_chats.push(index);
+      }
+    }
+  });
+  index_of_subed_chats.forEach(function(item) {
+    App.cable.subscriptions.remove(all[item]);
+  });
+}
+
+
+function RemoveNotificationDot(dot_id){
+  var dotspan = document.getElementById(dot_id);
+  dotspan.className = "";
+}
+
+function UserChatSub(chat_div_id, chat_id, channel, user_id, options={}){
+  RemoveChatsSub();
+  var chatdiv = document.getElementById(chat_div_id);
+
+  App.cable.subscriptions.create({ channel: channel, id: chat_id }, {
+    received: function(data) {
+      HtmlNode(data, options);
+      if (data['chat']['sender_id'] != user_id) {
+        TopDot();
+      }
+    }
+  })
+}
+
+function HtmlNode(data, options={}){
+  options = {
+    outerDivClass: options.outerDivClass || "pt3 ph3 ph2-l bg-white br2 shadow1 mb3",
+    innerDivClass: options.innerDivClass || "dt w-100 pb2 ph2 mt2",
+    imgDivClass: options.imgDivClass || "dtc w2 w3-ns v-mid",
+    imgClass: options.imgClass || "ba b--black-10 db br-100 w2 w3-ns h2 h3-ns",
+    userDivClass: options.userDivClass || "dtc v-mid pl3",
+    userNameClass: options.userNameClass || "f6 f5-ns fw6 lh-title black mv0",
+    timestampClass: options.timestampClass || "f6 fw4 mt0 mb0 black-60 i",
+    messageDivClass: options.messageDivClass || "ph3-l pb2",
+    messageClass: options.messageClass || "f5 lh-copy measure pb3"
+  }
+
+  var new_message = document.createElement("div");
+
+    new_message.className = options.outerDivClass;
+    var content = data['chat'].content.replace(/(?:\r\n|\r|\n)/g, '<br>');
+    new_message.innerHTML = `<div class="${options.innerDivClass}">
+    <div class="${options.imgDivClass}">
+    <img src="${data['chat'].image}" class="${options.imgClass}"/>
+    </div>
+    <div class="${options.userDivClass}">
+      <h1 class="${options.userNameClass}">${data['chat'].username}</h1>
+      <h2 class="${options.timestampClass}">${data['chat'].created_at}</h2>
+    </div>
+    </div>
+    <div class="${options.messageDivClass}"><p class="${options.messageClass}">${content}</p></div>`;
+    chatdiv.insertAdjacentElement('afterbegin', new_message);
+}

data/app/assets/stylesheets/kablam.scss

@@ -0,0 +1,25 @@
+div.kablam_fileinputs {
+  position: relative;
+}
+
+div.kablam_fakefile {
+  position: absolute;
+  top: 0px;
+  left: 0px;
+  z-index: 1;
+  width: 100%;
+  height: 100%;
+  text-align: center;
+}
+
+input.kablam_file {
+  position: relative;
+  text-align: right;
+  -moz-opacity:0 ;
+  filter: opacity(0);
+  opacity: 0;
+  z-index: 2;
+}
+.hidden {
+  display: none;
+}

data/app/channels/chat_channel.rb

@@ -0,0 +1,12 @@
+class ChatChannel < ApplicationCable::Channel
+  def subscribed
+    # stream_from "some_channel"
+    stream_from "ChatChannel_#{params[:id]}"
+
+    puts "subscribed to chat #{params[:id]}"
+  end
+
+  def unsubscribed
+    # Any cleanup needed when channel is unsubscribed
+  end
+end

data/app/controllers/concerns/api_settings.rb

@@ -0,0 +1,41 @@
+module Concerns
+  module ApiSettings
+    extend ActiveSupport::Concern
+    require 'securerandom'
+    protected
+    def send_to_bucket(bucket, upload_item)
+      puts "uploading..."
+      path = ENV.fetch("BUCKET_TRANSFER_API")
+      bucket = ENV.fetch("BUCKET_NAME")
+
+
+      post_params = {"oss"=> {
+        "bucket"     => bucket,
+        "user_id"    => "TEST",
+        "attachment" => upload_item,
+        "encrypted_name" => SecureRandom.hex
+      }}
+      response = RestClient.post(path, post_params)
+      JSON.parse(response.body)["url"]
+    end
+
+    def slack_it(url, content)
+      # url must be a SLACK webhook
+      message =
+        {
+          "attachments": [
+            {
+              "fallback": "",
+              "color": "#36a64f",
+              "pretext": "#{content[:pretext] || '---'}",
+              "author_name": "#{content[:author] || '-no_author_provided-'}",
+              "title": "#{content[:title] || '-no_title_provided-'}",
+              "text": "#{content[:text] || '-no_text_provided-'}"
+            }
+          ]
+        }.to_json
+
+      RestClient.post(url, message)
+    end
+  end
+end

data/app/controllers/data_controller.rb

@@ -0,0 +1,133 @@
+require 'rest-client'
+
+class DataController < ApplicationController
+  protect_from_forgery with: :exception
+  before_action :set_model, only: [:create, :update, :undo, :destroy, :form]
+  before_action :set_object, only: [:update, :destroy]
+  before_action :set_undo_object, only: [:undo]
+  include Concerns::ApiSettings
+
+  def form
+    # Automatically Render Vanilla Form for use w/ JS.load
+    if params[:id].present?
+      set_object
+    else
+      @object = @model.new
+      set_ref
+    end
+    render layout: false
+  end
+
+  def create
+    @object = @model.new(model_params)
+
+    if @object.save
+      slack?(:create)
+      respond_to do |format|
+        format.js
+        format.html do
+          redirect_to request.referrer
+          flash[:notice] = :Created
+        end
+      end
+    else
+      # TODO: Add some failure handling 👍
+    end
+  end
+
+  def update
+    if @object.update(model_params)
+      slack?(:update)
+      respond_to do |format|
+        format.js
+        format.html do
+          redirect_to request.referrer
+          flash[:notice] = :Destroyed
+        end
+      end
+    else
+      # ADD FAILURE HANDLING
+    end
+  end
+
+  def destroy
+    if @object.destroy
+      slack?(:destroy)
+      respond_to do |format|
+        format.js
+        format.html do
+          redirect_to request.referrer
+          flash[:notice] = :Destroyed
+        end
+      end
+    else
+      # TODO: Add some failure handling 👍
+    end
+  end
+
+  def undo
+    @object.update(undo_params)
+  end
+
+  def slack
+    render status: 200, json: params['challenge']
+  end
+
+  private
+
+  def slack?(crud_type)
+    if @model.slack_hook.present? && @object.slack_message[crud_type].present?
+      slack_it(@model.slack_hook, @object.slack_message[crud_type])
+    end
+  end
+
+  def set_object
+    @object = @model.find(params[:id])
+  end
+
+  def set_undo_object
+    @object = @model.unscoped.where.not(destroyed_at: nil).find(params[:id])
+  end
+
+  def set_model
+    db_index = Hash[ActiveRecord::Base.connection.tables.collect{|c| [c, c.classify]}].except("schema_migrations", "ar_internal_metadata")
+    @model = db_index[params[:name]].constantize # "users" => User
+  end
+
+  def undo_params
+    params.require(@model.to_s.underscore.to_sym).permit :destroyed_at
+  end
+
+  def base_params
+    arr = @model.attribute_names.map { |e| e.to_sym }
+    arr.delete(:id)
+    arr.delete(:created_at)
+    arr.delete(:updated_at)
+    arr.map! do |attr|
+      new_val = (@model.new.send(attr) == []) ? {attr=>[]} : attr
+      new_val
+    end
+    params.require(@model.to_s.underscore.to_sym).permit(arr)
+  end
+
+  def model_params
+    result = base_params
+    upload_items = base_params.select{|k,v| v.is_a? ActionDispatch::Http::UploadedFile }
+    upload_items.each do |k,v|
+      result[k] = send_to_bucket(v)
+    end
+    result
+  end
+
+  def set_ref
+    owners = @model.reflect_on_all_associations(:belongs_to) || []
+    if owners.count < 1
+      return true
+    elsif owners.count == 1
+      foreign_key = owners.first.name.to_s+"_id"
+      @object.write_attribute(foreign_key, params[:ref_id])
+    else
+      p "NOT ENOUGH REF'S ACCOUNTED FOR! REWRITE FORMS??"
+    end
+  end
+end