private void GetByWebAppName()
        {
            const string progressDescriptionFormat = "Progress: {0}/{1} web apps processed.";
            var progressRecord = new ProgressRecord(1, string.Format("Get web apps with name '{0}'", Name), "Progress:");

            WriteProgress(progressRecord);

            var sites = this.ResourcesClient.FilterPSResources(new PSResourceManagerModels.BasePSResourceParameters()
            {
                ResourceType = "Microsoft.Web/Sites"
            }).Where(s => string.Equals(s.Name, Name, StringComparison.OrdinalIgnoreCase)).ToArray();

            var list = new List<Site>();
            for (var i = 0; i < sites.Length; i++)
            {
                var s = sites[i];
                var result = WebsitesClient.GetWebApp(s.ResourceGroupName, s.Name, null);
                if (result != null)
                {
                    list.Add(result);
                }

                progressRecord.StatusDescription = string.Format(progressDescriptionFormat, i + 1, sites.Length);
                progressRecord.PercentComplete = (100 * (i + 1)) / sites.Length;
                WriteProgress(progressRecord);
            }

            WriteObject(list);
        }

		public PowwaProgressRecord(ProgressRecord record)
		{
			if (record != null)
			{
				this.ActivityId = record.ActivityId;
				this.ParentActivityId = record.ParentActivityId;
				this.Activity = record.Activity;
				this.StatusDescription = record.StatusDescription;
				this.CurrentOperation = record.CurrentOperation;
				this.PercentComplete = record.PercentComplete;
				this.RecordType = record.RecordType;
				if (record.SecondsRemaining <= 0)
				{
					this.TimeRemaining = string.Empty;
					return;
				}
				else
				{
					object[] objArray = new object[1];
					objArray[0] = TimeSpan.FromSeconds((double)record.SecondsRemaining);
					this.TimeRemaining = string.Format(CultureInfo.CurrentCulture, "{0}", objArray);
					return;
				}
			}
			else
			{
				throw new ArgumentNullException("record");
			}
		}

 private void HelpSystem_OnProgress(object sender, HelpProgressInfo arg)
 {
     ProgressRecord progressRecord = new ProgressRecord(0, base.CommandInfo.Name, arg.Activity) {
         PercentComplete = arg.PercentComplete
     };
     base.WriteProgress(progressRecord);
 }

        //private readonly MemoryStream _MemoryStream = new MemoryStream();

        public CmdletListener(DomainCommand command, ProgressRecord progress)
        {
            //_MemoryStream
            //base.Writer = new StreamWriter();
            _command = command;
            _progress = progress;
        }

        protected async Task RunTransferJob(FileTransferJob job, ProgressRecord record)
        {
            this.SetRequestOptionsInTransferJob(job);
            job.AccessCondition = this.AccessCondition;
            job.OverwritePromptCallback = this.ConfirmOverwrite;

            try
            {
                await this.transferJobRunner.RunTransferJob(job,
                        (percent, speed) =>
                        {
                            record.PercentComplete = (int)percent;
                            record.StatusDescription = string.Format(CultureInfo.CurrentCulture, Resources.FileTransmitStatus, (int)percent, Util.BytesToHumanReadableSize(speed));
                            this.OutputStream.WriteProgress(record);
                        },
                        this.CmdletCancellationToken);

                record.PercentComplete = 100;
                record.StatusDescription = Resources.TransmitSuccessfully;
                this.OutputStream.WriteProgress(record);
            }
            catch (OperationCanceledException)
            {
                record.StatusDescription = Resources.TransmitCancelled;
                this.OutputStream.WriteProgress(record);
            }
            catch (Exception e)
            {
                record.StatusDescription = string.Format(CultureInfo.CurrentCulture, Resources.TransmitFailed, e.Message);
                this.OutputStream.WriteProgress(record);
                throw;
            }
        }

 internal void AddProgress(ProgressRecord item)
 {
     if (this.progress != null)
     {
         this.progress.InternalAdd(this.psInstanceId, item);
     }
 }

 static private void HandleTransferException(Exception e, ProgressRecord record, TaskOutputStream outputStream)
 {
     if (record != null)
     {
         record.StatusDescription = string.Format(CultureInfo.CurrentCulture, Resources.TransmitFailed, e.Message);
         outputStream.WriteProgress(record);
     }
 }

 private static ProgressRecord Validate(ProgressRecord progressRecord)
 {
     if (progressRecord == null)
     {
         throw new ArgumentNullException("progressRecord");
     }
     return progressRecord;
 }

 public void OnStartTest()
 {
     ProgressRecord pr = null;
     command.OnTaskStart(pr);
     pr = new ProgressRecord(0, "a", "b");
     pr.PercentComplete = 10;
     command.OnTaskStart(pr);
     Assert.AreEqual(0, pr.PercentComplete);
 }

        public override void WriteProgress(long sourceId, ProgressRecord record)
        {
            var ev = Progress;
            if (null == ev)
            {
                return;
            }

            ev(this, new ProgressRecordEventArgs(sourceId, record));
        }

 protected override void ProcessRecord()
 {
     ProgressRecord progressRecord = new ProgressRecord(this.Id, this.Activity, this.Status) {
         ParentActivityId = this.ParentId,
         PercentComplete = this.PercentComplete,
         SecondsRemaining = this.SecondsRemaining,
         CurrentOperation = this.CurrentOperation,
         RecordType = (this.Completed != 0) ? ProgressRecordType.Completed : ProgressRecordType.Processing
     };
     base.WriteProgress((long) this.SourceId, progressRecord);
 }

 /// <summary>
 /// Cloning constructor (all fields are value types - can treat our implementation of cloning as "deep" copy) 
 /// </summary>
 /// <param name="other"></param>
 internal ProgressRecord(ProgressRecord other)
 {
     _activity = other._activity;
     _currentOperation = other._currentOperation;
     _id = other._id;
     _parentId = other._parentId;
     _percent = other._percent;
     _secondsRemaining = other._secondsRemaining;
     _status = other._status;
     _type = other._type;
 }

		internal ProgressNode(long sourceId, ProgressRecord record) : base(record.ActivityId, record.Activity, record.StatusDescription)
		{
			this.Style = ProgressNode.RenderStyle.FullPlus;
			base.ParentActivityId = record.ParentActivityId;
			base.CurrentOperation = record.CurrentOperation;
			base.PercentComplete = Math.Min(record.PercentComplete, 100);
			base.SecondsRemaining = record.SecondsRemaining;
			base.RecordType = record.RecordType;
			this.Style = ProgressNode.RenderStyle.FullPlus;
			this.SourceId = sourceId;
		}

 public void SafeWriteProgress(ProgressRecord progress)
 {
     if (CommandRuntime != null)
     {
         WriteProgress(progress);
     }
     else
     {
         Trace.WriteLine(progress.StatusDescription);
     }
 }

        internal static ProgressDetails Create(ProgressRecord progressRecord)
        {
            //progressRecord.RecordType == ProgressRecordType.Completed;
            //progressRecord.Activity;
            //progressRecord.

            return new ProgressDetails
            {
                PercentComplete = progressRecord.PercentComplete
            };
        }

 public void OnFinishTest()
 {
     ProgressRecord pr = null;
     ArgumentException e = new ArgumentException("test");
     command.OnTaskFinish(pr, null);
     pr = new ProgressRecord(0, "a", "b");
     command.OnTaskFinish(pr, null);
     Assert.AreEqual(100, pr.PercentComplete);
     Assert.AreEqual(String.Format(Resources.TransmitSuccessfully), pr.StatusDescription);
     command.OnTaskFinish(pr, e);
     Assert.AreEqual(100, pr.PercentComplete);
     Assert.AreEqual(String.Format(Resources.TransmitFailed, e.Message), pr.StatusDescription);
 }

 internal ProgressRecord(ProgressRecord other)
 {
     this.parentId = -1;
     this.percent = -1;
     this.secondsRemaining = -1;
     this.activity = other.activity;
     this.currentOperation = other.currentOperation;
     this.id = other.id;
     this.parentId = other.parentId;
     this.percent = other.percent;
     this.secondsRemaining = other.secondsRemaining;
     this.status = other.status;
     this.type = other.type;
 }

        ProgressNode(Int64 sourceId, ProgressRecord record)
            :
            base(record.ActivityId, record.Activity, record.StatusDescription)
        {
            Dbg.Assert(record.RecordType == ProgressRecordType.Processing, "should only create node for Processing records");

            this.ParentActivityId = record.ParentActivityId;
            this.CurrentOperation = record.CurrentOperation;
            this.PercentComplete = Math.Min(record.PercentComplete, 100);
            this.SecondsRemaining = record.SecondsRemaining;
            this.RecordType = record.RecordType;
            this.Style = RenderStyle.FullPlus;
            this.SourceId = sourceId;
        }

        protected override void ProcessRecord()
        {
            ProgressRecord pr = new ProgressRecord(1, "Upload file", string.Format("Upload file \"{0}\" into Azure ML Studio", Path.GetFileName(UploadFileName)));
            pr.PercentComplete = 1;
            pr.CurrentOperation = "Uploading...";
            WriteProgress(pr);

            // step 1. upload file
            Task<string> uploadTask = Sdk.UploadResourceAsnyc(GetWorkspaceSetting(), FileFormat, UploadFileName);
            while (!uploadTask.IsCompleted)
            {
                if (pr.PercentComplete < 100)
                    pr.PercentComplete++;
                else
                    pr.PercentComplete = 1;
                Thread.Sleep(500);
                WriteProgress(pr);
            }

            // step 2. generate schema
            pr.PercentComplete = 2;
            pr.StatusDescription = "Generating schema for dataset \"" + DatasetName + "\"";
            pr.CurrentOperation = "Generating schema...";
            WriteProgress(pr);
            JavaScriptSerializer jss = new JavaScriptSerializer();
            dynamic parsed = jss.Deserialize<object>(uploadTask.Result);
            string dtId = parsed["DataTypeId"];
            string uploadId = parsed["Id"];
            string dataSourceId = Sdk.StartDatasetSchemaGen(GetWorkspaceSetting(), dtId, uploadId, DatasetName, Description, UploadFileName);

            // step 3. get status for schema generation
            string schemaJobStatus = "NotStarted";
            while (true)
            {
                if (pr.PercentComplete < 100)
                    pr.PercentComplete++;
                else
                    pr.PercentComplete = 1;
                pr.CurrentOperation = "Schema generation status: " + schemaJobStatus;
                WriteProgress(pr);

                schemaJobStatus = Sdk.GetDatasetSchemaGenStatus(GetWorkspaceSetting(), dataSourceId);
                if (schemaJobStatus == "NotSupported" || schemaJobStatus == "Complete" || schemaJobStatus == "Failed")
                    break;
            }
            pr.PercentComplete = 100;
            WriteProgress(pr);

            WriteObject("Dataset upload status: " + schemaJobStatus);
        }

        protected override void BeginProcessing()
        {
            ProgressRecord pr = new ProgressRecord(1, "Create Custom Module", string.Format("Upload custom module ZIP file \"{0}\" into Azure ML Studio", CustomModuleZipFileName));
            pr.PercentComplete = 1;
            pr.CurrentOperation = "Uploading custom module ZIP file...";
            WriteProgress(pr);
            string uploadedResourceMetadata = Sdk.UploadResource(GetWorkspaceSetting(), "Zip");
            JavaScriptSerializer jss = new JavaScriptSerializer();
            dynamic m = jss.Deserialize<object>(uploadedResourceMetadata);
            string uploadId = m["Id"];
            Task<string> task = Sdk.UploadResourceInChunksAsnyc(GetWorkspaceSetting(), 1, 0, uploadId, CustomModuleZipFileName, "Zip");
            while (!task.IsCompleted)
            {
                if (pr.PercentComplete < 100)
                    pr.PercentComplete++;
                else
                    pr.PercentComplete = 1;
                Thread.Sleep(500);
                WriteProgress(pr);
            }
            string uploadMetadata = task.Result;
            string activityId = Sdk.BeginParseCustomModuleJob(GetWorkspaceSetting(), uploadMetadata);

            pr.CurrentOperation = "Creating custom module...";
            WriteProgress(pr);
            dynamic statusObj = jss.Deserialize<object>(Sdk.GetCustomModuleBuildJobStatus(GetWorkspaceSetting(), activityId));
            string jobStatus = statusObj[0];
            while (jobStatus == "Pending")
            {
                if (pr.PercentComplete < 100)
                    pr.PercentComplete++;
                else
                    pr.PercentComplete = 1;
                statusObj = jss.Deserialize<object>(Sdk.GetCustomModuleBuildJobStatus(GetWorkspaceSetting(), activityId));
                jobStatus = statusObj[0].ToString();
                Thread.Sleep(500);
                WriteProgress(pr);
            }

            pr.PercentComplete = 100;
            WriteProgress(pr);

            if (jobStatus == "Finished")
            {
                string moduleId = statusObj[1];
                WriteObject(moduleId);
            }
            else
                throw new System.Exception("Custom module upload failed: " + statusObj[1]);
        }