public void TestCustomBatchPropValues() { // Prerequisite entities Plastic pp = PlasticsRepository.CreatePlastic("PP", "Polypropylene"); Material mat = MaterialsRepository.CreateMaterial("mat", "manu", "manu-id", pp); StorageSite site = LocationsRepository.CreateStorageSite("test_site"); StorageArea area = LocationsRepository.CreateStorageArea(site, "test_area"); StorageLocation loc = new StorageLocation() { StorageSiteId = site.Id, StorageAreaId = area.Id, StorageSiteName = site.Name, StorageAreaName = area.Name }; CustomBatchProp prop1 = PropRepository.CreateCustomBatchProp("prop-1"); CustomBatchProp prop2 = PropRepository.CreateCustomBatchProp("prop-2"); // Create batch with custom prop values MaterialBatch batch = Repository.CreateMaterialBatch(mat, DateTime.Today.AddDays(17), loc, 42, 42, new Dictionary <Guid, string>() { { prop1.Id, "Ak Bars" }, { prop2.Id, "Aloha" } }, false); Assert.Equal(2, batch.CustomProps.Count); // Test updating batch.CustomProps[prop1.Id] = "UPDATE TEST"; Repository.UpdateMaterialBatch(batch); batch = Repository.GetMaterialBatch(batch.Id); Assert.Equal(2, batch.CustomProps.Count); Assert.Single(batch.CustomProps.Where(p => p.Value == "UPDATE TEST")); }
public IActionResult UpdateStorageArea(Guid siteId, Guid areaId, [FromBody] StorageAreaUpdateRequest storageAreaUpdateRequest) { if (siteId == null || areaId == null || storageAreaUpdateRequest == null || string.IsNullOrWhiteSpace(storageAreaUpdateRequest.Name)) { return(HandleBadRequest("A valid storage site ID, area ID and name have to be supplied.")); } try { StorageArea area = LocationsService.UpdateStorageArea(siteId, areaId, storageAreaUpdateRequest.Name); return(Ok(area)); } catch (StorageSiteNotFoundException exception) { return(HandleResourceNotFoundException(exception)); } catch (StorageAreaNotFoundException exception) { return(HandleResourceNotFoundException(exception)); } catch (Exception exception) { return(HandleUnexpectedException(exception)); } }
public void SendOrbBasicProgram(StorageArea area, IEnumerable <string> programLines) { foreach (var line in programLines) { AppendOrbBasicFragment(area, line); } }
private void CheckVariable(Node node, StorageArea storageArea) { if (!storageArea.NeedDeclaration) { return; } var area = storageArea.GetStorageAreaThatNeedDeclaration; if (area.SymbolReference == null) { return; } //Do not handle TCFunctionName, it'll be done by TypeCobolChecker if (area.SymbolReference.IsOrCanBeOfType(SymbolType.TCFunctionName)) { return; } var found = node.SymbolTable.GetVariable(area); if (found.Count < 1) { if (node.SymbolTable.GetFunction(area).Count < 1) { DiagnosticUtils.AddError(node.CodeElement, "Symbol " + area + " is not referenced"); } } if (found.Count > 1) { DiagnosticUtils.AddError(node.CodeElement, "Ambiguous reference to symbol " + area); } }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { switch (InputParameters["Action"].ToString().ToLower()) { case "addnew": // In inserimento creo uno storage vuoto //(DocumentArchive)e.Argument = new DocumentArchive(); storageAreaRule = new StorageAreaRule(); if (InputParameters["IdArchive"].ToString() != String.Empty) { attributes = Client.GetAttributesFromArchive((Guid)InputParameters["IdArchive"]); } break; case "modify": // Se sto modificando carico i dati da modificare storageAreaRule = Client.GetStorageAreaRule((Guid)InputParameters["IdStorageArea"], (Guid)InputParameters["IdAttribute"]); attributes = Client.GetAttributesFromArchive((Guid)InputParameters["IdArchive"]); break; } archives = Client.GetArchivesFromStorage((Guid)InputParameters["IdStorage"]); if (InputParameters["IdArchive"].ToString() == String.Empty && archives.Count() > 0) { attributes = Client.GetAttributesFromArchive(archives[0].IdArchive); } ruleOperators = Client.GetRuleOperators(); storageArea = Client.GetStorageArea((Guid)InputParameters["IdStorageArea"]); }
/// <summary> /// Report a variable. /// </summary> /// <param name="node">Node that contains the variable</param> private void ReportVariable(Node node, StorageArea variable) { StorageArea wname = variable; if (wname == null || !wname.NeedDeclaration) { return; } var area = wname.GetStorageAreaThatNeedDeclaration; if (area.SymbolReference == null) { return; } var found = node.GetDataDefinitionFromStorageAreaDictionary(wname); if (found != null) { //Take in account only if one instance has been discovered. List <DataDefinition> dataCopy = new List <DataDefinition>(); CollectInsideCopy(found, dataCopy); if (dataCopy.Count > 0) { string name = found.Name; string sourceText = node.CodeElement.SourceText.Replace('\r', ' ').Replace('\n', ' '); int line = node.CodeElement.Line; int column = node.CodeElement.Column; string fileName = node.CodeElement.TokenSource.SourceName; bool isMove = node is Move; string kind = isMove ? "MOVE" : "INITIALIZE"; foreach (DataDefinition d in dataCopy) { #if DEBUG_REPORT_CMR_FULL_FIELDS string copySourceText = d.CodeElement.SourceText.Replace('\r', ' ').Replace('\n', ' '); int copyLine = d.CodeElement.Line; int copyColumn = d.CodeElement.Column; #endif Preprocessor.ImportedToken firstImportedToken = d.CodeElement.ConsumedTokens.First(t => t is Preprocessor.ImportedToken) as Preprocessor.ImportedToken; if (firstImportedToken != null) { string copyName = firstImportedToken.CopyDirective.TextName; #if DEBUG_REPORT_CMR_FULL_FIELDS Writer.WriteLine(string.Format("CopyName={0};{1};Variable={2};SourceText={3};Line={4};Column={5};FileName={6};CopySourceText={7};CopyLine={8};CopyColumn={9};", copyName, kind, name, sourceText, line, column, fileName, copySourceText, copyLine, copyColumn)); #else Writer.WriteLine( string.Format("CopyName={0};{1};Variable={2};Line={3};Column={4};SourceText={5}", copyName, kind, name, line, column, sourceText)); #endif break; //Don't recurse within move or initialize. } } } } }
private static void UnregisterChangedEvent(StorageArea type) { Interop.Storage.ErrorCode err = Interop.Storage.StorageUnsetChanged((int)type, s_ChangedEventCallback); if (err != Interop.Storage.ErrorCode.None) { Log.Warn(LogTag, string.Format("Failed to Unreegister changed event callback for external storage. err = {0}", err)); } }
/// <summary> /// Updates a storage area. /// </summary> /// <param name="storageArea">Area to update.</param> /// <returns> /// Returns the updated area. /// </returns> public StorageArea UpdateStorageArea(StorageArea storageArea) { using (IDbConnection connection = GetNewConnection()) { connection.Execute("UPDATE storage_areas SET name=@Name WHERE id=@Id", new { storageArea.Id, storageArea.Name }); } return(storageArea); }
public static SpheroCommandPacket ExecuteOrbBasicProgram(StorageArea area, UInt16 fromLine) { byte[] data = new byte[3]; data[0] = (byte)area; data[1] = (byte)((fromLine & 0xFF00) >> 8); data[2] = (byte)(fromLine & 0x00FF); return(new SpheroCommandPacket(0x02, 0x62, 0x01, data)); }
public static SpheroCommandPacket AppendOrbBasicFragment(StorageArea area, string fragment) { List <byte> data = new List <byte>(); byte[] fragBytes = Encoding.Default.GetBytes(fragment); data.Add((byte)area); data.AddRange(fragBytes); return(new SpheroCommandPacket(0x02, 0x61, 0x01, data.ToArray())); }
public StorageArea CreateStorageArea(StorageSite storageSite, string areaName) { StorageArea area = new StorageArea(areaName); storageSite.Areas.Add(area); StorageAreas.Add(area.Id, area); StorageSites[storageSite.Id] = storageSite; return(area); }
/// <summary> /// Produce Cobol85 code which correspond of this StorageArea /// </summary> /// <param name="sa"></param> /// <returns></returns> public static string ToCobol85(this StorageArea sa) { StorageAreaPropertySpecialRegister specialRegister = sa as StorageAreaPropertySpecialRegister; if (specialRegister != null) { return(specialRegister.ToCobol85()); } return(sa.ToString()); }
protected void lbtnEdit_Click(object sender, EventArgs e) { string code = ((LinkButton)sender).CommandArgument; StorageArea storageArea = TheStorageAreaMgr.LoadStorageArea(code); this.ucEdit.InitPageParameter(storageArea); this.ucEdit.Visible = true; this.divAreaList.Visible = false; this.EditEvent((object)code, e); }
protected void ODS_StorageArea_Updating(object sender, ObjectDataSourceMethodEventArgs e) { StorageArea area = (StorageArea)e.InputParameters[0]; if (area != null) { string location = this.LocationCode; area.Location = TheLocationMgr.LoadLocation(location); area.Description = area.Description.Trim(); } }
public IActionResult CreateStorageArea(Guid siteId, [FromBody] StorageAreaCreationRequest storageAreaCreationRequest) { if (storageAreaCreationRequest == null || string.IsNullOrWhiteSpace(storageAreaCreationRequest.Name)) { return(HandleBadRequest("A valid storage area name has to be supplied.")); } StorageArea area = LocationsService.AddAreaToStorageSite(siteId, storageAreaCreationRequest.Name); return(Created(GetNewResourceUri(area.Id), area)); }
public void InitPageParameter(StorageArea area) { this.ODS_FV_StorageArea.SelectParameters["Code"].DefaultValue = area.Code; this.LocationCode = area.Location.Code; this.AreaCode = area.Code; //((TextBox)(this.FV_StorageArea.FindControl("tbAreaCode"))).Text = area.Code; //((TextBox)(this.FV_StorageArea.FindControl("tbLocationCode"))).Text = this.LocationCode; //((TextBox)(this.FV_StorageArea.FindControl("tbAreaDescription"))).Text = area.Description; //((CheckBox)(this.FV_StorageArea.FindControl("cbIsActive"))).Checked = area.IsActive; //((CheckBox)(this.FV_StorageBin.FindControl("cbIsActive"))).Checked = true; //this.ucBin.InitPageParameter(area.Code); }
public void AddReferences(StorageArea storageArea, Node node) { if (_References == null) { _References = new Dictionary <StorageArea, Node>(); } if (!_References.ContainsKey(storageArea)) { _References.Add(storageArea, node); } }
/// <summary> /// Updates a given area of a given storage site. /// </summary> /// <param name="siteId">ID of the site for which to update an area.</param> /// <param name="areaId">ID of the area to update.</param> /// <param name="areaName">Area name to update.</param> /// <returns>Returns the updated area.</returns> public StorageArea UpdateStorageArea(Guid siteId, Guid areaId, string areaName) { StorageSite site = GetStorageSiteOrThrowNotFoundException(siteId); StorageArea area = site.Areas.Where(a => a.Id == areaId).FirstOrDefault(); if (area == null) { throw new StorageAreaNotFoundException(siteId, areaId); } area.Name = areaName; area = LocationsRepository.UpdateStorageArea(area); return(area); }
public List <DataDefinition> GetVariable(StorageArea storageArea) { URI uri; if (storageArea.SymbolReference != null) { uri = storageArea.SymbolReference.URI; } else { uri = new URI(storageArea.ToString()); } return(GetVariable(uri)); }
public StorageArea[] GetStorageAreas() { List <StorageArea> buildings_to_return = new List <StorageArea>(); foreach (Building storageArea in buildings) { if (storageArea is StorageArea) { StorageArea Storagearea = storageArea as StorageArea; Debug.Log(Storagearea.inventory.Space); buildings_to_return.Add(Storagearea); } } return(buildings_to_return.ToArray()); }
public bool CreateStorageArea(StorageAreaCreate model) { var entity = new StorageArea()//Creating an instance of a new StorageArea { NameOfStorageArea = model.NameOfStorageArea, GameType = model.GameType, }; using (var ctx = new ApplicationDbContext())//Saving the created storage to the database { ctx.StorageAreas.Add(entity); return(ctx.SaveChanges() == 1); } }//End public CreateStorageArea
private static void UnregisterChangedEvent(StorageArea type) { Interop.Storage.ErrorCode err = Interop.Storage.StorageUnsetChanged((int)type, s_ChangedEventCallback); if (err != Interop.Storage.ErrorCode.None) { Log.Warn(LogTag, string.Format("Failed to Unreegister changed event callback for external storage. err = {0}", err)); switch (err) { case Interop.Storage.ErrorCode.NotSupported: throw new NotSupportedException("Storage Not Supported"); default: break; } } }
/// <summary> /// Creates a new area for an existing storage site. /// </summary> /// <param name="storageSite">Site to add an area to.</param> /// <param name="areaName">Name of the area to create.</param> /// <returns> /// Returns the newly created area. /// </returns> public StorageArea CreateStorageArea(StorageSite storageSite, string areaName) { Guid id = Guid.NewGuid(); StorageArea area = null; using (IDbConnection connection = GetNewConnection()) { connection.Execute("INSERT INTO storage_areas (id, name, site_id) VALUES (@Id, @Name, @SiteId)", new { Id = id, Name = areaName, SiteId = storageSite.Id }); area = connection.QuerySingleOrDefault <StorageArea>("SELECT * FROM storage_areas WHERE id=@Id", new { id }); } return(area); }
public StorageArea AddStorageArea(StorageArea newStorageArea) { var storageAreas = this.GetStorageAreas(); newStorageArea.Id = storageAreas.Max(sa => sa.Id) + 1; List <StorageArea> storageAreaList = storageAreas.ToList(); storageAreaList.Add(newStorageArea); using (StreamWriter file = File.CreateText(STORAGE_AREAS)) { JsonSerializer serializer = new JsonSerializer(); serializer.Serialize(file, storageAreaList); file.Close(); } return(newStorageArea); }
private void QualifiedStorageAreaSelecterForBoolean(StorageArea storage_area, Tuple <int, int, int, List <int>, List <int> > sourcePositions) { if (UsedStorageArea != null && UsedStorageArea.Contains(storage_area)) { return; } string name = storage_area?.SymbolReference?.Name; GenerateToken item = null; item = new GenerateToken( new TokenCodeElement(storage_area?.SymbolReference?.NameLiteral?.Token), name + "-value", sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); this.CurrentNode.Add(item); if (UsedStorageArea == null) { UsedStorageArea = new HashSet <StorageArea>(); } UsedStorageArea.Add(storage_area); }
public override bool Visit(StorageArea storageArea) { if (this.CurrentNode.IsFlagSet(Node.Flag.NodeContainsIndex) || this.CurrentNode.IsFlagSet(Node.Flag.NodeContainsBoolean)) { Tuple <int, int, int, List <int>, List <int> > sourcePositions = this.Generator.FromToPositions(this.CurrentNode); foreach (TypeCobol.Compiler.CodeElements.StorageArea storage_area in this.CurrentNode.QualifiedStorageAreas.Keys) { if (this.CurrentNode.IsFlagSet(Node.Flag.NodeContainsIndex)) { QualifiedStorageAreaSelecterForIndexes(storage_area, sourcePositions); } if (this.CurrentNode.IsFlagSet(Node.Flag.NodeContainsBoolean)) { QualifiedStorageAreaSelecterForBoolean(storage_area, sourcePositions); } } this.CurrentNode.Comment = true; } return(true); }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { switch (InputParameters["Action"].ToString().ToLower()) { case "addnew": // In inserimento creo uno storage vuoto //(DocumentArchive)e.Argument = new DocumentArchive(); storageArea = new StorageArea(); break; case "modify": // Se sto modificando carico i dati da modificare storageArea = Client.GetStorageArea((Guid)InputParameters["ID"]); break; } storageAreaStatus = Client.GetAllStorageAreaStatus(); storage = Client.GetStorage((Guid)InputParameters["IdStorage"]); }
/// <summary> /// Unregisters an eventhandler for state chages of specific storage type /// </summary> /// <param name="type">Storage type</param> /// <param name="handler">An eventhandler to unregister</param> /// <since_tizen> 5 </since_tizen> public static void UnsetChangedEvent(StorageArea type, EventHandler handler) { if (type == StorageArea.Internal) { Log.Warn(LogTag, "Internal storage state is not changed"); } if (type == StorageArea.External) { s_ExternalStorageChangedEventHandler -= handler; } else if (type == StorageArea.ExtendedInternal) { s_ExtendedInternalStorageChangedEventHandler -= handler; } if ((type == StorageArea.External && s_ExternalStorageChangedEventHandler == null) || (type == StorageArea.ExtendedInternal && s_ExtendedInternalStorageChangedEventHandler == null)) { UnregisterChangedEvent(type); } }
protected void ODS_StorageArea_Inserting(object source, ObjectDataSourceMethodEventArgs e) { StorageArea storageArea = (StorageArea)e.InputParameters[0]; string locationCode = ((TextBox)(this.FV_StorageArea.FindControl("tbLocationCode"))).Text.Trim(); string areaCode = ((TextBox)(this.FV_StorageArea.FindControl("tbAreaCode"))).Text.Trim(); string areaDescription = ((TextBox)(this.FV_StorageArea.FindControl("tbAreaDescription"))).Text.Trim(); if (areaCode == null || areaCode == string.Empty) { ShowErrorMessage("MasterData.Location.Area.Required.Code"); e.Cancel = true; return; } storageArea.Code = areaCode; storageArea.Description = areaDescription; storageArea.Location = TheLocationMgr.LoadLocation(locationCode); ShowSuccessMessage("MasterData.Location.Area.AddArea.Successfully", areaCode); if (CreateEvent != null) { CreateEvent(storageArea, null); this.Visible = false; } }
private void QualifiedStorageAreaSelecterForIndexes(StorageArea storageArea, Tuple <int, int, int, List <int>, List <int> > sourcePositions) { if (storageArea.SymbolReference != null && !storageArea.SymbolReference.IsQualifiedReference) { if (UsedStorageArea != null && UsedStorageArea.Contains(storageArea)) { return; } string name = storageArea.SymbolReference.Name; string qualified_name = this.CurrentNode.QualifiedStorageAreas[storageArea]; GenerateToken item = null; string hashName = GeneratorHelper.ComputeIndexHashName(qualified_name, this.CurrentNode); item = new GenerateToken( new TokenCodeElement(storageArea.SymbolReference.NameLiteral.Token), hashName, sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); this.CurrentNode.Add(item); if (UsedStorageArea == null) { UsedStorageArea = new HashSet <StorageArea>(); } UsedStorageArea.Add(storageArea); } }
public void CreateStorageArea(StorageArea storageArea) { TheStorageAreaMgr.CreateStorageArea(storageArea); }
public void DeleteStorageArea(StorageArea storageArea) { TheStorageAreaMgr.DeleteStorageArea(storageArea); }
public void UpdateStorageArea(StorageArea storageArea) { TheStorageAreaMgr.UpdateStorageArea(storageArea); }
public VariableOrExpression(StorageArea storageArea) : base(storageArea) { }
public VariableBase(StorageDataType dataType, StorageArea storageArea) { DataType = dataType; StorageArea = storageArea; }
public virtual void DeleteStorageArea(StorageArea entity) { entityDao.DeleteStorageArea(entity); }
public SymbolReferenceVariable(StorageDataType symbolType, StorageArea storageArea) : base(symbolType, storageArea) { }
public NumericVariable(StorageArea storageArea) : base(StorageDataType.Numeric, storageArea) { }
public IntegerVariable(StorageArea storageArea) : base(StorageDataType.Integer, storageArea) { }
public CharacterVariable(StorageArea storageArea) : base(StorageDataType.Character, storageArea) { }
public virtual void UpdateStorageArea(StorageArea entity) { entityDao.UpdateStorageArea(entity); }
public virtual void CreateStorageArea(StorageArea entity) { entityDao.CreateStorageArea(entity); }
public Variable(StorageArea reference) : base(StorageDataType.Any, reference) { }
public IList<StorageBin> GetStorageBin(StorageArea Area) { return GetStorageBin(Area.Code); }
public ReceivingStorageArea(StorageDataType dataType, StorageArea storageArea) : base(dataType, storageArea) { storageArea.IsReadFrom = false; storageArea.IsWrittenTo = true; }
public AlphanumericVariable(StorageArea storageArea) : base(StorageDataType.Alphanumeric, storageArea) { }