gestion 1.9.12

data/Views/Cashbox/Activity.rb

@@ -0,0 +1,191 @@
+class CashboxActivity < View
+  include PrintButton
+
+  def layout
+    @update = true
+    @order = 15
+
+    @functions_need = [:activities]
+
+    gui_hboxg do
+      gui_vboxg :nogroup do
+        show_entity_activity_all :activities, :single, :name, :flexheight => 1, :width => 200,
+                                 :callback => true
+        show_block_ro :show
+      end
+      gui_vboxg :nogroup do
+        gui_vboxg :nogroup do
+          show_entity_person :students, :single, :full_name,
+                             :flexheight => 1, :callback => true, :width => 300
+          show_str :full_name
+          show_button :search_student, :new_student, :signed_up_students
+          # show_print :print_activity
+        end
+      end
+      gui_vboxg :nogroup do
+        gui_vbox :nogroup do
+          show_table :table_activities, :headings => %w( Start End )
+          show_date :date_start
+        end
+        show_button :pay_act, :delete
+      end
+
+      gui_window :printing do
+        show_html :msg_print
+        show_int_hidden :step
+        show_button :print_next, :close
+      end
+    end
+  end
+
+  def rpc_update(session)
+    # reply_print(session) +
+    reply(:update, :date_start => Date.today.to_web)
+  end
+
+  def rpc_button_pay_act(session, data)
+    return unless (data._activities and data._students)
+    # dp data._students
+    ActivityPayments.pay(data._activities, data._students, session.owner,
+                         Date.from_web(data._date_start))
+    reply(:window_hide) +
+        rpc_list_choice_students(session, data)
+  end
+
+  def rpc_button_delete(session, data)
+    return unless (data._activities and data._students and
+        data._table_activities.length == 1)
+
+    act = ActivityPayments.match_by_activitypayment_id(data._table_activities.first)
+    if act.movement.account_src == act.person_cashed.account_due
+      act.movement.delete
+      act.delete
+      rpc_list_choice_students(session, data)
+    else
+      reply(:window_show, :printing)+
+          reply(:update, :msg_print => 'Ce mouvement est déjà comptabilisé')
+    end
+  end
+
+  def rpc_button_signed_up_students(session, data)
+    reply(:empty, :students) +
+        reply(:update, :students =>
+                         ActivityPayments.search_by_activity(data._activities).collect { |ap|
+                           ap.person_paid and ap.person_paid.to_list_id(session.owner)
+                         }.compact.sort_by { |i| i[1] })
+  end
+
+  def rpc_button_new_student(session, data)
+    return unless (data._full_name || data._full_name.to_s.length > 0)
+    student = Persons.create({first_name: data._full_name})
+    student.permissions = %w(student internet)
+    data._full_name = student.login_name
+    rpc_button_search_student(session, data) +
+        reply(:update, students: [student.person_id])
+  end
+
+  def rpc_button_search_student(session, data)
+    return unless (data._full_name || data._full_name.to_s.length > 0)
+    reply(:empty_update, students: Persons.search_in(data._full_name).
+                           collect { |p| p.to_list_id(session.owner) })
+  end
+
+  def rpc_list_choice_activities(session, data)
+    reply(:empty_nonlists_update, data._activities.to_hash) +
+        rpc_button_signed_up_students(session, data)
+  end
+
+  def rpc_list_choice_students(session, data)
+    return reply(:empty, %w(full_name table_activities)) unless data._students
+
+    act_table = ActivityPayments.for_user(data._students).collect { |act|
+      [act.activitypayment_id, [act.date_start, act.date_end]]
+    }.sort { |a, b| a[1] <=> b[1] }.reverse
+    reply(:empty_update, :table_activities => act_table) +
+        reply(:update, :date_start => Date.today.to_web)
+  end
+
+  def rpc_button_print_activity_steps(session, data)
+    ret = reply(:callback_button, :print_activity_steps)
+    var = session.s_data._print_activity
+    dputs(3) { "Doing with data #{var.inspect} step is #{var._step.inspect}" }
+    case var._step
+      when 1
+        dputs(3) { 'Showing prepare-window' }
+        var._students = var._activities.collect { |a| a.person_paid.login_name }
+        ret += reply(:window_show, :printing) +
+            reply(:update, :msg_print => 'Preparing students: <br><br>' +
+                             var._students.each_slice(5).collect { |s| s.join(', ') }.
+                                 join(',<br>')) +
+            reply(:hide, :print_next)
+      when 2
+        dputs(3) { 'Printing pdfs' }
+        files = var._activities.collect { |act| act.print }
+        var._pages = OpenPrint.pdf_nup_duplex(files, 'activity_cards')
+        cmd = cmd_printer(session, :print_activity)
+        dputs(3) { "Command is #{cmd} with pages #{var._pages.inspect}" }
+        if not cmd
+          ret = reply(:window_show, :printing) +
+              reply(:update, :msg_print => 'Click on one of the links:<ul>' +
+                               var._pages.collect { |r| "<li><a target='other' href=\"#{r}\">#{r}</a></li>" }.join('') +
+                               '</ul>')
+          var._step = 9
+        elsif var._pages.length > 0
+          ret = reply(:window_show, :printing) +
+              reply(:update, :msg_print => 'Impression de la page face en cours pour<ul>' +
+                               "<li>#{var._students.join('</li><li>')}</li></ul>" +
+                               "<br>Cliquez sur 'suivant' pour imprimer les pages arrières") +
+              reply(:unhide, :print_next)
+          cmd += " #{var._pages[0]}"
+          dputs(3) { "Printing-cmd is #{cmd.inspect}" }
+          System.run_bool(cmd)
+        else
+          var._step = 9
+        end
+      when 3
+        cmd = cmd_printer(session, :print_activity)
+        dputs(3) { "Command is #{cmd} with pages #{var._pages.inspect}" }
+        ret = reply(:window_show, :printing) +
+            reply(:update, :msg_print => 'Impression de la page face arrière en cours<ul>' +
+                             "<li>#{var._students.join('</li><li>')}</li></ul>") +
+            reply(:hide, :print_next)
+        cmd += " -o outputorder=reverse #{var._pages[1]}"
+        dputs(3) { "Printing-cmd is #{cmd.inspect}" }
+        System.run_bool(cmd)
+      when 4..10
+        dputs(3) { 'Hiding' }
+        ret = reply(:window_hide)
+      else
+        dputs(3) { "Oups - step is #{var._step.inspect}" }
+    end
+
+    var._step += 1
+    session.s_data[:print_activity] = var
+    dputs(3) { "Ret is #{ret.inspect}" }
+    return ret
+  end
+
+  def rpc_button_print_activity(session, data)
+    # dp "removed"
+    return nil
+    return unless data._students.length >= 1
+    acts = data._students.collect { |s|
+      if data._table_activities.length == 0
+        ActivityPayments.for_user(s).sort { |a, b| a.date_start <=> b.date_start }.
+            reverse.first
+      else
+        ActivityPayments.match_by_activitypayment_id(data._table_activities.first)
+      end
+    }
+
+    ret = rpc_print(session, :print_activity, data)
+    session.s_data._print_activity = {step: 1, activities: acts}
+    return ret + rpc_button_print_activity_steps(session, data)
+  end
+
+  def rpc_button_print_next(session, data)
+    rpc_button_print_activity_steps(session, data)
+  end
+
+end
+

data/Views/Cashbox/Course.rb

@@ -0,0 +1,141 @@
+# Allows for adding cash to a specific course
+
+class CashboxCourse < View
+  def layout
+    @order = 10
+    @update = true
+    @functions_need = [:cashbox, :accounting_courses]
+
+    gui_hboxg do
+      gui_vbox :nogroup do
+        show_entity_course :courses, :single, :name,
+                           :flexheight => 1, :callback => true, :width => 100
+      end
+      gui_vbox :nogroup do
+        show_entity_person :students, :single, :full_name,
+                           :flexheight => 1, :callback => true, :width => 300
+        show_str :full_name
+        show_button :add_student
+      end
+      gui_vbox :nogroup do
+        show_table :payments, :headings => [:Date, :Money, :Rest],
+                   :widths => [100, 75, 75], :height => 200,
+                   :columns => [0, :align_right, :align_right]
+        show_date :payment_date
+        show_int :cash
+        show_str :remark
+        show_str :receit_id
+        show_list_drop :old_cash, '%w( No Yes )'
+        show_button :pay, :delete, :move
+      end
+
+      gui_window :error do
+        show_html :msg
+        show_button :close
+      end
+
+      gui_window :win_move do
+        show_entity_person :move_students, :drop, :full_name, :width => 300
+        show_button :close, :do_move
+      end
+    end
+
+    @date_pay = Date.today
+  end
+
+  def rpc_list_choice_courses(session, data)
+    reply(:empty_nonlists, :students) +
+        reply(:update, :students => data._courses.list_students(true))
+  end
+
+  def rpc_list_choice_students(session, data)
+    reply(:empty, %w(cash remark receit_id)) +
+        reply(:update, :payment_date => @date_pay.strftime('%d.%m.%Y')) +
+        reply(:update, :payments =>
+                         data._courses.student_payments(data._students.login_name))
+  end
+
+  def rpc_button_pay(session, data)
+    if data._payment_date
+      @date_pay = Date.parse(data._payment_date)
+    end
+
+    [[session.owner.account_due, "No account for #{session.owner.full_name}"],
+     [data._courses != [], 'Chose a course first'],
+     [data._students != [], 'Chose a student first'],
+     [data._courses.entries != [], 'Course has no account attached'],
+     [data._cash.to_i != 0, 'Enter an amount']].each { |t, msg|
+      dputs(3) { "Testing #{t.inspect} - #{msg}" }
+      t or return reply(:window_show, :error) +
+          reply(:update, :msg => msg)
+    }
+
+    dputs(3) { "Data is #{data.inspect}" }
+    if data._cash.to_i != 0
+      data._courses.payment(session.owner, data._students, data._cash, @date_pay,
+                            session.owner.has_permission?(:admin) && data._old_cash.first == 'Yes',
+                            remark: data._remark)
+    end
+    rpc_list_choice_students(session, data)
+  end
+
+  def rpc_button_add_student(session, data)
+    if (name = data._full_name).to_s.length > 0 &&
+        (course = data._courses)
+      Persons.create_add_course(data._full_name, session.owner, course)
+      rpc_list_choice_courses(session, data)
+    end
+  end
+
+  def rpc_button_move(session, data)
+    if data._students && data._courses
+      reply(:empty, :move_students) +
+          reply(:window_show, :win_move) +
+          reply(:update, :move_students => data._courses.list_students(true))
+    end
+  end
+
+  def rpc_button_do_move(session, data)
+    if (src = data._students) &&
+        (dst = data._move_students) &&
+        src != dst &&
+        data._courses
+      dputs(3) { "Moving student #{src.inspect}, #{dst.inspect}" }
+      data._courses.move_payment(src.login_name, dst.login_name)
+    end
+    reply(:window_hide) +
+        rpc_list_choice_students(session, data)
+  end
+
+  def rpc_update(session)
+    if owner = session.owner
+      reply_visible(owner.has_permission?(:admin), :old_cash)
+    else
+      []
+    end +
+        reply(:empty_nonlists, :students) +
+        reply(:empty_nonlists, :courses) +
+        reply(:update, :courses => Courses.list_courses_entries)
+  end
+
+  def rpc_button_delete(session, data)
+    if (gid = data._payments.first).to_s.length > 0
+      if mov = Movements.match_by_global_id(gid)
+        log_msg 'cashbox_course', "Deleting movement #{mov.inspect}"
+        date, value = mov.date, mov.value
+        mov.delete
+        user, id = gid.match(/(.*)-(.*)/)[1..2]
+        ngid = [user, (id.to_i + 1).to_s].join("-")
+        # If the next movement starts with "old_cash" and has same date
+        # and value, we suppose they go together
+        if mov = Movements.match_by_global_id(ngid) and
+            mov.desc =~ /^old_cash/ and mov.date == date and
+            mov.value == value
+          log_msg 'cashbox_course', "Found old_cash at #{mov.inspect}"
+          mov.delete
+        end
+        rpc_list_choice_students(session, data)
+      end
+    end
+  end
+end

data/Views/Cashbox/Credit.rb

@@ -0,0 +1,79 @@
+=begin
+This module allows for charging the internet-credit of a person. You can also
+add a new person
+=end
+
+class CashboxCredit < View
+  def layout
+    set_data_class :Persons
+    @order = 30
+    @update = true
+    @functions_need = [:internet, :internet_cyber]
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        show_str :search
+        show_entity_person :person, :single, :login_name, :callback => true
+        show_button :search_person, :add_person
+      end
+
+      gui_vbox :nogroup do
+        show_int :credit_add
+        show_str_ro :login_name
+        show_str_ro :full_name
+        show_int_ro :internet_credit
+        show_button :add_credit
+      end
+
+      gui_window :win_add do
+        show_str :full_name
+        show_button :win_add_person, :close
+      end
+
+    end
+  end
+
+  def rpc_button_add_person(session, data)
+    reply(:window_show, :win_add) +
+        reply(:empty, :full_name)
+  end
+
+  def rpc_button_win_add_person(session, data)
+    ret = reply(:window_hide)
+    person = if data._full_name.to_s.length > 0
+               Persons.create(complete_name: data._full_name)
+             end
+    person.permissions = %w(default internet)
+    ret + (person ? rpc_button_search_person(session, search: person.login_name) : [])
+  end
+
+  def rpc_button_search_person(session, data)
+    return reply(:empty, :person) unless data._search.length > 2
+    results = Persons.search_in(data._search, 20)
+    reply(:empty_update, :person => results.collect { |r| r.to_list_id(session.owner) } +
+                           [results.first.person_id])
+  end
+
+  def rpc_button_add_credit(session, data)
+    dputs(3) { "Adding credit #{data.inspect}" }
+    rep = []
+    if person = Persons.add_internet_credit(session, data)
+      rep = reply(:update, :credit_add => '') +
+          reply(:update, :internet_credit => person.internet_credit)
+    end
+    rep + rpc_update(session)
+  end
+
+  def rpc_update(session)
+    super(session) +
+        reply(:parent, reply(:focus, :search))
+  end
+
+  def rpc_list_choice_person(session, data)
+    dputs(2) { "Got data: #{data.inspect}" }
+    if data._person
+      reply(:empty_update, data._person) +
+          reply(:focus, :credit_add)
+    end
+  end
+end

data/Views/Cashbox/Report.rb

@@ -0,0 +1,115 @@
+# Allows for adding cash to a specific course
+
+class CashboxReport < View
+  include PrintButton
+  
+  def layout
+    @order = 30
+    @update = true
+    @functions_need = [:cashbox]
+    
+    gui_hbox do
+      gui_vbox :nogroup do
+        show_list_single :report_type, :callback => true, :maxheight => 160
+        show_date :report_start, :callback => :date
+        show_entity_course :course, :single, :name, 
+          lambda{|c| c.entries}, :callback => true, :flexheight => 1
+        show_print :print
+      end
+      gui_vbox :nogroup do
+        show_table :report, :headings => [ :Date, :Desc, :Amount, :Sum ],
+          :widths => [ 100, 200, 75, 75 ], :height => 400, :width => 470,
+          :columns => [0, 0, :align_right, :align_right]
+        show_button :delete
+      end
+      
+      gui_window :print_status do
+        gui_vbox :nogroup do
+          show_html :status
+          show_button :close
+        end
+      end
+    end
+  end
+  
+  def rpc_show( session )
+    super( session )
+  end
+  
+  def rpc_update( session )
+    super( session ) +
+      reply( :empty_nonlists, [ :course, :report_type ] ) +
+      reply( :update, :report_type => 
+        %w( Course Due_Daily Due_All Paid_All ).
+        map.with_index{|d,i|
+        [ i + 1, d ]} ) +
+      reply( :update, :course => Courses.list_courses_entries(session) ) +
+      reply( :hide, [:report_start, :course ] ) +
+      reply( :update, :report_start => Date.today.strftime( "%d.%m.%Y") ) +
+      reply_visible( session.owner.has_permission?( :accounting ), :delete ) +
+      reply_print( session )
+  end
+  
+  def rpc_button_print( session, data )
+    ret = rpc_print( session, :print, data )
+    if data._report_type == []
+      return ret
+    end
+    date = Date.parse( data._report_start )
+    
+    if ( report = data._report_type.first ) > 1
+      file = session.owner.report_pdf( 
+        [ :daily, :all, :all_paid ][report - 2], date )
+    else
+      file = data._course.report_pdf
+    end
+    
+    if printer = send_printer( session, :print, file )
+      ret + reply( :window_show, :print_status ) +
+        reply( :update, :status => "Printed to #{printer}")
+    else
+      ret + reply( :window_show, :print_status ) +
+        reply( :update, :status => "<a href='#{file}' target='other'>#{file}</a>")
+    end
+  end
+  
+  def rpc_list_choice_report_type( session, data )
+    dputs(3){"report is #{data._report_start.inspect}"}
+    date = Date.parse( data._report_start.to_s )
+    ret = reply( :empty, :report )
+    
+    case report = data._report_type.first
+    when 1
+      if data._course != []
+        ret += reply( :update, :report => data._course.report_list )
+      end
+      show = :course
+    when 2..4
+      ret += reply( :update, :report => 
+          session.owner.report_list(
+          [ :daily, :all, :all_paid ][report - 2], date ) )
+      show = :report_start
+    end
+    
+    ret + reply( :unhide, show ) +
+      reply( :hide, show == :report_start ? :course : :report_start )
+  end
+  
+  def rpc_list_choice_course( session, data )
+    rpc_list_choice_report_type( session, data )
+  end
+  
+  def rpc_callback_date( session, data )
+    rpc_list_choice_report_type( session, data )
+  end
+  
+  def rpc_button_delete( session, data )
+    if ( gid = data._report.first ).to_s.length > 0
+      if mov = Movements.match_by_global_id( gid )
+        log_msg "cashbox_report", "Deleting movement #{mov.inspect}"
+        mov.delete
+        rpc_list_choice_report_type( session, data )
+      end
+    end
+  end
+end

data/Views/Cashbox/Service.rb

@@ -0,0 +1,105 @@
+class CashboxService < View
+  def layout
+    set_data_class :Persons
+    @update = true
+    @order = 20
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        gui_vbox :nogroup do
+          show_int :copies_intern, :callback => :calc
+          show_int :copies_extern, :callback => :calc
+          #show_int :heures_groupe_petit, :callback => :calc
+          show_int :heures_groupe_grand, :callback => :calc
+          show_int :CDs, :callback => :calc
+        end
+        gui_vbox :nogroup do
+          show_str :autres_text, :width => 200
+          show_int :autres_cfa, :callback => :calc
+        end
+        gui_vbox :nogroup do
+          show_int :services_total
+        end
+        show_date :date
+        show_button :add_cash
+      end
+      gui_vbox :nogroup do
+        gui_vbox :nogroup do
+          show_int_ro :account_total_due
+        end
+        gui_vbox :nogroup do
+          show_table :report, :headings => [:Date, :Desc, :Amount, :Sum],
+                     :widths => [100, 300, 75, 75], :height => 400,
+                     :columns => [0, 0, :align_right, :align_right]
+        end
+      end
+    end
+  end
+
+  def calc_total(values)
+    dputs(5) { "#{values.inspect}" }
+    services_total = 0
+    values.each { |k, v|
+      dputs(5) { "Searching for #{k}: #{v}" }
+      case k
+        when 'copies_intern'
+          services_total += v.to_i * 50
+        when 'copies_extern'
+          services_total += v.to_i * 100
+        when 'heures_groupe_grand'
+          services_total += v.to_f * 2500
+        when 'CDs'
+          services_total += v.to_i * 500
+        when 'autres_cfa'
+          services_total += v.to_i
+      end
+    }
+    services_total
+  end
+
+  def cash_msg(data)
+    '{' +
+        %w( copies_intern copies_extern heures_groupe_grand CDs autres_text ).select { |c|
+          data[c].to_s.length > 0
+        }.collect { |k|
+          "\"#{k}\"=>\"#{data[k]}\""
+        }.join(", ") +
+        '}'
+  end
+
+  # Adds the cash to the destination account, and puts the same amount into
+  # the AfriCompta-framework
+  def rpc_button_add_cash(session, data)
+    dputs(5) { "data is #{data.inspect}" }
+    services_total = calc_total(data)
+    dputs(5) { "which amounts to #{services_total} CFA" }
+    actor = session.owner
+    data.delete('services_total')
+    data.delete('account_total_due')
+    actor.pay_service(services_total, cash_msg(data),
+                      data._date)
+    reply(:empty_nonlists) + rpc_update(session)
+  end
+
+  def rpc_update(session)
+    dputs(3) { 'Fetching total' }
+    ret = reply(:update, :account_total_due => session.owner.account_total_due)
+    dputs(3) { 'Updating time' }
+    ret += reply(:update, :date => Date.today.strftime('%d.%m.%Y'))
+    dputs(3) { 'Getting report_list' }
+    ret += reply(:update, :report => session.owner.report_list(:all))
+    dputs(3) { 'Done' }
+    ret
+  end
+
+  def rpc_update_with_values(session, values = nil)
+    dputs(3) { "Got values: #{values.inspect}" }
+    reply(:update, :services_total => calc_total(values))
+  end
+
+  def rpc_callback(session, name, data)
+    rpc_update_with_values(session, data)
+  end
+
+end
+

data/Views/Cashbox/Tabs.rb

@@ -0,0 +1,10 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class CashboxTabs < View
+  def layout
+    @order = 90
+    @functions_need = [:cashbox]
+  end
+  
+end

data/Views/Compta/Accounts.rb

@@ -0,0 +1,36 @@
+class ComptaDefaults < View
+  def layout
+    @order = 300
+    @update = true
+    set_data_class(:ConfigBases)
+    @functions_need = [:accounting]
+
+    gui_vbox do
+      gui_hboxg :nogroup do
+        show_block :accounts
+        show_arg :account_cash, :width => 400
+      end
+      show_button :save
+    end
+  end
+
+  def rpc_update(session)
+    accounts_current = []
+    AccountRoot.current.get_tree_depth { |a|
+      accounts_current.push [a.id, a.get_path]
+    }
+    reply(:empty_nonlists) +
+        reply(:update, ConfigBases.get_block_fields(:accounts).collect { |acc|
+                       [acc, accounts_current]
+                     }.to_h) +
+        update_form_data(ConfigBases.singleton)
+
+  end
+
+  def rpc_button_save(session, data)
+    ConfigBase.store(data.to_sym)
+    dputs(3) { "Configuration is now #{ConfigBase.get_functions.inspect}" }
+
+    rpc_update(session)
+  end
+end