protected virtual void CompileScenario(List <Pickle> pickles, Func <IEnumerable <PickleStep> > backgroundStepsFactory, Scenario scenario, IEnumerable <Tag> featureTags, string language, string gherkinDocumentUri) { var steps = new List <PickleStep>(); if (scenario.Steps.Any()) { steps.AddRange(backgroundStepsFactory()); } var scenarioTags = new List <Tag>(); scenarioTags.AddRange(featureTags); scenarioTags.AddRange(scenario.Tags); steps.AddRange(PickleSteps(scenario.Steps)); Pickle pickle = new Pickle( _idGenerator.GetNewId(), gherkinDocumentUri, scenario.Name, language, steps, PickleTags(scenarioTags), new [] { scenario.Id } ); pickles.Add(pickle); }
public Pickle Add(Pickle pickle) { //pickle.Id = _pickles.Max(x => x.Id) + 1; //_pickles.Add(pickle); var sql = @"insert into Pickle(NumberInStock,Price,Size, Type) output inserted.* values(@NumberInStock, @Price, @Size, @Type)"; using (var db = new SqlConnection(ConnectionString)) { var result = db.QueryFirstOrDefault <Pickle>(sql, pickle); return(result); //db.Open(); //var cmd = db.CreateCommand(); //cmd.CommandText = sql; //cmd.Parameters.AddWithValue("NumberInStock", pickle.NumberInStock); //cmd.Parameters.AddWithValue("Price", pickle.Price); //cmd.Parameters.AddWithValue("Size", pickle.Size); //cmd.Parameters.AddWithValue("Type", pickle.Type); //var reader = cmd.ExecuteReader(); //if (reader.Read()) //{ // var newPickle = MapReaderToPickle(reader); // return newPickle; //} //return null; } }
private static void TryResolve <T>(Pickle pickle, PickleStep step, IStepResolver resolver, T context) { try { resolver.Resolve(step, context); } catch (Exception e) { var plocs = String.Join(",", pickle.Locations.Select(loc => $"{loc.Line}:{loc.Column}")); var slocs = String.Join(",", step.Locations.Select(loc => $"{loc.Line}:{loc.Column}")); var message = $@" Scenario: ({plocs}) {pickle.Name} Step: ({slocs}) {step.Text} Error: {(e.InnerException ?? e).Message} Test Trace: {(e.InnerException ?? e).StackTrace} "; throw new Exception(message); } }
public Pickle Add(Pickle pickle) { // using Max takes into account the possibility of repeats //pickle.Id = _pickles.Max(x => x.Id) + 1; //_pickles.Add(pickle); // Steps to Success // write a query in SQL Server Management Studio to see how it is going to work // copy it into C# as a string // create a connection, open a connection // create a command, set the command text // add any parameters you need to add // execute it // do something with the results // those are always going to be the steps var sql = @"INSERT INTO Pickle(NumberInStock, Price, Size, Type) OUTPUT inserted.* VALUES(@NumberInStock, @Price, @Size, @Type)"; using (var db = new SqlConnection(ConnectionString)) { // these two lines are the same as the commented out lines below var result = db.QueryFirstOrDefault <Pickle>(sql, pickle); return(result); } }
// descriptive name for method follows IActionResult // return type is IActionResult for flexibility ***What does that allow us, again?*** public IActionResult AddPickle(Pickle pickleToAdd) { // the below if statement says if there are none in stock, make the current thing the stock; // otherwise, find the thing that exists and add the stock to this one // every class should have one thing that it does; single responsibility principle // controllers single responsibility is to take things in from the internet and return things to the internet; communication with http stuff // currently, this class both stores info AND communicates http stuff; something with two jobs means you need to break the thing up; // common interview question: one of the more common ways that people deal with storing data is with a pattern called the repository pattern; // some people love it, some hate it; it does perform the job; specifically for managing data and data storage; // INTERVIEW QUESTIONS // what's the difference between an abstract class and an interface? // what's the difference between a value type and a reference type? // can you describe the repository pattern OR can you describe a pattern that you have used in code? // Repository pattern is one of the more common in software development // patterns are more for the person reading the code than for being a software developer // the DataAccessLayer(DAL, DataAccess, Data) are the same as our data folder in React; this is a division of duty significance // if we reuse the below if/else, we can move that code to aits own method called AddOrUpdate var existingPickle = _repository.GetByType(pickleToAdd.Type); if (existingPickle == null) { var newPickle = _repository.Add(pickleToAdd); return(Created("", newPickle)); } else { var updatedPickle = _repository.Update(pickleToAdd); return(Ok(pickleToAdd)); } // created says "what is the rest url to get it; nothing yet, so here's an empty string; // when we add things, we want a 201 http response }
public Pickle Update(Pickle pickle) { var pickleToupdate = GetByType(pickle.Type); pickleToupdate.NumberInStock += pickle.NumberInStock; return(pickleToupdate); }
public void Run() { Sandwich sandwich = new SmallSandwich(); sandwich = new Ham(sandwich); sandwich = new Pickle(sandwich); // sandwich.GetDescription() --> "Small sandwich, ham, pickle" // sandwich.GetPrice() --> 7.75 }
public Pickle Add(Pickle pickle) { var sql = @"insert into Pickle(NumberInStock,Price,Size,Type) output inserted.* values(@NumberInStock,@Price,@Size,@Type)"; using (var db = new SqlConnection(ConnectionString)) { var result = db.QueryFirstOrDefault <Pickle>(sql, pickle); return(result); } }
protected virtual void CompileScenarioOutline(List <Pickle> pickles, Func <IEnumerable <PickleStep> > backgroundStepsFactory, Scenario scenarioOutline, IEnumerable <Tag> featureTags, string language, string gherkinDocumentUri) { foreach (var examples in scenarioOutline.Examples) { if (examples.TableHeader == null) { continue; } var variableCells = examples.TableHeader.Cells; foreach (var values in examples.TableBody) { var valueCells = values.Cells; var steps = new List <PickleStep>(); if (scenarioOutline.Steps.Any()) { steps.AddRange(backgroundStepsFactory()); } var tags = new List <Tag>(); tags.AddRange(featureTags); tags.AddRange(scenarioOutline.Tags); tags.AddRange(examples.Tags); foreach (var scenarioOutlineStep in scenarioOutline.Steps) { string stepText = Interpolate(scenarioOutlineStep.Text, variableCells, valueCells); PickleStep pickleStep = CreatePickleStep( scenarioOutlineStep, stepText, CreatePickleArgument(scenarioOutlineStep, variableCells, valueCells), new[] { scenarioOutlineStep.Id, values.Id } ); steps.Add(pickleStep); } Pickle pickle = new Pickle( _idGenerator.GetNewId(), gherkinDocumentUri, Interpolate(scenarioOutline.Name, variableCells, valueCells), language, steps, PickleTags(tags), new[] { scenarioOutline.Id, values.Id } ); pickles.Add(pickle); } } }
Pickle MapReaderToPickle(SqlDataReader reader) { var pickle = new Pickle { Id = (int)reader["Id"], Type = (string)reader["Type"], Price = (decimal)reader["Price"], NumberInStock = (int)reader["NumberInStock"], Size = (string)reader["Size"] }; return(pickle); }
public List <int> getStorage() { if (isPickled() || needsReset() || fullyQualifiedName() == DEFAULT_NAME) { string file = storageFile(); Pickle.load(file, FLG_IMMEDIATE, false); } return(m_payload); }
public IActionResult AddPickle(Pickle pickleToAdd) { var existingPickle = _repository.GetByType(pickleToAdd.Type); if (existingPickle == null) { _repository.Add(pickleToAdd); return(Created("", pickleToAdd)); } else { var updatedPickle = _repository.Update(pickleToAdd); return(Ok(updatedPickle)); } }
public Pickle Update(Pickle pickle) { var sql = @"update Pickle set NumberInStock = NumberInStock + @NewStock output inserted.* where Id = @Id"; using (var db = new SqlConnection(ConnectionString)) { var parameters = new { NewStock = pickle.NumberInStock, Id = pickle.Id }; return(db.QueryFirstOrDefault <Pickle>(sql, parameters)); } }
public Pickle Update(Pickle pickle) { //var pickleToUpdate = GetByType(pickle.Type); //pickleToUpdate.NumberInStock += pickle.NumberInStock; //return pickleToUpdate; var sql = @"update Pickle set NumberInStock = NumberInStock + @NewStock output inserted.* where Id = @Id"; using (var db = new SqlConnection(ConnectionString)) { var parameters = new { NewStock = pickle.NumberInStock, Id = pickle.Id }; return(db.QueryFirstOrDefault <Pickle>(sql, parameters)); //connection.Open(); //var cmd = connection.CreateCommand(); //cmd.CommandText = sql; //cmd.Parameters.AddWithValue("NewStock", pickle.NumberInStock); //cmd.Parameters.AddWithValue("Id", pickle.Id); //var reader = cmd.ExecuteReader(); //if (reader.Read()) //{ // var updatedPickle = MapReaderToPickle(reader); // return updatedPickle; //} //return null; } }
public override ArcFile TryOpen(ArcView file) { if (0x20302e33 != file.View.ReadUInt32(4)) { return(null); } string index_offset_str = file.View.ReadString(8, 16, Encoding.ASCII); long index_offset; if (!long.TryParse(index_offset_str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out index_offset)) { return(null); } if (index_offset >= file.MaxOffset) { return(null); } uint key; string key_str = file.View.ReadString(0x19, 8, Encoding.ASCII); if (!uint.TryParse(key_str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out key)) { return(null); } IDictionary dict = null; using (var index = new ZLibStream(file.CreateStream(index_offset), CompressionMode.Decompress)) { var pickle = new Pickle(index); dict = pickle.Load() as IDictionary; } if (null == dict) { return(null); } var dir = new List <Entry> (dict.Count); foreach (DictionaryEntry item in dict) { var name_raw = item.Key as byte[]; var values = item.Value as IList; if (null == name_raw || null == values || values.Count < 1) { Trace.WriteLine("invalid index entry", "RpaOpener.TryOpen"); return(null); } string name = Encoding.UTF8.GetString(name_raw); if (string.IsNullOrEmpty(name)) { return(null); } var tuple = values[0] as IList; if (null == tuple || tuple.Count < 2) { Trace.WriteLine("invalid index tuple", "RpaOpener.TryOpen"); return(null); } var entry = FormatCatalog.Instance.Create <RpaEntry> (name); entry.Offset = (long)(Convert.ToInt64(tuple[0]) ^ key); entry.UnpackedSize = (uint)(Convert.ToInt32(tuple[1]) ^ key); entry.Size = entry.UnpackedSize; if (tuple.Count > 2) { entry.Header = tuple[2] as byte[]; if (null != entry.Header && entry.Header.Length > 0) { entry.Size -= (uint)entry.Header.Length; entry.IsPacked = true; } } dir.Add(entry); } if (dir.Count > 0) { Trace.TraceInformation("[{0}] [{1:X8}] [{2}]", dir[0].Name, dir[0].Offset, dir[0].Size); } return(new ArcFile(file, this, dir)); }
public override void Create(Stream output, IEnumerable <Entry> list, ResourceOptions options, EntryCallback callback) { var rpa_options = GetOptions <RpaOptions> (options); int callback_count = 0; var file_table = new Dictionary <PyString, ArrayList>(); long data_offset = 0x22; output.Position = data_offset; foreach (var entry in list) { if (null != callback) { callback(callback_count++, entry, arcStrings.MsgAddingFile); } string name = entry.Name.Replace(@"\", "/"); var rpa_entry = new RpaEntry { Name = name }; using (var file = File.OpenRead(entry.Name)) { var size = file.Length; if (size > uint.MaxValue) { throw new FileSizeException(); } int header_size = (int)Math.Min(size, 0x10); rpa_entry.Offset = output.Position ^ rpa_options.Key; rpa_entry.Header = new byte[header_size]; rpa_entry.UnpackedSize = (uint)size ^ rpa_options.Key; rpa_entry.Size = (uint)(size - header_size); file.Read(rpa_entry.Header, 0, header_size); file.CopyTo(output); } var py_name = new PyString(name); if (file_table.ContainsKey(py_name)) { file_table[py_name].Add(rpa_entry); } else { file_table[py_name] = new ArrayList { rpa_entry } }; } long index_pos = output.Position; string signature = string.Format(CultureInfo.InvariantCulture, "RPA-3.0 {0:x16} {1:x8}\n", index_pos, rpa_options.Key); var header = Encoding.ASCII.GetBytes(signature); if (header.Length > data_offset) { throw new ApplicationException("Signature serialization failed."); } if (null != callback) { callback(callback_count++, null, arcStrings.MsgWritingIndex); } using (var index = new ZLibStream(output, CompressionMode.Compress, CompressionLevel.Level9, true)) { var pickle = new Pickle(index); if (!pickle.Dump(file_table)) { throw new ApplicationException("Archive index serialization failed."); } } output.Position = 0; output.Write(header, 0, header.Length); } }
public static Scenario Create(Pickle pickle) => new Scenario(pickle);
public static bool HasTag(Pickle p, string tag) => p.Tags .Select(PickleTags.Name) .Where(FuzzyString.Compare, tag) .Any();
public static void Deactivate(Pickle pickle) { pooledPickles.Push(pickle.gameObject); pickle.gameObject.SetActive(false); }
public PickleEvent(string uri, Pickle pickle) { this.uri = uri; this.pickle = pickle; }
public void Add(Pickle pickle) { pickle.Id = _pickles.Max(x => x.Id) + 1; _pickles.Add(pickle); }
internal Scenario(Pickle pickle) => Pickle = pickle;