decidim-core 0.0.5 → 0.0.6

data/lib/decidim/has_reference.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to have a
+  # reference.
+  module HasReference
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :store_reference
+
+      validates :reference, presence: true
+
+      def reference
+        self[:reference] || calculate_reference
+      end
+
+      private
+
+      # Public: Calculates a unique reference for the model in
+      # the following format:
+      #
+      # "BCN-DPP-2017-02-6589" which in this example translates to:
+      #
+      # BCN: A setting configured at the organization to be prepended to each reference.
+      # PROP: Unique name identifier for a resource: Decidim::Proposals::Proposal (MEET for meetings or PROJ for projects).
+      # 2017-02: Year-Month of the resource creation date
+      # 6589: ID of the resource
+      #
+      # Returns a String.
+      def calculate_reference
+        return unless feature
+
+        ref = feature.participatory_process.organization.reference_prefix
+        class_identifier = self.class.name.demodulize[0..3].upcase
+        year_month = (created_at || Time.current).strftime("%Y-%m")
+
+        [ref, class_identifier, year_month, id].join("-")
+      end
+
+      # Internal: Sets the unique reference to the model.
+      #
+      # Returns nothing.
+      def store_reference
+        self[:reference] ||= calculate_reference
+      end
+    end
+  end
+end

data/lib/decidim/query_extensions.rb

@@ -27,6 +27,10 @@ module Decidim
             ctx[:current_user]
           }
         end
+
+        field :decidim, DecidimType, "Decidim's framework properties." do
+          resolve ->(_obj, _args, ctx) { Decidim }
+        end
       end
     end
   end

data/lib/decidim/reportable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to be reportable
+  module Reportable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :moderation, as: :reportable, foreign_key: "decidim_reportable_id", foreign_type: "decidim_reportable_type", class_name: "Decidim::Moderation"
+      has_many :reports, through: :moderation
+
+      scope :reported, -> { left_outer_joins(:moderation).where(Decidim::Moderation.arel_table[:report_count].gt 0) }
+      scope :hidden, -> { left_outer_joins(:moderation).where.not(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
+      scope :not_hidden, -> { left_outer_joins(:moderation).where(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
+
+      # Public: Check if the user has reported the proposal.
+      #
+      # Returns Boolean.
+      def reported_by?(user)
+        reports.where(user: user).any?
+      end
+
+      # Public: Checks if the proposal is hidden or not.
+      #
+      # Returns Boolean.
+      def hidden?
+        moderation&.hidden_at&.present?
+      end
+
+      # Public: Checks if the proposal has been reported or not.
+      #
+      # Returns Boolean.
+      def reported?
+        moderation&.report_count&.positive?
+      end
+
+      # Public: The reported content
+      #
+      # Returns html content
+      def reported_content
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/vendor/assets/javascripts/leaflet-svg-icon.js

@@ -0,0 +1,179 @@
+//Leaflet-SVGIcon
+//SVG icon for any marker class
+//Ilya Atkin
+//ilya.atkin@unh.edu
+
+L.DivIcon.SVGIcon = L.DivIcon.extend({
+    options: {
+        "circleText": "",
+        "className": "svg-icon",
+        "circleAnchor": null, //defaults to [iconSize.x/2, iconSize.x/2]
+        "circleColor": null, //defaults to color
+        "circleOpacity": null, // defaults to opacity
+        "circleFillColor": "rgb(255,255,255)",
+        "circleFillOpacity": null, //default to opacity 
+        "circleRatio": 0.5,
+        "circleWeight": null, //defaults to weight
+        "color": "rgb(0,102,255)",
+        "fillColor": null, // defaults to color
+        "fillOpacity": 0.4,
+        "fontColor": "rgb(0, 0, 0)",
+        "fontOpacity": "1",
+        "fontSize": null, // defaults to iconSize.x/4
+        "iconAnchor": null, //defaults to [iconSize.x/2, iconSize.y] (point tip)
+        "iconSize": L.point(32,48),
+        "opacity": 1,
+        "popupAnchor": null,
+        "weight": 2
+    },
+    initialize: function(options) {
+        options = L.Util.setOptions(this, options)
+
+        if (!options.circleAnchor) {
+            options.circleAnchor = L.point(Number(options.iconSize.x)/2, Number(options.iconSize.x)/2)
+        }
+        if (!options.circleColor) {
+            options.circleColor = options.color
+        }
+        if (!options.circleFillOpacity) {
+            options.circleFillOpacity = options.opacity
+        }
+        if (!options.circleOpacity) {
+            options.circleOpacity = options.opacity
+        }
+        if (!options.circleWeight) {
+            options.circleWeight = options.weight
+        }
+        if (!options.fillColor) { 
+            options.fillColor = options.color
+        }
+        if (!options.fontSize) {
+            options.fontSize = Number(options.iconSize.x/4) 
+        }
+        if (!options.iconAnchor) {
+            options.iconAnchor = L.point(Number(options.iconSize.x)/2, Number(options.iconSize.y))
+        }
+        if (!options.popupAnchor) {
+            options.popupAnchor = L.point(0, (-0.75)*(options.iconSize.y))
+        }
+
+        var path = this._createPath()
+        var circle = this._createCircle()
+
+        options.html = this._createSVG()
+    },
+    _createCircle: function() {
+        var cx = Number(this.options.circleAnchor.x) 
+        var cy = Number(this.options.circleAnchor.y)
+        var radius = this.options.iconSize.x/2 * Number(this.options.circleRatio)
+        var fill = this.options.circleFillColor.replace("rgb(", "rgba(").replace(")", "," + this.options.circleFillOpacity + ")")
+        var stroke = this.options.circleColor.replace("rgb(", "rgba(").replace(")", "," + this.options.circleOpacity + ")")
+        var strokeWidth = this.options.circleWeight
+        var className = this.options.className + "-circle"
+
+        var circle = '<circle class="' + className + '" cx="' + cx + '" cy="' + cy + '" r="' + radius + '" fill="' + fill + '" stroke="' + stroke + '" stroke-width="' + strokeWidth + '"/>'
+
+        return circle
+    },
+    _createPathDescription: function() {
+        var height = Number(this.options.iconSize.y)
+        var width = Number(this.options.iconSize.x)
+        var weight = Number(this.options.weight)
+        var margin = weight / 2
+
+        var startPoint = "M " + margin + " " + (width/2) + " "
+        var leftLine = "L " + (width/2) + " " + (height - weight) + " "
+        var rightLine = "L " + (width - margin) + " " + (width/2) + " "
+        var arc = "A " + (width/4) + " " + (width/4) + " 0 0 0 " + margin + " " + (width/2) + " Z"
+
+        var d = startPoint + leftLine + rightLine + arc
+
+        return d
+    },
+    _createPath: function() {
+        var pathDescription = this._createPathDescription()
+        var strokeWidth = this.options.weight
+        var stroke = this.options.color.replace("rgb(", "rgba(").replace(")", "," + this.options.opacity + ")")
+        var fill = this.options.fillColor.replace("rgb(", "rgba(").replace(")", "," + this.options.fillOpacity + ")")
+        var className = this.options.className + "-path"
+
+        var path = '<path class="' + className + '" d="' + pathDescription + '" stroke-width="' + strokeWidth + '" stroke="' + stroke + '" fill="' + fill + '"/>'
+
+        return path
+    },
+    _createSVG: function() {
+        var path = this._createPath()
+        var circle = this._createCircle()
+        var text = this._createText()
+        var className = this.options.className + "-svg"
+
+        var style = "width:" + this.options.iconSize.x + "; height:" + this.options.iconSize.y + ";"
+
+        var svg = '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" class="' + className + '" style="' + style + '">' + path + circle + text + '</svg>'
+
+        return svg
+    },
+    _createText: function() {
+        var fontSize = this.options.fontSize + "px"
+        var lineHeight = Number(this.options.fontSize)
+
+        var x = Number(this.options.iconSize.x) / 2
+        var y = x + (lineHeight * 0.35) //35% was found experimentally 
+        var circleText = this.options.circleText
+        var textColor = this.options.fontColor.replace("rgb(", "rgba(").replace(")", "," + this.options.fontOpacity + ")")
+
+        var text = '<text text-anchor="middle" x="' + x + '" y="' + y + '" style="font-size: ' + fontSize + '" fill="' + textColor + '">' + circleText + '</text>'
+
+        return text
+    }
+})
+
+L.divIcon.svgIcon = function(options) {
+    return new L.DivIcon.SVGIcon(options)
+}
+
+L.Marker.SVGMarker = L.Marker.extend({
+    options: {
+        "iconFactory": L.divIcon.svgIcon,
+        "iconOptions": {}
+    },
+    initialize: function(latlng, options) {
+        options = L.Util.setOptions(this, options)
+        options.icon = options.iconFactory(options.iconOptions)
+        this._latlng = latlng
+    },
+    onAdd: function(map) {
+        L.Marker.prototype.onAdd.call(this, map)
+    },
+    setStyle: function(style) {
+        if (this._icon) {
+            var svg = this._icon.children[0]
+            var iconBody = this._icon.children[0].children[0]
+            var iconCircle = this._icon.children[0].children[1]
+
+            if (style.color && !style.iconOptions) {
+                var stroke = style.color.replace("rgb","rgba").replace(")", ","+this.options.icon.options.opacity+")")
+                var fill = style.color.replace("rgb","rgba").replace(")", ","+this.options.icon.options.fillOpacity+")")
+                iconBody.setAttribute("stroke", stroke)
+                iconBody.setAttribute("fill", fill)
+                iconCircle.setAttribute("stroke", stroke)
+
+                this.options.icon.fillColor = fill
+                this.options.icon.color = stroke
+                this.options.icon.circleColor = stroke
+            }
+            if (style.opacity) {
+                this.setOpacity(style.opacity)
+            }
+            if (style.iconOptions) {
+                if (style.color) { style.iconOptions.color = style.color }
+                iconOptions = L.Util.setOptions(this.options.icon, style.iconOptions)
+                this.setIcon(L.divIcon.svgIcon(iconOptions))
+            }
+        }
+    }
+})
+
+L.marker.svgMarker = function(latlng, options) {
+    return new L.Marker.SVGMarker(latlng, options)
+}

data/vendor/assets/javascripts/leaflet-tilelayer-here.js

@@ -0,0 +1,166 @@
+
+// 🍂class TileLayer.HERE
+// Tile layer for HERE maps tiles.
+L.TileLayer.HERE = L.TileLayer.extend({
+
+	options: {
+		subdomains: '1234',
+		minZoom: 2,
+		maxZoom: 18,
+
+		// 🍂option scheme: String = 'normal.day'
+		// The "map scheme", as documented in the HERE API.
+		scheme: 'normal.day',
+
+		// 🍂option resource: String = 'maptile'
+		// The "map resource", as documented in the HERE API.
+		resource: 'maptile',
+
+		// 🍂option mapId: String = 'newest'
+		// Version of the map tiles to be used, or a hash of an unique map
+		mapId: 'newest',
+
+		// 🍂option format: String = 'png8'
+		// Image format to be used (`png8`, `png`, or `jpg`)
+		format: 'png8',
+
+		// 🍂option appId: String = ''
+		// Required option. The `app_id` provided as part of the HERE credentials
+		appId: '',
+
+		// 🍂option appCode: String = ''
+		// Required option. The `app_code` provided as part of the HERE credentials
+		appCode: '',
+	},
+
+
+	initialize: function initialize(options) {
+		options = L.setOptions(this, options);
+
+		// Decide if this scheme uses the aerial servers or the basemap servers
+		var schemeStart = options.scheme.split('.')[0];
+		options.tileResolution = 256;
+
+		if (L.Browser.retina) {
+			options.tileResolution = 512;
+		}
+
+// 		{Base URL}{Path}/{resource (tile type)}/{map id}/{scheme}/{zoom}/{column}/{row}/{size}/{format}
+// 		?app_id={YOUR_APP_ID}
+// 		&app_code={YOUR_APP_CODE}
+// 		&{param}={value}
+
+		var path = '/{resource}/2.1/{resource}/{mapId}/{scheme}/{z}/{x}/{y}/{tileResolution}/{format}?app_id={appId}&app_code={appCode}';
+		var attributionPath = '/maptile/2.1/copyright/{mapId}?app_id={appId}&app_code={appCode}';
+
+		var tileServer = 'base.maps.api.here.com';
+		if (schemeStart == 'satellite' ||
+				schemeStart == 'terrain' ||
+				schemeStart == 'hybrid') {
+			tileServer = 'aerial.maps.api.here.com';
+		}
+		if (options.scheme.indexOf('.traffic.') !== -1) {
+			tileServer = 'traffic.maps.api.here.com';
+		}
+
+		var tileUrl = 'https://{s}.' + tileServer + path;
+
+		this._attributionUrl = L.Util.template('https://1.' + tileServer + attributionPath, this.options);
+
+		L.TileLayer.prototype.initialize.call(this, tileUrl, options);
+
+		this._attributionText = '';
+
+	},
+
+	onAdd: function onAdd(map) {
+		L.TileLayer.prototype.onAdd.call(this, map);
+
+		if (!this._attributionBBoxes) {
+			this._fetchAttributionBBoxes();
+		}
+	},
+
+	onRemove: function onRemove(map) {
+		L.TileLayer.prototype.onRemove.call(this, map);
+
+		this._map.attributionControl.removeAttribution(this._attributionText);
+
+		this._map.off('moveend zoomend resetview', this._findCopyrightBBox, this);
+	},
+
+	_fetchAttributionBBoxes: function _onMapMove() {
+		var xmlhttp = new XMLHttpRequest();
+		xmlhttp.onreadystatechange = L.bind(function(){
+			if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
+				this._parseAttributionBBoxes(JSON.parse(xmlhttp.responseText));
+			}
+		}, this);
+		xmlhttp.open("GET", this._attributionUrl, true);
+		xmlhttp.send();
+	},
+
+	_parseAttributionBBoxes: function _parseAttributionBBoxes(json) {
+		if (!this._map) { return; }
+		var providers = json[this.options.scheme.split('.')[0]] || json.normal;
+		for (var i=0; i<providers.length; i++) {
+			if (providers[i].boxes) {
+				for (var j=0; j<providers[i].boxes.length; j++) {
+					var box = providers[i].boxes[j];
+					providers[i].boxes[j] = L.latLngBounds( [ [box[0], box[1]], [box[2], box[3]] ]);
+				}
+			}
+		}
+
+		this._map.on('moveend zoomend resetview', this._findCopyrightBBox, this);
+
+		this._attributionProviders = providers;
+
+		this._findCopyrightBBox();
+	},
+
+	_findCopyrightBBox: function _findCopyrightBBox() {
+		if (!this._map) { return; }
+		var providers = this._attributionProviders;
+		var visibleProviders = [];
+		var zoom = this._map.getZoom();
+		var visibleBounds = this._map.getBounds();
+
+		for (var i=0; i<providers.length; i++) {
+			if (providers[i].minLevel < zoom && providers[i].maxLevel > zoom)
+
+			if (!providers[i].boxes) {
+				// No boxes = attribution always visible
+				visibleProviders.push(providers[i]);
+				break;
+			}
+
+			for (var j=0; j<providers[i].boxes.length; j++) {
+				var box = providers[i].boxes[j];
+				if (visibleBounds.overlaps(box)) {
+					visibleProviders.push(providers[i]);
+					break;
+				}
+			}
+		}
+
+		var attributions = ['<a href="https://legal.here.com/terms/serviceterms/gb/">HERE maps</a>'];
+		for (var i=0; i<visibleProviders.length; i++) {
+			var provider = visibleProviders[i];
+			attributions.push('<abbr title="' + provider.alt + '">' + provider.label + '</abbr>');
+		}
+
+		var attributionText = '© ' + attributions.join(', ') + '. ';
+
+		if (attributionText !== this._attributionText) {
+			this._map.attributionControl.removeAttribution(this._attributionText);
+			this._map.attributionControl.addAttribution(this._attributionText = attributionText);
+		}
+	},
+
+});
+
+
+L.tileLayer.here = function(opts){
+	return new L.TileLayer.HERE(opts);
+}