protected void Page_Load(object sender, EventArgs e) { if (Page.IsPostBack) { Page.Validate(); if (Page.IsValid) { //get values from form string transactionAmountz = transactionAmount.Text; string customerAmountz = customerAmount.Text; //convert values double transactionAmount2 = Convert.ToDouble(transactionAmountz); double customerAmount2 = Convert.ToDouble(customerAmountz); double result = customerAmount2 - transactionAmount2; //class Change checking = new Change(); //set accessor checking.setValues(result); results.Text += "<h1>Change</h1>"; results.Text += "<div id='changeTotalDiv'><b>CHANGE AMOUNT = "+ result +"</b></div>"; //get accessor display results results.Text += checking.getValues(); form1.Visible = false; results.Visible = true; } } }
public Change UpcastIfRequired(Change toUpcast) { if (toUpcast.Version == Change.LatestVersion) return toUpcast; if (!UpcasterExistsFor(toUpcast)) return toUpcast; return GetUpcaster(toUpcast).Upcast(toUpcast); }
public void AddChange(Change c) { if (!this.Changes.Contains(c)) { this.Changes.Add(c); if (this.OnChange != null) { this.OnChange(this, c); } } }
private void Recurse(int amount, int index, Stack<Change> coins, Action<IEnumerable<Change>> emit) { if(amount == 0) { if(coins.Count!=0) emit(coins); return; } if(amount<0 || index<0) return; // It's the combination of solutions without the current coin : Recurse(amount, index - 1) // and the combination of the solutions minus the current amount and including the current coin Recurse(amount, index-1, coins, emit); if(m_Coins[index].Quantity>0) { var temp=m_Coins[index]; m_Coins[index]=new Change(temp.Coin,Math.Max(0, temp.Quantity-1)); coins.Push(new Change(m_Coins[index].Coin, 1)); Recurse(amount-m_Coins[index].Coin, index, coins, emit); m_Coins[index]=temp; coins.Pop(); } }
/// <summary> /// Converts a given <see cref="T:XElement"/> into a <see cref="T:ChangeSetHistory"/>. /// </summary> /// <param name="element">The <see cref="T:XElement"/> to convert.</param> /// <returns>The newly created <see cref="T:ChangeSetHistory"/>.</returns> public ChangeSetHistory FromXElement(XElement element) { ChangeSetHistory history = new ChangeSetHistory(); foreach (XElement changeSetElement in element.Nodes()) { ChangeSet changeSet = new ChangeSet(); // Get the change set details foreach (XElement changeSetElementChild in changeSetElement.Nodes()) { if (changeSetElementChild.Name.LocalName == "Applied") { changeSet.Applied = DateTime.Parse(changeSetElementChild.Value); } else if (changeSetElementChild.Name.LocalName == "Username") { changeSet.Username = changeSetElementChild.Value; } else if (changeSetElementChild.Name.LocalName == "Change") { Change change = new Change(); foreach (XElement changeElement in changeSetElementChild.Nodes()) { if (changeElement.Name.LocalName == "PropertyName") { change.PropertyName = changeElement.Value; } else if (changeElement.Name.LocalName == "OldValue") { change.OldValue = changeElement.Value; } else if (changeElement.Name.LocalName == "NewValue") { change.NewValue = changeElement.Value; } } changeSet.Changes.Add(change); } } history.Append(changeSet); } return history; }
public void UpdateChanges() { _changes.Clear(); var snapshot = _view.VisualSnapshot; var span = new SnapshotSpan(snapshot, 0, snapshot.Length); foreach (var tag in _aggregator.GetTags(span)) { ITextBuffer buffer = tag.Span.BufferGraph.TopBuffer; SnapshotPoint? start_pos = tag.Span.Start.GetPoint(buffer, PositionAffinity.Successor); SnapshotPoint? end_pos = tag.Span.End.GetPoint(buffer, PositionAffinity.Predecessor); if (start_pos.HasValue && end_pos.HasValue) { var change = new Change(); change.start_line = buffer.CurrentSnapshot.GetLineNumberFromPosition(start_pos.Value.Position); change.end_line = buffer.CurrentSnapshot.GetLineNumberFromPosition(end_pos.Value.Position); change.saved = !tag.Tag.ChangeTypes.HasFlag(ChangeTypes.ChangedSinceSaved); _changes.Add(change); } } if (ChangesChanged != null) ChangesChanged(this, EventArgs.Empty); }
/// <summary> /// Initializes a new instance of the <see cref="T:AclChangedEventArgs" /> class. /// </summary> /// <param name="entries">The entries that changed.</param> /// <param name="change">The change.</param> /// <exception cref="ArgumentNullException">If <paramref name="entries"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">If <paramref name="entries"/> is empty.</exception> public AclChangedEventArgs(AclEntry[] entries, Change change) { if(entries == null) throw new ArgumentNullException("entry"); if(entries.Length == 0) throw new ArgumentException("Entries cannot be empty", "entries"); this.entries = entries; this.change = change; }
/// <summary> /// constructor /// </summary> /// <param name="ChangingObject">changing object</param> /// <param name="ChangingPropertyName">changing property name pass "" if don't want </param> /// <param name="AutoAdd">pass true if you want to automatically push a change to undo or redo stack when desposing this object</param> /// <param name="UndoOrRedo">true = push change to undo stack when desposing false = push change to redo stack when desposing</param> /// <param name="ChangeToAdd">change to auto push</param> public ObjectChanging(object ChangingObject,string ChangingPropertyName,bool AutoAdd=false,bool UndoOrRedo=true,Change ChangeToAdd=null) { URD.NowChangingObject = ChangingObject; if (ChangingPropertyName != "" && ChangingPropertyName!=null) URD.NowChangingPropertyName = ChangingPropertyName; _AutoAdd = AutoAdd; _UndoOrRedo = UndoOrRedo; _ChangeToAdd = ChangeToAdd; }
public void Remove() { var person = new Person("Person", 10); var update = new Change<Person, string>(ChangeReason.Remove, "Person", person); Assert.AreEqual("Person", update.Key); Assert.AreEqual(ChangeReason.Remove, update.Reason); Assert.AreEqual(person, update.Current); Assert.AreEqual(Optional.None<Person>(), update.Previous); }
public void Add() { var person = new Person("Person", 10); var update = new Change<Person,Person>(ChangeReason.Add, person,person); Assert.AreEqual(person, update.Key); Assert.AreEqual(ChangeReason.Add, update.Reason); Assert.AreEqual(person, update.Current); Assert.AreEqual(Optional.None<Person>(), update.Previous); }
/// <summary> /// Initializes a new instance of the <see cref="T:RecentChange" /> class. /// </summary> /// <param name="page">The page pame.</param> /// <param name="title">The page title.</param> /// <param name="messageSubject">The message subject (or <c>null</c>).</param> /// <param name="dateTime">The date/time.</param> /// <param name="user">The user.</param> /// <param name="change">The change.</param> /// <param name="descr">The description (optional).</param> public RecentChange(string page, string title, string messageSubject, DateTime dateTime, string user, Change change, string descr) { this.page = page; this.title = title; this.messageSubject = messageSubject; this.dateTime = dateTime; this.user = user; this.change = change; this.descr = descr; }
public ChangeViewModel(IParserFinder parserFinder, IRunnerFactory runnerFactory, String workingDirectory, Change change) { _parserFinder = parserFinder; _runnerFactory = runnerFactory; _workingDirectory = workingDirectory; _change = change; }
internal void Show(Change change) { if (change == null) { Clear(); return; } var a = (change.ReferenceObject != null ? (change.ReferenceObject as Blob).RawData : new byte[0]); var b = (change.ComparedObject != null ? (change.ComparedObject as Blob).RawData : new byte[0]); Init(new Diff(a, b)); }
public void Update() { var current = new Person("Person", 10); var previous = new Person("Person", 9); var update = new Change<Person, string>(ChangeReason.Update, "Person", current, previous); Assert.AreEqual("Person", update.Key); Assert.AreEqual(ChangeReason.Update, update.Reason); Assert.AreEqual(current, update.Current); Assert.IsTrue(update.Previous.HasValue); Assert.AreEqual(previous, update.Previous.Value); }
public IEnumerator Load(string objName, string mtlName, string pngName) { Debug.Log (" ------------------------------------------- " + objName + ", " + mtlName + ", " + pngName); c = GameObject.Find ("Canvas").GetComponent<Change> (); loading = true; if (objData != null && objData.gameObjects != null) { for (var i = 0; i < objData.gameObjects.Length; i++) { Destroy (objData.gameObjects[i]); } } if(!mtlName.Equals("") && !pngName.Equals("")) { objFileName = URL_API + objName; objData = ObjReader.use.ConvertFileAsync (objFileName, true, standardMaterial, mtlName, pngName); } else { objData = ObjReader.use.ConvertFileAsync (objFileName, true, standardMaterial); } objData = ObjReader.use.ConvertFileAsync (objFileName, true, standardMaterial); while (!objData.isDone) { loadingText = "Loading... " + (objData.progress*100).ToString("f0") + "%"; if (Input.GetKeyDown (KeyCode.Escape)) { objData.Cancel(); loadingText = "Cancelled download"; loading = false; loadingText = "Error loading file"; c.ExitPanel (); yield break; } yield return null; } loading = false; if (objData == null || objData.gameObjects == null) { loadingText = "Error loading file"; c.ExitPanel (); yield return null; yield break; } //GameObject loadtext = GameObject.Find ("Canvas").transform.FindChild ("PanelPopupLoad").FindChild ("LoadText").gameObject; loadingText = "Import completed"; GameObject objecLoad = GameObject.Find ("material0"); GameObject model = GameObject.Find ("GameObjectModel").transform.FindChild("header").FindChild("default").gameObject; model.GetComponent<MeshFilter> ().mesh = objecLoad.GetComponent<MeshFilter> ().mesh; model.GetComponent<MeshRenderer> ().material = objecLoad.GetComponent<MeshRenderer> ().material; model.transform.position = new Vector3(model.transform.position.x,model.transform.position.y,model.transform.position.z); c.ExitPanel (); Destroy (objecLoad); objecLoad = GameObject.Find ("material0"); if(objecLoad != null) Destroy (objecLoad); //FocusOnObjects(); }
internal void Show(Change change) { if (change == null) { Clear(); return; } var a = (change.ReferenceObject != null ? (change.ReferenceObject as Blob).RawData : new byte[0]); var b = (change.ComparedObject != null ? (change.ComparedObject as Blob).RawData : new byte[0]); a = (Diff.IsBinary(a)==true ? Encoding.ASCII.GetBytes("Binary content\nFile size: "+a.Length) : a); b = (Diff.IsBinary(b) == true ? Encoding.ASCII.GetBytes("Binary content\nFile size: " + b.Length) : b); Init(new Diff(a, b)); }
public void Equality() { var a = new Change("file.txt", Change.StatusCode.Modified); Assert.Equal(a, a); var b = new Change("file.txt", Change.StatusCode.Modified); Assert.Equal(a, b); var c = new Change("file2.txt", Change.StatusCode.Modified); Assert.NotEqual(a, c); var d = new Change("fIlE.txt", Change.StatusCode.Modified); Assert.Equal(a, d); }
public void Track(string activityKey, string fromKey, string toKey, DateTime timestamp) { var activity = _repository.GetActivity(activityKey); var from = _repository.GetState(fromKey); var to = _repository.GetState(toKey); var change = new Change { Activity = activity, From = from, To = to, Timestamp = timestamp }; _repository.Add(change); }
/// <summary> /// Adds a new change. /// </summary> /// <param name="page">The page name.</param> /// <param name="title">The page title.</param> /// <param name="messageSubject">The message subject.</param> /// <param name="dateTime">The date/time.</param> /// <param name="user">The user.</param> /// <param name="change">The change.</param> /// <param name="descr">The description (optional).</param> public static void AddChange(string page, string title, string messageSubject, DateTime dateTime, string user, Change change, string descr) { RecentChange[] allChanges = GetAllChanges(); if(allChanges.Length > 0) { RecentChange lastChange = allChanges[allChanges.Length - 1]; if(lastChange.Page == page && lastChange.Title == title && lastChange.MessageSubject == messageSubject + "" && lastChange.User == user && lastChange.Change == change && (dateTime - lastChange.DateTime).TotalMinutes <= 60) { // Skip this change return; } } Settings.Provider.AddRecentChange(page, title, messageSubject, dateTime, user, change, descr); }
/// <summary> /// Performs a greedy algorithm change algorithm over the available coins. /// NOTE: It is valid for the changeAvailable sequence to have null values to /// indicate the absence of change. This simplifies the backtracking algorithm /// </summary> /// <param name="changeRequired">The change we need to give</param> /// <param name="changeAvailable">The change available for the algorithm</param> /// <returns>The outcome of the vending action</returns> protected VendingResult Greedy(int changeRequired, IEnumerable<Change> changeAvailable) { if(changeRequired < 0) throw new ArgumentException("change required must be at least zero", "changeRequired"); if(changeAvailable == null) throw new ArgumentNullException("changeAvailable"); int outstandingChangeRequired = changeRequired; List<Change> changeToGive = new List<Change>(); if(outstandingChangeRequired != 0) { foreach(Change change in changeAvailable) { if(change == null) continue; if(change.Denomination <= outstandingChangeRequired) { // We can use this denomination, work out how many we need int quantityNeeded = Math.Min(change.Quantity, outstandingChangeRequired / change.Denomination); // NOTE: Don't remove the change yet as this will invalidate the foreach enumeration Change changeToReturn = new Change(change.Denomination, quantityNeeded); changeToGive.Add(changeToReturn); outstandingChangeRequired -= changeToReturn.TotalValue; // Finished..? if(outstandingChangeRequired == 0) { break; } } } } if(outstandingChangeRequired == 0) { return VendingResult.CreateSuccess(changeToGive); } else { return VendingResult.CreateFailed(); } }
static bool TryRepresent(string value, string[] suffix, Change producer, out DateTime result) { result = DateTime.MinValue; foreach (var s in suffix) { if (!value.EndsWith(s, StringComparison.InvariantCultureIgnoreCase)) { continue; } var trimmed = value.Remove(value.Length - s.Length, s.Length).TrimEnd(); float res; if (!float.TryParse(trimmed, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out res)) { continue; } result = producer(res, DateTime.Now); return true; } return false; }
private int Count(int amount, int index) { if(amount==0) return 1; if(amount<0 || index<0) return 0; // It's the sum of the solutions without the current coin : Count(amount, index - 1) // plus the sum of the solutions minus the current amount and including the current coin int count1=Count(amount, index-1); int count2=0; if(m_Coins[index].Quantity>0) { var temp=m_Coins[index]; m_Coins[index]=new Change(temp.Coin, Math.Max(0,temp.Quantity-1)); count2=Count(amount-m_Coins[index].Coin, index); m_Coins[index]=temp; } return count1+count2; }
public static void RecordChangeInWebhookHistory(ClientContext cc, List changeList, Change change, ILogger log, string resourceId) { #region Grab the list used to write the webhook history // Ensure reference to the history list, create when not available List historyList = null; string historyListName = CloudConfigurationManager.GetSetting("HistoryListName"); if (!string.IsNullOrEmpty(historyListName)) { historyList = cc.Web.GetListByTitle(historyListName); if (historyList == null) { historyList = cc.Web.CreateList(ListTemplateType.GenericList, historyListName, false); cc.ExecuteQueryRetry(); } } #endregion if (historyList == null) { return; } try { ListItemCreationInformation newItem = new ListItemCreationInformation(); ListItem item = historyList.AddItem(newItem); item["Title"] = $"List {changeList.Title} had a Change of type \"{change.ChangeType.ToString()}\" on the item with Id {(change as ChangeItem).ItemId}. Change Token: {(change as ChangeItem).ChangeToken.StringValue}"; item.Update(); cc.ExecuteQueryRetry(); } catch (Exception ex) { log.LogError($"ERROR: {ex.Message}"); } }
protected void OnChange() => Change?.Invoke();
internal AreaChangeEntry(string sourcePath, string targetPath, Change change) : base("Area", sourcePath, targetPath, change) { }
public void Commit(IStorageTracer tracer) { if (_currentPosition == -1) { if (_logger.IsTrace) { _logger.Trace("No storage changes to commit"); } return; } if (_logger.IsTrace) { _logger.Trace("Committing storage changes"); } if (_changes[_currentPosition] == null) { throw new InvalidOperationException($"Change at current position {_currentPosition} was null when commiting {nameof(StorageProvider)}"); } if (_changes[_currentPosition + 1] != null) { throw new InvalidOperationException($"Change after current position ({_currentPosition} + 1) was not null when commiting {nameof(StorageProvider)}"); } HashSet <Address> toUpdateRoots = new HashSet <Address>(); bool isTracing = tracer != null; Dictionary <StorageAddress, ChangeTrace> trace = null; if (isTracing) { trace = new Dictionary <StorageAddress, ChangeTrace>(); } for (int i = 0; i <= _currentPosition; i++) { Change change = _changes[_currentPosition - i]; if (!isTracing && change.ChangeType == ChangeType.JustCache) { continue; } if (_committedThisRound.Contains(change.StorageAddress)) { if (isTracing && change.ChangeType == ChangeType.JustCache) { trace[change.StorageAddress] = new ChangeTrace(change.Value, trace[change.StorageAddress].After); } continue; } // if (_destructedStorages.ContainsKey(change.StorageAddress.Address)) // { // if (_destructedStorages[change.StorageAddress.Address].ChangeIndex > _currentPosition - i) // { // continue; // } // } _committedThisRound.Add(change.StorageAddress); if (change.ChangeType == ChangeType.Destroy) { continue; } int forAssertion = _intraBlockCache[change.StorageAddress].Pop(); if (forAssertion != _currentPosition - i) { throw new InvalidOperationException($"Expected checked value {forAssertion} to be equal to {_currentPosition} - {i}"); } switch (change.ChangeType) { case ChangeType.Destroy: break; case ChangeType.JustCache: break; case ChangeType.Update: if (_logger.IsTrace) { _logger.Trace($" Update {change.StorageAddress.Address}_{change.StorageAddress.Index} V = {change.Value.ToHexString(true)}"); } StorageTree tree = GetOrCreateStorage(change.StorageAddress.Address); Metrics.StorageTreeWrites++; toUpdateRoots.Add(change.StorageAddress.Address); tree.Set(change.StorageAddress.Index, change.Value); if (isTracing) { trace[change.StorageAddress] = new ChangeTrace(change.Value); } break; default: throw new ArgumentOutOfRangeException(); } } foreach (Address address in toUpdateRoots) { // since the accounts could be empty accounts that are removing (EIP-158) if (_stateProvider.AccountExists(address)) { Keccak root = RecalculateRootHash(address); _stateProvider.UpdateStorageRoot(address, root); } } Resettable <Change> .Reset(ref _changes, ref _capacity, ref _currentPosition, StartCapacity); _committedThisRound.Reset(); _intraBlockCache.Reset(); _originalValues.Reset(); // _destructedStorages.Clear(); if (isTracing) { ReportChanges(tracer, trace); } }
private async Task DocumentChanged(Change change) { UpdateTree(); }
private void addTransformer(Dictionary <int, Func <TNode, Scope, TNode> > transformers, Change change) { var transform = change.Transform; Func <TNode, Scope, TNode> existing; if (transformers.TryGetValue(change.ID, out existing)) { var newTransform = transform; transform = (node, scope) => { var result = existing(node, scope); return(newTransform(result, scope)); }; } transformers[change.ID] = transform; }
private void addTransformer(Dictionary <int, Func <TNode, TNode, TModel, Scope, TNode> > transformers, Change change) { var transform = change.SemanticalTransform; if (transform == null) { Debug.Assert(change.Transform != null); transform = (oldNode, newNode, model, scope) => change.Transform(oldNode, scope); } Func <TNode, TNode, TModel, Scope, TNode> existing; if (transformers.TryGetValue(change.ID, out existing)) { var newTransform = transform; transform = (oldNode, newNode, model, scope) => { var result = existing(oldNode, newNode, model, scope); return(newTransform(oldNode, result, model, scope)); }; } transformers[change.ID] = transform; }
private void addString(Change change) { jsonString.Append("{'changeType':'" + change.ChangeType + "','name':'" + change.Name + "','patientID':'" + change.PatientId + "','numVisits':'" + change.NumVisits + "'},"); }
public PlayerChangedEventArgs(Change registeredChange, int currentNumberOfPlayers) { RegisteredChange = registeredChange; CurrentNumberOfPlayers = currentNumberOfPlayers; }
/// <summary> /// Adds a new change. /// </summary> /// <param name="wiki">The wiki.</param> /// <param name="page">The page name.</param> /// <param name="title">The page title.</param> /// <param name="messageSubject">The message subject.</param> /// <param name="dateTime">The date/time.</param> /// <param name="user">The user.</param> /// <param name="change">The change.</param> /// <param name="descr">The description (optional).</param> public static void AddChange(string wiki, string page, string title, string messageSubject, DateTime dateTime, string user, Change change, string descr) { RecentChange[] allChanges = GetAllChanges(wiki); if (allChanges.Length > 0) { RecentChange lastChange = allChanges[allChanges.Length - 1]; if (lastChange.Page == page && lastChange.Title == title && lastChange.MessageSubject == messageSubject + "" && lastChange.User == user && lastChange.Change == change && (dateTime - lastChange.DateTime).TotalMinutes <= 60) { // Skip this change return; } } Settings.GetProvider(wiki).AddRecentChange(page, title, messageSubject, dateTime, user, change, descr); }
/// <summary> /// Used to modify recordset with value from api gateway code deploy in another account. /// </summary> /// <param name="jobEvent">CodePipeline event.</param> /// <param name="context">Lambda Context</param> /// <returns>Job success of the Lambda</returns> public async Task <AmazonWebServiceResponse> UpdateApiGatewayAliasRecordSet(CodePipelineJobEvent jobEvent, ILambdaContext context) { var jobId = jobEvent.CodePipelineJob.Id; context.Logger.LogLine($"JobId: {jobId}"); using (var codePipelineClient = new AmazonCodePipelineClient()) using (var s3Client = new AmazonS3Client()) using (var dnsClient = new AmazonRoute53Client()) { // Prep the user parameters var userParameters = jobEvent.CodePipelineJob.Data.ActionConfiguration.Configuration["UserParameters"]; context.Logger.LogLine("UserParameters:"); context.Logger.LogLine(userParameters); var paramDict = JsonConvert.DeserializeObject <Dictionary <string, string> >(userParameters); try { DnsSettings dnsSettings = null; // Get the first (only) input artifact var artifact = jobEvent.CodePipelineJob.Data.InputArtifacts.First(); var artifactBucketName = artifact.Location.S3Location.BucketName; var artifactBucketKey = artifact.Location.S3Location.ObjectKey; // Unzip and get json using (var getResponse = await s3Client.GetObjectAsync(artifactBucketName, artifactBucketKey)) { var memoryStream = new MemoryStream(); using (var objectStream = getResponse.ResponseStream) { objectStream.CopyTo(memoryStream); } var searchFile = paramDict["DnsJson"]; context.Logger.LogLine("Unziping artifact"); context.Logger.LogLine($"Searching for {searchFile}"); using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Read)) { foreach (var entry in archive.Entries) { var fileName = entry.Name; context.Logger.LogLine("Checking File: " + entry.Name); if (searchFile == fileName) { using (var fileStream = entry.Open()) using (var streamReader = new StreamReader(fileStream)) { var dnsJson = await streamReader.ReadToEndAsync(); dnsSettings = JsonConvert.DeserializeObject <DnsSettings>(dnsJson); } break; } } } } // Get the hosted zones in the tools region context.Logger.LogLine($"Searching for {dnsSettings.HostedZoneLookupDomainName}"); var hostedZones = await dnsClient.ListHostedZonesAsync(); var myHostedZone = hostedZones.HostedZones.FirstOrDefault(z => z.Name == dnsSettings.HostedZoneLookupDomainName); if (myHostedZone == null) { var noZoneMessage = $"Hosted Zone {dnsSettings.HostedZoneLookupDomainName} could not be found"; context.Logger.LogLine(noZoneMessage); var failureDetails = new FailureDetails { Message = noZoneMessage, Type = FailureType.ConfigurationError }; return(await codePipelineClient.PutJobFailureResultAsync(jobId, failureDetails)); } // The record set we need to create var recordSet = new ResourceRecordSet { Name = dnsSettings.WebApiDnsDomain, Type = RRType.A, ResourceRecords = new List <ResourceRecord> { new ResourceRecord { Value = $"ALIAS {dnsSettings.RegionalDomainName}" } } }; var rsChange = new Change { Action = ChangeAction.UPSERT, ResourceRecordSet = recordSet }; var rsChangeBatch = new ChangeBatch { Changes = new List <Change> { rsChange } }; // Create/Update the recordset var changeDnsRequest = new ChangeResourceRecordSetsRequest { ChangeBatch = rsChangeBatch, HostedZoneId = myHostedZone.Id }; var changeResponse = await dnsClient.ChangeResourceRecordSetsAsync(changeDnsRequest); // Log and send the success response context.Logger.LogLine($"Request Id {changeResponse.ChangeInfo.Id} submitted"); context.Logger.LogLine($"{dnsSettings.WebApiDnsDomain} => A ALIAS {dnsSettings.RegionalDomainName}"); var successResultRequest = new PutJobSuccessResultRequest { JobId = jobId }; return(await codePipelineClient.PutJobSuccessResultAsync(successResultRequest)); } catch (Exception ex) { // Send the failure response and log return(await DoException(codePipelineClient, ex, jobId, context)); } } }
public static Change CreateChange(int changeset, string path) { Change change = new Change(); change.Changeset = changeset; change.Path = path; return change; }
/// <summary> /// Generates a new fuzzed file, returns a string representing the path to the generated file. /// </summary> /// <returns></returns> public override string Next() { this.Changes.Clear(); string testFile = this.GetFileName(); FileStream fuzzedFile = new FileStream(testFile, FileMode.Create, FileAccess.Write); this.BaseFileStream.Position = 0; this.BaseFileStream.CopyTo(fuzzedFile); fuzzedFile.Flush(); Change change = new Change(); change.CurrentValue = new byte[(int)this.sizes[this.sizeCount]]; change.FuzzModificationByte = this.modificationValues[this.modificationValueCount]; change.FuzzModificationOperation = this.modifications[this.modificationCount]; change.Offset = this.currentPosition; this.BaseFileStream.Position = this.currentPosition; this.BaseFileStream.Read(change.CurrentValue, 0, change.CurrentValue.Length); byte[] temp = new byte[change.CurrentValue.Length]; for (int index = 0; index < temp.Length; ++index) temp[index] = (byte)this.modificationValues[this.modificationValueCount]; change.NewValue = this.Modify(change.CurrentValue, temp, this.GetOperation(change.FuzzModificationOperation)); fuzzedFile.Position = this.currentPosition; fuzzedFile.Write(change.NewValue, 0, change.NewValue.Length); fuzzedFile.Close(); this.Changes.Add(change); this.currentPosition += (int)this.increments[this.incrementCount]; if (currentPosition > this.endingByte) { this.currentPosition = this.startingByte; if(++this.modificationValueCount >= this.modificationValues.Count) { this.modificationValueCount = 0; if(++this.modificationCount >= this.modifications.Count) { this.modificationCount = 0; if (++this.sizeCount >= this.sizes.Count) { this.sizeCount = 0; if (++this.incrementCount >= this.increments.Count) this.incrementCount = 0; } } } } return testFile; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> public UpdateWithFilter(bool isMatch, Change <TObject, TKey> change) { IsMatch = isMatch; Change = change; }
/// <summary> /// Atomically update the ResourceRecordSet collection. /// Documentation https://developers.google.com/dns/v2beta1/reference/changes/create /// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong. /// </summary> /// <param name="service">Authenticated dns service.</param> /// <param name="project">Identifies the project addressed by this request.</param> /// <param name="managedZone">Identifies the managed zone addressed by this request. Can be the managed zone name or id.</param> /// <param name="body">A valid dns v2beta1 body.</param> /// <param name="optional">Optional paramaters.</param> /// <returns>ChangeResponse</returns> public static Change Create(dnsService service, string project, string managedZone, Change body, ChangesCreateOptionalParms optional = null) { try { // Initial validation. if (service == null) { throw new ArgumentNullException("service"); } if (body == null) { throw new ArgumentNullException("body"); } if (project == null) { throw new ArgumentNullException(project); } if (managedZone == null) { throw new ArgumentNullException(managedZone); } // Building the initial request. var request = service.Changes.Create(body, project, managedZone); // Applying optional parameters to the request. request = (ChangesResource.CreateRequest)SampleHelpers.ApplyOptionalParms(request, optional); // Requesting data. return(request.Execute()); } catch (Exception ex) { throw new Exception("Request Changes.Create failed.", ex); } }
// Internal action methods Sale will forward requests to // - As the base class for all states, any common logic can be included here // - To keep the core logic encapsulated in the Sale class, these methods call internal methods on the sale class internal virtual ActionResult AddChange(Change change) { return(Sale.AddChangeInternal(change)); }
/// Output method protected void Output(TextWriter writer, string[] tokens, FileSystemWatcher source, Change type, string name) { foreach (var token in tokens) { var path = Path.Combine(source.Path, name); switch (token[0]) { case 'e': writer.Write(type); if (Directory.Exists(path)) { writer.Write(",ISDIR"); } break; case 'f': writer.Write(Path.GetFileName(path)); break; case 'w': writer.Write(Path.Combine(source.Path, Path.GetDirectoryName(path))); break; case 'T': writer.Write(DateTime.Now); break; default: writer.Write(token); break; } } writer.WriteLine(); }
public void Advise(Lifetime lifetime, Action <R> handler) => Change.Advise(lifetime, handler);
public void Restore(int snapshot) { if (_logger.IsTrace) { _logger.Trace($"Restoring storage snapshot {snapshot}"); } if (snapshot > _currentPosition) { throw new InvalidOperationException($"{nameof(StorageProvider)} tried to restore snapshot {snapshot} beyond current position {_currentPosition}"); } if (snapshot == _currentPosition) { return; } List <Change> keptInCache = new List <Change>(); for (int i = 0; i < _currentPosition - snapshot; i++) { Change change = _changes[_currentPosition - i]; if (_intraBlockCache[change.StorageAddress].Count == 1) { if (_changes[_intraBlockCache[change.StorageAddress].Peek()].ChangeType == ChangeType.JustCache) { int actualPosition = _intraBlockCache[change.StorageAddress].Pop(); if (actualPosition != _currentPosition - i) { throw new InvalidOperationException($"Expected actual position {actualPosition} to be equal to {_currentPosition} - {i}"); } keptInCache.Add(change); _changes[actualPosition] = null; continue; } } int forAssertion = _intraBlockCache[change.StorageAddress].Pop(); if (forAssertion != _currentPosition - i) { throw new InvalidOperationException($"Expected checked value {forAssertion} to be equal to {_currentPosition} - {i}"); } // if (change.ChangeType == ChangeType.Destroy) // { // _storages[change.StorageAddress.Address] = _destructedStorages[change.StorageAddress.Address].Storage; // _destructedStorages.Remove(change.StorageAddress.Address); // } _changes[_currentPosition - i] = null; if (_intraBlockCache[change.StorageAddress].Count == 0) { _intraBlockCache.Remove(change.StorageAddress); } } _currentPosition = snapshot; foreach (Change kept in keptInCache) { _currentPosition++; _changes[_currentPosition] = kept; _intraBlockCache[kept.StorageAddress].Push(_currentPosition); } }
protected void btnSaveClose_Click(object sender, EventArgs e) { //PageContext.RegisterStartupScript(ActiveWindow.GetHidePostBackReference()); int budgetID = GetQueryIntValue("id"); if (budgetID > 0) { Infobasis.Data.DataEntity.BudgetTemplate data = DB.BudgetTemplates .Where(u => u.ID == budgetID).FirstOrDefault(); if (data == null) { // 参数错误,首先弹出Alert对话框然后关闭弹出窗口 Alert.Show("参数错误!", String.Empty, ActiveWindow.GetHideReference()); return; } data.Code = tbxCode.Text.Trim(); data.Name = tbxName.Text; data.DisplayOrder = Change.ToInt(tbxDisplayOrder.Text); if (Change.ToInt(DropDownProvince.SelectedValue) > 0) { data.ProvinceID = Change.ToInt(DropDownProvince.SelectedValue); data.ProvinceName = DropDownProvince.SelectedText; } if (Change.ToInt(DropDownBoxBudgetType.SelectedValue) > 0) { data.BudgetTypeID = Change.ToInt(DropDownBoxBudgetType.SelectedValue); data.BudgetTypeName = DropDownBoxBudgetType.SelectedText; } data.IsActive = tbxIsActive.Checked; data.BudgetTemplateStatus = tbxIsActive.Checked ? BudgetTemplateStatus.Enabled : BudgetTemplateStatus.Disabled; data.LastUpdateDatetime = DateTime.Now; data.Remark = tbxRemark.Text; data.LastUpdateByID = UserInfo.Current.ID; data.LastUpdateByName = UserInfo.Current.ChineseName; } else { Infobasis.Data.DataEntity.BudgetTemplate data = new Infobasis.Data.DataEntity.BudgetTemplate() { CreateDatetime = DateTime.Now, Code = tbxCode.Text.Trim(), Name = tbxName.Text, Remark = tbxRemark.Text, BudgetTemplateStatus = Infobasis.Data.DataEntity.BudgetTemplateStatus.Enabled }; data.DisplayOrder = Change.ToInt(tbxDisplayOrder.Text); if (Change.ToInt(DropDownProvince.SelectedValue) > 0) { data.ProvinceID = Change.ToInt(DropDownProvince.SelectedValue); data.ProvinceName = DropDownProvince.SelectedText; } if (Change.ToInt(DropDownBoxBudgetType.SelectedValue) > 0) { data.BudgetTypeID = Change.ToInt(DropDownBoxBudgetType.SelectedValue); data.BudgetTypeName = DropDownBoxBudgetType.Text; } data.IsActive = tbxIsActive.Checked; data.BudgetTemplateStatus = tbxIsActive.Checked ? BudgetTemplateStatus.Enabled : BudgetTemplateStatus.Disabled; DB.BudgetTemplates.Add(data); } SaveChanges(); ShowNotify("添加成功"); PageContext.RegisterStartupScript(ActiveWindow.GetHideRefreshReference()); }
public async Task <ChangeResourceRecordSetsResponse> ChangeResourceRecordSetsAsync(string zoneId, ResourceRecordSet resourceRecordSet, Change change) { var sw = Stopwatch.StartNew(); int _timeout = 5 * 60 * 10000; PriorRequestNotCompleteException exception = null; do { try { return(await _stopWatch.TimeLock(_rateLimit, _locker, async() => { return await _client.ChangeResourceRecordSetsAsync( new ChangeResourceRecordSetsRequest() { ChangeBatch = new ChangeBatch() { Changes = new List <Change>() { change } }, HostedZoneId = zoneId }).EnsureSuccessAsync(); })); } catch (PriorRequestNotCompleteException ex) //requires client reconnection { exception = ex; await Task.Delay(5000); _locker.Lock(() => { Initialize(); }); } } while (sw.ElapsedMilliseconds < _timeout); throw exception; }
/// <summary> /// Method doing actually something with the changes obtained via the web hook notification. /// In this demo we're just logging to a list, in your implementation you do what you need to do :-) /// </summary> private static void DoWork(ClientContext approvalCC, List approvalList, ClientContext notificationCC, List notificationSourceList, Change change, NotificationModel notification, TraceWriter log) { try { log.Info("Loading source item with id: " + ((ChangeItem)change).ItemId); log.Info("Notification Source List name:" + notificationSourceList.Title + " " + notificationSourceList.ParentWebUrl); ListItem li = notificationSourceList.GetItemById(((ChangeItem)change).ItemId); notificationCC.Load(li); notificationCC.ExecuteQuery(); log.Info("Loaded source item with ID: " + ((ChangeItem)change).ItemId); // Only add approval item if in PEnding approval status if (li.FieldValues["_ModerationStatus"].ToString() == "2") { var changeItem = change as ChangeItem; CamlQuery camlQuery = new CamlQuery(); camlQuery.ViewXml = "<View><Query><Where><And><And>"; camlQuery.ViewXml += $"<Eq><FieldRef Name='ClientState' /><Value Type='Text'>{notification.ClientState}</Value></Eq>"; camlQuery.ViewXml += $"<Eq><FieldRef Name='Resource' /><Value Type='Text'>{notification.Resource}</Value></Eq></And>"; camlQuery.ViewXml += $"<And><Eq><FieldRef Name='ItemId' /><Value Type='Text'>{changeItem.ItemId}</Value></Eq>"; camlQuery.ViewXml += $"<Eq><FieldRef Name='ActivityId' /><Value Type='Text'>{changeItem.UniqueId}</Value></Eq>"; camlQuery.ViewXml += $"</And></And></Where></Query></View>"; ListItemCollection matchingItems = approvalList.GetItems(camlQuery); approvalCC.Load(matchingItems); approvalCC.ExecuteQuery(); if (matchingItems.Count() == 0) { ListItemCreationInformation newItem = new ListItemCreationInformation(); ListItem item = approvalList.AddItem(newItem); var editor = li.FieldValues["Editor"] as FieldUserValue; item["Title"] = string.Format("List {0} had a Change of type \"{1}\" on the item with Id {2}.", notificationSourceList.Title, change.ChangeType.ToString(), (change as ChangeItem).ItemId); item["ClientState"] = notification.ClientState; item["SubscriptionId"] = notification.SubscriptionId; item["ExpirationDateTime"] = notification.ExpirationDateTime; item["Resource"] = notification.Resource; item["TenantId"] = notification.TenantId; item["SiteUrl"] = notification.SiteUrl; item["WebId"] = notification.WebId; item["ItemId"] = changeItem.ItemId; item["ActivityId"] = changeItem.UniqueId; item["EditorEmail"] = editor.Email; item["Activity"] = change.ChangeType.ToString(); item.Update(); approvalCC.ExecuteQueryRetry(); } } } catch (Exception exp) { log.Error("Unable to log approval: " + exp.Message + ":::" + exp.StackTrace); } }
private void changeChange_execute(Change change) //Change preferences { Data.Instance.ChangeSettings(change.Name); }
protected NodeChangeEntry(string source, string sourcePath, string targetPath, Change change) : base("AreasOrIteration", sourcePath, targetPath, change.ToString()) { }
/// <summary>Translates to.</summary> /// <param name="idiom">The idiom.</param> public static void TranslateTo(Idiom idiom) { Change.Invoke(null, idiom); }
public override string ToString() { return($"[{Change.ToString()}] {AttOriginId}/{Path.GetFileName(FilePath)}"); }
IChangeUpcaster GetUpcaster(Change toUpcast) { return upcasters.Single(u => u.ChangeType == toUpcast.GetType()); }
private Change compareGeometry(RevitElement current, RevitElement previous) { // try to do a comparison based on bounding boxes and locations... // this is CERTAINLY imperfect double tolerance = 0.0006; // decimal feet - 1/128"? double dist = -1; if (didMove(current.LocationPoint, previous.LocationPoint, tolerance, out dist)) { Change c = new Change() { ChangeType = Change.ChangeTypeEnum.Move, Category = current.Category, ElementId = current.ElementId, UniqueId = current.UniqueId, ChangeDescription = "Location Offset " + dist + " ft." }; if (current.BoundingBox != null) { c.BoundingBoxDescription = Utilities.RevitUtils.SerializeBoundingBox(current.BoundingBox); } // we want to check if the LocationPoint2 also moved? if ((current.LocationPoint2 != null) && (previous.LocationPoint2 != null) && (didMove(current.LocationPoint2, previous.LocationPoint2, tolerance, out dist))) { // both moved. record both. c.MoveDescription = Utilities.RevitUtils.SerializeDoubleMove(previous.LocationPoint, current.LocationPoint, previous.LocationPoint2, current.LocationPoint2); } else { // single move. c.MoveDescription = Utilities.RevitUtils.SerializeMove(previous.LocationPoint, current.LocationPoint); } return(c); } // only a move of the second one... if ((current.LocationPoint2 != null) && (previous.LocationPoint2 != null) && didMove(previous.LocationPoint2, current.LocationPoint2, tolerance, out dist)) { Change c = new Change() { ChangeType = Change.ChangeTypeEnum.Move, Category = current.Category, ElementId = current.ElementId, UniqueId = current.UniqueId, ChangeDescription = "Location Offset " + dist + " ft.", Level = current.Level }; if (current.BoundingBox != null) { c.BoundingBoxDescription = Utilities.RevitUtils.SerializeBoundingBox(current.BoundingBox); } // only one side moved though... c.MoveDescription = Utilities.RevitUtils.SerializeMove(previous.LocationPoint2, current.LocationPoint2); return(c); } // check rotation float rotationTolerance = 0.0349f; // two degrees? float rotationDiff = current.Rotation - previous.Rotation; if (Math.Abs(rotationDiff) > rotationTolerance) { Change c = new Change() { ChangeType = Change.ChangeTypeEnum.Rotate, Category = current.Category, ElementId = current.ElementId, UniqueId = current.UniqueId, ChangeDescription = "Rotation: " + ((rotationDiff) * 180.0 / Math.PI).ToString("F2") + " degrees", Level = current.Level }; if (current.BoundingBox != null) { c.BoundingBoxDescription = Utilities.RevitUtils.SerializeBoundingBox(current.BoundingBox); } c.RotationDescription = Utilities.RevitUtils.SerializeRotation(current.LocationPoint, XYZ.BasisZ, rotationDiff); return(c); } // now the bounding box... if ((current.BoundingBox != null) && (previous.BoundingBox != null)) { double maxDist = Math.Max(current.BoundingBox.Min.DistanceTo(previous.BoundingBox.Min), current.BoundingBox.Max.DistanceTo(previous.BoundingBox.Max)); if (maxDist > tolerance) { Change c = new Change() { ChangeType = Change.ChangeTypeEnum.GeometryChange, Category = current.Category, ElementId = current.ElementId, UniqueId = current.UniqueId, ChangeDescription = "BoundingBox Offset " + maxDist + " ft.", }; c.BoundingBoxDescription = Utilities.RevitUtils.SerializeBoundingBox(current.BoundingBox); return(c); } } return(null); }
private void OnNext(Change<JObject> obj, ref int onNext) { Console.WriteLine("On Next"); obj.Dump(); onNext++; }
private void ApplyChange(Change change) { // Zero-change if (change.Parameter == ModificationParameter.None || Mathf.Abs(change.Amount) < 1e-6) { return; } var oldHp = _hp; var hpFraction = _hp / MaxHealth; switch (change.Parameter) { case ModificationParameter.HpFlat: _hp = Mathf.Min(_hp + change.Amount, MaxHealth); break; case ModificationParameter.HpMult: _hp = Mathf.Min(_hp * (1 + change.Amount), MaxHealth); break; case ModificationParameter.MaxHpFlat: _maxHpFlatModSum += change.Amount; _hp = hpFraction * MaxHealth; break; case ModificationParameter.MaxHpMult: _maxHpMultModSum += change.Amount; _hp = hpFraction * MaxHealth; break; case ModificationParameter.DmgFlat: _dmgFlatModSum += change.Amount; break; case ModificationParameter.DmgMult: _dmgMultModSum += change.Amount; break; case ModificationParameter.EvasionChanceFlat: _evasionModMulProduct *= change.Amount; break; case ModificationParameter.CritChanceFlat: throw new NotImplementedException(); case ModificationParameter.SpeedFlat: _speedFlatModSum += change.Amount; break; case ModificationParameter.SpeedMult: _speedMultModSum += change.Amount; break; case ModificationParameter.SizeFlat: _sizeFlatModSum += change.Amount; break; case ModificationParameter.SizeMult: _sizeMultModSum += change.Amount; break; case ModificationParameter.SpellStacksFlat: _assFlatModSum += change.Amount; break; case ModificationParameter.SpellDamageAmpFlat: _spellDamageAmpFlatModSum += change.Amount; break; case ModificationParameter.Stun: _stunScale += change.Amount; break; } switch (change.Parameter) { // Update transform scale if changed case ModificationParameter.SizeFlat: case ModificationParameter.SizeMult: transform.localScale = _baseScale * Size; break; // Process hp change events case ModificationParameter.HpFlat: case ModificationParameter.HpMult: case ModificationParameter.MaxHpMult: case ModificationParameter.MaxHpFlat: // If taking damage if (_hp < oldHp) { if (_hp <= 0f) { HandleDeath(); } else { _animationController.PlayHitImpactAnimation(); } } HealthChanged?.Invoke(_hp); break; } }
public void AddToChanges(Change change) { base.AddObject("Changes", change); }
private IEnumerable <TurtleData> CompileQueue(List <ParsedData> data, CancellationToken token) { List <TurtleData> interData = new List <TurtleData>(); ParsedData current; UpdateVars(From); UpdateVars(To); int FromInt = From.Evaluate(); int ToInt = To.Evaluate(); int ChangeInt = 1; if (Operator == OperatorType.MinusEquals || Operator == OperatorType.PlusEquals) { UpdateVars(Change); ChangeInt = Change.Evaluate(); } void Exec(int i) { token.ThrowIfCancellationRequested(); for (int counter = 0; counter < data.Count; counter++) { current = data[counter]; current.Variables[LoopVariable] = i; foreach (var item in Variables) { current.Variables[item.Key] = item.Value; } if (current.IsBlock) { interData.AddRange(current.CompileBlock(token)); } else if (current is VariableData variableChange) { current.UpdateVars(variableChange.Value); Variables[variableChange.VariableName] = variableChange.Value.Evaluate(); } else { interData.Add(current.Compile(token)); } } } switch (Condition) { case ConditionType.Greater: { if (Operator == OperatorType.PlusPlus) { for (int i = FromInt; i > ToInt; i++) { Exec(i); } } if (Operator == OperatorType.PlusEquals) { for (int i = FromInt; i > ToInt; i += ChangeInt) { Exec(i); } } if (Operator == OperatorType.MinMin) { for (int i = FromInt; i > ToInt; i--) { Exec(i); } } if (Operator == OperatorType.MinusEquals) { for (int i = FromInt; i > ToInt; i -= ChangeInt) { Exec(i); } } break; } case ConditionType.Less: { if (Operator == OperatorType.PlusPlus) { for (int i = FromInt; i < ToInt; i++) { Exec(i); } } if (Operator == OperatorType.PlusEquals) { for (int i = FromInt; i < ToInt; i += ChangeInt) { Exec(i); } } if (Operator == OperatorType.MinMin) { for (int i = FromInt; i < ToInt; i--) { Exec(i); } } if (Operator == OperatorType.MinusEquals) { for (int i = FromInt; i < ToInt; i -= ChangeInt) { Exec(i); } } break; } case ConditionType.GreaterOrEqual: { if (Operator == OperatorType.PlusPlus) { for (int i = FromInt; i >= ToInt; i++) { Exec(i); } } if (Operator == OperatorType.PlusEquals) { for (int i = FromInt; i >= ToInt; i += ChangeInt) { Exec(i); } } if (Operator == OperatorType.MinMin) { for (int i = FromInt; i >= ToInt; i--) { Exec(i); } } if (Operator == OperatorType.MinusEquals) { for (int i = FromInt; i >= ToInt; i -= ChangeInt) { Exec(i); } } break; } case ConditionType.LessOrEqual: { if (Operator == OperatorType.PlusPlus) { for (int i = FromInt; i <= ToInt; i++) { Exec(i); } } if (Operator == OperatorType.PlusEquals) { for (int i = FromInt; i <= ToInt; i += ChangeInt) { Exec(i); } } if (Operator == OperatorType.MinMin) { for (int i = FromInt; i <= ToInt; i--) { Exec(i); } } if (Operator == OperatorType.MinusEquals) { for (int i = FromInt; i <= ToInt; i -= ChangeInt) { Exec(i); } } break; } } return(interData); }
private void BuildChanges() { changes = new Dictionary<int, Change>(); for (int i = 0; i < config.changes.Length; ++i) { Change change = new Change(config.changes[i]); changes.Add(change.code, change); } }
List <ChangeSet> GetChangeSetsInternal(string path) { var change_sets = new List <ChangeSet> (); GitCommand git; string log_args = "--since=1.month --name-status --date=iso --find-renames --no-merges --no-color"; if (path == null) { git = new GitCommand(LocalPath, "--no-pager log " + log_args); } else { path = path.Replace("\\", "/"); git = new GitCommand(LocalPath, "--no-pager log " + log_args + " -- \"" + path + "\""); } string output = git.StartAndReadStandardOutput(); if (path == null && string.IsNullOrWhiteSpace(output)) { git = new GitCommand(LocalPath, "--no-pager log -n 75 " + log_args); output = git.StartAndReadStandardOutput(); } // Offset the output so our log_regex can be simpler string commit_sep = "commit "; if (output.StartsWith(commit_sep)) { output = output.Substring(commit_sep.Length) + "\n\n" + commit_sep; } MatchCollection matches = this.log_regex.Matches(output); foreach (Match match in matches) { ChangeSet change_set = ParseChangeSet(match); if (change_set == null) { continue; } int count = 0; foreach (string line in match.Groups["files"].Value.Split("\n".ToCharArray())) { if (count++ == 256) { break; } Change change = ParseChange(line); if (change == null) { continue; } change.Timestamp = change_set.Timestamp; change_set.Changes.Add(change); } if (path == null && change_sets.Count > 0) { ChangeSet last_change_set = change_sets [change_sets.Count - 1]; // If a change set set already exists for this user and day, group into that one if (change_set.Timestamp.Year == last_change_set.Timestamp.Year && change_set.Timestamp.Month == last_change_set.Timestamp.Month && change_set.Timestamp.Day == last_change_set.Timestamp.Day && change_set.User.Name.Equals(last_change_set.User.Name)) { last_change_set.Changes.AddRange(change_set.Changes); if (DateTime.Compare(last_change_set.Timestamp, change_set.Timestamp) < 1) { last_change_set.FirstTimestamp = last_change_set.Timestamp; last_change_set.Timestamp = change_set.Timestamp; last_change_set.Revision = change_set.Revision; } else { last_change_set.FirstTimestamp = change_set.Timestamp; } } else { change_sets.Add(change_set); } } else if (path != null) { // Don't show removals or moves in the history list of a file var changes = new Change [change_set.Changes.Count]; change_set.Changes.CopyTo(changes); foreach (Change change in changes) { if (!change.Path.Equals(path)) { continue; } if (change.Type == ChangeType.Deleted || change.Type == ChangeType.Moved) { change_set.Changes.Remove(change); } } change_sets.Add(change_set); } else { change_sets.Add(change_set); } } return(change_sets); }
/// Output method protected void Output(TextWriter writer, string[] tokens, FileSystemWatcher source, Change type, string name) { foreach (var token in tokens) { var path = Path.Combine(source.Path, name); switch (token[0]) { case 'e': writer.Write(type); if (Directory.Exists(path)) { writer.Write(",ISDIR"); } break; case 'f': writer.Write(Path.GetFileName(path)); break; case 'w': writer.Write(Path.Combine(source.Path, Path.GetDirectoryName(path))); break; case 'T': writer.Write(DateTime.Now); break; default: writer.Write(token); break; } } writer.WriteLine(); }
Change ParseChange(string line) { // Skip lines containing backspace characters or the .sparkleshare file if (line.Contains("\\177") || line.Contains(".sparkleshare")) { return(null); } // File lines start with a change type letter and then a tab character if (!line.StartsWith("A\t") && !line.StartsWith("M\t") && !line.StartsWith("D\t") && !line.StartsWith("R100\t")) { return(null); } Change change = new Change() { Type = ChangeType.Added }; string file_path; int first_tab_pos = line.IndexOf('\t'); int last_tab_pos = line.LastIndexOf('\t'); if (first_tab_pos == last_tab_pos) { char type_letter = line [0]; if (type_letter == 'M') { change.Type = ChangeType.Edited; } if (type_letter == 'D') { change.Type = ChangeType.Deleted; } file_path = line.Substring(first_tab_pos + 1); } else { change.Type = ChangeType.Moved; // The "to" and "from" file paths are separated by a tab string [] parts = line.Split("\t".ToCharArray()); file_path = parts [1]; string to_file_path = parts [2]; to_file_path = to_file_path.Replace("\\\"", "\""); change.MovedToPath = to_file_path; } file_path = file_path.Replace("\\\"", "\""); change.Path = file_path; string empty_name = ".empty"; // Handle .empty files as if they were folders if (change.Path.EndsWith(empty_name)) { change.Path = change.Path.Substring(0, change.Path.Length - empty_name.Length); if (change.Type == ChangeType.Moved) { change.MovedToPath = change.MovedToPath.Substring(0, change.MovedToPath.Length - empty_name.Length); } change.IsFolder = true; } try { change.Path = EnsureSpecialChars(change.Path); if (change.Type == ChangeType.Moved) { change.MovedToPath = EnsureSpecialChars(change.MovedToPath); } } catch (Exception e) { Logger.LogInfo("Local", string.Format("Error parsing line due to special character: '{0}'", line), e); return(null); } return(change); }
private void OnAclChanged(AclEntry[] entries, Change change) { if(AclChanged != null) { AclChanged(this, new AclChangedEventArgs(entries, change)); } }
public static Optional <Change <TObject, TKey> > Reduce <TObject, TKey>(Optional <Change <TObject, TKey> > previous, Change <TObject, TKey> next) { if (!previous.HasValue) { return(next); } var previousValue = previous.Value; switch (previousValue.Reason) { case ChangeReason.Add when next.Reason == ChangeReason.Remove: return(Optional <Change <TObject, TKey> > .None); case ChangeReason.Remove when next.Reason == ChangeReason.Add: return(new Change <TObject, TKey>(ChangeReason.Update, next.Key, next.Current, previousValue.Current, next.CurrentIndex, previousValue.CurrentIndex)); case ChangeReason.Add when next.Reason == ChangeReason.Update: return(new Change <TObject, TKey>(ChangeReason.Add, next.Key, next.Current, next.CurrentIndex)); case ChangeReason.Update when next.Reason == ChangeReason.Update: return(new Change <TObject, TKey>(ChangeReason.Update, previousValue.Key, next.Current, previousValue.Previous, next.CurrentIndex, previousValue.PreviousIndex)); default: return(next); } }