marty 2.5.2 → 2.5.4

data/app/models/marty/tag.rb

@@ -4,10 +4,10 @@ class Marty::Tag < Marty::Base
   mcfly_validates_uniqueness_of :name
   validates_presence_of :name, :comment
 
-  belongs_to :user, class_name: "Marty::User"
+  belongs_to :user, class_name: 'Marty::User'
 
   def self.get_struct_attrs
-    self.struct_attrs ||= super + ["id", "created_dt"]
+    self.struct_attrs ||= super + ['id', 'created_dt']
   end
 
   def self.make_name(dt)
@@ -23,7 +23,7 @@ class Marty::Tag < Marty::Base
 
   before_validation :set_tag_name
   def set_tag_name
-    self.name = self.class.make_name(self.created_dt)
+    self.name = self.class.make_name(created_dt)
     true
   end
 
@@ -60,21 +60,21 @@ class Marty::Tag < Marty::Base
       tag = tag_id
     end
     raise "bad tag identifier #{tag_id.inspect}" unless tag.is_a?(Marty::Tag)
+
     tag
   end
 
-  cached_delorean_fn :lookup, sig: 1 do
-    |name|
-    t = self.find_by_name(name).select(get_struct_attrs)
+  cached_delorean_fn :lookup, sig: 1 do |name|
+    t = find_by_name(name).select(get_struct_attrs)
     t && t.attributes
   end
 
   def self.get_latest1
-    order("created_dt DESC").find_by("created_dt <> 'infinity'")
+    order('created_dt DESC').find_by("created_dt <> 'infinity'")
   end
 
   def self.find_match(dt)
-    order("created_dt DESC").find_by("created_dt <= ?", dt)
+    order('created_dt DESC').find_by('created_dt <= ?', dt)
   end
 
   # Performance hack for script sets -- FIXME: making find_mtach

data/app/models/marty/token.rb

@@ -15,7 +15,8 @@ class Marty::Token < Marty::Base
   #   return Time.now > self.created_on + @@validity_time
   # end
 
-private
+  private
+
   def self.generate_token_value
     SecureRandom.hex(20)
   end
@@ -26,5 +27,4 @@ private
       Token.delete_all(['user_id = ?', user.id])
     end
   end
-
 end

data/app/models/marty/user.rb

@@ -58,9 +58,9 @@ class Marty::User < Marty::Base
 
     auth_source = cf.auth_source.to_s
 
-    if auth_source == "local"
+    if auth_source == 'local'
       ok = password == cf.local_password
-    elsif auth_source == "ldap"
+    elsif auth_source == 'ldap'
       # IMPORTANT NOTE: if server allows anonymous LDAP access, empty
       # passwords will succeed!  i.e. if a valid user with empty
       # password is sent in, ldap.bind will return OK.
@@ -71,7 +71,7 @@ class Marty::User < Marty::Base
                            encryption: cf.encryption,
                            auth: {
                              method: :simple,
-                             username: cf.domain + "\\" + login,
+                             username: cf.domain + '\\' + login,
                              password: password,
                            })
       ok = ldap.bind
@@ -90,12 +90,13 @@ class Marty::User < Marty::Base
     Mcfly.whodunnit
   end
 
- def self.has_role(role)
-    mr = Mcfly.whodunnit.roles rescue []
-    mr.any? {|attr| attr.name == role}
- end
+  def self.has_role(role)
+     mr = Mcfly.whodunnit.roles rescue []
+     mr.any? { |attr| attr.name == role }
+  end
+
+  private
 
-private
   def verify_changes
     # If current users role is only user_manager, restrict following
     # 1 - Do not allow user to edit own record
@@ -105,37 +106,37 @@ private
         Rails.configuration.marty.system_account.to_s)
       system_id = system_user.id if system_user
 
-      if self.id == Mcfly.whodunnit.id
-        roles.each {|r| roles.delete r unless r.name == "user_manager"}
-        errors.add :base, "User Managers cannot edit "\
-          "or add additional roles to their own accounts"
-      elsif self.id == system_id
+      if id == Mcfly.whodunnit.id
+        roles.each { |r| roles.delete r unless r.name == 'user_manager' }
+        errors.add :base, 'User Managers cannot edit '\
+          'or add additional roles to their own accounts'
+      elsif id == system_id
         errors.add :base,
-        "User Managers cannot edit the application system account"
+                   'User Managers cannot edit the application system account'
       end
     end
 
-    errors.add :base, "The application system account cannot be deactivated" if
-      self.login == Rails.configuration.marty.system_account.to_s &&
-      !self.active
+    errors.add :base, 'The application system account cannot be deactivated' if
+      login == Rails.configuration.marty.system_account.to_s &&
+      !active
 
     errors.blank?
   end
 
   def user_manager_only
-    Marty::User.has_role("user_manager") && !Marty::User.has_role("admin")
+    Marty::User.has_role('user_manager') && !Marty::User.has_role('admin')
   end
 
   def destroy_user
-    errors.add :base, "You cannot delete your own account" if
-      self.login == Mcfly.whodunnit.login
+    errors.add :base, 'You cannot delete your own account' if
+      login == Mcfly.whodunnit.login
 
-    errors.add :base, "You cannot delete the system account" if
-      self.login == Rails.configuration.marty.system_account.to_s
+    errors.add :base, 'You cannot delete the system account' if
+      login == Rails.configuration.marty.system_account.to_s
     # Default to disallowing any deletions for now
 
     errors.add :base,
-    "Users cannot be deleted - set 'Active' to false to disable the account"
+               "Users cannot be deleted - set 'Active' to false to disable the account"
 
     throw :abort unless errors.blank?
   end

data/app/models/marty/vw_promise.rb

@@ -1,12 +1,11 @@
 class Marty::VwPromise < Marty::Base
-
   has_many :children,
            foreign_key: 'parent_id',
-           class_name: "Marty::VwPromise",
+           class_name: 'Marty::VwPromise',
            dependent: :destroy
 
-  belongs_to :parent, class_name: "Marty::VwPromise"
-  belongs_to :user, class_name: "Marty::User"
+  belongs_to :parent, class_name: 'Marty::VwPromise'
+  belongs_to :user, class_name: 'Marty::User'
 
   self.table_name = 'marty_vw_promises'
   self.primary_key = 'id'
@@ -54,19 +53,19 @@ class Marty::VwPromise < Marty::Base
 
   # Support UI live search -- FIXME: hacky to have UI scoping here
   scope :live_search, lambda { |search_text|
-    return if !search_text || search_text.strip.length < 1
+    return if !search_text || search_text.strip.empty?
 
     # Searches user login/firstname/lastname
     query = [
-             "marty_users.login ILIKE ?",
-             "marty_users.firstname ILIKE ?",
-             "marty_users.lastname ILIKE ?",
-             "marty_roles.name ILIKE ?",
-            ].join(' OR ')
+      'marty_users.login ILIKE ?',
+      'marty_users.firstname ILIKE ?',
+      'marty_users.lastname ILIKE ?',
+      'marty_roles.name ILIKE ?',
+    ].join(' OR ')
 
     st = "%#{search_text}%"
     # Convert "Role Name" or "Role name" to "role_name" (underscore is key)
     st2 = "%#{search_text.titleize.gsub(/\s/, '').underscore}%"
-    joins({:user => :roles}).where(query, st, st, st, st2).distinct
+    joins(:user => :roles).where(query, st, st, st, st2).distinct
   }
 end

data/config/routes.rb

@@ -3,8 +3,8 @@ Rails.application.routes.draw do
 end
 
 Marty::Engine.routes.draw do
-  match via: [:get, :post], "rpc/evaluate(.:format)" => "rpc", as: :rpc
-  match via: [:get, :post], "report(.:format)" => "report#index", as: :report
+  match via: [:get, :post], 'rpc/evaluate(.:format)' => 'rpc', as: :rpc
+  match via: [:get, :post], 'report(.:format)' => 'report#index', as: :report
   get  'job/download' => 'job', as: :job
   post 'delayed_job/trigger' => 'delayed_job#trigger', as: :trigger_delayed_job
   get  'diag', to: 'diagnostic/#op'

data/delorean/blame_report.dl

@@ -0,0 +1,268 @@
+import MartyFields
+import Styles
+
+PostingField2: MartyFields::PostingField2
+    store = [ ["NOW", "NOW"] ] + [ [ lp.name, lp.name + ' (' + lp.comment + ')']
+                       for lp in Marty::Posting.get_latest_by_type(
+                         20, ['BASE', 'INTRA', 'CLOSE'])]
+
+StyleRow:
+    profile     =?
+    obj         = profile["obj"]
+    status      = profile["status"]
+    attrs       = profile["attrs"]
+    user_name   = Marty::DataChange.user_name(obj.user_id)
+    delete      = profile["deleted"]
+    create      = status == "new"
+
+    o_user_name = if delete then Marty::DataChange.user_name(obj.o_user_id)
+                  else ""
+    o_dt        = if delete then obj.obsoleted_dt.to_s else ""
+    del_style   = if delete then Styles::Style.bg_redish else {}
+    mod_style   = Styles::Style.bg_tan
+    new_style   = if create then Styles::Style.bg_lightgreen else {}
+
+    b_style     = Styles::Style.calibri + new_style
+    b_c_style   = b_style + mod_style
+    m_style     = b_style + Styles::Style.bg_lightgray + del_style
+    m_d_style   = m_style + Styles::Style.datetime
+
+    row = [
+        obj.group_id,
+        obj.created_dt.to_s,
+        user_name,
+        o_dt,
+        o_user_name,
+        ] + [ a.value for a in attrs]
+
+    row_styles = [
+        m_style,
+        m_d_style,
+        m_style,
+        m_d_style,
+        m_style,
+        ] + [
+        (if a.changed then b_c_style else b_style)
+        for a in attrs
+        ]
+
+    s_row = ["row", row, {"style": row_styles}]
+
+StyleGroup:
+    group =?
+    rows = [
+        StyleRow(profile = profile).s_row
+        for profile in group
+        ]
+
+ModelRows:
+    klass       =?
+    t1          =?
+    t2          =?
+    ids         =?
+
+    groups = Marty::DataChange.changes(t1, t2, klass, ids)
+
+    headers = ["Group ID", "Created", "By", "Deleted", "By"] +
+        Marty::DataChange.class_headers(klass)
+
+    width = headers.length
+    border = [
+        "border",
+        [0, {"off": 1}, width, {"off": 1}],
+        Styles::Style.border_thin,
+        ]
+
+    row_groups = [
+        StyleGroup(group = x[1]).rows + [border]
+        for x in groups
+        ]
+
+    s_style     = {"style": [Styles::Style.s_hdr] * width}
+    s_headers   = ["row", headers, s_style]
+    rows        = [s_headers] + row_groups.flatten(1)
+    count       = row_groups.length
+    ws          = if count > 0 then [klass, rows] else nil
+
+OptionalIDsField: MartyFields::TextField
+    field_label = "Group IDs (optional)"
+    name = "restrict_to_ids"
+
+DataBlameReport:
+    title = "Data Blame Report"
+
+    pt_name1    =?
+    posting1    =? Marty::Posting.lookup(pt_name1)
+    t1          = posting1.created_dt
+
+    pt_name2    =?
+    posting2    =? Marty::Posting.lookup(pt_name2)
+    t2          = posting2.created_dt
+
+    class_list  =? false
+    restrict_to_ids =? nil
+
+    form = [
+        MartyFields::PostingField1,
+        PostingField2,
+        MartyFields::ClassListField,
+        OptionalIDsField
+        ]
+
+    ts = if Marty::Helper.infinity_dt(t1)
+         then [t2, t1]
+         else if Marty::Helper.infinity_dt(t2)
+              then [t1, t2]
+              else [t1, t2].sort
+
+    sanitized = if class_list
+        then Marty::DataChange.sanitize_classes(class_list)
+        else Marty::DataChange.class_list
+
+    ids = if restrict_to_ids
+        then [ idstr.to_i for idstr in restrict_to_ids.split(',') ]
+        else nil
+
+    ids_check = if ids && ids.length > 0 && sanitized.length > 1
+        then ERR("Can't specify Group IDs if more than one class selected")
+        else true
+
+    result = ids_check && [
+        ModelRows(t1 = ts[0], t2 = ts[1], klass = klass,
+                  ids = ids).ws
+        for klass in sanitized
+        ].compact
+
+    format = "xlsx"
+
+ModelSummaryRow:
+    klass       =?
+    t1          =?
+    t2          =?
+
+    r = Marty::DataChange.change_summary(t1, t2, klass)
+    cr = r['created']
+    up = r['updated']
+    dl = r['deleted']
+
+    ws = if cr > 0 || up > 0 || dl > 0 then ["row", [klass, cr, up, dl]] else nil
+
+DataBlameReportSummary:
+    title = "Summary Data Blame Report"
+
+    pt_name1    =?
+    posting1    =? Marty::Posting.lookup(pt_name1)
+    t1          = posting1.created_dt
+
+    pt_name2    =?
+    posting2    =? Marty::Posting.lookup(pt_name2)
+    t2          = posting2.created_dt
+
+    form = [
+        MartyFields::PostingField1,
+        PostingField2,
+        ]
+
+    postings = [
+        ["Posting 1", pt_name1,],
+        ["Posting 2", pt_name2,],
+        ]
+
+    hrow = [
+        "row", ["Data Table", "Created", "Updated", "Deleted",],
+        Styles::Style.m_hdr_style0,
+        ]
+
+    ts = if Marty::Helper.infinity_dt(t1)
+         then [t2, t1]
+         else if Marty::Helper.infinity_dt(t2)
+              then [t1, t2]
+              else [t1, t2].sort
+
+    rows = [
+        ModelSummaryRow(t1 = ts[0], t2 = ts[1], klass = klass).ws
+        for klass in Marty::DataChange.class_list
+        ].compact
+
+    header = [["row", r, {"style" : [Styles::Style.s_hdr]}] for r in postings]
+    result = [[title,[hrow] + rows, {"widths" : [30]}], ["Parameters", header]]
+    format = "xlsx"
+
+DeadReferenceReport:
+    title = "Dead Reference Report"
+
+    class_list =? false
+    pt_name    =?
+    posting    =? Marty::Posting.lookup(pt_name)
+
+    sanitized = if class_list
+        then Marty::DataChange.sanitize_classes(class_list)
+        else Marty::DataChange.class_list
+
+    form = [
+        MartyFields::PostingField,
+        MartyFields::ClassListField,
+        ]
+
+    result = [
+        [[[klass, attr, obj].flatten for obj in list]
+         for attr, list in Marty::DataChange.dead_refs(posting.created_dt,
+                                                       klass)].flatten(1)
+        for klass in sanitized
+        ].flatten(1)
+
+    format = "csv"
+
+######################################################################
+
+DataImportParam:
+    field_label = "Input Rows"
+    name        = "data_import_field"
+    xtype       = ":textareafield"
+    scrollable = true
+    field_style = {
+        "font_family": 'courier new',
+        "font_size":   '12px',
+        }
+    height      =  600
+
+CommaSepField: MartyFields::CheckboxField
+    name        = "comma_sep"
+    field_label = "Comma Separated"
+
+DiffReport:
+    title = "Diff Report"
+
+    class_name        =? false
+    data_import_field =?
+    comma_sep         =? false
+
+    klass = Marty::Helper.constantize(class_name)
+
+    col_types = Marty::Helper.get_column_types(klass)
+    data      = Marty::Helper.parse_csv_to_hash(
+        data_import_field, comma_sep, col_types)
+
+    diff = Marty::DataChange.diff(klass, data)
+
+    result = [{"title"  : "different",
+               "format" : "csv",
+               "result" : diff["different"].flatten},
+              {"title"  : "same",
+               "format" : "csv",
+               "result" : diff["same"]},
+              {"title"  : "only_input",
+               "format" : "csv",
+               "result" : diff["only_input"]},
+              {"title"  : "only_source",
+               "format" : "csv",
+               "result" : diff["only_source"]},
+              ]
+
+    form = [
+        MartyFields::ClassField,
+        DataImportParam,
+        CommaSepField,
+        ]
+
+    format = "zip"