text:
package entrypoint

import (
	"context"
	"net"
	"net/http"
	"net/http/httputil"
	"net/http/pprof"
	"net/url"

	"github.com/datawire/ambassador/pkg/acp"
	"github.com/datawire/ambassador/pkg/debug"
	"github.com/datawire/dlib/dhttp"
)

func handleCheckAlive(w http.ResponseWriter, r *http.Request, ambwatch *acp.AmbassadorWatcher) {
	// The liveness check needs to explicitly try to talk to Envoy...
	ambwatch.FetchEnvoyReady(r.Context())

	// ...then check if the watcher says we're alive.
	ok := ambwatch.IsAlive()

	if ok {
		w.Write([]byte("Ambassador is alive and well\n"))
	} else {
		http.Error(w, "Ambassador is not alive\n", http.StatusServiceUnavailable)
	}
}

func handleCheckReady(w http.ResponseWriter, r *http.Request, ambwatch *acp.AmbassadorWatcher) {
	// The readiness check needs to explicitly try to talk to Envoy, too. Why?
	// Because if you have a pod configured with only the readiness check but
	// not the liveness check, and we don't try to talk to Envoy here, then we
	// will never ever attempt to talk to Envoy at all, Envoy will never be
	// declared alive, and we'll never consider Ambassador ready.
	ambwatch.FetchEnvoyReady(r.Context())

	ok := ambwatch.IsReady()

	if ok {
		w.Write([]byte("Ambassador is ready and waiting\n"))
	} else {
		http.Error(w, "Ambassador is not ready\n", http.StatusServiceUnavailable)
	}
}

func healthCheckHandler(ctx context.Context, ambwatch *acp.AmbassadorWatcher) error {
	dbg := debug.FromContext(ctx)

	// We need to do some HTTP stuff by hand to catch the readiness and liveness
	// checks here, but forward everything else to diagd.
	sm := http.NewServeMux()

	// Handle the liveness check and the readiness check directly, by handing them
	// off to our functions.

	livenessTimer := dbg.Timer("check_alive")
	sm.HandleFunc("/ambassador/v0/check_alive",
		livenessTimer.TimedHandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			handleCheckAlive(w, r, ambwatch)
		}))

	readinessTimer := dbg.Timer("check_ready")
	sm.HandleFunc("/ambassador/v0/check_ready",
		readinessTimer.TimedHandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			handleCheckReady(w, r, ambwatch)
		}))

	// Serve any debug info from the golang codebase.
	sm.Handle("/debug", dbg)

	// Serve pprof endpoints to aid in live debugging.
	sm.HandleFunc("/debug/pprof/", pprof.Index)

	// For everything else, use a ReverseProxy to forward it to diagd.
	//
	// diagdOrigin is where diagd is listening.
	diagdOrigin, _ := url.Parse("http://127.0.0.1:8004/")

	// This reverseProxy is dirt simple: use a director function to
	// swap the scheme and host of our request for the ones from the
	// diagdOrigin. Leave everything else (notably including the path)
	// alone.
	reverseProxy := &httputil.ReverseProxy{
		Director: func(req *http.Request) {
			req.URL.Scheme = diagdOrigin.Scheme
			req.URL.Host = diagdOrigin.Host

			// If this request is coming from localhost, tell diagd about that.
			if acp.HostPortIsLocal(req.RemoteAddr) {
				req.Header.Set("X-Ambassador-Diag-IP", "127.0.0.1")
			}
		},
	}

	// Finally, use the reverseProxy to handle anything coming in on
	// the magic catchall path.
	sm.HandleFunc("/", reverseProxy.ServeHTTP)

	// Create a listener by hand, so that we can listen on TCP v4. If we don't
	// explicitly say "tcp4" here, we seem to listen _only_ on v6, and Bad Things
	// Happen.
	//
	// XXX Why, exactly, is this? That's a lovely question -- we _should_ be OK
	// here on a proper dualstack system, but apparently we don't have a proper
	// dualstack system? It's quite bizarre, but Kubernetes won't become ready
	// without this.
	//
	// XXX In fact, should we set up another Listener for v6??
	listener, err := net.Listen("tcp4", ":8877")
	if err != nil {
		return err
	}

	s := &dhttp.ServerConfig{
		Handler: sm,
	}

	return s.Serve(ctx, listener)
}


text:
[![](https://images.microbadger.com/badges/image/schodemeiss/npm-tools.svg)](http://microbadger.com/images/schodemeiss/npm-tools "Get your own image badge on microbadger.com") [![](https://images.microbadger.com/badges/version/schodemeiss/npm-tools.svg)](http://microbadger.com/images/schodemeiss/npm-tools "Get your own version badge on microbadger.com")

# Single Container NPM Tools
A collection of NPM tools to aid in the development and QA of Javascript/Web applications.

## Current Tools

* npm
* bower
* gulp
* grunt
* webpack
* browserify
* mocha

## Usage

You can simply call:

```
docker run --rm -it -v "$PWD":/app schodemeiss/npm-tools
```

By default this will run "npm install && gulp". IE: Install all packages inside the folders "packages.json" and then run the default gulp task if one exists.

You can call the tools by simply using:

```
docker run --rm -it -v "$PWD":/app schodemeiss/npm-tools bower install
```

This will run "bower" with the "install" argument.

Any of the other tools can be called with their respective usages.

## Helper Scripts
### Powershell
A Powershell function alias script can be found here: https://github.com/schodemeiss/docker-npm-tools/blob/master/npm-tools-aliases.ps1

This will allow you to run "npm" without having to run any docker specific commands.

### Bash
Coming Soon!

redpajama_set_name: RedPajamaGithub


text:
Intercept and decrypt all snapchats received over your network

## Quickstart
Installing is easy:
```
pip install snapception
```

Starting it is easy too:
```
snapception --help
Usage: snapception [OPTIONS]

Options:
  -v, --verbose        Enable logging
  -vv, --very-verbose  Include mitmdump in logging
  -o, --output TEXT    Specify output directory (Default is ~/snaps)
  --help               Show this message and exit.
```

Configuring it is also pretty easy:

1. Configure your device to use a proxy pointing to Port 8080 of the host computer
2. Install a CA on your device by visiting mitm.it once connected to the proxy
3. Watch all the Snapchats you receive over the network become available on your computer

## Isn't this just SnapSave/SnapBox/SnapSomething?
Nope. Those require you to authenticate with Snapchat's backend by giving the third party your username and password. Snapception, on the other hand, intercepts *all* snapchats received over the network so long as the receiving device is connected to the computer running Snapception via a proxy. Those applications also require you to manually login and save your snapchat before officially opening it; Snapception automatically intercepts, decrypts, and saves your received snaps.

## What's your aim? Privacy invasion? World domination?
Nope. I just created this to call attention to a security vulnerability that's been present in Snapchat for over a year. Did you know they use *one*, *hardcoded* key for *all* video and image encryption?

Anyway, for Snapception to intercept your snapchats, you must be connected to the computer via a proxy and have installed its CA, so someone can't just intercept your snapchats if you merely are using their network.

## What's the technology stack behind Snapception?
Glad you asked! The core of my script is basically a glorified event handler built on top of [mitmdump](https://github.com/mitmproxy/mitmproxy), a highly extensible and easily scriptable man-in-the-middle proxy server. Besides the event handler I built a basic command line interface using [click](https://github.com/mitsuhiko/click), which both launched mitmdump and glued together its custom event handler.

I would not have been able to build Snapception without the decryption ruby script by [AJ Jenkins](https://github.com/ajenkins/comp116-ajenkins/tree/master/final_project), who in turn based it upon the code written by [Amelia Cuss](https://kivikakk.ee/2013/05/10/snapchat.html). My code expands upon theirs in that in automatically intercepts the encrypted snapchats before decrypting them whereas before the encrypted snapchats would have to manually be obtained some other way.

## Can I contribute?
Please! Feel free to submit any pull requests. I whipped this application up in less than a day, so there is bound to be some bugs, missing features, or hastily written code.


text:
using System;

namespace Newtonsoft.Json
{
  /// <summary>
  /// Instructs the <see cref="JsonSerializer"/> how to serialize the collection.
  /// </summary>
  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
  public sealed class JsonArrayAttribute : JsonContainerAttribute
  {
    private bool _allowNullItems;

    /// <summary>
    /// Gets or sets a value indicating whether null items are allowed in the collection.
    /// </summary>
    /// <value><c>true</c> if null items are allowed in the collection; otherwise, <c>false</c>.</value>
    public bool AllowNullItems
    {
      get { return _allowNullItems; }
      set { _allowNullItems = value; }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="JsonArrayAttribute"/> class.
    /// </summary>
    public JsonArrayAttribute()
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="JsonObjectAttribute"/> class with a flag indicating whether the array can contain null items
    /// </summary>
    /// <param name="allowNullItems">A flag indicating whether the array can contain null items.</param>
    public JsonArrayAttribute(bool allowNullItems)
    {
      _allowNullItems = allowNullItems;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="JsonArrayAttribute"/> class with the specified container Id.
    /// </summary>
    /// <param name="id">The container Id.</param>
    public JsonArrayAttribute(string id)
      : base(id)
    {
    }
  }
}
#endif


text:
<?php

namespace Oro\Bundle\TrackingBundle\Tests\Unit\DependencyInjection;

use Oro\Bundle\TrackingBundle\DependencyInjection\OroTrackingExtension;

class OroBundleTrackingExtensionTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var OroTrackingExtension
     */
    protected $extension;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    protected $container;

    protected function setUp()
    {
        $this->container = $this->getMockBuilder('Symfony\Component\DependencyInjection\ContainerBuilder')
            ->disableOriginalConstructor()
            ->getMock();
        $this->extension = new OroTrackingExtension();
    }

    public function testLoad()
    {
        $this->container->expects($this->once())
            ->method('prependExtensionConfig')
            ->with('oro_tracking', $this->isType('array'));
        $this->extension->load([], $this->container);
    }
}


text:
    <colgroup>
        @foreach ($columns as $column)
            <col width="{!! $column->getWidth() !!}" />
        @endforeach
    </colgroup>

        @foreach ($columns as $column)
            getHeader()->htmlAttributesToString() !!}>
                {!! $column->getHeader()->render() !!}

        @endforeach

    @foreach ($collection as $model)

            @foreach ($columns as $column)
                <?php $column->setModel($model); ?>
                htmlAttributesToString() !!}>
                    {!! $column->render() !!}

            @endforeach

    @endforeach

    @yield('table.footer')

@if($collection instanceof \Illuminate\Contracts\Pagination\Paginator)

        {!! (new \Illuminate\Pagination\BootstrapThreePresenter($collection))->render() !!}

@endif


text:
{% extends 'theme/post_archives.html' %}

{% block page_title %}Posts tagged '{{ tag }}'{% endblock %}


text:
var user_task_dto_1 = require("../dto/user-task-dto");
var task_dto_1 = require("../dto/task-dto");
var user_dto_1 = require("../dto/user-dto");
var user_calendar_dto_1 = require("../dto/user-calendar-dto");
var user_task_summary_dto_1 = require("../dto/user-task-summary-dto");
var EntityConverterService = (function () {
    function EntityConverterService() {
    }
    EntityConverterService.prototype.toTaskDTO = function (model) {
        return new task_dto_1.TaskDTO(model['id'], model['key'], model['assignee'], model['estimation'], model['summary'], model['status'], model['epic_key']);
    };
    EntityConverterService.prototype.toTaskDbObject = function (entity) {
        return {
            id: entity.id,
            key: entity.key,
            assignee: entity.assignee,
            estimation: entity.estimation,
            summary: entity.summary,
            status: entity.status,
            epic_key: entity.epicKey
        };
    };
    EntityConverterService.prototype.toUserTaskDTO = function (model) {
        return new user_task_dto_1.UserTaskDTO(model['id'], model['task_id'], model['user_id'], model['start_time'], model['end_time']);
    };
    EntityConverterService.prototype.toUserTaskDbObject = function (entity) {
        return {
            id: entity.id,
            task_id: entity.taskId,
            user_id: entity.userId,
            start_time: entity.startTime,
            end_time: entity.endTime
        };
    };
    EntityConverterService.prototype.toUserDTO = function (model) {
        return new user_dto_1.UserDTO(model['id'], model['name']);
    };
    EntityConverterService.prototype.toUserCalendarDTO = function (model) {
        return new user_calendar_dto_1.UserCalendarDTO(model['id'], model['user_id'], model['date'], model['start_time'], model['end_time']);
    };
    EntityConverterService.prototype.toUserTaskSummaryDTO = function (model) {
        return new user_task_summary_dto_1.UserTaskSummaryDTO(model['task_id'], model['user_id'], model['start_time'], model['end_time'], model['spent_time']);
    };
    EntityConverterService.prototype.isEquals = function (modelOne, modelTwo) {
        return JSON.stringify(modelOne) == JSON.stringify(modelTwo);
    };
    return EntityConverterService;
})();
exports.EntityConverterService = EntityConverterService;


text:
package controller

import (
	"crypto/sha256"
	"fmt"
	"net/url"
	"time"

	monitoringv1alpha1 "github.com/coreos/prometheus-operator/pkg/client/monitoring/v1alpha1"
	"github.com/sirupsen/logrus"
	appsv1 "k8s.io/api/apps/v1"
	"k8s.io/api/autoscaling/v2beta1"
	corev1 "k8s.io/api/core/v1"
	apiequality "k8s.io/apimachinery/pkg/api/equality"
	k8sErrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	"k8s.io/apimachinery/pkg/util/wait"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/cache"
	"k8s.io/client-go/util/workqueue"

	"github.com/ghodss/yaml"
	kubelessApi "github.com/kubeless/kubeless/pkg/apis/kubeless/v1beta1"
	"github.com/kubeless/kubeless/pkg/client/clientset/versioned"
	kv1beta1 "github.com/kubeless/kubeless/pkg/client/informers/externalversions/kubeless/v1beta1"
	"github.com/kubeless/kubeless/pkg/langruntime"
	"github.com/kubeless/kubeless/pkg/registry"
	"github.com/kubeless/kubeless/pkg/utils"
)

const (
	maxRetries        = 5
	funcKind          = "Function"
	funcAPIVersion    = "kubeless.io/v1beta1"
	functionFinalizer = "kubeless.io/function"
)

// FunctionController object
type FunctionController struct {
	logger           *logrus.Entry
	clientset        kubernetes.Interface
	kubelessclient   versioned.Interface
	smclient         *monitoringv1alpha1.MonitoringV1alpha1Client
	Functions        map[string]*kubelessApi.Function
	queue            workqueue.RateLimitingInterface
	informer         cache.SharedIndexInformer
	config           *corev1.ConfigMap
	langRuntime      *langruntime.Langruntimes
	imagePullSecrets []corev1.LocalObjectReference
}

// Config contains k8s client of a controller
type Config struct {
	KubeCli        kubernetes.Interface
	FunctionClient versioned.Interface
}

// NewFunctionController returns a new *FunctionController
func NewFunctionController(cfg Config, smclient *monitoringv1alpha1.MonitoringV1alpha1Client) *FunctionController {
	queue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter())

	apiExtensionsClientset := utils.GetAPIExtensionsClientInCluster()
	config, err := utils.GetKubelessConfig(cfg.KubeCli, apiExtensionsClientset)
	if err != nil {
		logrus.Fatalf("Unable to read the configmap: %s", err)
	}

	informer := kv1beta1.NewFunctionInformer(cfg.FunctionClient, config.Data["functions-namespace"], 0, cache.Indexers{})

	informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
		AddFunc: func(obj interface{}) {
			key, err := cache.MetaNamespaceKeyFunc(obj)
			if err == nil {
				queue.Add(key)
			}
		},
		UpdateFunc: func(old, new interface{}) {
			key, err := cache.MetaNamespaceKeyFunc(new)
			if err == nil {
				newFunctionObj := new.(*kubelessApi.Function)
				oldFunctionObj := old.(*kubelessApi.Function)
				if functionObjChanged(oldFunctionObj, newFunctionObj) {
					queue.Add(key)
				}
			}
		},
		DeleteFunc: func(obj interface{}) {
			key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(obj)
			if err == nil {
				queue.Add(key)
			}
		},
	})

	var lr = langruntime.New(config)
	lr.ReadConfigMap()

	imagePullSecrets := utils.GetSecretsAsLocalObjectReference(config.Data["provision-image-secret"], config.Data["builder-image-secret"])
	if config.Data["enable-build-step"] == "true" {
		imagePullSecrets = append(imagePullSecrets, utils.GetSecretsAsLocalObjectReference("kubeless-registry-credentials")...)
	}
	return &FunctionController{
		logger:           logrus.WithField("pkg", "function-controller"),
		clientset:        cfg.KubeCli,
		smclient:         smclient,
		kubelessclient:   cfg.FunctionClient,
		informer:         informer,
		queue:            queue,
		config:           config,
		langRuntime:      lr,
		imagePullSecrets: imagePullSecrets,
	}
}

// Run starts the kubeless controller
func (c *FunctionController) Run(stopCh <-chan struct{}) {
	defer utilruntime.HandleCrash()
	defer c.queue.ShutDown()

	c.logger.Info("Starting Function controller")

	go c.informer.Run(stopCh)

	if !cache.WaitForCacheSync(stopCh, c.HasSynced) {
		utilruntime.HandleError(fmt.Errorf("Timed out waiting for caches to sync"))
		return
	}

	c.logger.Info("Function controller synced and ready")

	wait.Until(c.runWorker, time.Second, stopCh)
}

// HasSynced is required for the cache.Controller interface.
func (c *FunctionController) HasSynced() bool {
	return c.informer.HasSynced()
}

// LastSyncResourceVersion is required for the cache.Controller interface.
func (c *FunctionController) LastSyncResourceVersion() string {
	return c.informer.LastSyncResourceVersion()
}

func (c *FunctionController) runWorker() {
	for c.processNextItem() {
		// continue looping
	}
}

func (c *FunctionController) processNextItem() bool {
	key, quit := c.queue.Get()
	if quit {
		return false
	}
	defer c.queue.Done(key)

	err := c.processItem(key.(string))
	if err == nil {
		// No error, reset the ratelimit counters
		c.queue.Forget(key)
	} else if c.queue.NumRequeues(key) < maxRetries {
		c.logger.Errorf("Error processing %s (will retry): %v", key, err)
		c.queue.AddRateLimited(key)
	} else {
		// err != nil and too many retries
		c.logger.Errorf("Error processing %s (giving up): %v", key, err)
		c.queue.Forget(key)
		utilruntime.HandleError(err)
	}

	return true
}

func (c *FunctionController) processItem(key string) error {
	c.logger.Infof("Processing change to Function %s", key)

	ns, name, err := cache.SplitMetaNamespaceKey(key)
	if err != nil {
		return err
	}

	obj, exists, err := c.informer.GetIndexer().GetByKey(key)
	if err != nil {
		return fmt.Errorf("Error fetching object with key %s from store: %v", key, err)
	}

	// this is an update when Function API object is actually deleted, we dont need to process anything here
	if !exists {
		c.logger.Infof("Function object %s not found in the cache, ignoring the deletion update", key)
		return nil
	}

	funcObj := obj.(*kubelessApi.Function)

	// Function API object is marked for deletion (DeletionTimestamp != nil), so lets process the delete update
	if funcObj.ObjectMeta.DeletionTimestamp != nil {

		// If finalizer is removed, then we already processed the delete update, so just return
		if !utils.FunctionObjHasFinalizer(funcObj, functionFinalizer) {
			return nil
		}

		// Function object should be deleted, so cleanup the associated resources and remove the finalizer
		err := c.deleteK8sResources(ns, name)
		if err != nil {
			c.logger.Errorf("Can't delete function: %v", err)
			return err
		}

		// remove finalizer from the function object, so that we dont have to process any further and object can be deleted
		err = utils.FunctionObjRemoveFinalizer(c.kubelessclient, funcObj, functionFinalizer)
		if err != nil {
			c.logger.Errorf("Failed to remove function controller as finalizer to Function Obj: %s object due to: %v: ", key, err)
			return err
		}
		c.logger.Infof("Function object %s has been successfully processed and marked for deletion", key)
		return nil
	}

	// If function object in not marked with self as finalizer, then add the finalizer
	if !utils.FunctionObjHasFinalizer(funcObj, functionFinalizer) {
		err = utils.FunctionObjAddFinalizer(c.kubelessclient, funcObj, functionFinalizer)
		if err != nil {
			c.logger.Errorf("Error adding Function controller as finalizer to Function Obj: %s CRD due to: %v: ", key, err)
			return err
		}
	}

	err = c.ensureK8sResources(funcObj)
	if err != nil {
		c.logger.Errorf("Function can not be created/updated: %v", err)
		return err
	}

	c.logger.Infof("Processed change to function: %s", key)
	return nil
}

// startImageBuildJob creates (if necessary) a job that will build an image for the given function
// returns the name of the image, a boolean indicating if the build job has been created and an error
func (c *FunctionController) startImageBuildJob(funcObj *kubelessApi.Function, or []metav1.OwnerReference) (string, bool, error) {
	imagePullSecret, err := c.clientset.CoreV1().Secrets(funcObj.ObjectMeta.Namespace).Get("kubeless-registry-credentials", metav1.GetOptions{})
	if err != nil {
		return "", false, fmt.Errorf("Unable to locate registry credentials to build function image: %v", err)
	}
	reg, err := registry.New(*imagePullSecret)
	if err != nil {
		return "", false, fmt.Errorf("Unable to retrieve registry information: %v", err)
	}
	// Use function content and deps as tag (digested)
	tag := fmt.Sprintf("%x", sha256.Sum256([]byte(fmt.Sprintf("%v%v", funcObj.Spec.Function, funcObj.Spec.Deps))))
	imageName := fmt.Sprintf("%s/%s", reg.Creds.Username, funcObj.ObjectMeta.Name)
	// Check if image already exists
	exists, err := reg.ImageExists(imageName, tag)
	if err != nil {
		return "", false, fmt.Errorf("Unable to check is target image exists: %v", err)
	}
	regURL, err := url.Parse(reg.Endpoint)
	if err != nil {
		return "", false, fmt.Errorf("Unable to parse registry URL: %v", err)
	}
	image := fmt.Sprintf("%s/%s:%s", regURL.Host, imageName, tag)
	if !exists {
		tlsVerify := true
		if c.config.Data["function-registry-tls-verify"] == "false" {
			tlsVerify = false
		}
		err = utils.EnsureFuncImage(c.clientset, funcObj, c.langRuntime, or, imageName, tag, c.config.Data["builder-image"], regURL.Host, imagePullSecret.Name, c.config.Data["provision-image"], tlsVerify, c.imagePullSecrets)
		if err != nil {
			return "", false, fmt.Errorf("Unable to create image build job: %v", err)
		}
	} else {
		// Image already exists
		return image, false, nil
	}
	return image, true, nil
}

// ensureK8sResources creates/updates k8s objects (deploy, svc, configmap) for the function
func (c *FunctionController) ensureK8sResources(funcObj *kubelessApi.Function) error {
	if len(funcObj.ObjectMeta.Labels) == 0 {
		funcObj.ObjectMeta.Labels = make(map[string]string)
	}
	funcObj.ObjectMeta.Labels["function"] = funcObj.ObjectMeta.Name

	deployment := appsv1.Deployment{}
	if deploymentConfigData, ok := c.config.Data["deployment"]; ok {
		err := yaml.Unmarshal([]byte(deploymentConfigData), &deployment)
		if err != nil {
			logrus.Errorf("Error parsing Deployment data in ConfigMap kubeless-function-deployment-config: %v", err)
			return err
		}
		err = utils.MergeDeployments(&funcObj.Spec.Deployment, &deployment)
		if err != nil {
			logrus.Errorf(" Error while merging function.Spec.Deployment and Deployment from ConfigMap: %v", err)
			return err
		}
	}

	or, err := utils.GetOwnerReference(funcKind, funcAPIVersion, funcObj.Name, funcObj.UID)
	if err != nil {
		return err
	}

	err = utils.EnsureFuncConfigMap(c.clientset, funcObj, or, c.langRuntime)
	if err != nil {
		return err
	}

	err = utils.EnsureFuncService(c.clientset, funcObj, or)
	if err != nil {
		return err
	}

	prebuiltImage := ""
	if len(funcObj.Spec.Deployment.Spec.Template.Spec.Containers) > 0 && funcObj.Spec.Deployment.Spec.Template.Spec.Containers[0].Image != "" {
		prebuiltImage = funcObj.Spec.Deployment.Spec.Template.Spec.Containers[0].Image
	}
	// Skip image build step if using a custom runtime
	if prebuiltImage == "" {
		if c.config.Data["enable-build-step"] == "true" {
			var isBuilding bool
			prebuiltImage, isBuilding, err = c.startImageBuildJob(funcObj, or)
			if err != nil {
				logrus.Errorf("Unable to build function: %v", err)
			} else {
				if isBuilding {
					logrus.Infof("Started build process for function %s", funcObj.ObjectMeta.Name)
				} else {
					logrus.Infof("Found existing image %s", prebuiltImage)
				}
			}
		}
	} else {
		logrus.Infof("Skipping image-build step for %s", funcObj.ObjectMeta.Name)
	}

	err = utils.EnsureFuncDeployment(c.clientset, funcObj, or, c.langRuntime, prebuiltImage, c.config.Data["provision-image"], c.imagePullSecrets)
	if err != nil {
		return err
	}

	if funcObj.Spec.HorizontalPodAutoscaler.Name != "" && funcObj.Spec.HorizontalPodAutoscaler.Spec.ScaleTargetRef.Name != "" {
		funcObj.Spec.HorizontalPodAutoscaler.OwnerReferences = or
		if funcObj.Spec.HorizontalPodAutoscaler.Spec.Metrics[0].Type == v2beta1.ObjectMetricSourceType {
			// A service monitor is needed when the metric is an object
			err = utils.CreateServiceMonitor(*c.smclient, funcObj, funcObj.ObjectMeta.Namespace, or)
			if err != nil {
				return err
			}
		}
		err = utils.CreateAutoscale(c.clientset, funcObj.Spec.HorizontalPodAutoscaler)
		if err != nil && k8sErrors.IsAlreadyExists(err) {
			err = utils.UpdateAutoscale(c.clientset, funcObj.Spec.HorizontalPodAutoscaler)
		}
		if err != nil {
			return err
		}
	} else {
		// HorizontalPodAutoscaler doesn't exists, try to delete if it already existed
		err = c.deleteAutoscale(funcObj.ObjectMeta.Namespace, funcObj.ObjectMeta.Name)
		if err != nil && !k8sErrors.IsNotFound(err) {
			return err
		}
	}
	return nil
}

func (c *FunctionController) deleteAutoscale(ns, name string) error {
	if c.smclient != nil {
		// Delete Service monitor if the client is available
		err := utils.DeleteServiceMonitor(*c.smclient, name, ns)
		if err != nil && !k8sErrors.IsNotFound(err) {
			return err
		}
	}
	// delete autoscale
	err := utils.DeleteAutoscale(c.clientset, name, ns)
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}
	return nil
}

// deleteK8sResources removes k8s objects of the function
func (c *FunctionController) deleteK8sResources(ns, name string) error {

	// delete deployment
	deletePolicy := metav1.DeletePropagationBackground
	err := c.clientset.Extensions().Deployments(ns).Delete(name, &metav1.DeleteOptions{PropagationPolicy: &deletePolicy})
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}
	// delete svc
	err = c.clientset.Core().Services(ns).Delete(name, &metav1.DeleteOptions{})
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}

	// delete cm
	err = c.clientset.Core().ConfigMaps(ns).Delete(name, &metav1.DeleteOptions{})
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}

	// delete service monitor
	err = c.deleteAutoscale(ns, name)
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}

	// delete build job
	err = c.clientset.BatchV1().Jobs(ns).DeleteCollection(&metav1.DeleteOptions{}, metav1.ListOptions{
		LabelSelector: fmt.Sprintf("created-by=kubeless,function=%s", name),
	})
	if err != nil && !k8sErrors.IsNotFound(err) {
		return err
	}

	return nil
}

func functionObjChanged(oldFunctionObj, newFunctionObj *kubelessApi.Function) bool {
	// If the function object's deletion timestamp is set, then process
	if oldFunctionObj.DeletionTimestamp != newFunctionObj.DeletionTimestamp {
		return true
	}
	// If the new and old function object's resource version is same
	if oldFunctionObj.ResourceVersion == newFunctionObj.ResourceVersion {
		return false
	}
	newSpec := &oldFunctionObj.Spec
	oldSpec := &newFunctionObj.Spec

	if newSpec.Function != oldSpec.Function ||
		// compare checksum since the url content type uses Function field to pass the URL for the function
		// comparing the checksum ensures that if the function code has changed but the URL remains the same, the function will get redeployed
		newSpec.Checksum != oldSpec.Checksum ||
		newSpec.Handler != oldSpec.Handler ||
		newSpec.FunctionContentType != oldSpec.FunctionContentType ||
		newSpec.Deps != oldSpec.Deps ||
		newSpec.Timeout != oldSpec.Timeout {
		return true
	}

	if !apiequality.Semantic.DeepEqual(newSpec.Deployment, oldSpec.Deployment) ||
		!apiequality.Semantic.DeepEqual(newSpec.HorizontalPodAutoscaler, oldSpec.HorizontalPodAutoscaler) ||
		!apiequality.Semantic.DeepEqual(newSpec.ServiceSpec, oldSpec.ServiceSpec) {
		return true
	}
	return false
}


text:
using System;
using System.Data;
using System.Collections;
using System.Reflection;
using System.Text;

namespace Inform.Common {

	/// <summary>
	/// This type supports the Inform infrastructure and is not intended to be used directly from your code.
	/// </summary>
	public abstract class DataStorageManager {

		private RegisteredMemberMappingCollection registeredMemberTypeMappings;
		private RelationshipMappingCollection relationshipMappings;
		private TypeMappingCollection typeMappings;
		private DataStore dataStore;

		/// <summary>
		/// Provides access to a DataStore's DataStorageManager.
		/// </summary>
		/// <param name="dataStore"></param>
		/// <returns></returns>
		public static DataStorageManager GetDataStorageManager(DataStore dataStore) {
			return dataStore.DataStorageManager;
		}

		/// <summary>
		/// Gets the TypeMappingCollection.
		/// </summary>
		public TypeMappingCollection TypeMappings {
			get { return typeMappings; }
		}

		/// <summary>
		/// Gets the RelationshipMappingCollection.
		/// </summary>
		public RelationshipMappingCollection RelationshipMappings {
			get { return relationshipMappings; }
		}

		/// <summary>
		/// Gets the DataStore that created this DataStorageManager.
		/// </summary>
		protected DataStore ManagedDataStore {
			get { return dataStore; }
		}

		protected DataStorageManager(DataStore dataStore) {
			this.dataStore = dataStore;
			this.typeMappings = new TypeMappingCollection();
			this.registeredMemberTypeMappings = new RegisteredMemberMappingCollection();
			this.relationshipMappings = new RelationshipMappingCollection();
		}

		#region Abstract Methods

		abstract public bool TableExists(string tableName);
		abstract public bool ExistsStorage(TypeMapping typeMapping);

		abstract public string GenerateCreateTableSql(TypeMapping typeMapping);
		abstract public string GenerateDeleteTableSql(TypeMapping typeMapping);

		abstract public string GenerateCreateRelationshipSql(RelationshipMapping rm);

		abstract public string GenerateCreateInsertProcedureSql(TypeMapping typeMapping);
		abstract public string GenerateCreateUpdateProcedureSql(TypeMapping typeMapping);
		abstract public string GenerateCreateDeleteProcedureSql(TypeMapping typeMapping);

		abstract public string GenerateInsertSql(TypeMapping typeMapping);
		abstract public string GenerateUpdateSql(TypeMapping typeMapping);
		abstract public string GenerateDeleteSql(TypeMapping typeMapping);

		abstract public string GenerateDropProcedureSql(string procedureName);

		abstract public string GenerateFindByPrimaryKeySql(TypeMapping typeMapping);

		#endregion

		public void CreateStorage(TypeMapping typeMapping){

			if(typeMapping == null){
				throw new ArgumentNullException("typeMapping");
			}

			IDataAccessCommand createCommand;

			RelationshipMapping baseMapping = null;
			if(typeMapping.BaseType != null){

				TypeMapping baseTypeMapping = this.GetTypeMapping(typeMapping.BaseType);
				TypeMappingState state = CheckMapping(baseTypeMapping);
				if (state.Condition == TypeMappingState.TypeMappingStateCondition.TableMissing){
					CreateStorage(baseTypeMapping);
				} else if (state.Condition != TypeMappingState.TypeMappingStateCondition.None) {
					throw new TypeMappingException("TypeMappingState: " + state.Condition.ToString());
				}

				baseMapping = new RelationshipMapping();
				baseMapping.Name = string.Format("{0}_{1}",typeMapping.TableName,baseTypeMapping.TableName);
				baseMapping.ChildType = typeMapping.MappedType;
				baseMapping.ParentType = baseTypeMapping.MappedType;
				baseMapping.ChildMember = typeMapping.PrimaryKey.MemberInfo.Name;
				baseMapping.ParentMember = baseTypeMapping.PrimaryKey.MemberInfo.Name;
				baseMapping.Type = Relationship.OneToOne;
			}

			createCommand = ManagedDataStore.CreateDataAccessCommand(
				GenerateCreateTableSql(typeMapping), CommandType.Text);
			createCommand.ExecuteNonQuery();

			if(baseMapping != null){
				createCommand = ManagedDataStore.CreateDataAccessCommand(
					GenerateCreateRelationshipSql(baseMapping), CommandType.Text);
				createCommand.ExecuteNonQuery();
			}

			if(typeMapping.UseStoredProcedures){
				CreateInsertProcedure(typeMapping);
				CreateUpdateProcedure(typeMapping);
				CreateDeleteProcedure(typeMapping);
			}

			foreach(RelationshipMapping rm in RelationshipMappings){
				if(rm.ChildType == typeMapping.MappedType){
					createCommand = ManagedDataStore.CreateDataAccessCommand(
						GenerateCreateRelationshipSql(rm), CommandType.Text);
					createCommand.ExecuteNonQuery();
				}
			}

		}

		public void DeleteStorage(TypeMapping typeMapping){

			IDataAccessCommand deleteCommand;

			//delete table
			deleteCommand = ManagedDataStore.CreateDataAccessCommand(GenerateDeleteTableSql(typeMapping), CommandType.Text);
			deleteCommand.ExecuteNonQuery();

			//delete insert
			if(typeMapping.UseStoredProcedures){
				deleteCommand = ManagedDataStore.CreateDataAccessCommand(GenerateDropProcedureSql(GetInsertProcedureName(typeMapping)), CommandType.Text);
				deleteCommand.ExecuteNonQuery();

				//delete update
				deleteCommand = ManagedDataStore.CreateDataAccessCommand(GenerateDropProcedureSql(GetUpdateProcedureName(typeMapping)), CommandType.Text);
				deleteCommand.ExecuteNonQuery();

				//delete delete
				deleteCommand = ManagedDataStore.CreateDataAccessCommand(GenerateDropProcedureSql(GetDeleteProcedureName(typeMapping)), CommandType.Text);
				deleteCommand.ExecuteNonQuery();
			}

		}

		public string GetInsertProcedureName(TypeMapping typeMapping){
			return typeMapping.TableName + "_Insert";
		}

		public string GetUpdateProcedureName(TypeMapping typeMapping){
			return typeMapping.TableName + "_Update";
		}

		public string GetDeleteProcedureName(TypeMapping typeMapping){
			return typeMapping.TableName + "_Delete";
		}

		public void CreateInsertProcedure(TypeMapping typeMapping){
			IDataAccessCommand createCommand = ManagedDataStore.CreateDataAccessCommand(GenerateCreateInsertProcedureSql(typeMapping), CommandType.Text);
			createCommand.ExecuteNonQuery();
		}

		public void CreateUpdateProcedure(TypeMapping typeMapping){
			if(typeMapping.PrimaryKey != null){
				IDataAccessCommand createCommand = ManagedDataStore.CreateDataAccessCommand(GenerateCreateUpdateProcedureSql(typeMapping), CommandType.Text);
				createCommand.ExecuteNonQuery();
			}
		}

		public void CreateDeleteProcedure(TypeMapping typeMapping){
			if(typeMapping.PrimaryKey != null){
				IDataAccessCommand createCommand = ManagedDataStore.CreateDataAccessCommand(GenerateCreateDeleteProcedureSql(typeMapping), CommandType.Text);
				createCommand.ExecuteNonQuery();
			}
		}

		public TypeMapping GetTypeMapping(Type type){
			TypeMapping typeMapping = (TypeMapping)this.typeMappings[type.FullName];

			if(typeMapping == null && this.dataStore.Settings.AutoGenerate){
				typeMapping = CreateTypeMappingFromAttributes(type);
				AddTypeMapping(typeMapping);
				AddDefaultRelationshipMappings(type);
			}

			return typeMapping;
		}

		public TypeMapping GetTypeMapping(Type type, bool throwError){
			TypeMapping typeMapping = GetTypeMapping(type);
			if(typeMapping == null && throwError){
				throw new ApplicationException("There is no TypeMapping defined for " + type.FullName);
			}
			return typeMapping;
		}

		public void AddTypeMapping(TypeMapping typeMapping){
			this.typeMappings.Add(typeMapping);
			if(typeMapping.BaseType != null){
				this.GetTypeMapping(typeMapping.BaseType).SubClasses.Add(typeMapping.MappedType);
			}
		}

		public IMemberMapping CreateDefaultMemberMapping(MemberInfo memberInfo, MemberMappingAttribute mma){

			Type mappedType;

			if(memberInfo is FieldInfo){
				mappedType = ((FieldInfo)memberInfo).FieldType;
			} else if(memberInfo is PropertyInfo) {
				mappedType = ((PropertyInfo)memberInfo).PropertyType;
			} else {
				throw new DataStoreException("Unsupported MemberType: " + memberInfo.MemberType );
			}

			IMemberMapping mapping = GetPropertyMapping(mappedType);

			if (mapping == null){
				throw new ArgumentException("Could not create MemberMapping for " + mappedType.FullName );
			}

			if(mma.ColumnName != null){
				mapping.ColumnName = mma.ColumnName;
			} else {
				mapping.ColumnName = memberInfo.Name;
			}

			mapping.PrimaryKey = mma.PrimaryKey;
			mapping.Identity = mma.Identity;
			mapping.MemberDbType.IsNullable = mma.AllowNulls;
			mapping.MemberInfo = memberInfo;

			if(mma.UseDbType){ mapping.MemberDbType.DbType = mma.DbType; }
			//TODO: Only apply to Decimal?
			if(mma.UseLength){ mapping.MemberDbType.Length = mma.Length; }
			if(mma.UsePrecision){ mapping.MemberDbType.Precision = mma.Precision;}
			if(mma.UseScale){ mapping.MemberDbType.Scale = mma.Scale; }

			return mapping;
		}

		/// <summary>
		/// Creates a TypeMapping using special attributes to classes and members.
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public TypeMapping CreateTypeMappingFromAttributes(Type type){

			TypeMapping typeMapping = new TypeMapping();
			typeMapping.UseStoredProcedures = dataStore.Settings.UseStoredProcedures;

			//Set the type
			typeMapping.MappedType = type;

			TypeMappingAttribute[] typeMappingAttributes = (TypeMappingAttribute[])type.GetCustomAttributes(typeof(TypeMappingAttribute),false);
			TypeMappingAttribute typeMappingAttibute = null;
			if(typeMappingAttributes.Length > 0){
				typeMappingAttibute =  typeMappingAttributes[0];
			}

			if(typeMappingAttibute != null && typeMappingAttibute.BaseType != null){
				typeMapping.BaseType = typeMappingAttibute.BaseType;
			}

			if(typeMappingAttibute != null && typeMappingAttibute.TableName != null){
				typeMapping.TableName = typeMappingAttibute.TableName;
			} else {
				typeMapping.TableName = CreateDefaultTableName(type);
			}

			foreach(MemberInfo memberInfo in type.GetMembers(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)){

				if(!((memberInfo is PropertyInfo) || (memberInfo is FieldInfo))){
					continue;
				}

				MemberMappingAttribute mma = (MemberMappingAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(MemberMappingAttribute), true);

				if(mma != null && !mma.Ignore){

					if(typeMapping.BaseType != null && !mma.PrimaryKey && !MemberIsDeclaredAbove(memberInfo,typeMapping.BaseType)){
						continue;
					}

					if(mma.PrimaryKey){
						if(typeMapping.BaseType != null){ // && MemberIsDeclaredAbove(memberInfo,typeMapping.BaseType)
							mma.Identity = false;
						}
					}

					IMemberMapping mapping = CreateDefaultMemberMapping(memberInfo, mma);
					typeMapping.MemberMappings.Add(mapping);

				}

				AddDefaultCacheMappings(memberInfo, typeMapping);
			}

			AddDefaultRelationshipMappings(type);

			if(typeMapping.MemberMappings.Count == 0 && typeMapping.BaseType == null){
				throw new TypeMappingException(string.Format("TypeMapping has no MemberMappings defined for type '{0}'.", type.FullName));
			}
			return typeMapping;
		}

		private void AddDefaultRelationshipMappings(Type type){
			RelationshipMappingAttribute[] relationshipMappingAttributes = (RelationshipMappingAttribute[])type.GetCustomAttributes(typeof(RelationshipMappingAttribute),false);
			foreach(RelationshipMappingAttribute rma in relationshipMappingAttributes){
				RelationshipMapping rm = new RelationshipMapping();
				rm.Name = rma.Name;
				if(rma.ParentType != null){
					rm.ParentType = rma.ParentType;
					rm.ChildType = type;
				} else {
					rm.ParentType = type;
					rm.ChildType = rma.ChildType;
				}

				rm.ParentMember = rma.ParentMember;
				rm.ChildMember = rma.ChildMember;

				rm.Type = rma.Type; //TODO: rename RelationshipType

				relationshipMappings.Add(rm);
			}
		}

		private void AddDefaultCacheMappings(MemberInfo memberInfo, TypeMapping typeMapping){

			RelationshipMappingAttribute rma = (RelationshipMappingAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(RelationshipMappingAttribute),false);
			if(rma != null){

				RelationshipMapping rm = new RelationshipMapping();
				rm.Name = rma.Name;
				if(rma.ParentType != null){
					rm.ParentType = rma.ParentType;
					rm.ChildType = typeMapping.MappedType;
				} else {
					rm.ParentType = typeMapping.MappedType;
					rm.ChildType = rma.ChildType;
				}
				rm.ParentMember = rma.ParentMember;
				rm.ChildMember = rma.ChildMember;
				rm.Type = rma.Type;
				relationshipMappings.Add(rm);
			}

			CacheMappingAttribute ca = (CacheMappingAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(CacheMappingAttribute), false);
			if(ca != null){
				CacheMapping cm = new CacheMapping();
				cm.Relationship = ca.Relationship == null ? rma.Name : ca.Relationship;
				cm.MemberInfo = memberInfo;
				cm.DataStore = this.dataStore;
				cm.OrderBy = ca.OrderBy;
				typeMapping.CacheMappings.Add(cm);
			} else if(rma != null){
				CacheMapping cm = new CacheMapping();
				cm.Relationship = rma.Name;
				cm.MemberInfo = memberInfo;
				cm.DataStore = this.dataStore;
				typeMapping.CacheMappings.Add(cm);
			}
		}

		public RelationshipMapping GetRelationshipMapping(string name){
			return (RelationshipMapping)relationshipMappings[name];
		}

		public bool MemberIsDeclaredAbove(MemberInfo memberInfo, Type type){
			Type reflectedType = memberInfo.ReflectedType;
			Type declaringType = memberInfo.DeclaringType;

			while(reflectedType != null){
				if(reflectedType.FullName == type.FullName){
					return false;
				}
				if(reflectedType.FullName == declaringType.FullName){
					return true;
				}
				reflectedType = reflectedType.BaseType;
			}

			return false;
		}

		public IMemberMapping GetPropertyMapping(Type type){
			Type memberMappingType = (Type)registeredMemberTypeMappings[type];

			//TODO: Review if this is the best method for capturing enums
			if(type.IsEnum){
				memberMappingType = (Type)registeredMemberTypeMappings[typeof(Enum)];
			}

			if(memberMappingType == null){
				throw new ApplicationException("DataStore does not contain IMemberMapping for " + type.FullName);
			}

			object memberMapping = memberMappingType.GetConstructor(new Type[]{}).Invoke(null);

			if(memberMapping == null){
				throw new ApplicationException("DataStore could not create IMemberMapping for " + type.FullName);
			}

			return (IMemberMapping)memberMapping;
		}

		public void AddPropertyMappingType(Type type, Type memberMappingType){
			registeredMemberTypeMappings.Register(type, memberMappingType);
		}

		internal string CreateDefaultTableName(Type type){

			if(type.Name.EndsWith("Y")){
				return type.Name.Substring(0,type.Name.Length-1) + "IES";
			} else if(type.Name.EndsWith("y")) {
				return type.Name.Substring(0,type.Name.Length-1) + "ies";
			} else if(type.Name.EndsWith("S")) {
				return type.Name + "ES";
			} else if(type.Name.EndsWith("s")) {
				return type.Name + "es";
			} else if(char.IsUpper(type.Name,type.Name.Length-1)) {
				return type.Name + "S";
			} else {
				return type.Name + "s";
			}

		}

		abstract public TypeMappingState CheckMapping(TypeMapping typeMapping);

		abstract public string CreateQuery(Type type, string filter, bool polymorphic);

		public string BuildSubClassColumnList(TypeMapping typeMapping){
			StringBuilder columns = new StringBuilder();
			bool notFirst = false;
			foreach(IMemberMapping propertyMapping in typeMapping.MemberMappings){
				if(notFirst){
					columns.Append(",");
				} else {
					notFirst = true;
				}
				columns.AppendFormat(" [{0}].[{1}] AS [{0}_{1}]", typeMapping.TableName, propertyMapping.ColumnName);
			}
			foreach(Type subClass in typeMapping.SubClasses){
				string subClassColumns = BuildSubClassColumnList(GetTypeMapping(subClass));
				if(subClassColumns.Length > 0){
					columns.Append("," + subClassColumns);
				}
			}
			return columns.ToString();
		}

		public string PolymorphicPrimaryKey(TypeMapping typeMapping){
			return string.Format("{0}_{1}", typeMapping.TableName, typeMapping.PrimaryKey.ColumnName);
		}

		public string BuildBaseClassColumnList(TypeMapping typeMapping){

			if(typeMapping.BaseType != null){
				typeMapping = GetTypeMapping(typeMapping.BaseType);

				StringBuilder columns = new StringBuilder();
				bool addComma = true;
				foreach(IMemberMapping propertyMapping in typeMapping.MemberMappings){
					if(addComma){
						columns.Append(",");
					} else {
						addComma = true;
					}
					columns.AppendFormat(" {0}.{1} AS [{0}_{1}]", typeMapping.TableName, propertyMapping.ColumnName);
				}

				columns.Append(BuildBaseClassColumnList(typeMapping));
				return columns.ToString();
			} else {
				return string.Empty;
			}
		}

	}

}


text:
package com.mpatric.mp3agic;

public class MutableInteger {

	private int value;

	public MutableInteger(int value) {
		this.value = value;
	}

	public void increment() {
		value++;
	}

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public boolean equals(Object obj) {
		if (! (obj instanceof MutableInteger)) return false;
		if (super.equals(obj)) return true;
		MutableInteger other = (MutableInteger) obj;
		if (value != other.value) return false;
		return true;
	}
}


text:
<?php
return [
    '@class' => 'Grav\\Common\\File\\CompiledYamlFile',
    'filename' => '/Users/cmiller/GoogleDrive/local/personal/mamp_sites/scholarship_new/user/plugins/admin/languages/it.yaml',
    'modified' => 1478520864,
    'data' => [
        'PLUGIN_ADMIN' => [
            'ADMIN_BETA_MSG' => 'Questa è una versione beta! Usare in produzione a proprio rischio e pericolo…',
            'ADMIN_REPORT_ISSUE' => 'Trovato un problema? Per favore, apri un ticket su GitHub',
            'EMAIL_FOOTER' => 'Powered by Grav - Il CMS Flat File e Moderno',
            'LOGIN_BTN' => 'Accedi',
            'LOGIN_BTN_FORGOT' => 'Dimenticata',
            'LOGIN_BTN_RESET' => 'Ripristina la password',
            'LOGIN_BTN_SEND_INSTRUCTIONS' => 'Invia istruzioni di ripristino',
            'LOGIN_BTN_CLEAR' => 'Resetta il modulo',
            'LOGIN_BTN_CREATE_USER' => 'Crea Utente',
            'LOGIN_LOGGED_IN' => 'Login effettuato con successo',
            'LOGIN_FAILED' => 'Login fallito',
            'LOGGED_OUT' => 'Sei stato disconnesso',
            'RESET_NEW_PASSWORD' => 'Si prega di inserire una nuova password …',
            'RESET_LINK_EXPIRED' => 'Il link di ripristino è scaduto, ritenta per favore',
            'RESET_PASSWORD_RESET' => 'La password è stata ripristinata',
            'RESET_INVALID_LINK' => 'Il link di ripristino non è valido, ritenta per favore',
            'FORGOT_INSTRUCTIONS_SENT_VIA_EMAIL' => 'Le istruzioni per ripristinare la password sono state inviate via email a %s',
            'FORGOT_FAILED_TO_EMAIL' => 'Invio della email fallito, per favore ritenta più tardi',
            'FORGOT_CANNOT_RESET_EMAIL_NO_EMAIL' => 'Impossibile ripristinare la password per %s, nessun indirizzo email impostato',
            'FORGOT_USERNAME_DOES_NOT_EXIST' => 'L\'utente con username %s non esiste',
            'FORGOT_EMAIL_NOT_CONFIGURED' => 'Impossibile ripristinare la password. Il sito non è configurato per inviare email',
            'FORGOT_EMAIL_SUBJECT' => '%s Richiesta di ripristino password',
            'FORGOT_EMAIL_BODY' => '
Reset password

Caro %1$s,

Una richiesta di reset password è stata effettuata su %4$s.

Clicca qui per resettare la tua password

In alternativa, copia il seguente URL nella barra indirizzi del tuo browser:

%2$s

Cordiali saluti,

%3$s
',
            'MANAGE_PAGES' => 'Gestione Pagine',
            'CONFIGURATION' => 'Impostazioni',
            'PAGES' => 'Pagine',
            'PLUGINS' => 'Plugins',
            'PLUGIN' => 'Plugin',
            'THEMES' => 'Temi',
            'LOGOUT' => 'Esci',
            'BACK' => 'Indietro',
            'ADD_PAGE' => 'Aggiungi Pagina',
            'ADD_MODULAR' => 'Aggiungi Modulo',
            'MOVE' => 'Sposta',
            'DELETE' => 'Elimina',
            'SAVE' => 'Salva',
            'NORMAL' => 'Normale',
            'EXPERT' => 'Esperto',
            'EXPAND_ALL' => 'Espandi tutto',
            'COLLAPSE_ALL' => 'Comprimi tutto',
            'ERROR' => 'Errore',
            'CLOSE' => 'Chiudi',
            'CANCEL' => 'Cancella',
            'CONTINUE' => 'Continua',
            'MODAL_DELETE_PAGE_CONFIRMATION_REQUIRED_TITLE' => 'Conferma richiesta',
            'MODAL_CHANGED_DETECTED_TITLE' => 'Modifiche rilevate',
            'MODAL_CHANGED_DETECTED_DESC' => 'Sono stati rilevati cambiamenti non salvati. Si è sicuri di voler lasciare la pagina senza prima salvare?',
            'MODAL_DELETE_FILE_CONFIRMATION_REQUIRED_TITLE' => 'Conferma richiesta',
            'MODAL_DELETE_FILE_CONFIRMATION_REQUIRED_DESC' => 'Si è sicuri di voler eliminare questo file? Questa azione non può essere annullata.',
            'ADD_FILTERS' => 'Aggiungi filtri',
            'SEARCH_PAGES' => 'Cerca pagine',
            'VERSION' => 'Versione',
            'WAS_MADE_WITH' => 'Prodotto con',
            'BY' => 'Da',
            'UPDATE_THEME' => 'Aggiorna Tema',
            'UPDATE_PLUGIN' => 'Aggiorna Plugin',
            'OF_THIS_THEME_IS_NOW_AVAILABLE' => 'di questo tema è ora disponibile',
            'OF_THIS_PLUGIN_IS_NOW_AVAILABLE' => 'di questo plugin è ora disponibile',
            'AUTHOR' => 'Autore',
            'HOMEPAGE' => 'Pagina iniziale',
            'DEMO' => 'Demo',
            'BUG_TRACKER' => 'Bug Tracker',
            'KEYWORDS' => 'Parole chiave',
            'LICENSE' => 'Licenza',
            'DESCRIPTION' => 'Descrizione',
            'README' => 'Leggimi',
            'REMOVE_THEME' => 'Rimuovi tema',
            'INSTALL_THEME' => 'Installa tema',
            'THEME' => 'Tema',
            'BACK_TO_THEMES' => 'Torna ai Temi',
            'BACK_TO_PLUGINS' => 'Torna ai Plugins',
            'CHECK_FOR_UPDATES' => 'Controlla aggiornamenti',
            'ADD' => 'Aggiungi',
            'CLEAR_CACHE' => 'Svuota Cache',
            'CLEAR_CACHE_ALL_CACHE' => 'Tutta la Cache',
            'CLEAR_CACHE_ASSETS_ONLY' => 'Solo Assets',
            'CLEAR_CACHE_IMAGES_ONLY' => 'Solo Immagini',
            'CLEAR_CACHE_CACHE_ONLY' => 'Solo Cache',
            'DASHBOARD' => 'Pannello di Controllo',
            'UPDATES_AVAILABLE' => 'Aggiornamenti disponibili',
            'DAYS' => 'Giorni',
            'UPDATE' => 'Aggiorna',
            'BACKUP' => 'Backup',
            'STATISTICS' => 'Statistiche',
            'TODAY' => 'Oggi',
            'WEEK' => 'Settimana',
            'MONTH' => 'Mese',
            'LATEST_PAGE_UPDATES' => 'Ultimi Aggiornamenti della Pagina',
            'MAINTENANCE' => 'Manutenzione',
            'UPDATED' => 'Aggiornato',
            'MON' => 'Lun',
            'TUE' => 'Mar',
            'WED' => 'Mer',
            'THU' => 'Gio',
            'FRI' => 'Ven',
            'SAT' => 'Sab',
            'SUN' => 'Dom',
            'COPY' => 'Copia',
            'EDIT' => 'Modifica',
            'CREATE' => 'Crea',
            'GRAV_ADMIN' => 'Admin di Grav',
            'GRAV_OFFICIAL_PLUGIN' => 'Plugin Ufficiale Grav',
            'GRAV_OFFICIAL_THEME' => 'Tema Ufficiale Grav',
            'PLUGIN_SYMBOLICALLY_LINKED' => 'Questo plugin ha un link simbolico. Gli aggiornamenti verranno ignorati.',
            'THEME_SYMBOLICALLY_LINKED' => 'Questo tema ha un link simbolico. Gli aggiornamenti verranno ignorati',
            'REMOVE_PLUGIN' => 'Rimuovi Plugin',
            'INSTALL_PLUGIN' => 'Installa Plugin',
            'AVAILABLE' => 'Disponibile',
            'INSTALLED' => 'Installato',
            'INSTALL' => 'Installa',
            'ACTIVE_THEME' => 'Tema attivo',
            'SWITCHING_TO' => 'Passando a',
            'SWITCHING_TO_DESCRIPTION' => 'Cambiando il tema, non è garantito che tutti i layout di pagina siano supportati, potenzialmente causando errori quando si tenta di caricare tali pagine.',
            'SWITCHING_TO_CONFIRMATION' => 'Si desidera continuare e cambiare il tema',
            'CREATE_NEW_USER' => 'Crea nuovo utente',
            'REMOVE_USER' => 'Rimuovi utente',
            'ACCESS_DENIED' => 'Accesso negato',
            'ACCOUNT_NOT_ADMIN' => 'il tuo account non ha permessi di amministratore',
            'PHP_INFO' => 'PHP Info',
            'INSTALLER' => 'Installazione',
            'AVAILABLE_THEMES' => 'Temi disponibili',
            'AVAILABLE_PLUGINS' => 'Plugin disponibili',
            'INSTALLED_THEMES' => 'Temi installati',
            'INSTALLED_PLUGINS' => 'Plugins installati',
            'BROWSE_ERROR_LOGS' => 'Vedi log errori',
            'SITE' => 'Sito',
            'INFO' => 'Info',
            'SYSTEM' => 'Sistema',
            'USER' => 'Utente',
            'ADD_ACCOUNT' => 'Aggiungi utente',
            'SWITCH_LANGUAGE' => 'Cambia lingua',
            'SUCCESSFULLY_ENABLED_PLUGIN' => 'Plugin abilitato con successo',
            'SUCCESSFULLY_DISABLED_PLUGIN' => 'Plugin disabilitato con successo',
            'SUCCESSFULLY_CHANGED_THEME' => 'Tema cambiato con successo',
            'INSTALLATION_FAILED' => 'Intallazione fallita',
            'INSTALLATION_SUCCESSFUL' => 'Installazione avvenuta con successo',
            'UNINSTALL_FAILED' => 'Disinstallazione fallita',
            'UNINSTALL_SUCCESSFUL' => 'Disinstallazione riuscita',
            'SUCCESSFULLY_SAVED' => 'Salvato con successo',
            'SUCCESSFULLY_COPIED' => 'Copiato con successo',
            'REORDERING_WAS_SUCCESSFUL' => 'Riordinato con successo',
            'SUCCESSFULLY_DELETED' => 'Eliminato con successo',
            'SUCCESSFULLY_SWITCHED_LANGUAGE' => 'Lingua cambiata con successo',
            'INSUFFICIENT_PERMISSIONS_FOR_TASK' => 'Permissi insufficenti per l\'operazione',
            'CACHE_CLEARED' => 'Cache svuotata',
            'METHOD' => 'Metodo',
            'ERROR_CLEARING_CACHE' => 'Errore nella pulizia della cache',
            'AN_ERROR_OCCURRED' => 'Errore rilevato',
            'YOUR_BACKUP_IS_READY_FOR_DOWNLOAD' => 'Il tuo backup è pronto per il download',
            'DOWNLOAD_BACKUP' => 'Scarica backup',
            'PAGES_FILTERED' => 'Pagine filtrate',
            'NO_PAGE_FOUND' => 'Nessuna pagina trovata',
            'INVALID_PARAMETERS' => 'Parametri invalidi',
            'NO_FILES_SENT' => 'Nessun file inviato',
            'EXCEEDED_FILESIZE_LIMIT' => 'Superati i limiti di dimensione file',
            'UNKNOWN_ERRORS' => 'Errore sconosciuto',
            'EXCEEDED_GRAV_FILESIZSE_LIMIT' => 'Superato il limite di dimensioni per file.',
            'UNSUPPORTED_FILE_TYPE' => 'Tipo di file non supportato',
            'FAILED_TO_MOVE_UPLOADED_FILE' => 'Fallito lo spostamento del file caricato',
            'FILE_UPLOADED_SUCCESSFULLY' => 'File caricato con successo',
            'FILE_DELETED' => 'File eliminato',
            'FILE_COULD_NOT_BE_DELETED' => 'Il file non può essere eliminato',
            'FILE_NOT_FOUND' => 'File non trovato',
            'NO_FILE_FOUND' => 'Nessun file trovato',
            'GRAV_WAS_SUCCESSFULLY_UPDATED_TO' => 'Grav è stato correttamente aggiornato a',
            'GRAV_UPDATE_FAILED' => 'Aggiornamento di Grav fallito',
            'EVERYTHING_UPDATED' => 'Tutto aggiornato',
            'UPDATES_FAILED' => 'Aggiornamento fallito',
            'AVATAR_BY' => 'Avatar da',
            'LAST_BACKUP' => 'Ultimo Backup',
            'FULL_NAME' => 'Nome completo',
            'USERNAME' => 'Nome utente',
            'EMAIL' => 'Email',
            'PASSWORD' => 'Password',
            'PASSWORD_CONFIRM' => 'Conferma Password',
            'TITLE' => 'Titolo',
            'LANGUAGE' => 'Lingua',
            'ACCOUNT' => 'Profilo',
            'EMAIL_VALIDATION_MESSAGE' => 'Deve essere un indirizzo email valido',
            'PASSWORD_VALIDATION_MESSAGE' => 'La password deve contenere almeno un numero, una lettera maiuscola e una minuscola, ed essere lunga almeno 8 caratteri',
            'LANGUAGE_HELP' => 'Imposta la lingua preferita',
            'MEDIA' => 'Media',
            'DEFAULTS' => 'Impostazioni predefinite',
            'SITE_TITLE' => 'Titolo del sito',
            'SITE_TITLE_PLACEHOLDER' => 'Titolo di tutto il sito',
            'SITE_TITLE_HELP' => 'Il titolo di default per il tuo sito, usato soprattutto dai temi',
            'DEFAULT_AUTHOR' => 'Autore predefinito',
            'DEFAULT_AUTHOR_HELP' => 'Un nome autore di default, usato dai temi o dal contenuto delle pagine',
            'DEFAULT_EMAIL' => 'Email predefinita',
            'DEFAULT_EMAIL_HELP' => 'Una email predefinita, usata dal tema o dalle pagine',
            'TAXONOMY_TYPES' => 'Tassonomie',
            'TAXONOMY_TYPES_HELP' => 'Le tassonomie devono essere definite qui per essere utilizzate nelle pagine',
            'PAGE_SUMMARY' => 'Sommario pagina',
            'ENABLED' => 'Abilitato',
            'ENABLED_HELP' => 'Abilita il sommario pagina (il sommario viene preso dal contenuto della pagina)',
            'YES' => 'Sì',
            'NO' => 'No',
            'SUMMARY_SIZE' => 'Dimensione del sommario',
            'SUMMARY_SIZE_HELP' => 'Il numero di caratteri del contenuto della pagina da usare come sommario',
            'FORMAT' => 'Formato',
            'FORMAT_HELP' => 'corto = usa la prima occorrenza di un delimitatore; lungo = il delimitatore di sommario verrà ignorato',
            'SHORT' => 'Corto',
            'LONG' => 'Lungo',
            'DELIMITER' => 'Delimitatore',
            'DELIMITER_HELP' => 'Il delimitatore di sommario (predefinito \'===\')',
            'METADATA' => 'Metadati',
            'METADATA_HELP' => 'I valori metadata predefiniti che verranno mostrati in ogni pagina, a meno che sovrascritti dalla pagina (override)',
            'NAME' => 'Nome',
            'CONTENT' => 'Contenuto',
            'REDIRECTS_AND_ROUTES' => 'Redirect & Route',
            'CUSTOM_REDIRECTS' => 'Redirect custom',
            'CUSTOM_REDIRECTS_HELP' => 'Route impostate per ridirigere gli alias indicati verso altre pagine. Regex accettate.',
            'CUSTOM_REDIRECTS_PLACEHOLDER_KEY' => '/il-tuo/alias',
            'CUSTOM_REDIRECTS_PLACEHOLDER_VALUE' => '/il-tuo/redirect',
            'CUSTOM_ROUTES' => 'Route custom',
            'CUSTOM_ROUTES_HELP' => 'Route impostate per essere alias di altre pagine. Regex accettate.',
            'CUSTOM_ROUTES_PLACEHOLDER_KEY' => '/il-tuo/alias',
            'CUSTOM_ROUTES_PLACEHOLDER_VALUE' => '/la-tua/route',
            'FILE_STREAMS' => 'Stream File',
            'DEFAULT' => 'Predefinito',
            'PAGE_MEDIA' => 'Media della pagina',
            'OPTIONS' => 'Opzioni',
            'PUBLISHED' => 'Pubblicato',
            'PUBLISHED_HELP' => 'Di default una pagina è pubblicata a meno che non venga esplicitamente impostata published: false, o con l\'opzione publish_date impostata per il futuro, o altrimenti con l\'opzione unpublish_date impostata nel passato',
            'DATE' => 'Data',
            'DATE_HELP' => 'La variabile data permette di specificare una data associata a questa pagina.',
            'PUBLISHED_DATE' => 'Data di pubblicazione',
            'PUBLISHED_DATE_HELP' => 'Fornisce una data che permette la pubblicazione automatica della pagina.',
            'UNPUBLISHED_DATE' => 'Data di rimozione dalla pubblicazione',
            'UNPUBLISHED_DATE_HELP' => 'Può fornire una data per rimuovere automaticamente la pubblicazione della pagina.',
            'ROBOTS' => 'Robot',
            'TAXONOMIES' => 'Tassonomie',
            'TAXONOMY' => 'Tassonomia',
            'ADVANCED' => 'Avanzato',
            'SETTINGS' => 'Settaggi',
            'FOLDER_NUMERIC_PREFIX' => 'Prefisso numerico della cartella',
            'FOLDER_NUMERIC_PREFIX_HELP' => 'Prefisso numerico che fornisce ordinamento manuale ed implica visibilità',
            'FOLDER_NAME' => 'Nome Cartella',
            'FOLDER_NAME_HELP' => 'Il nome della cartella che sarà memorizzato nel filesystem per questa pagina',
            'PARENT' => 'Superiore',
            'DEFAULT_OPTION_ROOT' => '- Radice -',
            'DEFAULT_OPTION_SELECT' => '- Seleziona -',
            'DISPLAY_TEMPLATE' => 'Visualizza Template',
            'DISPLAY_TEMPLATE_HELP' => 'Il tipo di pagina che si traduce nel template Twig che genera la pagina',
            'BODY_CLASSES' => 'Classi del tag body',
            'ORDERING' => 'Ordinamento',
            'PAGE_ORDER' => 'Ordine pagina',
            'OVERRIDES' => 'Sovrascrittura',
            'MENU' => 'Menu',
            'MENU_HELP' => 'La stringa da utilizzare in un menù.  Se non impostata, verrà utilizzato il Title.',
            'SLUG' => 'Slug',
            'SLUG_HELP' => 'La variabile slug permette di specificare la porzione di URL associata alla pagina',
            'SLUG_VALIDATE_MESSAGE' => 'Lo slug deve contenere solo caratteri alfanumerici minuscoli e trattini',
            'PROCESS' => 'Processa',
            'PROCESS_HELP' => 'Controlla come sono processate le pagine. Può essere impostato per pagina anzichè globale',
            'DEFAULT_CHILD_TYPE' => 'Child Type Predefinito',
            'USE_GLOBAL' => 'Usa globale',
            'ROUTABLE' => 'Routabile',
            'ROUTABLE_HELP' => 'Se questa pagina è raggiungibile tramite URL',
            'CACHING' => 'Cache',
            'VISIBLE' => 'Visibile',
            'VISIBLE_HELP' => 'Determina se una pagina è visible nella navigazione',
            'DISABLED' => 'Disabilitato',
            'ITEMS' => 'Elementi',
            'ORDER_BY' => 'Ordina per',
            'ORDER' => 'Ordine',
            'FOLDER' => 'Cartella',
            'ASCENDING' => 'Ascendente',
            'DESCENDING' => 'Discendente',
            'ADD_MODULAR_CONTENT' => 'Aggiungi contenuto modulare',
            'PAGE_TITLE' => 'Titolo pagina',
            'PAGE_TITLE_HELP' => 'Il titolo della pagina',
            'PAGE' => 'Pagina',
            'MODULAR_TEMPLATE' => 'Template modulare',
            'FRONTMATTER' => 'Frontmatter',
            'FILENAME' => 'Nome del file',
            'PARENT_PAGE' => 'Pagina Superiore',
            'HOME_PAGE' => 'Pagina iniziale',
            'HOME_PAGE_HELP' => 'La pagina che Grav userà come pagina predefinita di base',
            'DEFAULT_THEME' => 'Tema predefinito',
            'DEFAULT_THEME_HELP' => 'Imposta il tema predefinito utilizzato da Grav (il predefinito è Antimatter)',
            'TIMEZONE' => 'Fuso orario',
            'TIMEZONE_HELP' => 'Sovrascrivi il fuso orario predefinito del server',
            'SHORT_DATE_FORMAT' => 'Formato di data corto',
            'SHORT_DATE_FORMAT_HELP' => 'Imposta il formato di data corto che può essere usato dai temi',
            'LONG_DATE_FORMAT' => 'Formato di data lungo',
            'LONG_DATE_FORMAT_HELP' => 'Imposta il formato di data lungo che può essere usato dai temi',
            'DEFAULT_ORDERING' => 'Ordine predefinito',
            'DEFAULT_ORDERING_HELP' => 'Le pagine in una lista saranno disposte in questo ordine a meno che sia sovrascritto',
            'DEFAULT_ORDERING_DEFAULT' => 'Predefinito - basato sul nome della cartella',
            'DEFAULT_ORDERING_FOLDER' => 'Cartella - basato su nome della cartella senza prefisso',
            'DEFAULT_ORDERING_TITLE' => 'Titolo - basato sul campo titolo nell\'intestazione della pagina',
            'DEFAULT_ORDERING_DATE' => 'Data - basato sul campo \'date\' nell\'intestazione della pagina',
            'DEFAULT_ORDER_DIRECTION' => 'Direzione ordinamento predefinita',
            'DEFAULT_ORDER_DIRECTION_HELP' => 'La direzione dell\'ordine delle pagine in una lista',
            'DEFAULT_PAGE_COUNT' => 'Numero di pagine predefinito',
            'DEFAULT_PAGE_COUNT_HELP' => 'Il numero massimo predefinito di pagine elencate in una lista',
            'DATE_BASED_PUBLISHING' => 'Pubblicazione basata sulla data',
            'DATE_BASED_PUBLISHING_HELP' => 'Rimuovi dalla pubblicazione automaticamente i post in base alla data',
            'EVENTS' => 'Eventi',
            'EVENTS_HELP' => 'Abilita o disabilita specifici eventi. Disabitando questo campo può causare problemi nei plugin',
            'REDIRECT_DEFAULT_ROUTE' => 'Redirect alla route predefinita',
            'REDIRECT_DEFAULT_ROUTE_HELP' => 'Esegui il redirect automatico di una pagina verso la sua route predefinita',
            'LANGUAGES' => 'Linguaggi',
            'SUPPORTED' => 'Supportati',
            'SUPPORTED_HELP' => 'Lista separata da virgole dei codici di linguaggio a 2 caratteri supportati (ad esempio en,fr,de)',
            'TRANSLATIONS_ENABLED' => 'Abilita traduzioni',
            'TRANSLATIONS_ENABLED_HELP' => 'Supporta le traduzioni in Grav, plugin e temi',
            'TRANSLATIONS_FALLBACK' => 'Fallback delle traduzioni',
            'TRANSLATIONS_FALLBACK_HELP' => 'Esegui il fallback delle traduzioni se la lingua attiva non ha una traduzione disponibile',
            'ACTIVE_LANGUAGE_IN_SESSION' => 'Linguaggio attivo nella sessione',
            'ACTIVE_LANGUAGE_IN_SESSION_HELP' => 'Memorizza il linguaggio attivo nella sessione',
            'HTTP_HEADERS' => 'Intestazioni HTTP',
            'EXPIRES' => 'Scade',
            'EXPIRES_HELP' => 'Imposta l\'header expires. Il valore è espresso in secondi',
            'LAST_MODIFIED' => 'Ultima modifica',
            'LAST_MODIFIED_HELP' => 'Imposta l\'header di ultima modifica che può aiutare ad ottimizzare proxy e cache del browser',
            'ETAG' => 'ETag',
            'ETAG_HELP' => 'Imposta l\'header ETag per aiutare ad identificare quanto una pagina è stata modificata',
            'VARY_ACCEPT_ENCODING' => 'Vary accept encoding',
            'VARY_ACCEPT_ENCODING_HELP' => 'Imposta l\'header `Vary: Accept Encoding` per aiutare con proxy e cache del CDN',
            'MARKDOWN_EXTRA_HELP' => 'Abilita il supporto predefinito per Markdown Extra - https://michelf.ca/projects/php-markdown/extra/',
            'AUTO_LINE_BREAKS' => 'Interruzione di riga automatica',
            'AUTO_LINE_BREAKS_HELP' => 'Abilita il supporto per l\'interruzione di rigua automatica in markdown',
            'AUTO_URL_LINKS' => 'Link URL automatici',
            'AUTO_URL_LINKS_HELP' => 'Abilita la conversione automatica di URL in link HTML',
            'ESCAPE_MARKUP' => 'Escape del markup',
            'ESCAPE_MARKUP_HELP' => 'Abilita l\'escape automatico di tags di markup nelle entità HTML',
            'CACHING_HELP' => 'Switch globale per abilitare o disabilitare la cache di Grav',
            'CACHE_CHECK_METHOD' => 'Metodo controllo cache',
            'CACHE_CHECK_METHOD_HELP' => 'Seleziona il metodo usato da Grav per controllare che i file di una pagina siano stati modificati',
            'CACHE_DRIVER' => 'Driver di cache',
            'CACHE_DRIVER_HELP' => 'Scegli quale driver di cache deve essere usato da Grav. \'Auto Detect\' troverà il migliore automaticamente',
            'CACHE_PREFIX' => 'Prefisso cache',
            'CACHE_PREFIX_HELP' => 'Un identificatore per parte della chiave cache di Grav. Non modificare a meno di essere sicuri di quello che si sta facendo.',
            'CACHE_PREFIX_PLACEHOLDER' => 'Derivato dall\'URL di base (sovrascrivere inserendo una stringa random)',
            'LIFETIME' => 'Durata',
            'LIFETIME_HELP' => 'Imposta la durata della cache in secondi. 0 = infinito',
            'GZIP_COMPRESSION' => 'Compressione GZip',
            'GZIP_COMPRESSION_HELP' => 'Abilita la compressione GZip per incrementare la performance della pagina',
            'TWIG_TEMPLATING' => 'Template Twig',
            'TWIG_CACHING' => 'Cache di Twig',
            'TWIG_CACHING_HELP' => 'Controlla il sistema di caching di Twig. Abilitare per una migliore prestazione',
            'TWIG_DEBUG' => 'Debug Twig',
            'TWIG_DEBUG_HELP' => 'Abilita o meno l\'estensione Debugger di Twig',
            'DETECT_CHANGES' => 'Rileva cambiamenti',
            'DETECT_CHANGES_HELP' => 'Ricompila automaticamente la cache di Twig se vengono rilevati cambiamenti nei template Twig',
            'AUTOESCAPE_VARIABLES' => 'Autoescape variabili',
            'AUTOESCAPE_VARIABLES_HELP' => 'Autoescape tutte le variabili. Questo potrebbe facilmente causare errori nel sito',
            'ASSETS' => 'Assets',
            'CSS_PIPELINE' => 'Pipeline CSS',
            'CSS_PIPELINE_HELP' => 'La pipeline CSS è l\'unificazione di più file CSS in uno solo',
            'CSS_PIPELINE_INCLUDE_EXTERNALS' => 'Includere file esterni nella pipeline di CSS',
            'CSS_PIPELINE_INCLUDE_EXTERNALS_HELP' => 'Gli URL esterni a volte hanno riferimenti di file relativi e non dovrebbero essere sottoposti a pipelining',
            'CSS_PIPELINE_BEFORE_EXCLUDES' => 'Inserisci prima la pipeline di CSS',
            'CSS_PIPELINE_BEFORE_EXCLUDES_HELP' => 'Il rendering della pipeline CSS viene inserito prima di qualsiasi altro riferimento CSS non incluso',
            'CSS_MINIFY' => 'Minify CSS',
            'CSS_MINIFY_HELP' => 'Minify il CSS durante il pipelining',
            'CSS_MINIFY_WINDOWS_OVERRIDE' => 'CSS minify su Windows',
            'CSS_MINIFY_WINDOWS_OVERRIDE_HELP' => 'Ability il minify su piattaforma Windows. Disabilitato di default a causa di ThreadStackSize',
            'CSS_REWRITE' => 'Riscrivi CSS',
            'CSS_REWRITE_HELP' => 'Riscrivi tutti gli URL relativi contenuti nei file CSS durante il pipelining',
            'JAVASCRIPT_PIPELINE' => 'Pipeline JavaScript',
            'JAVASCRIPT_PIPELINE_HELP' => 'La pipeline di JavaScript è l\'unificazione di più file JS in uno solo',
            'JAVASCRIPT_PIPELINE_INCLUDE_EXTERNALS' => 'Includere file esterni nella pipeline di JS',
            'JAVASCRIPT_PIPELINE_INCLUDE_EXTERNALS_HELP' => 'Gli URL esterni a volte hanno riferimenti di file relativi e non dovrebbero essere sottoposti a pipelining',
            'JAVASCRIPT_PIPELINE_BEFORE_EXCLUDES' => 'Inserisci prima la pipeline di JS',
            'JAVASCRIPT_PIPELINE_BEFORE_EXCLUDES_HELP' => 'Il rendering della pipeline JS viene inserito prima di qualsiasi altro riferimento JS non incluso',
            'JAVASCRIPT_MINIFY' => 'Minify JavaScript',
            'JAVASCRIPT_MINIFY_HELP' => 'Attiva il minify di JavaScript durante il pipelining',
            'ENABLED_TIMESTAMPS_ON_ASSETS' => 'Abilita timestamp sugli assets',
            'ENABLED_TIMESTAMPS_ON_ASSETS_HELP' => 'Abilita timestamp sugli assets',
            'COLLECTIONS' => 'Collezioni',
            'ERROR_HANDLER' => 'Gestione degli errori',
            'DISPLAY_ERRORS' => 'Mostra errori',
            'DISPLAY_ERRORS_HELP' => 'Mostra l\'output completo degli errori',
            'LOG_ERRORS' => 'Log errori',
            'LOG_ERRORS_HELP' => 'Logga gli errori nella cartella /logs',
            'DEBUGGER' => 'Debugger',
            'DEBUGGER_HELP' => 'Abilita il debugger di Grav ed i seguenti settaggi',
            'DEBUG_TWIG' => 'Debug Twig',
            'DEBUG_TWIG_HELP' => 'Abilita il debug dei template Twig',
            'SHUTDOWN_CLOSE_CONNECTION' => 'Chiudi la connessione in onShutdown',
            'SHUTDOWN_CLOSE_CONNECTION_HELP' => 'Chiudi la connessione prima di chiamare onShutdown(). Disabilita in fase di debug.',
            'DEFAULT_IMAGE_QUALITY' => 'Qualità delle immagini predefinita',
            'DEFAULT_IMAGE_QUALITY_HELP' => 'La qualità predefinita per le immagini, utilizzata durante resampling o caching delle immagini (85%)',
            'CACHE_ALL' => 'Attiva la cache su tutte le immagini',
            'CACHE_ALL_HELP' => 'Attiva la cache su tutte le immagini, anche quelle che non subiscono manipolazioni da parte di Grav',
            'IMAGES_DEBUG' => 'Debug immagini',
            'IMAGES_DEBUG_HELP' => 'Mostra un overlay sopra le immagini riportante ad esempio la densità di pixel',
            'UPLOAD_LIMIT' => 'Limite di upload dei file',
            'UPLOAD_LIMIT_HELP' => 'Imposta la dimensione di massimo upload dei file, in byte (0 = illimitato)',
            'ENABLE_MEDIA_TIMESTAMP' => 'Abilita timestamps sui media',
            'ENABLE_MEDIA_TIMESTAMP_HELP' => 'Aggiunge un identificativo basato sulla data di ultima modifica di ogni media file',
            'SESSION' => 'Sessione',
            'SESSION_ENABLED_HELP' => 'Abilita il supporto alle sessioni in Grav',
            'TIMEOUT' => 'Timeout',
            'TIMEOUT_HELP' => 'Imposta il timeout di sessione, espresso in secondi',
            'SESSION_NAME_HELP' => 'Indentificatore usato per formare il nome del cookie di sessione',
            'ABSOLUTE_URLS' => 'URL assoluti',
            'ABSOLUTE_URLS_HELP' => 'URL assoluti o relativi per `base_url`',
            'PARAMETER_SEPARATOR' => 'Separatore dei parametri',
            'PARAMETER_SEPARATOR_HELP' => 'Separatore dei parametri passati, che può essere cambiato per Apache su Windows',
            'TASK_COMPLETED' => 'Operazione completata',
            'EVERYTHING_UP_TO_DATE' => 'Tutto aggiornato',
            'UPDATES_ARE_AVAILABLE' => 'aggiornamenti disponibili',
            'IS_AVAILABLE_FOR_UPDATE' => 'è disponibile per aggiornamento',
            'IS_NOW_AVAILABLE' => 'è ora disponibile',
            'CURRENT' => 'Corrente',
            'UPDATE_GRAV_NOW' => 'Aggiorna Grav adesso',
            'GRAV_SYMBOLICALLY_LINKED' => 'Grav è linkato simbolicamente, non è possibile aggiornare da qui',
            'UPDATING_PLEASE_WAIT' => 'Aggiornando... attendi per favore, sto scaricando',
            'OF_THIS' => 'di questo',
            'OF_YOUR' => 'del tuo',
            'HAVE_AN_UPDATE_AVAILABLE' => 'ha un aggiornamento disponibile',
            'SAVE_AS' => 'Salva come',
            'MODAL_DELETE_PAGE_CONFIRMATION_REQUIRED_DESC' => 'Sei sicuro di voler cancellare questa pagina e tutte le pagine figlie? Se la pagina è stata tradotta in altre lingue, tali lingue verranno preservate e dovranno essere cancellate singolarmente altrimenti verrà cancellata la cartella della pagina e tutte le sottopagine. Questa azione non può essere annullata.',
            'AND' => 'e',
            'UPDATE_AVAILABLE' => 'Aggiornamento disponibile',
            'METADATA_KEY' => 'Chiave (ad esempio \' parole chiave\')',
            'METADATA_VALUE' => 'Valore (ad esempio \' Blog, Grav\')',
            'USERNAME_HELP' => 'Il nome utente deve essere compreso tra 3 e 16 caratteri, composti da lettere minuscole, numeri, trattini o il carattere di sottolineatura. Lettere maiuscole, spazi e caratteri speciali non sono consentiti',
            'FULLY_UPDATED' => 'Tutto aggiornato',
            'SAVE_LOCATION' => 'Salvato in',
            'PAGE_FILE' => 'Modello di pagina',
            'PAGE_FILE_HELP' => 'Nome file del modello di pagina e, per impostazione predefinita, il modello di visualizzazione per questa pagina',
            'NO_USER_ACCOUNTS' => 'Nessun utente trovato, per cortesia creane uno prima...',
            'REDIRECT_TRAILING_SLASH' => 'Reindirizza trailing slash',
            'REDIRECT_TRAILING_SLASH_HELP' => 'Eseguire un redirect 301 piuttosto che utilizzare la gestione delle URI.',
            'DEFAULT_DATE_FORMAT' => 'Formato data pagina',
            'DEFAULT_DATE_FORMAT_HELP' => 'Formato data della pagina utilizzata da Grav. Come impostazione predefinita Grav cerca di utilizzare il tuo formato data, oppure puoi utilizzare un formato personalizzato seguendo la sintassi di PHP (esempio: Y-m-d H:i)',
            'DEFAULT_DATE_FORMAT_PLACEHOLDER' => 'Imposta automaticamente',
            'IGNORE_FILES' => 'Ignora i files',
            'IGNORE_FILES_HELP' => 'Files da ignorare quando le pagine vengono processate',
            'IGNORE_FOLDERS' => 'Ignora le cartelle',
            'IGNORE_FOLDERS_HELP' => 'Cartelle ignorate quando le pagine vengono processate',
            'HTTP_ACCEPT_LANGUAGE' => 'Importa la lingua dal Browser',
            'HTTP_ACCEPT_LANGUAGE_HELP' => 'Si può scegliere di tentare di impostare la lingua sulla base del tag utilizzato in `http_accept_language` nel browser',
            'OVERRIDE_LOCALE' => 'Sovrascrivi locale',
            'OVERRIDE_LOCALE_HELP' => 'Sovrascrivi l\'impostazione locale in PHP basato sulla tua lingua corrente',
            'REDIRECT' => 'Pagina di reindirizzamento',
            'REDIRECT_HELP' => 'Inserisci la route alla pagina oppure un URL esterno per questa pagina. Esempio: `/some/route` or `http://somesite.com`',
            'PLUGIN_STATUS' => 'Stato plugin',
            'INCLUDE_DEFAULT_LANG' => 'Include la lingua predefinita',
            'INCLUDE_DEFAULT_LANG_HELP' => 'Include l\'identificatore della lingua in tutti gli URL nella lingua predefinita e.g. `/en/blog/my-post`',
            'ALLOW_URL_TAXONOMY_FILTERS' => 'Abilita Filtri di Tassonomia via URL',
            'ALLOW_URL_TAXONOMY_FILTERS_HELP' => 'Abilita la possibilità di filtrare le pagine attraverso URL di tipo `/taxonomy:value`.',
            'REDIRECT_DEFAULT_CODE' => 'Codice redirect predefinito',
            'REDIRECT_DEFAULT_CODE_HELP' => 'L\'HTTP status code da utilizzare per i redirect',
            'IGNORE_HIDDEN' => 'Ignora file nascosti',
            'IGNORE_HIDDEN_HELP' => 'Ignora tutti i file e cartelle che iniziano con un PUNTO',
            'WRAPPED_SITE' => 'Sito wrappato',
            'WRAPPED_SITE_HELP' => 'Permette a temi e plugin di sapere se Grav è inserito (wrappato) in un altra piattaforma',
            'FALLBACK_TYPES' => 'Tipi di fallback file consentiti',
            'FALLBACK_TYPES_HELP' => 'Abilita i tipi di file a cui si può accedere tramite Page Route. Per default sono consentiti tutti i file media supportati.',
            'INLINE_TYPES' => 'Tipi di file inline',
            'INLINE_TYPES_HELP' => 'Lista di tipi di file che devono essere visualizzati anzichè scaricati',
            'APPEND_URL_EXT' => 'Appendi l\'estensione all\'URL',
            'APPEND_URL_EXT_HELP' => 'Aggiunge una estensione customizzata all\'URL della pagina. Nota, questo significa che Grav cercherà il template `<template>.<extension>.twig`',
            'PAGE_MODES' => 'Modalità della pagina',
            'PAGE_TYPES' => 'Tipi di pagina',
            'ACCESS_LEVELS' => 'Livelli di accesso',
            'GROUPS' => 'Gruppi',
            'GROUPS_HELP' => 'Lista dei gruppi a cui appartiene l\'utente',
            'ADMIN_ACCESS' => 'Accesso Amministrazione',
            'SITE_ACCESS' => 'Accesso Sito',
            'INVALID_SECURITY_TOKEN' => 'Token di sicurezza non valido',
            'ACTIVATE' => 'Attiva',
            'TWIG_UMASK_FIX' => 'Umask Fix',
            'TWIG_UMASK_FIX_HELP' => 'Per impostazione predefinita Twig crea file memorizzati nella cache come 0755, questa opzione li imposta 0775',
            'CACHE_PERMS' => 'Permessi Cache',
            'CACHE_PERMS_HELP' => 'Impostazione predefinita dei permessi della cartella cache. Solitamente 0755 o 0775 a seconda della configurazione',
            'REMOVE_SUCCESSFUL' => 'Rimozione avvenuta con Sucesso',
            'REMOVE_FAILED' => 'Rimozione Fallita',
            'HIDE_HOME_IN_URLS' => 'Nascondi il route Home negli URL',
            'HIDE_HOME_IN_URLS_HELP' => 'Assicura che i routes predefiniti per ogni pagina sotto Home, non riferiscano allo stesso route Home',
            'TWIG_FIRST' => 'Processa prima Twig',
            'TWIG_FIRST_HELP' => 'Se Twig Page Processing è abilitato, puoi configurare Twig in modo da essere processato prima o dopo Markdown',
            'SESSION_SECURE' => 'Cookie Sicuri',
            'SESSION_SECURE_HELP' => 'Indica che la comunicazione di questo cookie deve avvenire attraverso una trasmissione cifrata. ATTENZIONE: Abilitare soltanto su siti che vengono serviti esclusivamente via HTTPS',
            'SESSION_HTTPONLY' => 'Solo HTTP',
            'SESSION_HTTPONLY_HELP' => 'Indica che i cookie debbano soltanto essere usati attraverso HTTP, e la modifica via JavaScript non è abilitata',
            'REVERSE_PROXY' => 'Proxy inverso',
            'REVERSE_PROXY_HELP' => 'Abilitare se si utilizza proxy inverso e si riscontrano problemi con gli URL contenenti porte non corrette',
            'INVALID_FRONTMATTER_COULD_NOT_SAVE' => 'Frontmatter non valido, impossibile salvare',
            'ADD_FOLDER' => 'Aggiungi cartella',
            'PROXY_URL' => 'URL del proxy',
            'PROXY_URL_HELP' => 'Inserire l\'HOST o l\'IP del proxy e la porta',
            'NOTHING_TO_SAVE' => 'Nulla da salvare',
            'FILE_ERROR_ADD' => 'Si è verificato un errore durante il tentativo di aggiungere il file',
            'FILE_ERROR_UPLOAD' => 'Si è verificato un errore durante il tentativo di caricare il file',
            'FILE_UNSUPPORTED' => 'Tipo di file non supportato',
            'ADD_ITEM' => 'Aggiungi elemento',
            'FILE_TOO_LARGE' => 'Il file è troppo grande per essere caricato. Il massimo consentito è %s secondo
le tue impostazioni PHP. Aumentare il valore PHP di \'post_max_size\'',
            'INSTALLING' => 'Installazione',
            'LOADING' => 'Caricamento..',
            'DEPENDENCIES_NOT_MET_MESSAGE' => 'Le seguenti dipendenze devono essere soddisfatte prima:',
            'ERROR_INSTALLING_PACKAGES' => 'Errore durante l\'installazione del pacchetto/i',
            'INSTALLING_DEPENDENCIES' => 'Installa le dipendenze...',
            'INSTALLING_PACKAGES' => 'Installo i pacchetti...',
            'PACKAGES_SUCCESSFULLY_INSTALLED' => 'Pacchetto/i installati correttamente.',
            'READY_TO_INSTALL_PACKAGES' => 'Pronto per installare il pacchetto/i',
            'PACKAGES_NOT_INSTALLED' => 'Pacchetti non installati',
            'PACKAGES_NEED_UPDATE' => 'Pacchetti già installati, ma in una versione troppo vecchia',
            'PACKAGES_SUGGESTED_UPDATE' => 'Pacchetti già installati, ma che verranno aggiornati per avere l\'ultima versione disponibile',
            'REMOVE_THE' => 'Rimuovi il %s',
            'CONFIRM_REMOVAL' => 'Sicuro di voler cancellare questo %s?',
            'REMOVED_SUCCESSFULLY' => '%s rimosso con successo',
            'ERROR_REMOVING_THE' => 'Errore durante la rimozione di %s',
            'ADDITIONAL_DEPENDENCIES_CAN_BE_REMOVED' => '%s richiede le seguenti dipendenze, che non sono richiesti da altri pacchetti installati. Se non li si utilizza, è possibile rimuoverli direttamente da qui.',
            'READY_TO_UPDATE_PACKAGES' => 'Pronto ad aggiornare il pacchetto/i',
            'ERROR_UPDATING_PACKAGES' => 'Errore durante l\'aggiornamento del pacchetto/i',
            'UPDATING_PACKAGES' => 'Aggiorno il pacchetto/i...',
            'PACKAGES_SUCCESSFULLY_UPDATED' => 'Pacchetto/i aggiornati correttamente.',
            'UPDATING' => 'Aggiorno',
            'GPM_RELEASES' => 'GPM Releases',
            'GPM_RELEASES_HELP' => 'Scegliere \'Test\' per installare versioni beta o test',
            'STABLE' => 'Stabile',
            'TESTING' => 'Test',
            'FRONTMATTER_PROCESS_TWIG' => 'Elabora il frontmatter Twig',
            'FRONTMATTER_PROCESS_TWIG_HELP' => 'Quando attivate, è possibile utilizzare le variabili di configurazione Twig nel frontmatter della pagina',
            'FRONTMATTER_IGNORE_FIELDS' => 'Ignora i campi del frontmatter',
            'FRONTMATTER_IGNORE_FIELDS_HELP' => 'Alcuni campi del frontmatter potrebbero contenere Twig ma, come nei \'form\' questi non dovrebbero essere elaborati',
            'PACKAGE_X_INSTALLED_SUCCESSFULLY' => 'Pacchetto %s installato con successo',
            'NEEDS_GRAV_1_1' => ' Stai usando Grav v%s. È necessario aggiornare all\'ultima versione Grav v1.1.x al fine di garantire la compatibilità. Potrebbe essere necessario passare alle release di Testing GPM nella Configurazione di Sistema.',
            'ORDERING_DISABLED_BECAUSE_PARENT_SETTING_ORDER' => 'Ordinamento della parent, ordinamento disabilitato',
            'ORDERING_DISABLED_BECAUSE_PAGE_NOT_VISIBLE' => 'Pagina non visibile, ordinamento disabilitato',
            'ORDERING_DISABLED_BECAUSE_TOO_MANY_SIBLINGS' => 'L\'ordinamento tramite Admin non è supportato perché ci sono più di 200 elementi da ordinare',
            'CANNOT_ADD_MEDIA_FILES_PAGE_NOT_SAVED' => 'NOTA: non è possibile aggiungere file dei media fino a quando non si salva la pagina. Clicca \'Salva\' in alto per salvare la pagina',
            'CANNOT_ADD_FILES_PAGE_NOT_SAVED' => 'NOTA: La pagina deve essere salvata prima di poter caricare dei file.',
            'DROP_FILES_HERE_TO_UPLOAD' => 'Rilascia i file qui o fai click in questa area',
            'INSERT' => 'Inserisci',
            'UNDO' => 'Ripristina',
            'REDO' => 'Ripeti azione',
            'HEADERS' => 'Headers',
            'BOLD' => 'Grassetto',
            'ITALIC' => 'Corsivo',
            'STRIKETHROUGH' => 'Barrato',
            'SUMMARY_DELIMITER' => 'Segno di interruzione del riassunto',
            'LINK' => 'Link',
            'IMAGE' => 'Immagine',
            'BLOCKQUOTE' => 'Virgolettato',
            'UNORDERED_LIST' => 'Elenco non ordinato',
            'ORDERED_LIST' => 'Elenco ordinato',
            'EDITOR' => 'Editor',
            'PREVIEW' => 'Anteprima',
            'FULLSCREEN' => 'Schermo intero',
            'MODULAR' => 'Modulo',
            'NON_ROUTABLE' => 'Non-routabile',
            'NON_MODULAR' => 'Non modulo',
            'NON_VISIBLE' => 'Non visibile',
            'NON_PUBLISHED' => 'Non pubblicato',
            'CHARACTERS' => 'caratteri',
            'PUBLISHING' => 'Pubblicazione',
            'MEDIA_TYPES' => 'Tipi di media',
            'IMAGE_OPTIONS' => 'Opzioni immagine',
            'MIME_TYPE' => 'Tipo di MIME',
            'THUMB' => 'Miniatura immagine',
            'TYPE' => 'Tipo',
            'FILE_EXTENSION' => 'Estensioni dei file',
            'LEGEND' => 'Legenda di pagina',
            'MEMCACHE_SERVER' => 'Server Memcache',
            'MEMCACHE_SERVER_HELP' => 'L\'indirizzo del server Memcache',
            'MEMCACHE_PORT' => 'Porta Memcache',
            'MEMCACHE_PORT_HELP' => 'La porta del server Memcache',
            'MEMCACHED_SERVER' => 'Server Memcached',
            'MEMCACHED_SERVER_HELP' => 'L\'indirizzo del server nella Memcache',
            'MEMCACHED_PORT' => 'Porta Memcached',
            'MEMCACHED_PORT_HELP' => 'La porta del server nella Memcache',
            'REDIS_SERVER' => 'Server Redis',
            'REDIS_SERVER_HELP' => 'L\'indirizzo del server Redis',
            'REDIS_PORT' => 'Porta Redis',
            'REDIS_PORT_HELP' => 'La porta del server Redis',
            'ALL' => 'Tutti',
            'FROM' => 'da',
            'TO' => 'a'
        ]
    ]
];


text:
from django.contrib import admin
from django.utils.translation import ugettext as _
from vkontakte_api.admin import VkontakteModelAdmin
from models import User

class UserAdmin(VkontakteModelAdmin):
    def image_preview(self, obj):
        return u'' % (obj.photo_big, obj.photo)
    image_preview.short_description = u'Аватар'
    image_preview.allow_tags = True

    list_display = ('image_preview','first_name','last_name','vk_link','rate','sex','bdate','timezone','city','country','has_mobile','home_phone','mobile_phone',)
    list_display_links = ('first_name','last_name')
    list_filter = ('sex','has_mobile','timezone',)
    search_fields = ('first_name','last_name','screen_name')
    exclude = ('friends_users',)

admin.site.register(User, UserAdmin)


text:
using System;
using DNTProfiler.ServiceLayer.Contracts;

namespace DNTProfiler.WebFormsTest
{
    public partial class WebForm1 : BasePage
    {
        public IProductService ProductService { set; get; }

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                GridView1.DataSource = ProductService.GetAllProductsIncludeCategory();
                GridView1.DataBind();
            }
        }
    }
}


text:
// Generated by ast.js

package com.shapesecurity.shift.es2018.ast;

import javax.annotation.Nonnull;
import com.shapesecurity.functional.data.HashCodeBuilder;

public class Export implements ExportDeclaration {
    @Nonnull
    public final FunctionDeclarationClassDeclarationVariableDeclaration declaration;

    public Export (@Nonnull FunctionDeclarationClassDeclarationVariableDeclaration declaration) {
        this.declaration = declaration;
    }

    @Override
    public boolean equals(Object object) {
        return object instanceof Export && this.declaration.equals(((Export) object).declaration);
    }

    @Override
    public int hashCode() {
        int code = HashCodeBuilder.put(0, "Export");
        code = HashCodeBuilder.put(code, this.declaration);
        return code;
    }

}


text:
package org.apache.catalina.servlets;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;

import org.apache.catalina.Context;
import org.apache.catalina.WebResource;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.startup.TomcatBaseTest;
import org.apache.tomcat.util.buf.ByteChunk;

@RunWith(Parameterized.class)
public class TestDefaultServletIfMatchRequests extends TomcatBaseTest {

    private static final Integer RC_200 = Integer.valueOf(200);
    private static final Integer RC_304 = Integer.valueOf(304);
    private static final Integer RC_400 = Integer.valueOf(400);
    private static final Integer RC_412 = Integer.valueOf(412);

    private static final String[] CONCAT = new String[] { ",", " ,", ", ", " , " };
    private static String resourceETagStrong;
    private static String resourceETagWeak;

    @Parameterized.Parameters(name = "{index} resource-strong [{0}], matchHeader [{1}]")
    public static Collection<Object[]> parameters() {

        // Get the length of the file used for this test
        // It varies by platform due to line-endings
        File index = new File("test/webapp/index.html");
        resourceETagStrong = "\"" + index.length() + "-" + index.lastModified() + "\"";
        resourceETagWeak = "W/" + resourceETagStrong;

        String otherETagStrong = "\"123456789\"";
        String otherETagWeak = "W/\"123456789\"";

        List<Object[]> parameterSets = new ArrayList<>();

        for (Boolean resourceWithStrongETag : booleans) {
            // No match header
            parameterSets.add(new Object[] { resourceWithStrongETag, null, RC_200, RC_200 });

            // match header is invalid
            parameterSets.add(new Object[] { resourceWithStrongETag, "", RC_400, RC_400 });
            parameterSets.add(new Object[] { resourceWithStrongETag, "W", RC_400, RC_400 });
            parameterSets.add(new Object[] { resourceWithStrongETag, "W/", RC_400, RC_400 });
            parameterSets.add(new Object[] { resourceWithStrongETag, "w/" + resourceETagStrong, RC_400, RC_400 });
            parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong + " x", RC_400, RC_400 });
            parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong + "x", RC_400, RC_400 });
            for (String concat : CONCAT) {
                parameterSets.add(new Object[] { resourceWithStrongETag, concat + resourceETagStrong, RC_400, RC_400 });
                parameterSets.add(new Object[] { resourceWithStrongETag, concat + resourceETagWeak, RC_400, RC_400 });
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong + concat, RC_400, RC_400 });
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagWeak + concat, RC_400, RC_400 });
            }

            // match header always matches resource (leading and trailing space should be ignored)
            parameterSets.add(new Object[] { resourceWithStrongETag, "*", RC_200, RC_304 });
            parameterSets.add(new Object[] { resourceWithStrongETag, " *", RC_200, RC_304 });
            parameterSets.add(new Object[] { resourceWithStrongETag, "* ", RC_200, RC_304 });

            // match header never matches resource
            parameterSets.add(new Object[] { resourceWithStrongETag, otherETagStrong, RC_412, RC_200 });
            parameterSets.add(new Object[] { resourceWithStrongETag, otherETagWeak, RC_412, RC_200 });

            // match header includes weak tag
            parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagWeak, RC_412, RC_304 });
            for (String concat : CONCAT) {
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagWeak + concat + otherETagWeak,
                        RC_412, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagWeak + concat + otherETagStrong,
                        RC_412, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, otherETagWeak + concat + resourceETagWeak,
                        RC_412, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, otherETagStrong + concat + resourceETagWeak,
                        RC_412, RC_304 });
            }

            // match header includes strong entity tag
            // If-Match result depends on whether the resource has a strong entity tag
            Integer rcIfMatch;
            if (resourceWithStrongETag.booleanValue()) {
                rcIfMatch = RC_200;
            } else {
                rcIfMatch = RC_412;
            }
            parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong, rcIfMatch, RC_304 });
            for (String concat : CONCAT) {
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong + concat + otherETagWeak,
                        rcIfMatch, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, resourceETagStrong + concat + otherETagStrong,
                        rcIfMatch, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, otherETagWeak + concat + resourceETagStrong,
                        rcIfMatch, RC_304 });
                parameterSets.add(new Object[] { resourceWithStrongETag, otherETagStrong + concat + resourceETagStrong,
                        rcIfMatch, RC_304 });
            }
        }

        return parameterSets;
    }

    @Parameter(0)
    public boolean resourceHasStrongETag;

    @Parameter(1)
    public String matchHeader;

    @Parameter(2)
    public int ifMatchResponseCode;

    @Parameter(3)
    public int ifNoneMatchResponseCode;

    @Test
    public void testIfMatch() throws Exception {
        doMatchTest("If-Match", ifMatchResponseCode, false);
    }

    @Test
    public void testIfNoneMatch() throws Exception {
        doMatchTest("If-None-Match", ifNoneMatchResponseCode, true);
    }

    private void doMatchTest(String headerName, int responseCodeExpected, boolean responseHasEtag) throws Exception {
        Tomcat tomcat = getTomcatInstance();

        File appDir = new File("test/webapp");
        Context ctxt = tomcat.addContext("", appDir.getAbsolutePath());

        if (resourceHasStrongETag) {
            Tomcat.addServlet(ctxt, "default", DefaultWithStrongETag.class.getName());
        } else {
            Tomcat.addServlet(ctxt, "default", DefaultServlet.class.getName());
        }
        ctxt.addServletMappingDecoded("/", "default");

        tomcat.start();

        // Set up parameters
        String path = "http://localhost:" + getPort() + "/index.html";
        ByteChunk responseBody = new ByteChunk();
        Map<String,List<String>> responseHeaders = new HashMap<>();

        Map<String,List<String>> requestHeaders = null;
        if (matchHeader != null) {
            List<String> values = Collections.singletonList(matchHeader);
            requestHeaders = Collections.singletonMap(headerName, values);
        }

        int rc = getUrl(path, responseBody, requestHeaders, responseHeaders);

        // Check the result
        Assert.assertEquals(responseCodeExpected, rc);

        // If-None-Match should have a real resource ETag in successful response
        if (responseHasEtag && (rc == 200 || rc == 304)) {
            System.out.println(responseHeaders);
            String responseEtag = responseHeaders.get("ETag").get(0);
            Assert.assertEquals(resourceHasStrongETag ? resourceETagStrong : resourceETagWeak, responseEtag);
        }
    }

    public static class DefaultWithStrongETag extends DefaultServlet {

        private static final long serialVersionUID = 1L;

        @Override
        protected String generateETag(WebResource resource) {
            String weakETag = super.generateETag(resource);
            // Make it a strong ETag
            return weakETag.substring(2);
        }
    }
}