Module: Jinda::JindaHelper

Includes:
REXML
Defined in:
app/helpers/jinda_engine/jinda_helper.rb

Defined Under Namespace

Classes: String

Instance Method Summary collapse

Instance Method Details

#add_jinda(doc, attr_hash) ⇒ Object 



631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 631

def add_jinda(doc, attr_hash)
  if doc =~ /#{@btext}/
    s1,s2,s3= doc.partition(/  #{@btext}.*#{@etext}\n/m)
      s2= ""
  else
    s1,s2,s3= doc.partition("include Mongoid::Document\n")
  end
  doc= s1+s2+ <<-EOT
  #{@btext}
  include Mongoid::Timestamps
  EOT

  attr_hash.each do |a|
    # doc+= "\n*****"+a.to_s+"\n"
    if a[:edit]
      doc += "  #{a[:text]}\n"
    else
      doc += "  field :#{a[:code]}, :type => #{a[:type].capitalize}\n"
    end
  end
  doc += "  #{@etext}\n"
  doc + s3
end

#add_utf8(doc) ⇒ Object 



655
656
657
658
659
660
661
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 655

def add_utf8(doc)
  unless doc =~ /encoding\s*:\s*utf-8/
    doc.insert 0, "# encoding: utf-8\n"
  else
    doc
  end
end

#affirm(s) ⇒ Object 



861
862
863
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 861

def affirm(s)
  return s =~ /[y|yes|t|true]/i ? true : false
end

#ajax?(s) ⇒ Boolean

Returns:

  • (Boolean) 


356
357
358
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 356

def ajax?(s)
  return s.match('file_field') ? false : true
end

#ajax_notice ⇒ Object 



61
62
63
64
65
66
67
68
69
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 61

def ajax_notice
  if notice=Jinda::Notice.recent(current_ma_user, request.env["REMOTE_ADDR"])
    notice.update_attribute :unread, false
    js = "notice('#{notice.message}');"
  else
    js = ""
  end
  render plain: "<script>#{js}</script>"
end

#align_text(s, pixel = 3) ⇒ Object 



327
328
329
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 327

def align_text(s, pixel=3)
  "<span style='position:relative; top:-#{pixel}px;'>#{s}</span>".html_safe
end

#authorize? ⇒ Boolean

use in pending tasks

Returns:

  • (Boolean) 


271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 271

def authorize? # use in pending tasks
  @runseq= @xmain.runseqs.find @xmain.current_runseq
  return false unless @runseq
  @user = current_ma_user
  set_global
  return false unless eval(@runseq.rule) if @runseq.rule
  return true if true_action?(@runseq.action)
  # return false if check_wait
  return true if @runseq.role.blank?
  unless @runseq.role.empty?
    return false unless @user.role
    return @user.role.upcase.split(',').include?(@runseq.role.upcase)
  end
  return true
end

#authorize_init? ⇒ Boolean

use when initialize new transaction

Returns:

  • (Boolean) 


286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 286

def authorize_init? # use when initialize new transaction
  # check module role
  mrole = @service.module.role
  return false if mrole && !current_ma_user
  return false if mrole && !current_ma_user.has_role(mrole)

  # check step 1 role
  xml= @service.xml
  step1 = REXML::Document.new(xml).root.elements['node']
  role= get_option_xml("role", step1) || ""
  #    rule= get_option_xml("rule", step1) || true
  rule= get_option_xml("rule", step1) || true
  return true if role==""
  unless current_ma_user
    return role.blank?
  else
    return false unless current_ma_user.role
    return current_ma_user.has_role(role)
  end

end

#b(s) ⇒ Object 



169
170
171
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 169

def b(s)
  "<b>#{s}</b>".html_safe
end

#clear_xmains ⇒ Object 



57
58
59
60
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 57

def clear_xmains
  Jinda::Xmain.where(:status =>{'$in'=>['R','I']}).update_all(:status=>'X')
  redirect_to action:"pending"
end

#code_div(s) ⇒ Object 



353
354
355
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 353

def code_div(s)
  "<pre style='background-color: #efffef;'><code class='ruby' lang='ruby'>    #{s}</code></pre>".html_safe
end

#code_text(s) ⇒ Object

old def code(s)



175
176
177
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 175

def code_text(s) # old def code(s)
  "<pre style='background-color: #efffef;'><code class='ruby' lang='ruby'>#{s}</code></pre>".html_safe
end

#controller_exists?(modul) ⇒ Boolean

Returns:

  • (Boolean) 


756
757
758
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 756

def controller_exists?(modul)
  File.exists? "#{Rails.root}/app/controllers/#{modul}_controller.rb"
end

#create_runseq(xmain) ⇒ Object

]

Each xmain  will create many run_seq as many as steps and form_steps

]

@runseq ################################]
@runseq => #<Jinda::Runseq _id: 5df31912a54d758417a7afc9, 
 created_at: 2019-12-13 04:52:34 UTC, 
 updated_at: 2019-12-13 04:52:43 UTC, 
 user_id: nil, 
 xmain_id: BSON::ObjectId('5df31912a54d758417a7afc7'), 
 action: "do", 
 status: "R", 
 code: "create", 
 name: "Create Article", 
 role: "", 
 rule: "true", 
 rstep: 2, 
 form_step: 1, 
 start: 2019-12-13 04:52:43 UTC, 
 stop: nil, 
 end: true, 
 xml: "<node CREATED='1493419491125' ID='ID_1687683396' MODIFIED='1493483244848' TEXT='create: Create Article'><icon BUILTIN='bookmark'/></node>", 
 ip: nil>

]



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 96

def create_runseq(xmain)
  @xvars= xmain.xvars
  default_role= get_default_role
  xml= xmain.service.xml
  root = REXML::Document.new(xml).root
  i= 0; j= 0 # i= step, j= form_step
  root.elements.each('node') do |activity|
    text= activity.attributes['TEXT']
    next if ma_comment?(text)
    next if text =~/^rule:\s*/
    action= freemind2action(activity.elements['icon'].attributes['BUILTIN']) if activity.elements['icon']
    return false unless action
    i= i + 1
    output_ma_display= false
    if action== ('output'|| 'list' ||'folder')
      ma_display= get_option_xml("display", activity)
      if ma_display && !affirm(ma_display)
        output_ma_display= false
      else
        output_ma_display= true
      end
    end
    j= j + 1 if (action=='form' || output_ma_display)
    @xvars['referer'] = activity.attributes['TEXT'] if action=='redirect'
    if action!= 'if' && !text.blank?
      scode, name= text.split(':', 2)
      name ||= scode; name.strip!
      code= name2code(scode)
    else
      code= text
      name= text
    end
    role= get_option_xml("role", activity) || default_role
    rule= get_option_xml("rule", activity) || "true"
    runseq= Jinda::Runseq.create :xmain=>xmain.id,
      :name=> name, :action=> action,
      :code=> code, :role=>role.upcase, :rule=> rule,
      :rstep=> i, :form_step=> j, :status=>'I',
      :xml=>activity.to_s
    xmain.current_runseq= runseq.id if i==1
  end
  @xvars['total_steps']= i
  @xvars['total_form_steps']= j
end

#create_xmain(service) ⇒ Object

] Each Service at one moment will create one xmain ]



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 37

def create_xmain(service)
  c = name2camel(service.module.code)
  custom_controller= "#{c}Controller"
  params["return"] = request.env['HTTP_REFERER']
  Jinda::Xmain.create :service=>service,
    :start=>Time.now,
    :name=>service.name,
    :ip=> get_ip,
    :status=>'I', # init
    :user=>current_ma_user,
    :xvars=> {
      :service_id=>service.id,
      :p=>params.to_unsafe_h,
      :id=>params[:id],
      :user_id=>current_ma_user.try(:id),
      :custom_controller=>custom_controller,
      :host=>request.host,
      :referer=>request.env['HTTP_REFERER']
    }
end

#current_ma_user ⇒ Object 



375
376
377
378
379
380
381
382
383
384
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 375

def current_ma_user
  # if session[:user_id]
  #   return @user ||= User.find(session[:user_id]['$oid'])
  # else
  #   return nil
  # end
  #@user ||= User.find_by_auth_token!(cookies[:auth_token]) if cookies[:auth_token]
  @user ||= User.where(:auth_token => cookies[:auth_token]).first if cookies[:auth_token]
  return @user
end

#dup_hash(a) ⇒ Object 



759
760
761
762
763
764
765
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 759

def dup_hash(a)
  h = Hash.new(0)
  a.each do |aa|
    h[aa] += 1
  end
  return h
end

#freemind2action(s) ⇒ Object 



829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 829

def freemind2action(s)
  case s.downcase
    #when 'bookmark' # Excellent
    #  'call'
  when 'bookmark' # Excellent
    'do'
  when 'attach' # Look here
    'form'
  when 'edit' # Refine
    'pdf'
  when 'wizard' # Magic
    'ws'
  when 'help' # Question
    'if'
  when 'forward' # Forward
    # 'redirect'
    'direct_to'
  when 'kaddressbook' #Phone
    'invoke' # invoke new service along the way
  when 'idea' # output
    'output'
  when 'list' # List
    'list'
  when 'folder' # Folder
    'folder'
  when 'mail'
    'mail'
  # when 'xmag' # Tobe discussed
  when 'To be discusssed'
    'search'  
  end
end

#gen_view_createfile(s, f, t) ⇒ Object 



749
750
751
752
753
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 749

def gen_view_createfile(s,f,t)
  FileUtils.cp s,f
  # FileUtils.cp "app/jinda/template/linkview.haml",f
  t << "create file #{f}"
end

#gen_view_file_exist?(dir) ⇒ Boolean

Methods to be overrided by gemhelp #

for Rspec Test

Returns:

  • (Boolean) 


740
741
742
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 740

def gen_view_file_exist?(dir)
  File.exists?(dir)
end

#gen_view_mkdir(dir, t) ⇒ Object 



744
745
746
747
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 744

def gen_view_mkdir(dir,t)
  Dir.mkdir(dir)
  t << "create directory #{dir}"
end

#gen_views ⇒ Object

Jinda Rake Task #



524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 524

def gen_views
  t = ["*** generate ui ***"]

  # create array of files to be tested
  $afile = Array.new

  Jinda::Module.all.each do |m|
    m.services.each do |s|
      dir ="app/views/#{s.module.code}"
      unless gen_view_file_exist?(dir)
        gen_view_mkdir(dir,t) 
      end

      if s.code=='link'
        f= "app/views/#{s.module.code}/index.haml"
        $afile << f
        unless gen_view_file_exist?(f)
          sv = "app/jinda/template/linkview.haml"
          f= "app/views/#{s.module.code}/index.haml"
          gen_view_createfile(sv,f,t)
        end
        next   
      end

      dir ="app/views/#{s.module.code}/#{s.code}"
      unless gen_view_file_exist?(dir)
        gen_view_mkdir(dir,t) 
      end

      xml= REXML::Document.new(s.xml)
      xml.elements.each('*/node') do |activity|
        icon = activity.elements['icon']
        next unless icon
        action= freemind2action(icon.attributes['BUILTIN'])
        next unless ui_action?(action)
        code_name = activity.attributes["TEXT"].to_s
        next if code_name.comment?
        code= name2code(code_name)
        if action=="pdf"
          f= "app/views/#{s.module.code}/#{s.code}/#{code}.pdf.prawn"
        else
          f= "app/views/#{s.module.code}/#{s.code}/#{code}.html.erb"
        end
        $afile << f
        unless gen_view_file_exist?(f)
          sv = "app/jinda/template/view.html.erb"
          gen_view_createfile(sv,f,t)
        end
      end
    end
  end
  puts $afile.join("\n")
  puts t.join("\n")
  return $afile  
end

#get_app ⇒ Object

##########################################################################

Load index.mm from Rails

##########################################################################



490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 490

def get_app
  # MM was defined in Rails: config/initializer/jinda.rb
  f= MM || "#{Rails.root}/app/jinda/index.mm" 
  dir= File.dirname(f)
  t= REXML::Document.new(File.read(MM).gsub("\n","")).root
  recheck= true ; first_pass= true
  while recheck
    recheck= false
    t.elements.each("//node") do |n|
      if n.attributes['LINK'] # has attached file
        if first_pass
          f= "#{dir}/#{n.attributes['LINK']}"
        else
          f= n.attributes['LINK']
        end
        next unless File.exists?(f)
        tt= REXML::Document.new(File.read(f).gsub("\n","")).root.elements["node"]
        make_folders_absolute(f,tt)
        tt.elements.each("node") do |tt_node|
          n.parent.insert_before n, tt_node
        end
        recheck= true
        n.parent.delete_element n
      end
    end
    first_pass = false
  end
  return t
end

#get_default_role ⇒ Object 



224
225
226
227
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 224

def get_default_role
  default_role= Jinda::Role.where(:code =>'default').first
  return default_role ? default_role.name.to_s : ''
end

#get_ip ⇒ Object 



221
222
223
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 221

def get_ip
  request.env['HTTP_X_FORWARDED_FOR'] || request.env['REMOTE_ADDR']
end

#get_login_user_info ⇒ Object

############################### Themes ###################################

Check login user information from User model: name(code), image for Themes

##########################################################################



242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 242

def 
  if current_ma_user.present?
    $user_image = current_ma_user.image
    $user_name = current_ma_user.code
    $user_email = current_ma_user.email
    $user_id = current_ma_user.try(:id)
  else
    $user_image = asset_url("user.png", :width => "48")
    $user_name = 'Guest User'
    $user_email = '[email protected]'
    $user_id = ''
  end
  return $user_image, $user_name, $user_email,$user_id
end

#get_option(opt, runseq = @runseq) ⇒ Object

Todo refactor code



204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 204

def get_option(opt, runseq=@runseq)
  xml= REXML::Document.new(runseq.xml).root
  url=''
  # get option from second element of node using '//node'
  xml.each_element('//node') do |n|
    if n.attributes['TEXT']
      text = n.attributes['TEXT']
      url= text if text =~ /^#{opt}:\s*/
    end
  end
  return nil if url.blank?
  c, h= url.split(':', 2)
  opt= h ? h.strip : false
end

#get_option_xml(opt, xml) ⇒ Object

return nil or value of opt: if provided



781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 781

def get_option_xml(opt, xml)
  if xml
    url=''
    xml.each_element('node') do |n|
      text= n.attributes['TEXT']
      # check if opt match from beginning of text
      url= text if text =~/^#{opt}/
    end
    return nil if url.blank?
    c, h= url.split(':', 2)
    opt= h ? h.strip : true
  else
    return nil
  end
end

#init_vars(xmain) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 141

def init_vars(xmain)
  @xmain= Jinda::Xmain.find xmain
  @xvars= @xmain.xvars
  @runseq= @xmain.runseqs.find @xmain.current_runseq
  #    authorize?
  @xvars['current_step']= @runseq.rstep
  @xvars['referrer']= request.referrer
  session[:xmain_id]= @xmain.id
  session[:runseq_id]= @runseq.id
  unless params[:action]=='run_call'
    @runseq.start ||= Time.now
    @runseq.status= 'R' # running
    @runseq.save
  end
  $xmain= @xmain; $xvars= @xvars
  $runseq_id= @runseq.id
  $user_id= current_ma_user.try(:id)
end

#init_vars_by_runseq(runseq_id) ⇒ Object 



159
160
161
162
163
164
165
166
167
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 159

def init_vars_by_runseq(runseq_id)
  @runseq= Jinda::Runseq.find runseq_id
  @xmain= @runseq.xmain
  @xvars= @xmain.xvars
  #@xvars[:current_step]= @runseq.rstep
  @runseq.start ||= Time.now
  @runseq.status= 'R' # running
  @runseq.save
end

#link_to_blank(body, url_options = {}, html_options = {}) ⇒ Object 



172
173
174
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 172

def link_to_blank(body, url_options = {}, html_options = {})
  link_to(body, url_options, html_options.merge(target: "_blank"))
end

#listed(node) ⇒ Object

Option to unlisted in the menu_mm if icon ‘button_cancel’



806
807
808
809
810
811
812
813
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 806

def listed(node)
  icons=[]
  node.each_element("icon") do |nn|
    icons << nn.attributes["BUILTIN"]
  end

  return !icons.include?("button_cancel")
end

#login? ⇒ Boolean

Returns:

  • (Boolean) 


766
767
768
769
770
771
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 766

def login?
  ## To use remember me cookies then remove
  #session[:user_id] != nil
  current_ma_user != nil
  #cookies[:auth_token] != nil
end

#m_icon(node) ⇒ Object 



796
797
798
799
800
801
802
803
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 796

def m_icon(node)
  mcons=[]
  node.each_element("icon") do |mn|
    mcons << mn.attributes["BUILTIN"]
  end
  ticon = mcons[0].to_s
  return ticon
end

#ma_comment?(s) ⇒ Boolean

Returns:

  • (Boolean) 


218
219
220
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 218

def ma_comment?(s)
  s[0]==35
end

#ma_log(message) ⇒ Object Also known as: ma_notice 



307
308
309
310
311
312
313
314
315
316
317
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 307

def ma_log(message)
  #  Jinda::Notice.create :message => ERB::Util.html_escape(message.gsub("`","'")),
  #    :unread=> true, :ip=> ($ip || request.env["REMOTE_ADDR"])
  if session[:user_id]
    Jinda::Notice.create :message => ERB::Util.html_escape(message.gsub("`","'")),
      :user_id => $user.id, :unread=> true, :ip=>request.env["REMOTE_ADDR"]
  else
    Jinda::Notice.create :message => ERB::Util.html_escape(message.gsub("`","'")),
      :unread=> true, :ip=>request.env["REMOTE_ADDR"]
  end
end

#ma_menu? ⇒ Boolean

Returns:

  • (Boolean) 


821
822
823
824
825
826
827
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 821

def ma_menu?
  icons=[]
  node.each_element("icon") do |mn|
    icons << mn.attributes["BUILTIN"]
  end
  return icons.include?("menu")
end

#ma_secured?(node) ⇒ Boolean

Returns:

  • (Boolean) 


814
815
816
817
818
819
820
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 814

def ma_secured?(node)
  icons=[]
  node.each_element("icon") do |nn|
    icons << nn.attributes["BUILTIN"]
  end
  return icons.include?("password")
end

#make_fields(n) ⇒ Object 



682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 682

def make_fields(n)
  # s= field string used by generate model cli (old style jinda)
  s= ""
  # h= hash :code, :type, :edit, :text
  h= []
  n.each_element('node') do |nn|
    text = nn.attributes['TEXT']
    icon = nn.elements['icon']
    edit= (icon && icon.attribute('BUILTIN').value=="edit")
    next if text.comment? && !edit

    # sometimes freemind puts all fields inside a blank node
    unless text.empty?
      k,v= text.split(/:\s*/,2)
      v ||= 'string'
      v= 'float' if v=~/double/i
      s << " #{name2code(k.strip)}:#{v.strip} "
      h << {:code=>name2code(k.strip), :type=>v.strip, :edit=>edit, :text=>text}
    else
      nn.each_element('node') do |nnn|
        icon = nnn.elements['icon']
        edit1= (icon && icon.attribute('BUILTIN').value=="edit")
        text1 = nnn.attributes['TEXT']
        next if text1 =~ /\#.*/
        k,v= text1.split(/:\s*/,2)
        v ||= 'string'
        v= 'float' if v=~/double/i
        s << " #{name2code(k.strip)}:#{v.strip} "
        h << {:code=>name2code(k.strip), :type=>v.strip, :edit=>edit1, :text=>text1}
      end
    end
  end
  # f
  h
end

#make_folders_absolute(f, tt) ⇒ Object

inspect all nodes that has attached file (2 cases) and replace relative path with absolute path



664
665
666
667
668
669
670
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 664

def make_folders_absolute(f,tt)
  tt.elements.each("//node") do |nn|
    if nn.attributes['LINK']
      nn.attributes['LINK']= File.expand_path(File.dirname(f))+"/#{nn.attributes['LINK']}"
    end
  end
end

#markdown(text) ⇒ Object

methods from application_helper



322
323
324
325
326
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 322

def markdown(text)
  erbified = ERB.new(text.html_safe).result(binding)
  red = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true, :space_after_headers => true)
  red.render(erbified).html_safe
end

#model_exists?(model) ⇒ Boolean

Returns:

  • (Boolean) 


678
679
680
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 678

def model_exists?(model)
  File.exists? "#{Rails.root}/app/models/#{model}.rb"
end

#name2camel(s) ⇒ Object 



262
263
264
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 262

def name2camel(s)
  s.gsub(' ','_').camelcase
end

#name2code(s) ⇒ Object 



257
258
259
260
261
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 257

def name2code(s)
  # rather not ignore # symbol cause it could be comment
  code, name = s.split(':')
  code.downcase.strip.gsub(' ','_').gsub(/[^#_\/a-zA-Z0-9]/,'')
end

#negate(s) ⇒ Object 



864
865
866
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 864

def negate(s)
  return s =~ /[n|no|f|false]/i ? true : false
end

#own_xmain? ⇒ Boolean

cookies != nil

Returns:

  • (Boolean) 


772
773
774
775
776
777
778
779
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 772

def own_xmain?
  if $xmain
    return current_ma_user.id==$xvars['user_id']
  else
    # if eval on first step would return true so user can start service
    return true
  end
end

#process_controllers ⇒ Object 



580
581
582
583
584
585
586
587
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 580

def process_controllers
  process_services
  modules= Jinda::Module.all
  modules.each do |m|
    next if controller_exists?(m.code)
    system("rails generate controller #{m.code}")
  end
end

#process_models ⇒ Object 



589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 589

def process_models

  # app= get_app
  # t= ["process models"]
  #  xml map sample from index.mm 
  #   node @CREATED=1273819432637 @ID=ID_1098419600 @MODIFIED=1334737006485 @TEXT=Jinda 
  #    node @CREATED=1273819462973 @ID=ID_282419531 @MODIFIED=1493705904561 @POSITION=right @TEXT=services 
  #     node @CREATED=1273819465949 @FOLDED=true @ID=ID_855471610 @MODIFIED=1493768913078 @POSITION=right @TEXT=roles 
  #      node @CREATED=1273819456867 @ID=ID_1677010054 @MODIFIED=1493418874718 @POSITION=left @TEXT=models 
  #       node @CREATED=1292122118499 @FOLDED=true @ID=ID_1957754752 @MODIFIED=1493705885123 @TEXT=person 
  #       node @CREATED=1292122236285 @FOLDED=true @ID=ID_959987887 @MODIFIED=1493768919147 @TEXT=address 
  #       node @CREATED=1493418879485 @ID=ID_1995497233 @MODIFIED=1493718770637 @TEXT=article 
  #       node @CREATED=1493418915637 @ID=ID_429078131 @MODIFIED=1493418930081 @TEXT=comment 

  models= @app.elements["//node[@TEXT='models']"] || REXML::Document.new
  models.each_element('node') do |model|
    # t << "= "+model.attributes["TEXT"]
    model_name= model.attributes["TEXT"]
    next if model_name.comment?
    model_code= name2code(model_name)
    model_file= "#{Rails.root}/app/models/#{model_code}.rb"

    if File.exists?(model_file)
      doc= File.read(model_file)
    else
      system("rails generate model #{model_code}")
      doc= File.read(model_file)
    end

    doc = add_utf8(doc)
    attr_hash= make_fields(model)
    doc = add_jinda(doc, attr_hash)
    # t << "modified:   #{model_file}"
    File.open(model_file, "w") do |f|
      f.puts doc
    end

  end

  # puts t.join("\n")
end

#process_services ⇒ Object

##########################################################################

Create / Update Modules, Runseqs, Services from XML

##########################################################################



404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 404

def process_services
  # todo: persist mm_md5
  xml= @app||get_app
  if defined? session
    md5= Digest::MD5.hexdigest(xml.to_s)
    if session[:mm_md5]
      return if session[:mm_md5]==md5
    else
      session[:mm_md5]= md5
    end
  end
  protected_services = []
  protected_modules = []
  mseq= 0
  @services= xml.elements["//node[@TEXT='services']"] || REXML::Document.new
  @services.each_element('node') do |m|
    # get icon for service menu
    ss= m.attributes["TEXT"]
    code, name= ss.split(':', 2)
    next if code.blank?
    next if code.comment?
    module_code= code.to_code
    menu_icon = m_icon(m)

    # ##########################################################################
    # First Node eg: Module Name 
    # ##########################################################################
    # create or update to GmaModule
    ma_module= Jinda::Module.find_or_create_by :code=>module_code
    ma_module.update_attributes :uid=>ma_module.id.to_s, :icon=>menu_icon
    protected_modules << ma_module.uid
    name = module_code if name.blank?
    ma_module.update_attributes :name=> name.strip, :seq=> mseq
    mseq += 1
    seq= 0

    # ##########################################################################
    # Second Nodes eg: Role, Link otherwise Services
    # ##########################################################################
    m.each_element('node') do |s|
      service_name= s.attributes["TEXT"].to_s
      scode, sname= service_name.split(':', 2)
      sname ||= scode; sname.strip!
      scode= scode.to_code
      if scode=="role"
        ma_module.update_attribute :role, sname
        next
      end
      if scode.downcase=="link"
        role= get_option_xml("role", s) || ""
        rule= get_option_xml("rule", s) || ""
        ma_service= Jinda::Service.find_or_create_by :module_code=> ma_module.code, :code=> scode, :name=> sname
        ma_service.update_attributes :xml=>s.to_s, :name=>sname,
          :list=>listed(s), :ma_secured=>ma_secured?(s),
          :module_id=>ma_module.id, :seq => seq,
          :confirm=> get_option_xml("confirm", xml),
          :role => role, :rule => rule, :uid=> ma_service.id.to_s
        seq += 1
        protected_services << ma_service.uid
      else

        # ##########################################################################
        # Second and Third Nodes eg: Role, Normal Services
        # ##########################################################################
        # normal service
        step1 = s.elements['node']
        role= get_option_xml("role", step1) || ""
        rule= get_option_xml("rule", step1) || ""
        ma_service= Jinda::Service.find_or_create_by :module_code=> ma_module.code, :code=> scode
        ma_service.update_attributes :xml=>s.to_s, :name=>sname,
          :list=>listed(s), :ma_secured=>ma_secured?(s),
          :module_id=>ma_module.id, :seq => seq,
          :confirm=> get_option_xml("confirm", xml),
          :role => role, :rule => rule, :uid=> ma_service.id.to_s
        seq += 1
        protected_services << ma_service.uid
      end
    end
  end
  Jinda::Module.not_in(:uid=>protected_modules).delete_all
  Jinda::Service.not_in(:uid=>protected_services).delete_all
end

#read_binary(path) ⇒ Object

def refresh_to

respond_to do |format|
  format.js { render :js => "refresh();" }
end

end



196
197
198
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 196

def read_binary(path)
  File.open path, "rb" do |f| f.read end
end

#redirect_to_root ⇒ Object 



199
200
201
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 199

def redirect_to_root
  redirect_to root_path
end

#refresh_to(url = '/', option = {}) ⇒ Object 



179
180
181
182
183
184
185
186
187
188
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 179

def refresh_to(url='/', option={})
  if option[:alert]
    ma_log option[:alert]
  end
  # skip # 
  # Rails 5.2 not allow to use js inline call
  render inline: "<script>window.location.replace('#{url}')</script>"
  # redirect_to url
  # render js: "window.location.replace(\'#{url}\')" 
end

#role_name(code) ⇒ Object 



346
347
348
349
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 346

def role_name(code)
  role= Jinda::Role.where(code:code).first
  return role ? role.name : ""
end

#set_global ⇒ Object 



268
269
270
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 268

def set_global
  $xmain= @xmain ; $runseq = @runseq ; $user = current_ma_user ; $xvars= @xmain.xvars; $ip = request.env["REMOTE_ADDR"]
end

#sign_in? ⇒ Boolean

Returns:

  • (Boolean) 


229
230
231
232
233
234
235
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 229

def sign_in?
  if current_ma_user.present?
    return true
  else
    return false
  end
end

#status_icon(status) ⇒ Object 



330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 330

def status_icon(status)
  case status
  when 'R'
    image_tag 'user.png'
  when 'F'
    image_tag 'tick.png'
  when 'I'
    image_tag 'control_play.png'
  when 'E'
    image_tag 'logout.png'
  when 'X'
    image_tag 'cross.png'
  else
    image_tag 'cancel.png'
  end
end

#step(s, total) ⇒ Object

square text



359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 359

def step(s, total) # square text
  s = (s==0)? 1: s.to_i
  total = total.to_i
  out ="<div class='step'>"
  (s-1).times {|ss| out += "<span class='steps_done'>#{(ss+1)}</span>" }
  out += %Q@<span class='step_now' >@
  out += s.to_s
  out += "</span>"
  out += %Q@@
  for i in s+1..total
    out += "<span class='steps_more'>#{i}</span>"
  end
  out += "</div>"
  out.html_safe
end

#true_action?(s) ⇒ Boolean

Returns:

  • (Boolean) 


265
266
267
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 265

def true_action?(s)
  %w(call ws redirect invoke email).include? s
end

#ui_action?(s) ⇒ Boolean

Returns:

  • (Boolean) 


386
387
388
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 386

def ui_action?(s)
  %w(form output mail pdf).include? s
end

#uncomment(s) ⇒ Object 



350
351
352
 
# File 'app/helpers/jinda_engine/jinda_helper.rb', line 350

def uncomment(s)
  s.sub(/^#\s/,'')
end