static void Main()
{
IFoo bar = new Bar();
IFoo jar = new Jar();
bar.Ping += Bar_Ping;
}
static void Main()
{
var bar = new Bar();
var jar = new Jar();
bar.Ping += Bar_Ping;
}
public async Task <Jar> AddJar(Jar jar)
{
context.Jars.Add(jar);
await context.SaveChangesAsync();
return(jar);
}
public async Task AddMoneyToJar([FromBody] JarViewModel jarViewModel, int money)
{
User user = await _userManager.GetUserAsync(HttpContext.User);
var jar = new Jar
{
User = user,
Name = jarViewModel.Name,
CurrentAmount = jarViewModel.CurrentAmount,
Goal = jarViewModel.Goal,
State = jarViewModel.State,
};
if (jar.CurrentAmount + money >= jar.Goal)
{
jar.State = State.Reached;
await _notificationRepository.SaveNotyfication(new Notification
{
Title = $"End jar {jarViewModel.Name}",
Describe = $"Congratulations The jar is full",
User = user,
IsVisible = true
});
}
jar.CurrentAmount += money;
await _jarRepositorycs.EditJar(jar);
}
public IEnumerable <Jar> Get(string projectName)
{
string projectPath = Path.Combine(Folders.Projects, projectName, "src", projectName + ".Configuration", "public");
var configurations = Directory.GetFiles(projectPath).Where(x => x.EndsWith(".json", StringComparison.Ordinal));
foreach (var config in configurations)
{
Jar jarObject = null;
try
{
jarObject = JsonConvert.DeserializeObject <Jar>(System.IO.File.ReadAllText(config));
}
catch (Exception ex)
{
log.Error(ex);
continue;
}
if (config != null)
{
yield return(jarObject);
}
}
}
public static Jar FromFile(string jarPath)
{
var jar = new Jar();
var javaClasses = new List <FileItem>();
using (ZipArchive archive = ZipFile.Open(jarPath, ZipArchiveMode.Read))
{
foreach (var entry in archive.Entries)
{
if (!entry.FullName.EndsWith(".class"))
{
continue;
}
using (var javaClassStream = entry.Open())
{
var fileItem = GetClass(javaClassStream);
javaClasses.Add(fileItem);
}
}
}
jar.FileItems = new ReadOnlyCollection <FileItem>(javaClasses);
return(jar);
}
// Use this for initialization
public void initializeJar()
{
jar = new Jar(traitDB, defaultProperties);
jarNum++;
ID = jarNum;
}
public void setupCustomizer(Jar jar, PropertyDB propertyDB)
{
this.jar = jar;
this.propertyDB = propertyDB;
this.gameObject.SetActive(true);
inputBlocker.SetActive(true);
setupDropdowns();
setupInitialProperties();
jarInfo.setupTooltip(jar);
}
public void Coin010AddJarTest()
{
Coin010 coin010 = new Coin010();
Jar jar = new Jar();
//add the 10-cent coin to the jar
coin010.AddToJar(jar);
//assert jar.Coin010Counter is 1 and jar.CurrentAmount is $0.10
Assert.AreEqual(1, jar.Coin010Counter);
Assert.AreEqual(0.10m, jar.CurrentAmount);
}
public void Coin025AddJarTest()
{
Coin025 coin025 = new Coin025();
Jar jar = new Jar();
//add the 25-cent coin to the jar
coin025.AddToJar(jar);
//assert jar.Coin025Counter is 1 and jar.CurrentAmount is $0.25
Assert.AreEqual(1, jar.Coin025Counter);
Assert.AreEqual(0.25m, jar.CurrentAmount);
}
public async Task Add(Jar jar, JarTransaction item)
{
try
{
item.Id = jar.Id.ToString() + "::" + ObjectId.GenerateNewId();
await _context.JarTransactions.InsertOneAsync(item);
}
catch (Exception ex)
{
throw new ApplicationException("Error: " + ex.Message);
}
}
public bool DeleteJar(Jar jar)
{
Jar dbEntity = context.Jars.FirstOrDefault(p => p.ID == jar.ID);
if (dbEntity != null)
{
context.Jars.Remove(dbEntity);
context.SaveChanges();
return(true);
}
return(false);
}
public void Coin100AddJarTest()
{
Coin100 coin100 = new Coin100();
Jar jar = new Jar();
//add the $1 coin to the jar
coin100.AddToJar(jar);
//assert jar.Coin100Counter is 1 and jar.CurrentAmount is $1.00
Assert.AreEqual(1, jar.Coin100Counter);
Assert.AreEqual(1.00m, jar.CurrentAmount);
}
public void Coin001AddJarTest()
{
Coin001 coin001 = new Coin001();
Jar jar = new Jar();
//add the 1-cent coin to the jar
coin001.AddToJar(jar);
//assert jar.Coin001Counter is 1 and jar.CurrentAmount is $0.01
Assert.AreEqual(1, jar.Coin001Counter);
Assert.AreEqual(0.01m, jar.CurrentAmount);
}
public void FillUpwithRandomCoinTest()
{
Jar jar = new Jar();
// The Random() constructor uses the system clock to provide a seed value.
Random rnd = new Random();
// coin.AddToJar failure indicates jar full.
var addJarSucceeded = false;
do
{
// Generate random int with range of [1,6]
// 1-- 1 cent coin
// 2-- 5 cent coin
// 3-- 10 cent coin
// 4-- 25 cent coin
// 5-- 50 cent coin
// 6-- $1 coin
var coinType = rnd.Next(1, 7);
switch (coinType)
{
case 1:
addJarSucceeded = new Coin001().AddToJar(jar);
break;
case 2:
addJarSucceeded = new Coin005().AddToJar(jar);
break;
case 3:
addJarSucceeded = new Coin010().AddToJar(jar);
break;
case 4:
addJarSucceeded = new Coin025().AddToJar(jar);
break;
case 5:
addJarSucceeded = new Coin050().AddToJar(jar);
break;
default:
addJarSucceeded = new Coin100().AddToJar(jar);
break;
}
}
//loop while last filling succeeded
while (addJarSucceeded);
jar.PrintJar();
}
public void FillUpwith1CentCoinTest()
{
Jar jar = new Jar();
Coin001 coin001 = new Coin001();
//fill up with 1-cent coins
while (coin001.AddToJar(jar))
{
;
}
jar.PrintJar();
}
public void FillUpwith10CentCoinTest()
{
Jar jar = new Jar();
Coin010 coin010 = new Coin010();
//fill up with 10-cent coins
while (coin010.AddToJar(jar))
{
;
}
jar.PrintJar();
}
public void FillUpwith25CentCoinTest()
{
Jar jar = new Jar();
Coin025 coin025 = new Coin025();
//fill up with 25-cent coins
while (coin025.AddToJar(jar))
{
;
}
jar.PrintJar();
}
public void FillUpwith100CentCoinTest()
{
Jar jar = new Jar();
Coin100 coin100 = new Coin100();
//fill up with $1 coins
while (coin100.AddToJar(jar))
{
;
}
jar.PrintJar();
}
public async Task <Jar> Add(Jar jar, IFormFile file)
{
jar.FileName = file.FileName;
await CheckForUniqueConstraints(jar);
var uploadedJar = await _jarRepository.Add(jar);
var filePath = Path.Combine(JarPath, jar.FileName);
await using var stream = File.Create(filePath);
await file.CopyToAsync(stream);
return(uploadedJar);
}
public async Task <bool> EditJar(Jar jar)
{
Jar dbEntity = context.Jars.FirstOrDefault(x => x.ID == jar.ID);
if (dbEntity != null)
{
dbEntity.Name = jar.Name;
dbEntity.Goal = jar.Goal;
dbEntity.State = jar.State;
await context.SaveChangesAsync();
return(true);
}
return(false);
}
public void setupTooltip(Jar jar)
{
Title.text = jar.name;
breedingSpeed = jar.getBreedingSpeed();
fertility = jar.getFertility();
survivability = jar.getSurvivability();
carryingCapacity = jar.getCarryingCapacity();
mutationRate = jar.getMutationRate();
selectiveFitnessAdvantage = jar.selectiveFitnessAdvantage;
selectiveSurvivabilityAdvantage = jar.selectiveSurvivabilityAdvantage;
statModification = jar.statModification;
setupTooltip();
}
public async Task <IActionResult> DeleteJar([FromBody] JarViewModel jarViewModel)
{
User user = await _userManager.GetUserAsync(HttpContext.User);
var jar = new Jar
{
ID = jarViewModel.ID,
Name = jarViewModel.Name,
State = State.NotReached,
Goal = jarViewModel.Goal,
CurrentAmount = jarViewModel.CurrentAmount,
User = user
};
return(Json(new { succeed = _jarRepositorycs.EditJar(jar) }));
}
public async Task <ActionResult> Upload([FromForm] Jar jar, ApiVersion version)
{
try
{
var uploadedJar = await _jarService.Add(jar, jar.File);
return(CreatedAtAction("GetById",
"Plugin",
new { id = uploadedJar.Id, version = version.ToString() },
uploadedJar));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
/// <summary>
/// Add the coin to a jar
/// </summary>
/// <param name="jar"></param>
/// <returns>true: succeeded adding the coin to the jar</returns>
public override bool AddToJar(Jar jar)
{
decimal v = GetVolume();
if (jar.CurrentVolume + v < Jar.maxVolume)
{
jar.Coin001Counter++;
jar.CurrentAmount += 0.01m;
jar.CurrentVolume += v;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Perform JAR digital signature verification against a JAR filename on disk
/// </summary>
/// <param name="stream">JAR file stream</param>
/// <param name="certificates">certificate to verify / accept against</param>
/// <param name="nonStandardCountCheck">whether to perform the additional file count verification check against
/// MANIFEST.MF (recommended if the file is actually an arbitrary ZIP)</param>
/// <returns>digital signature verification state of the JAR</returns>
public static VerificationResult Jar(Stream stream, IVerificationCertificates certificates,
bool nonStandardCountCheck = true)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (certificates == null)
{
throw new ArgumentNullException(nameof(certificates));
}
using (IJar jar = new Jar(stream))
{
return(Jar(jar, certificates, nonStandardCountCheck));
}
}
/// <summary>
/// Perform JAR digital signature verification against a JAR filename on disk
/// </summary>
/// <param name="filename">JAR filename</param>
/// <param name="certificates">certificate to verify / accept against</param>
/// <param name="nonStandardCountCheck">whether to perform the additional file count verification check against
/// MANIFEST.MF (recommended if the file is actually an arbitrary ZIP)</param>
/// <returns>digital signature verification state of the JAR</returns>
public static VerificationResult Jar(string filename, IVerificationCertificates certificates,
bool nonStandardCountCheck = true)
{
if (filename.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(filename));
}
if (certificates == null)
{
throw new ArgumentNullException(nameof(certificates));
}
using (IJar jar = new Jar(filename))
{
return(Jar(jar, certificates, nonStandardCountCheck));
}
}
public ConfigurationDTO(ClaimsPrincipal user, Jar jar, string projectName)
{
this.user = user;
box = Box.Box.Mistranslate(jar);
pandora = new Pandora(box);
SecurityAccess = GetSecurityAccess();
ApplicationName = jar.Name;
ProjectName = projectName;
Defaults = GetDefaults();
Clusters = GetAllClusters();
Machines = new List<MachineDTO>();
foreach (var cluster in Clusters)
{
var machines = GetAllMachines(cluster.Cluster.Name);
Machines.AddRange(machines);
}
}
public void ResetJarTest()
{
Jar jar = new Jar();
Coin001 coin001 = new Coin001();
coin001.AddToJar(jar);
jar.ResetJar();
// After calling jar.ResetJar() all properties of jar should be 0.
Assert.AreEqual(0.0m, jar.CurrentAmount);
Assert.AreEqual(0.0m, jar.CurrentVolume);
Assert.AreEqual(0, jar.Coin001Counter);
Assert.AreEqual(0, jar.Coin005Counter);
Assert.AreEqual(0, jar.Coin010Counter);
Assert.AreEqual(0, jar.Coin025Counter);
Assert.AreEqual(0, jar.Coin050Counter);
Assert.AreEqual(0, jar.Coin100Counter);
}
public ConfigurationDTO(ClaimsPrincipal user, Jar jar, string projectName)
{
this.user = user;
box = Box.Box.Mistranslate(jar);
pandora = new Pandora(box);
SecurityAccess = GetSecurityAccess();
ApplicationName = jar.Name;
ProjectName = projectName;
Defaults = GetDefaults();
Clusters = GetAllClusters();
Machines = new List <MachineDTO>();
foreach (var cluster in Clusters)
{
var machines = GetAllMachines(cluster.Cluster.Name);
Machines.AddRange(machines);
}
}
/// <summary>
/// Open a class by it's filename
/// </summary>
public ClassFile OpenClass(string fileName)
{
ClassFile result;
if (classFiles.TryGetValue(fileName, out result))
{
return(result);
}
result = Jar.OpenClass(fileName);
if (result == null)
{
return(null);
}
classFiles[fileName] = result;
#if DEBUG
module.OnClassLoaded(result);
#endif
return(result);
}
public void Initialize(ColorPalette palette)
{
jar = SandJar.CreateTargetSandJar(palette);
CreateTargetSandJarGameObject(jar, targetSandJarParent.transform);
}
public GameObject CreateTargetSandJarGameObject(Jar jar, Transform parent)
{
for (int i = 0; i < jar.ColorsToFill.Count; i++)
{
GameObject layer = Instantiate(sandLayerPrefab);
layer.GetComponent<Renderer>().material.color = jar.ColorsToFill[i];
layer.transform.parent = parent;
layer.transform.localPosition = Vector3.zero;
layer.transform.position += Vector3.up*layer.transform.localScale.y*2*i;
}
return sandLayerPrefab;
}
public ActionResult Applications(string projectName, string applicationName, string fileName, string config)
{
var hostName = ApplicationConfiguration.Get("pandora_api_url");
var url = hostName + "/api/Jars/" + projectName + "/" + applicationName + "/" + fileName;
var client = new RestSharp.RestClient(url);
var request = new RestSharp.RestRequest(RestSharp.Method.POST);
request.RequestFormat = RestSharp.DataFormat.Json;
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer " + User.IdToken());
if (!string.IsNullOrWhiteSpace(config))
{
try
{
var jar = JsonConvert.DeserializeObject<Jar>(config);
var box = Box.Box.Mistranslate(jar);
}
catch (Exception)
{
var jar = new Jar();
jar.Name = applicationName;
config = JsonConvert.SerializeObject(jar);
}
}
else
{
var jar = new Jar();
jar.Name = applicationName;
config = JsonConvert.SerializeObject(jar);
}
request.AddBody(config);
var response = client.Execute(request);
Elders.Pandora.Server.UI.ViewModels.User.GiveAccess(User, projectName, applicationName, "Defaults", Access.WriteAccess);
return Redirect("/Projects/" + projectName + "/" + applicationName + "/Clusters");
}
