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 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)
{
}
