private void populateMesh(MOM mom)
{
Mesh m = LibLSDUnity.CreateMeshesFromTMD(mom.TMD).First();
rotateUpright(m);
_meshFilter.sharedMesh = m;
}
public async Task <int> AddMOM(MOM mom)
{
db.MOMs.Add(mom);
int result = await db.SaveChangesAsync();
return(result);
}
public async Task <string> UpdateMOM(MOM moms)
{
MOM mom = MOMRepository.GetMOMs().FirstOrDefault(c => c.MOMId == moms.MOMId);
if (mom == default(MOM))
{
return("projectplan doen't exist");
}
else
{
if (moms.TaskComplitionDate == null)
{
mom.MeetingDate = moms.MeetingDate.Value;
}
else
{
mom.Status = moms.Status;
mom.TaskComplitionDate = moms.TaskComplitionDate.Value;
}
}
int updatemom = await MOMRepository.UpdateMOM(mom);
return(updatemom == 0 ? "Successfully updated Meeting and Minutes record" : "Updation failed");
}
public string DeleteMOM(int momid)
{
MOM mom = MOMRepository.GetMOMs().SingleOrDefault(c => c.MOMId == momid);
int deletedmom = Task.Run <int>(async() => await MOMRepository.DeleteMOM(momid)).Result;
return(deletedmom > 0 ? "Successfully Deleted project plan record" : "Deletion failed");
}
public async Task <int> DeleteMOM(int momid)
{
MOM mom = await FetchbyMOMId(momid);
db.MOMs.Remove(mom);
int result = await db.SaveChangesAsync();
return(result);
}
public IHttpActionResult UpdateMOM(MOM mom)
{
if (!ModelState.IsValid)
{
return(BadRequest("Not a valid model"));
}
Task.Run(async() => await _MOM.UpdateMOM(mom));
return(Ok());
}
public async Task <int> UpdateMOM(MOM mom)
{
MOM existingMOM = await FetchbyMOMId(mom.MOMId);
db.Entry(existingMOM).State = EntityState.Detached;
db.Entry(existingMOM).State = EntityState.Modified;
int result = await db.SaveChangesAsync();
return(result);
}
public IHttpActionResult PostMOM(MOM mom)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid data."));
}
int i = Task.Run <int>(async() => await _MOM.AddMOM(mom)).Result;
return(Ok(i));
}
public InteractiveObjectData(MOM mom, Material mat)
{
_mom = mom;
ObjectTable = LibLSDUnity.CreateMeshesFromTMD(mom.TMD);
Animations = new List <TODAnimation>();
foreach (var anim in _mom.MOS.TODs)
{
Animations.Add(new TODAnimation(anim, ObjectTable, mat));
}
}
/// <summary>
/// Load a MOM file from disk.
/// </summary>
/// <param name="path">The path to the MOM file.</param>
/// <param name="span">The span ID for how long this resource should be cached.</param>
public void Load(string path, int span)
{
MOM mom;
using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open)))
{
mom = new MOM(br);
}
Resource <MOM> resource = new Resource <MOM>(mom, span);
ResourceManager.RegisterResource(path, resource);
}
public void Awake()
{
ResourceManager.RegisterHandler(new MOMHandler());
_greymanMom =
ResourceManager.Load <MOM>(PathUtil.Combine(Application.streamingAssetsPath, PATH_TO_GREYMAN_MOM));
_meshFilter = GetComponent <MeshFilter>();
_meshRenderer = GetComponent <MeshRenderer>();
_meshRenderer.sharedMaterial = GreymanMaterial;
populateMesh(_greymanMom);
}
public static MOM LoadMOM(string filePath)
{
Log.Information($"Loading MOM from: {filePath}");
MOM mom;
using (BinaryReader br = new BinaryReader(File.Open(filePath, FileMode.Open)))
{
mom = new MOM(br);
}
Log.Information("Successfully loaded MOM");
return(mom);
}
public void LoadMOM(string momPath)
{
Logger.Log()(LogLevel.INFO, $"Loading MOM from: {momPath}");
MOM mom;
using (BinaryReader br = new BinaryReader(File.Open(momPath, FileMode.Open)))
{
mom = new MOM(br);
}
Logger.Log()(LogLevel.INFO, "Successfully loaded MOM");
MOMDocument document = CreateDocument(mom);
_treeController.PopulateTreeWithDocument(document, Path.GetFileName(momPath));
}
public static List <GameObject> CreateGameObjectsFromMOM(MOM mom, Material mat)
{
var meshes = CreateMeshesFromTMD(mom.TMD);
List <GameObject> meshObjects = new List <GameObject>();
foreach (var mesh in meshes)
{
GameObject meshObj = new GameObject($"mesh {meshObjects.Count}");
MeshRenderer mr = meshObj.AddComponent <MeshRenderer>();
MeshFilter mf = meshObj.AddComponent <MeshFilter>();
mr.sharedMaterial = mat;
mf.sharedMesh = mesh;
meshObjects.Add(meshObj);
}
return(meshObjects);
}
//----------------------------------------------------------------------------
// Public methods
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Private methods
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Event triggers and Handlers
//----------------------------------------------------------------------------
private void MOM_OnInstantiateCompleted(MOM obj)
{
GameObject _grassPartInstance;
for (int i = 0; i <= 100; i++)
{
_grassPartInstance = Instantiate (_grassPartPrefab) as GameObject;
_grassPartInstance.transform.parent = transform;
Vector3 localScale = _grassPartInstance.transform.localScale;
//don't horizontally flip for variety (because it doesn't render from 'behind')
// localScale.x = Random.Range (0,1) -1;
// Debug.Log ("localScale.x: " + localScale.x);
// _grassParInstance.transform.localScale = localScale;
_grassPartInstance.transform.position = GameManager.Instance.GetRandomPositionWithinGameBounds();
}
}
/// <summary>
/// keltner constructor.
/// </summary>
/// <param name="initialNextUpdateDateTime"></param>
/// <param name="keltnerTradingVariables"></param>
/// <param name="marketOpens"></param>
/// <param name="marketCloses"></param>
public KeltnerIndicatorManager(DateTime initialNextUpdateDateTime, KeltnerTradingVariables keltnerTradingVariables, List <DateTime> marketOpens, List <DateTime> marketCloses)
: base()
{
// Load keltner trading parameters.
m_KeltnerTradingVariables = keltnerTradingVariables;
m_EMALength = keltnerTradingVariables.EMALength;
m_ATRLength = keltnerTradingVariables.ATRLength;
m_MOMLength = keltnerTradingVariables.MomentumLength;
m_BarUpdateIntervalSecond = keltnerTradingVariables.BarIntervalInSeconds;
// Create indicators.
m_EMA = new EMA(m_EMASeriesID, m_EMASeriesName, m_EMALength);
m_ATR = new ATR(m_ATRSeriesID, m_ATRSeriesName, m_ATRLength);
m_MOM = new MOM(m_MOMSeriesID, m_MOMSeriesName, m_MOMLength);
this.AddIndicator(m_EMA, m_EMASeriesName);
this.AddIndicator(m_ATR, m_ATRSeriesName);
this.AddIndicator(m_MOM, m_MOMSeriesName);
// Initial setup for the trading indicators.
initialNextUpdateDateTime = Functions.GetNextBarUpdateDateTime(initialNextUpdateDateTime, m_BarUpdateIntervalSecond);
m_EMA.SetupIndicator(m_BarUpdateIntervalSecond, initialNextUpdateDateTime, marketOpens, marketCloses);
m_ATR.SetupIndicator(m_BarUpdateIntervalSecond, initialNextUpdateDateTime, marketOpens, marketCloses);
m_MOM.SetupIndicator(m_BarUpdateIntervalSecond, initialNextUpdateDateTime, marketOpens, marketCloses);
}
public async Task <MOM> FetchbyMOMId(int momid)
{
MOM mom = await db.MOMs.FindAsync(momid);
return(mom);
}
public MOMDocument CreateDocument(MOM mom)
{
TMDDocument models = _tmdController.CreateDocument(mom.TMD);
return(new MOMDocument(mom, models));
}
public async Task <int> AddMOM(MOM mom)
{
int insertedmomid = await MOMRepository.AddMOM(new MOM { ProjectId = mom.ProjectId, MOMType = mom.MOMType, MeetingDate = mom.MeetingDate, Minutes = mom.Minutes, TaskComplitionDate = mom.TaskComplitionDate, CreatedDate = mom.CreatedDate, CreatedBy = mom.CreatedBy });
return(insertedmomid > 0 ? insertedmomid : 0);
}
