DNEnvironment

Complexity

Total Complexity

198

Size/Duplication

Total Lines	1331
Duplicated Lines	11.04 %

Coupling/Cohesion

Components	4
Dependencies	39

Importance

Changes	1
Bugs	0	Features	1

62 Methods

Rating	Name	Duplication	Size	Complexity
A	CurrentMenu()	0	3	1
A	getFullName()	0	3	1
A	create_from_path()	0	10	1
B	Backend()	0	23	4
A	Menu()	0	17	2
A	getDefaultURL()	0	3	1
A	getBareURL()	0	6	2
A	getBareDefaultURL()	0	6	2
A	HasPipelineSupport()	0	4	2
A	GenericPipeline()	0	5	1
A	GenericPipelineConfig()	0	6	2
A	loadPipelineConfig()	0	8	2
A	DependsOnEnvironment()	0	8	2
A	HasCurrentPipeline()	0	3	2
A	CurrentPipeline()	0	3	1
A	CanCancelPipeline()	0	7	2
B	canView()	0	21	7
B	canDeploy()	18	18	8
A	getCannotDeployMessage()	0	3	1
B	canRestore()	18	18	8
C	canBackup()	23	23	10
C	canUploadArchive()	23	23	10
B	canDownloadArchive()	18	18	8
B	canAbort()	15	15	5
B	canApprove()	14	14	5
B	canDeleteArchive()	18	18	8
A	getDeployersList()	0	9	1
A	getCanRestoreMembersList()	0	9	1
A	getCanBackupMembersList()	0	9	1
A	getArchiveUploadersList()	0	9	1
A	getArchiveDownloadersList()	0	9	1
A	getArchiveDeletersList()	0	9	1
A	getPipelineApproversList()	0	9	1
A	getPipelineCancellersList()	0	9	1
A	DNData()	0	3	1
B	CurrentBuild()	0	32	6
A	DeployHistory()	0	5	1
B	getCommitData()	0	24	3
A	Link()	0	3	1
A	isCurrent()	0	3	2
A	isSection()	0	5	2
A	buildPermissionField()	0	15	1
C	getCMSFields()	0	175	12
A	setDeployConfigurationFields()	0	20	3
B	setPipelineConfigurationFields()	0	25	4
A	onBeforeWrite()	0	9	3
A	onAfterWrite()	0	15	4
A	checkEnvironmentPath()	0	7	3
B	writeConfigFile()	0	16	8
B	writePipelineFile()	0	13	5
B	onAfterDelete()	0	12	5
A	getEnvironmentConfig()	0	6	2
A	envFileExists()	0	6	2
A	getConfigFilename()	0	9	3
A	getPipelineFilename()	0	10	3
A	pipelineFileExists()	0	7	2
B	array_to_viewabledata()	0	25	5
B	getDependentFilteredCommits()	0	25	5
A	enableMaintenace()	0	4	1
A	disableMaintenance()	0	4	1
A	validate()	0	10	3
A	runningDeployments()	0	8	1

<?php

/**
 * DNEnvironment
 *
 * This dataobject represents a target environment that source code can be deployed to.
 * Permissions are controlled by environment, see the various many-many relationships.
 *
 * @property string $Filename
 * @property string $Name
 * @property string $URL
 * @property string $BackendIdentifier
 * @property bool $DryRunEnabled
 * @property bool $Usage
 *
 * @method DNProject Project()
 * @property int $ProjectID
 *
 * @method HasManyList Deployments()
 * @method HasManyList DataArchives()
 * @method HasManyList Pipelines()
 *
 * @method ManyManyList Viewers()
 * @method ManyManyList ViewerGroups()
 * @method ManyManyList Deployers()
 * @method ManyManyList DeployerGroups()
 * @method ManyManyList CanRestoreMembers()
 * @method ManyManyList CanRestoreGroups()
 * @method ManyManyList CanBackupMembers()
 * @method ManyManyList CanBackupGroups()
 * @method ManyManyList ArchiveUploaders()
 * @method ManyManyList ArchiveUploaderGroups()
 * @method ManyManyList ArchiveDownloaders()
 * @method ManyManyList ArchiveDownloaderGroups()
 * @method ManyManyList ArchiveDeleters()
 * @method ManyManyList ArchiveDeleterGroups()
 * @method ManyManyList PipelineApprovers()
 * @method ManyManyList PipelineApproverGroups()
 * @method ManyManyList PipelineCancellers()
 * @method ManyManyList PipelineCancellerGroups()
 */
class DNEnvironment extends DataObject {

	/**
	 * If this is set to a full pathfile, it will be used as template
	 * file when creating a new capistrano environment config file.
	 *
	 * If not set, the default 'environment.template' from the module
	 * root is used
	 *
	 * @config
	 * @var string
	 */
	private static $template_file = '';

	/**
	 * Set this to true to allow editing of the environment files via the web admin
	 *
	 * @var bool
	 */
	private static $allow_web_editing = false;

	/**
	 * @var array
	 */
	private static $casting = array(
		'DeployHistory' => 'Text'
	);

	/**
	 * Allowed backends. A map of Injector identifier to human-readable label.
	 *
	 * @config
	 * @var array
	 */
	private static $allowed_backends = array();

	/**
	 * @var array
	 */
	public static $db = array(
		"Filename" => "Varchar(255)",
		"Name" => "Varchar(255)",
		"URL" => "Varchar(255)",
		"BackendIdentifier" => "Varchar(255)", // Injector identifier of the DeploymentBackend
		"DryRunEnabled" => "Boolean", // True if the dry run button should be enabled on the frontend
		"Usage" => "Enum('Production, UAT, Test, Unspecified', 'Unspecified')"
	);

	/**
	 * @var array
	 */
	public static $has_one = array(
		"Project" => "DNProject",
		"CreateEnvironment" => "DNCreateEnvironment"
	);

	/**
	 * @var array
	 */
	public static $has_many = array(
		"Deployments" => "DNDeployment",
		"DataArchives" => "DNDataArchive",
		"Pipelines" => "Pipeline" // Only one Pipeline can be 'Running' at any one time. @see self::CurrentPipeline().
	);

	/**
	 * @var array
	 */
	public static $many_many = array(
		"Viewers"            => "Member", // Who can view this environment
		"ViewerGroups"       => "Group",
		"Deployers"          => "Member", // Who can deploy to this environment
		"DeployerGroups" => "Group",
		"CanRestoreMembers"  => "Member", // Who can restore archive files to this environment
		"CanRestoreGroups"  => "Group",
		"CanBackupMembers"   => "Member", // Who can backup archive files from this environment
		"CanBackupGroups"   => "Group",
		"ArchiveUploaders"   => "Member", // Who can upload archive files linked to this environment
		"ArchiveUploaderGroups" => "Group",
		"ArchiveDownloaders" => "Member", // Who can download archive files from this environment
		"ArchiveDownloaderGroups" => "Group",
		"ArchiveDeleters"    => "Member", // Who can delete archive files from this environment,
		"ArchiveDeleterGroups" => "Group",
		"PipelineApprovers"  => "Member", // Who can approve / reject pipelines from this environment
		"PipelineApproverGroups" => "Group",
		"PipelineCancellers"   => "Member", // Who can abort pipelines
		"PipelineCancellerGroups" => "Group"
	);

	/**
	 * @var array
	 */
	public static $summary_fields = array(
		"Name" => "Environment Name",
		"Usage" => "Usage",
		"URL" => "URL",
		"DeployersList" => "Can Deploy List",
		"CanRestoreMembersList" => "Can Restore List",
		"CanBackupMembersList" => "Can Backup List",
		"ArchiveUploadersList" => "Can Upload List",
		"ArchiveDownloadersList" => "Can Download List",
		"ArchiveDeletersList"  => "Can Delete List",
		"PipelineApproversList" => "Can Approve List",
		"PipelineCancellersList" => "Can Cancel List"
	);

	private static $singular_name = 'Capistrano Environment';

	private static $plural_name = 'Capistrano Environments';

	/**
	 * @var array
	 */
	public static $searchable_fields = array(
		"Name",
	);

	/**
	 * @var string
	 */
	private static $default_sort = 'Name';

	/**
	 * Used by the sync task
	 *
	 * @param string $path
	 * @return \DNEnvironment
	 */
	public static function create_from_path($path) {
		$e = DNEnvironment::create();
		$e->Filename = $path;
		$e->Name = basename($e->Filename, '.rb');

		// add each administrator member as a deployer of the new environment
		$adminGroup = Group::get()->filter('Code', 'administrators')->first();
		$e->DeployerGroups()->add($adminGroup);
		return $e;
	}

	/**
	 * Get the deployment backend used for this environment.
	 *
	 * Enforces compliance with the allowed_backends setting; if the DNEnvironment.BackendIdentifier value is
	 * illegal then that value is ignored.
	 *
	 * @return DeploymentBackend
	 */
	public function Backend() {
		$backends = array_keys($this->config()->get('allowed_backends', Config::FIRST_SET));
		switch(sizeof($backends)) {
		// Nothing allowed, use the default value "DeploymentBackend"
			case 0:
				$backend = "DeploymentBackend";
				break;

			// Only 1 thing allowed, use that
			case 1:
				$backend = $backends[0];
				break;

			// Multiple choices, use our choice if it's legal, otherwise default to the first item on the list
			default:
				$backend = $this->BackendIdentifier;
				if(!in_array($backend, $backends)) {
					$backend = $backends[0];
				}
		}

		return Injector::inst()->get($backend);
	}

	public function Menu() {
		$list = new ArrayList();

		$controller = Controller::curr();
		$actionType = $controller->getField('CurrentActionType');

		$list->push(new ArrayData(array(
			'Link' => sprintf('naut/project/%s/environment/%s', $this->Project()->Name, $this->Name),
			'Title' => 'Deployments',
			'IsCurrent' => $this->isCurrent(),
			'IsSection' => $this->isSection() && $actionType == DNRoot::ACTION_DEPLOY
		)));

		$this->extend('updateMenu', $list);

		return $list;
	}

	/**
	 * Return the current object from $this->Menu()
	 * Good for making titles and things
	 */
	public function CurrentMenu() {
		return $this->Menu()->filter('IsSection', true)->First();
	}

	/**
	 * Return a name for this environment.
	 *
	 * @param string $separator The string used when concatenating project with env name
	 * @return string
	 */
	public function getFullName($separator = ':') {
		return sprintf('%s%s%s', $this->Project()->Name, $separator, $this->Name);
	}

	/**
	 * URL for the environment that can be used if no explicit URL is set.
	 */
	public function getDefaultURL() {
		return null;
	}

	public function getBareURL() {
		$url = parse_url($this->URL);
		if(isset($url['host'])) {
			return strtolower($url['host']);
		}
	}

	public function getBareDefaultURL() {
		$url = parse_url($this->getDefaultURL());
		if(isset($url['host'])) {
			return strtolower($url['host']);
		}
	}

	/**
	 * @return boolean true if there is a pipeline for the current environment.
	 */
	public function HasPipelineSupport() {
		$config = $this->GenericPipelineConfig();
		return $config instanceof ArrayData && isset($config->Steps);
	}

	/**
	 * Returns a {@link Pipeline} object that is linked to this environment, but isn't saved into the database. This
	 * shouldn't be saved into the database unless you plan on starting an actual pipeline.
	 *
	 * @return Pipeline
	 */
	public function GenericPipeline() {
		$pipeline = Pipeline::create();
		$pipeline->EnvironmentID = $this->ID;
		return $pipeline;
	}

	/**
	 * Returns the parsed config, based on a {@link Pipeline} being created for this {@link DNEnvironment}.
	 *
	 * @return ArrayData
	 */
	public function GenericPipelineConfig() {
		$config = $this->loadPipelineConfig();
		if($config) {
			return self::array_to_viewabledata($config);
		}
	}

	/**
	 * Extract pipeline configuration data from the source yml file
	 *
	 * @return array
	 */
	public function loadPipelineConfig() {
		require_once 'thirdparty/spyc/spyc.php';

		$path = $this->getPipelineFilename();
		if(file_exists($path)) {
			return Spyc::YAMLLoad($path);
		}
	}

	/**
	 * Returns the {@link DNEnvironment} object relating to the pipeline config for this environment. The environment
	 * YAML file (e.g. project1-uat.yml; see docs/en/pipelines.md) contains two variable called `DependsOnProject` and
	 * `DependsOnEnvironment` - these are used together to find the {@link DNEnvironment} that this environment should
	 * rely on.
	 */
	public function DependsOnEnvironment() {
		if($this->HasPipelineSupport()) {
			$pipeline = $this->GenericPipeline();
			return $pipeline->getDependentEnvironment();
		}

		return null;
	}

	/**
	 * @return bool true if there is a currently running Pipeline, and false if there isn't
	 */
	public function HasCurrentPipeline() {
		return $this->CurrentPipeline() && $this->CurrentPipeline()->isInDB();
	}

	/**
	 * This can be used to determine if there is a currently running pipeline (there can only be one running per
	 * {@link DNEnvironment} at once), as well as getting the current pipeline to be shown in templates.
	 *
	 * @return DataObject|null The currently running pipeline, or null if there isn't any.
	 */
	public function CurrentPipeline() {
		return $this->Pipelines()->filter('Status', array('Running', 'Rollback'))->first();
	}

	/**
	 * @return bool true if the current user can cancel a running pipeline
	 */
	public function CanCancelPipeline() {
		// do we have a current pipeline
		if($this->HasCurrentPipeline()) {
			return $this->CurrentPipeline()->canAbort();
		}
		return false;
	}

	/**
	 * Environments are only viewable by people that can view the environment.
	 *
	 * @param Member|null $member
	 * @return boolean
	 */
	public function canView($member = null) {
		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if(Permission::checkMember($member, 'ADMIN')) {
			return true;
		}

		// if no Viewers or ViewerGroups defined, fallback to DNProject::canView permissions
		if($this->Viewers()->exists() || $this->ViewerGroups()->exists()) {
			return $this->Viewers()->byID($member->ID)
				|| $member->inGroups($this->ViewerGroups());
		}

		return $this->Project()->canView($member);
	}

	/**
	 * Allow deploy only to some people.
	 *
	 * @param Member|null $member
	 * @return boolean
	 */
	public function canDeploy($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_DEPLOYMENT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_DEPLOYMENT, $member)) return true;
		}

		return $this->Deployers()->byID($member->ID)
			|| $member->inGroups($this->DeployerGroups());
	}

	/**
	 * Provide reason why the user cannot deploy.
	 *
	 * @return string
	 */
	public function getCannotDeployMessage() {
		return 'You cannot deploy to this environment.';
	}

	/**
	 * Allows only selected {@link Member} objects to restore {@link DNDataArchive} objects into this
	 * {@link DNEnvironment}.
	 *
	 * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
	 * @return boolean true if $member can restore, and false if they can't.
	 */
	public function canRestore($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) return true;
		}

		return $this->CanRestoreMembers()->byID($member->ID)
			|| $member->inGroups($this->CanRestoreGroups());
	}

	/**
	 * Allows only selected {@link Member} objects to backup this {@link DNEnvironment} to a {@link DNDataArchive}
	 * file.
	 *
	 * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
	 * @return boolean true if $member can backup, and false if they can't.
	 */
	public function canBackup($member = null) {

This method seems to be duplicated in your project.

		$project = $this->Project();
		if($project->HasDiskQuota() && $project->HasExceededDiskQuota()) {
			return false;
		}

		if(!$member) {
			$member = Member::currentUser();
		}
		// Must be logged in to check permissions
		if(!$member) {
			return false;
		}

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) return true;
		}

		return $this->CanBackupMembers()->byID($member->ID)
			|| $member->inGroups($this->CanBackupGroups());
	}

	/**
	 * Allows only selected {@link Member} objects to upload {@link DNDataArchive} objects linked to this
	 * {@link DNEnvironment}.
	 *
	 * Note: This is not uploading them to the actual environment itself (e.g. uploading to the live site) - it is the
	 * process of uploading a *.sspak file into Deploynaut for later 'restoring' to an environment. See
	 * {@link self::canRestore()}.
	 *
	 * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
	 * @return boolean true if $member can upload archives linked to this environment, false if they can't.
	 */
	public function canUploadArchive($member = null) {

This method seems to be duplicated in your project.

		$project = $this->Project();
		if($project->HasDiskQuota() && $project->HasExceededDiskQuota()) {
			return false;
		}

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) return true;
		}

		return $this->ArchiveUploaders()->byID($member->ID)
			|| $member->inGroups($this->ArchiveUploaderGroups());
	}

	/**
	 * Allows only selected {@link Member} objects to download {@link DNDataArchive} objects from this
	 * {@link DNEnvironment}.
	 *
	 * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
	 * @return boolean true if $member can download archives from this environment, false if they can't.
	 */
	public function canDownloadArchive($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) return true;
		}

		return $this->ArchiveDownloaders()->byID($member->ID)
			|| $member->inGroups($this->ArchiveDownloaderGroups());
	}

	/**
	 * Determine if the specified user can abort any pipelines
	 *
	 * @param Member|null $member
	 * @return boolean
	 */
	public function canAbort($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}

		if(Permission::checkMember($member, 'ADMIN')) {
			return true;
		}

		return $this->PipelineCancellers()->byID($member->ID)
			|| $member->inGroups($this->PipelineCancellerGroups());
	}

	/**
	 * Determine if the specified user can approve any pipelines
	 *
	 * @param Member|null $member
	 * @return boolean
	 */
	public function canApprove($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}

		if(Permission::checkMember($member, 'ADMIN')) {
			return true;
		}
		return $this->PipelineApprovers()->byID($member->ID)
			|| $member->inGroups($this->PipelineApproverGroups());
	}

	/**
	 * Allows only selected {@link Member} objects to delete {@link DNDataArchive} objects from this
	 * {@link DNEnvironment}.
	 *
	 * @param Member|null $member The {@link Member} object to test against. If null, uses Member::currentMember();
	 * @return boolean true if $member can delete archives from this environment, false if they can't.
	 */
	public function canDeleteArchive($member = null) {

This method seems to be duplicated in your project.

		if(!$member) {
			$member = Member::currentUser();
		}
		if(!$member) {
			return false;
		}
		// Must be logged in to check permissions

		if ($this->Usage==='Production' || $this->Usage==='Unspecified') {
			if ($this->Project()->allowed(DNRoot::ALLOW_PROD_SNAPSHOT, $member)) return true;
		} else {
			if ($this->Project()->allowed(DNRoot::ALLOW_NON_PROD_SNAPSHOT, $member)) return true;
		}

		return $this->ArchiveDeleters()->byID($member->ID)
			|| $member->inGroups($this->ArchiveDeleterGroups());
	}
	/**
	 * Get a string of groups/people that are allowed to deploy to this environment.
	 * Used in DNRoot_project.ss to list {@link Member}s who have permission to perform this action.
	 *
	 * @return string
	 */
	public function getDeployersList() {
		return implode(
			", ",
			array_merge(
				$this->DeployerGroups()->column("Title"),
				$this->Deployers()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to restore {@link DNDataArchive} objects into this environment.
	 *
	 * @return string
	 */
	public function getCanRestoreMembersList() {
		return implode(
			", ",
			array_merge(
				$this->CanRestoreGroups()->column("Title"),
				$this->CanRestoreMembers()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to backup {@link DNDataArchive} objects from this environment.
	 *
	 * @return string
	 */
	public function getCanBackupMembersList() {
		return implode(
			", ",
			array_merge(
				$this->CanBackupGroups()->column("Title"),
				$this->CanBackupMembers()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to upload {@link DNDataArchive}
	 *  objects linked to this environment.
	 *
	 * @return string
	 */
	public function getArchiveUploadersList() {
		return implode(
			", ",
			array_merge(
				$this->ArchiveUploaderGroups()->column("Title"),
				$this->ArchiveUploaders()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to download {@link DNDataArchive} objects from this environment.
	 *
	 * @return string
	 */
	public function getArchiveDownloadersList() {
		return implode(
			", ",
			array_merge(
				$this->ArchiveDownloaderGroups()->column("Title"),
				$this->ArchiveDownloaders()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to delete {@link DNDataArchive} objects from this environment.
	 *
	 * @return string
	 */
	public function getArchiveDeletersList() {
		return implode(
			", ",
			array_merge(
				$this->ArchiveDeleterGroups()->column("Title"),
				$this->ArchiveDeleters()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to approve pipelines
	 *
	 * @return string
	 */
	public function getPipelineApproversList() {
		return implode(
			", ",
			array_merge(
				$this->PipelineApproverGroups()->column("Title"),
				$this->PipelineApprovers()->column("FirstName")
			)
		);
	}

	/**
	 * Get a string of groups/people that are allowed to cancel pipelines
	 *
	 * @return string
	 */
	public function getPipelineCancellersList() {
		return implode(
			", ",
			array_merge(
				$this->PipelineCancellerGroups()->column("Title"),
				$this->PipelineCancellers()->column("FirstName")
			)
		);
	}

	/**
	 * @return DNData
	 */
	public function DNData() {
		return DNData::inst();
	}

	/**
	 * Get the current deployed build for this environment
	 *
	 * Dear people of the future: If you are looking to optimize this, simply create a CurrentBuildSHA(), which can be
	 * a lot faster. I presume you came here because of the Project display template, which only needs a SHA.
	 *
	 * @return false|DNDeployment
	 */
	public function CurrentBuild() {
		// The DeployHistory function is far too slow to use for this

		/** @var DNDeployment $deploy */
		$deploy = DNDeployment::get()->filter(array(
			'EnvironmentID' => $this->ID,
			'Status' => 'Finished'
		))->sort('LastEdited DESC')->first();

		if(!$deploy || (!$deploy->SHA)) {

The expression $deploy->SHA of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

			return false;
		}

		$repo = $this->Project()->getRepository();
		if(!$repo) {
			return $deploy;
		}

		try {
			$commit = $repo->getCommit($deploy->SHA);
			if($commit) {
				$deploy->Message = Convert::raw2xml($commit->getMessage());

The property Message does not exist on object<DNDeployment>. Since you implemented __set, maybe consider adding a @property annotation.

				$deploy->Committer = Convert::raw2xml($commit->getCommitterName());

The property Committer does not exist on object<DNDeployment>. Since you implemented __set, maybe consider adding a @property annotation.

				$deploy->CommitDate = $commit->getCommitterDate()->Format('d/m/Y g:ia');

The property CommitDate does not exist on object<DNDeployment>. Since you implemented __set, maybe consider adding a @property annotation.

				$deploy->Author = Convert::raw2xml($commit->getAuthorName());

The property Author does not exist on object<DNDeployment>. Since you implemented __set, maybe consider adding a @property annotation.

				$deploy->AuthorDate = $commit->getAuthorDate()->Format('d/m/Y g:ia');

The property AuthorDate does not exist on object<DNDeployment>. Since you implemented __set, maybe consider adding a @property annotation.

			}
			// We can't find this SHA, so we ignore adding a commit message to the deployment
		} catch(Exception $ex) { }

		return $deploy;
	}

	/**
	 * A history of all builds deployed to this environment
	 *
	 * @return ArrayList
	 */
	public function DeployHistory() {
		return $this->Deployments()
			->where('SHA IS NOT NULL')
			->sort('LastEdited DESC');
	}

	/**
	 * @param string $sha
	 * @return array
	 */
	protected function getCommitData($sha) {
		try {
			$repo = $this->Project()->getRepository();
			if($repo !== false) {
				$commit = new \Gitonomy\Git\Commit($repo, $sha);
				return [
					'AuthorName' => (string)Convert::raw2xml($commit->getAuthorName()),
					'AuthorEmail' => (string)Convert::raw2xml($commit->getAuthorEmail()),
					'Message' => (string)Convert::raw2xml($commit->getMessage()),
					'ShortHash' => Convert::raw2xml($commit->getFixedShortHash(8)),
					'Hash' => Convert::raw2xml($commit->getHash())
				];
			}
		} catch(\Gitonomy\Git\Exception\ReferenceNotFoundException $exc) {
			SS_Log::log($exc, SS_Log::WARN);
		}
		return array(
			'AuthorName' => '(unknown)',
			'AuthorEmail' => '(unknown)',
			'Message' => '(unknown)',
			'ShortHash' => $sha,
			'Hash' => '(unknown)',
		);
	}

	/**
	 * @return string
	 */
	public function Link() {
		return $this->Project()->Link() . "/environment/" . $this->Name;
	}

	/**
	 * Is this environment currently at the root level of the controller that handles it?
	 * @return bool
	 */
	public function isCurrent() {
		return $this->isSection() && Controller::curr()->getAction() == 'environment';
	}

	/**
	 * Is this environment currently in a controller that is handling it or performing a sub-task?
	 * @return bool
	 */
	public function isSection() {
		$controller = Controller::curr();
		$environment = $controller->getField('CurrentEnvironment');
		return $environment && $environment->ID == $this->ID;
	}


	/**
	 * Build a set of multi-select fields for assigning permissions to a pair of group and member many_many relations
	 *
	 * @param string $groupField Group field name
	 * @param string $memberField Member field name
	 * @param array $groups List of groups
	 * @param array $members List of members
	 * @return FieldGroup
	 */
	protected function buildPermissionField($groupField, $memberField, $groups, $members) {
		return FieldGroup::create(
			ListboxField::create($groupField, false, $groups)
				->setMultiple(true)
				->setAttribute('data-placeholder', 'Groups')
				->setAttribute('placeholder', 'Groups')
				->setAttribute('style', 'width: 400px;'),

			ListboxField::create($memberField, false, $members)
				->setMultiple(true)
				->setAttribute('data-placeholder', 'Members')
				->setAttribute('placeholder', 'Members')
				->setAttribute('style', 'width: 400px;')
		);
	}

	/**
	 * @return FieldList
	 */
	public function getCMSFields() {
		$fields = new FieldList(new TabSet('Root'));

		$project = $this->Project();
		if($project && $project->exists()) {
			$viewerGroups = $project->Viewers();
			$groups = $viewerGroups->sort('Title')->map()->toArray();
			$members = array();
			foreach($viewerGroups as $group) {
				foreach($group->Members()->map() as $k => $v) {
					$members[$k] = $v;
				}
			}
			asort($members);
		} else {
			$groups = array();
			$members = array();
		}

		// Main tab
		$fields->addFieldsToTab('Root.Main', array(
			// The Main.ProjectID
			TextField::create('ProjectName', 'Project')
				->setValue(($project = $this->Project()) ? $project->Name : null)
				->performReadonlyTransformation(),

			// The Main.Name
			TextField::create('Name', 'Environment name')
				->setDescription('A descriptive name for this environment, e.g. staging, uat, production'),


			$this->obj('Usage')->scaffoldFormField('Environment usage'),

			// The Main.URL field
			TextField::create('URL', 'Server URL')
				->setDescription('This url will be used to provide the front-end with a link to this environment'),

			// The Main.Filename
			TextField::create('Filename')
				->setDescription('The capistrano environment file name')
				->performReadonlyTransformation(),
		));

		// Backend identifier - pick from a named list of configurations specified in YML config
		$backends = $this->config()->get('allowed_backends', Config::FIRST_SET);
		// If there's only 1 backend, then user selection isn't needed
		if(sizeof($backends) > 1) {
			$fields->addFieldToTab('Root.Main', DropdownField::create('BackendIdentifier', 'Deployment backend')
				->setSource($backends)
				->setDescription('What kind of deployment system should be used to deploy to this environment'));
		}

		$fields->addFieldsToTab('Root.UserPermissions', array(
			// The viewers of the environment
			$this
				->buildPermissionField('ViewerGroups', 'Viewers', $groups, $members)
				->setTitle('Who can view this environment?')
				->setDescription('Groups or Users who can view this environment'),

			// The Main.Deployers
			$this
				->buildPermissionField('DeployerGroups', 'Deployers', $groups, $members)
				->setTitle('Who can deploy?')
				->setDescription('Groups or Users who can deploy to this environment'),

			// A box to select all snapshot options.
			$this
				->buildPermissionField('TickAllSnapshotGroups', 'TickAllSnapshot', $groups, $members)
				->setTitle("<em>All snapshot permissions</em>")
				->addExtraClass('tickall')
				->setDescription('UI shortcut to select all snapshot-related options - not written to the database.'),

			// The Main.CanRestoreMembers
			$this
				->buildPermissionField('CanRestoreGroups', 'CanRestoreMembers', $groups, $members)
				->setTitle('Who can restore?')
				->setDescription('Groups or Users who can restore archives from Deploynaut into this environment'),

			// The Main.CanBackupMembers
			$this
				->buildPermissionField('CanBackupGroups', 'CanBackupMembers', $groups, $members)
				->setTitle('Who can backup?')
				->setDescription('Groups or Users who can backup archives from this environment into Deploynaut'),

			// The Main.ArchiveDeleters
			$this
				->buildPermissionField('ArchiveDeleterGroups', 'ArchiveDeleters', $groups, $members)
				->setTitle('Who can delete?')
				->setDescription("Groups or Users who can delete archives from this environment's staging area."),

			// The Main.ArchiveUploaders
			$this
				->buildPermissionField('ArchiveUploaderGroups', 'ArchiveUploaders', $groups, $members)
				->setTitle('Who can upload?')
				->setDescription(
					'Users who can upload archives linked to this environment into Deploynaut.<br />' .
					'Linking them to an environment allows limiting download permissions (see below).'
				),

			// The Main.ArchiveDownloaders
			$this
				->buildPermissionField('ArchiveDownloaderGroups', 'ArchiveDownloaders', $groups, $members)
				->setTitle('Who can download?')
				->setDescription(<<<PHP
Users who can download archives from this environment to their computer.<br />
Since this implies access to the snapshot, it is also a prerequisite for restores
to other environments, alongside the "Who can restore" permission.<br>
Should include all users with upload permissions, otherwise they can't download
their own uploads.
PHP
				),

			// The Main.PipelineApprovers
			$this
				->buildPermissionField('PipelineApproverGroups', 'PipelineApprovers', $groups, $members)
				->setTitle('Who can approve pipelines?')
				->setDescription('Users who can approve waiting deployment pipelines.'),

			// The Main.PipelineCancellers
			$this
				->buildPermissionField('PipelineCancellerGroups', 'PipelineCancellers', $groups, $members)
				->setTitle('Who can cancel pipelines?')
				->setDescription('Users who can cancel in-progess deployment pipelines.')
		));

		// The Main.DeployConfig
		if($this->Project()->exists()) {
			$this->setDeployConfigurationFields($fields);
		}

		// The DataArchives
		$dataArchiveConfig = GridFieldConfig_RecordViewer::create();
		$dataArchiveConfig->removeComponentsByType('GridFieldAddNewButton');
		if(class_exists('GridFieldBulkManager')) {
			$dataArchiveConfig->addComponent(new GridFieldBulkManager());
		}
		$dataArchive = GridField::create('DataArchives', 'Data Archives', $this->DataArchives(), $dataArchiveConfig);
		$fields->addFieldToTab('Root.DataArchive', $dataArchive);

		// Pipeline templates
		$this->setPipelineConfigurationFields($fields);

		// Pipelines
		if($this->Pipelines()->Count()) {
			$pipelinesConfig = GridFieldConfig_RecordEditor::create();
			$pipelinesConfig->removeComponentsByType('GridFieldAddNewButton');
			if(class_exists('GridFieldBulkManager')) {
				$pipelinesConfig->addComponent(new GridFieldBulkManager());
			}
			$pipelines = GridField::create('Pipelines', 'Pipelines', $this->Pipelines(), $pipelinesConfig);
			$fields->addFieldToTab('Root.Pipelines', $pipelines);
		}

		// Deployments
		$deploymentsConfig = GridFieldConfig_RecordEditor::create();
		$deploymentsConfig->removeComponentsByType('GridFieldAddNewButton');
		if(class_exists('GridFieldBulkManager')) {
			$deploymentsConfig->addComponent(new GridFieldBulkManager());
		}
		$deployments = GridField::create('Deployments', 'Deployments', $this->Deployments(), $deploymentsConfig);
		$fields->addFieldToTab('Root.Deployments', $deployments);

		Requirements::javascript('deploynaut/javascript/environment.js');

		// Add actions
		$action = new FormAction('check', 'Check Connection');
		$action->setUseButtonTag(true);
		$dataURL = Director::absoluteBaseURL() . 'naut/api/' . $this->Project()->Name . '/' . $this->Name . '/ping';
		$action->setAttribute('data-url', $dataURL);
		$fields->insertBefore($action, 'Name');

'Name' is of type string, but the function expects a object<FormField>.

		// Allow extensions
		$this->extend('updateCMSFields', $fields);
		return $fields;
	}

	/**
	 * @param FieldList $fields
	 */
	protected function setDeployConfigurationFields(&$fields) {
		if(!$this->config()->get('allow_web_editing')) {
			return;
		}

		if($this->envFileExists()) {
			$deployConfig = new TextareaField('DeployConfig', 'Deploy config', $this->getEnvironmentConfig());
			$deployConfig->setRows(40);
			$fields->insertAfter($deployConfig, 'Filename');

'Filename' is of type string, but the function expects a object<FormField>.

			return;
		}

		$warning = 'Warning: This environment doesn\'t have deployment configuration.';
		$noDeployConfig = new LabelField('noDeployConfig', $warning);
		$noDeployConfig->addExtraClass('message warning');
		$fields->insertAfter($noDeployConfig, 'Filename');

'Filename' is of type string, but the function expects a object<FormField>.

		$createConfigField = new CheckboxField('CreateEnvConfig', 'Create Config');
		$createConfigField->setDescription('Would you like to create the capistrano deploy configuration?');
		$fields->insertAfter($createConfigField, 'noDeployConfig');

'noDeployConfig' is of type string, but the function expects a object<FormField>.

	}

	/**
	 * @param FieldList $fields
	 */
	protected function setPipelineConfigurationFields($fields) {
		if(!$this->config()->get('allow_web_editing')) {
			return;
		}
		$config = $this->pipelineFileExists()
			? file_get_contents($this->getPipelineFilename())
			: '';
		$deployConfig = new TextareaField('PipelineConfig', 'Pipeline config', $config);
		$deployConfig->setRows(40);
		if(!$this->pipelineFileExists()) {
			$deployConfig->setDescription(
				"No pipeline is configured for this environment. Saving content here will generate a new template."
			);
		}
		$fields->addFieldsToTab('Root.PipelineSettings', array(
			FieldGroup::create(
				CheckboxField::create('DryRunEnabled', 'Enable dry-run?')
			)
				->setTitle('Pipeline Options')
				->setDescription(
					"Allows admins to run simulated pipelines without triggering deployments or notifications."
				),
			$deployConfig
		));
	}

	/**
	 */
	public function onBeforeWrite() {
		parent::onBeforeWrite();
		if($this->Name && $this->Name . '.rb' != $this->Filename) {
			$this->Filename = $this->Name . '.rb';
		}
		$this->checkEnvironmentPath();
		$this->writeConfigFile();
		$this->writePipelineFile();
	}

	public function onAfterWrite() {
		parent::onAfterWrite();

		if($this->Usage == 'Production' || $this->Usage == 'UAT') {
			$conflicting = DNEnvironment::get()
				->filter('ProjectID', $this->ProjectID)
				->filter('Usage', $this->Usage)
				->exclude('ID', $this->ID);

			foreach($conflicting as $otherEnvironment) {
				$otherEnvironment->Usage = 'Unspecified';
				$otherEnvironment->write();
			}
		}
	}


	/**
	 * Ensure that environment paths are setup on the local filesystem
	 */
	protected function checkEnvironmentPath() {
		// Create folder if it doesn't exist
		$configDir = dirname($this->getConfigFilename());
		if(!file_exists($configDir) && $configDir) {
			mkdir($configDir, 0777, true);
		}
	}

	/**
	 * Write the deployment config file to filesystem
	 */
	protected function writeConfigFile() {
		if(!$this->config()->get('allow_web_editing')) {
			return;
		}

		// Create a basic new environment config from a template
		if(!$this->envFileExists()
			&& $this->Filename
			&& $this->CreateEnvConfig

The property CreateEnvConfig does not exist on object<DNEnvironment>. Since you implemented __get, maybe consider adding a @property annotation.

		) {
			$templateFile = $this->config()->template_file ?: BASE_PATH . '/deploynaut/environment.template';
			file_put_contents($this->getConfigFilename(), file_get_contents($templateFile));
		} else if($this->envFileExists() && $this->DeployConfig) {

The property DeployConfig does not exist on object<DNEnvironment>. Since you implemented __get, maybe consider adding a @property annotation.

			file_put_contents($this->getConfigFilename(), $this->DeployConfig);

The property DeployConfig does not exist on object<DNEnvironment>. Since you implemented __get, maybe consider adding a @property annotation.

		}
	}

	/**
	 * Write the pipeline config file to filesystem
	 */
	protected function writePipelineFile() {
		if(!$this->config()->get('allow_web_editing')) {
			return;
		}
		$path = $this->getPipelineFilename();
		if($this->PipelineConfig) {

The property PipelineConfig does not exist on object<DNEnvironment>. Since you implemented __get, maybe consider adding a @property annotation.

			// Update file
			file_put_contents($path, $this->PipelineConfig);

The property PipelineConfig does not exist on object<DNEnvironment>. Since you implemented __get, maybe consider adding a @property annotation.

		} elseif($this->isChanged('PipelineConfig') && file_exists($path)) {
			// Remove file if deleted
			unlink($path);
		}
	}

	/**
	 * Delete any related config files
	 */
	public function onAfterDelete() {
		parent::onAfterDelete();
		// Create a basic new environment config from a template
		if($this->config()->get('allow_web_editing') && $this->envFileExists()) {
			unlink($this->getConfigFilename());
		}

		$create = $this->CreateEnvironment();

The method CreateEnvironment does not exist on object<DNEnvironment>? Since you implemented __call, maybe consider adding a @method annotation.

		if($create && $create->exists()) {
			$create->delete();
		}
	}

	/**
	 * @return string
	 */
	protected function getEnvironmentConfig() {
		if(!$this->envFileExists()) {
			return '';
		}
		return file_get_contents($this->getConfigFilename());
	}

	/**
	 * @return boolean
	 */
	protected function envFileExists() {
		if(!$this->getConfigFilename()) {
			return false;
		}
		return file_exists($this->getConfigFilename());
	}

	/**
	 * Returns the path to the ruby config file
	 *
	 * @return string
	 */
	public function getConfigFilename() {
		if(!$this->Project()->exists()) {
			return '';
		}
		if(!$this->Filename) {
			return '';
		}
		return $this->DNData()->getEnvironmentDir() . '/' . $this->Project()->Name . '/' . $this->Filename;
	}

	/**
	 * Returns the path to the {@link Pipeline} configuration for this environment.
	 * Uses the same path and filename as the capistrano config, but with .yml extension.
	 *
	 * @return string
	 */
	public function getPipelineFilename() {
		$name = $this->getConfigFilename();
		if(!$name) {
			return null;
		}
		$path = pathinfo($name);
		if($path) {
			return $path['dirname'] . '/' . $path['filename'] . '.yml';
		}
	}

	/**
	 * Does this environment have a pipeline config file
	 *
	 * @return boolean
	 */
	protected function pipelineFileExists() {
		$filename = $this->getPipelineFilename();
		if(empty($filename)) {
			return false;
		}
		return file_exists($filename);
	}

	/**
	 * Helper function to convert a multi-dimensional array (associative or indexed) to an {@link ArrayList} or
	 * {@link ArrayData} object structure, so that values can be used in templates.
	 *
	 * @param array $array The (single- or multi-dimensional) array to convert
	 * @return object Either an {@link ArrayList} or {@link ArrayData} object, or the original item ($array) if $array
	 * isn't an array.
	 */
	public static function array_to_viewabledata($array) {
		// Don't transform non-arrays
		if(!is_array($array)) {
			return $array;
		}

		// Figure out whether this is indexed or associative
		$keys = array_keys($array);
		$assoc = ($keys != array_keys($keys));
		if($assoc) {
			// Treat as viewable data
			$data = new ArrayData(array());
			foreach($array as $key => $value) {
				$data->setField($key, self::array_to_viewabledata($value));
			}
			return $data;
		} else {
			// Treat this as basic non-associative list
			$list = new ArrayList();
			foreach($array as $value) {
				$list->push(self::array_to_viewabledata($value));
			}
			return $list;
		}
	}



	/**
	 * Helper function to retrieve filtered commits from an environment
	 * this environment depends on
	 *
	 * @return DataList
	 */
	public function getDependentFilteredCommits() {
		// check if this environment depends on another environemnt
		$dependsOnEnv = $this->DependsOnEnvironment();
		if(empty($dependsOnEnv)) {
			return null;
		}

		// Check if there is a filter
		$config = $this->GenericPipelineConfig();
		$filter = isset($config->PipelineConfig->FilteredCommits)
			? $config->PipelineConfig->FilteredCommits
			: null;
		if(empty($filter)) {
			return null;
		}

		// Create and execute filter
		if(!class_exists($filter)) {
			throw new Exception(sprintf("Class %s does not exist", $filter));
		}
		$commitClass = $filter::create();
		// setup the environment to check for commits
		$commitClass->env = $dependsOnEnv;
		return $commitClass->getCommits();
	}

	/**
	 * Enable the maintenance page
	 *
	 * @param DeploynautLogFile $log
	 */
	public function enableMaintenace($log) {
		$this->Backend()
			->enableMaintenance($this, $log, $this->Project());
	}

	/**
	 * Disable maintenance page
	 *
	 * @param DeploynautLogFile $log
	 */
	public function disableMaintenance($log) {
		$this->Backend()
			->disableMaintenance($this, $log, $this->Project());
	}

	protected function validate() {
		$result = parent::validate();
		$backend = $this->Backend();

		if(strcasecmp('test', $this->Name) === 0 && get_class($backend) == 'CapistranoDeploymentBackend') {
			$result->error('"test" is not a valid environment name when using Capistrano backend.');
		}

		return $result;
	}

	/**
	 * Fetchs all deployments in progress. Limits to 1 hour to prevent deployments
	 * if an old deployment is stuck.
	 *
	 * @return DataList
	 */
	public function runningDeployments() {
		return DNDeployment::get()
			->filter([
				'EnvironmentID' => $this->ID,
				'Status' => ['Queued', 'Started'],
				'Created:GreaterThan' => strtotime('-1 hour')
			]);
	}

}