public IActionResult Post([FromBody] Mesure mesure)
{
using (var scope = new TransactionScope())
{
_mesureRepository.InsertMesure(mesure);
scope.Complete();
return(CreatedAtAction(nameof(Get), new { id = mesure.Id }, mesure));
}
}
private void AddTrame()
{
while (BufferF.Count > 14)
{
if (checkframe())
{
Base obj = new Base();
/////////////////////////////////
///Creation d'une trame d'information
if (BufferF[3] < 11 && BufferF[3] != 0)
{
obj = new Mesure();
}
if (BufferF[3] == 50)
{
obj = new Alarm();
}
////////////////////////////////////////
///Commencement de la recuperation des informations de la trame
/////id position
obj.id = BufferF[3];
////////////////
///Nombre de data
obj.cptOctet = BufferF[4];
////////////////
///Type
obj.Type = BufferF[5];
//////////////////
///Data
//////////////////
///Checksumm
obj.checksum = BufferF[6 + obj.cptOctet];
//////////////////////////////////////////
///Fin de trame
for (int cpt = 0; cpt < obj.cptOctet; cpt++)
{
obj.data += (((UInt32)BufferF[6 + cpt]) << 8 * cpt);
}
if (checkListBase(obj))
{
uptadeData(obj);
}
else
{
LBase.Add(obj);
}
Console.WriteLine("taille de la liste:" + LBase.Count);
for (int cpt = 0; cpt < 10 + obj.cptOctet; cpt++)
{
BufferF.RemoveAt(0);
}
}
}
bData_received = true;
}
public IActionResult Put([FromBody] Mesure Model)
{
if (Model != null)
{
using (var scope = new TransactionScope())
{
_mesureRepository.UpdateMesure(Model);
scope.Complete();
return(new OkResult());
}
}
return(new NoContentResult());
}
public string GetPositionText(int tick)
{
int ticks = 0;
int beat = 0;
int measures = 0;
int currentTick = 0;
var mesure = new Mesure()
{
denominator = 4,
numerator = 4
};
foreach (var ev in mEventList)
{
if (tick <= currentTick)
{
break;
}
while (currentTick < ev.Tick)
{
currentTick++;
ticks++;
if (3840 / mesure.denominator <= ticks)
{
ticks -= 3840 / mesure.denominator;
++beat;
if (mesure.numerator <= beat)
{
beat -= mesure.numerator;
++measures;
}
}
}
if (E_STATUS.META == ev.Type)
{
if (E_META.MEASURE == ev.Meta.Type)
{
mesure = new Mesure(ev.Meta.Int);
}
}
}
return(string.Format(
"{0}:{1}:{2}",
(measures + 1).ToString("0000"),
(beat + 1).ToString("00"),
ticks.ToString("0000")
));
}
public void InsertMesure(Mesure Mesure)
{
if (Mesure != null)
{
Indicateur indicateur = _dbContext.Indicateurs.Where(A => A.Id == Mesure.IndicateurId).FirstOrDefault();
//Calcul de valeur de mesure par l'indictateur.
string expression = indicateur.Methode;
string exp = expression.Replace("A", Mesure.Valeur1.ToString()).Replace("B", Mesure.Valeur2.ToString());
DataTable dt = new DataTable();
long v = (long)Convert.ToInt64(dt.Compute(exp, string.Empty));
Mesure.Resultat = v;
indicateur.Mesures.Add(Mesure);
Save();
}
}
public void UpdateMesure(Mesure Mesure)
{
_dbContext.Entry(Mesure).State = EntityState.Modified;
Save();
}
private void MainProc()
{
foreach (Event e in mEventList)
{
if (!IsPlay)
{
return;
}
var ev = e;
while (mCurrentTick < ev.Tick)
{
if (!IsPlay)
{
return;
}
var current_mSec = mSw.ElapsedMilliseconds;
var deltaTime = current_mSec - mPrevious_mSec;
mCurrentTick += 0.96 * mBPM * Speed * deltaTime / 60.0;
mTick += mCurrentTick - mPreviousTick;
if (3840 / mMeasureDenomi <= mTick)
{
mTick -= 3840 / mMeasureDenomi;
++mBeat;
if (mMeasureNumer <= mBeat)
{
mBeat -= mMeasureNumer;
++mMeasure;
}
}
mPrevious_mSec = current_mSec;
mPreviousTick = mCurrentTick;
Thread.Sleep(1);
}
switch (ev.Type)
{
case E_STATUS.NOTE_OFF: {
var chParam = mSender.Channel(ev.Channel);
if (0 == chParam.InstId.isDrum)
{
if ((ev.Data[1] + Transpose) < 0 || 127 < (ev.Data[1] + Transpose))
{
continue;
}
else
{
ev = new Event(ev.Channel, E_STATUS.NOTE_OFF, ev.Data[1] + Transpose, ev.Data[2]);
}
}
else
{
continue;
}
}
break;
case E_STATUS.NOTE_ON: {
var chParam = mSender.Channel(ev.Channel);
if (ev.Data[2] != 0)
{
if (0.25 * 960 < (mCurrentTick - ev.Tick))
{
continue;
}
if (!chParam.Enable || (0 <= SoloChannel && SoloChannel != ev.Channel))
{
continue;
}
}
if (0 == chParam.InstId.isDrum)
{
if ((ev.Data[1] + Transpose) < 0 || 127 < (ev.Data[1] + Transpose))
{
continue;
}
else
{
ev = new Event(ev.Channel, E_STATUS.NOTE_ON, ev.Data[1] + Transpose, ev.Data[2]);
}
}
}
break;
case E_STATUS.META:
switch (ev.Meta.Type)
{
case E_META.TEMPO:
mBPM = 60000000.0 / ev.Meta.Int;
break;
case E_META.MEASURE:
var m = new Mesure(ev.Meta.Int);
mMeasureNumer = m.numerator;
mMeasureDenomi = m.denominator;
break;
case E_META.KEY:
mKey = (E_KEY)ev.Meta.Int;
break;
}
break;
}
//
mSender.Send(ev);
}
}
private void putDrawEvents()
{
mDrawNoteList.Clear();
var beginTime = snapTimeScroll();
var endTime = snapTimeScroll(mBmpRoll.Width);
var dispNoteList = new List <DrawNote>();
foreach (var ev in mEventList)
{
switch (ev.Type)
{
case E_STATUS.NOTE_OFF:
for (int i = 0; i < dispNoteList.Count; i++)
{
var dispEv = dispNoteList[i];
if (dispEv.track == ev.Track && dispEv.data1 == ev.Data[1])
{
if (beginTime <= ev.Tick)
{
dispEv.end = ev.Tick;
if (mSelectState == E_SELECT.SELECT)
{
dispEv.selected = dispEv.data1 == mToneEnd &&
dispEv.begin <= mTimeEnd && mTimeEnd < dispEv.end;
}
mDrawNoteList.Add(dispEv);
}
dispNoteList.RemoveAt(i);
i--;
}
}
break;
case E_STATUS.NOTE_ON:
if (ev.Tick <= endTime)
{
var selected = mSelectState == E_SELECT.SELECT_AREA &&
EditTrack == ev.Track &&
mTimeBegin <= ev.Tick && ev.Tick <= mTimeEnd &&
mToneBegin <= ev.Data[1] && ev.Data[1] <= mToneEnd;
dispNoteList.Add(new DrawNote(ev.Track, selected, ev.Tick, ev.Data));
}
break;
}
}
var mesureDeno = 4;
var mesureNume = 4;
var mesureTick = 0;
var mesureNum = 1;
var mesureInterval = 3840;
var beatInterval = 960;
mDrawMeasureList.Clear();
foreach (var ev in mEventList)
{
if (ev.Type != E_STATUS.META || ev.Meta.Type != E_META.MEASURE)
{
continue;
}
for (; mesureTick < ev.Tick; mesureTick += mesureInterval)
{
for (int beatTick = 0; beatTick < mesureInterval; beatTick += beatInterval)
{
var tick = mesureTick + beatTick;
if (beginTime <= tick && tick <= endTime)
{
var mesure = new DrawMeasure();
mesure.IsBar = beatTick == 0;
mesure.Tick = tick;
mesure.Number = mesureNum;
mDrawMeasureList.Add(mesure);
}
}
mesureNum++;
}
var m = new Mesure(ev.Meta.Int);
mesureDeno = m.denominator;
mesureNume = m.numerator;
mesureInterval = 3840 * mesureNume / mesureDeno;
beatInterval = 3840 / mesureDeno;
}
for (; mesureTick <= endTime; mesureTick += mesureInterval)
{
for (int beatTick = 0; beatTick < mesureInterval; beatTick += beatInterval)
{
var tick = mesureTick + beatTick;
if (beginTime <= tick && tick <= endTime)
{
var mesure = new DrawMeasure();
mesure.IsBar = beatTick == 0;
mesure.Tick = tick;
mesure.Number = mesureNum;
mDrawMeasureList.Add(mesure);
}
}
mesureNum++;
}
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
SameUserRequirement requirement,
object resource)
{
if (resource.GetType() == typeof(Projet))
{
Projet model = (Projet)resource;
Projet Projet = _projetRepository.GetProjetByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Document))
{
Document d = (Document)resource;
Document document = _documentRepository.GetDocumentByID(d.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == document.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Phase))
{
Phase model = (Phase)resource;
Phase Phase = _phaseRepository.GetPhaseByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Phase.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Models.Action))
{
Models.Action model = (Models.Action)resource;
Models.Action Action = _actionRepository.GetActionByID(model.Id);
if (Action.ProjetId != null)
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Action.Projet.UserId)
{
context.Succeed(requirement);
}
}
else
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Action.Phase.Projet.UserId)
{
context.Succeed(requirement);
}
}
}
else if (resource.GetType() == typeof(Tache))
{
Tache model = (Tache)resource;
Tache Tache = _tacheRepository.GetTacheByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Tache.Action.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Reunion))
{
Reunion model = (Reunion)resource;
Reunion Reunion = _reunionRepository.GetReunionByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Reunion.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Objectif))
{
Objectif model = (Objectif)resource;
Objectif Objectif = _objectifRepository.GetObjectifByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Risque))
{
Risque model = (Risque)resource;
Risque Risque = _risqueRepository.GetRisqueByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Risque.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Opportunite))
{
Opportunite model = (Opportunite)resource;
Opportunite Opportunite = _opportuniteRepository.GetOpportuniteByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Opportunite.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Indicateur))
{
Indicateur model = (Indicateur)resource;
Indicateur Indicateur = _indicateurRepository.GetIndicateurByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Indicateur.Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Mesure))
{
Mesure model = (Mesure)resource;
Mesure Mesure = _mesureRepository.GetMesureByID(model.Id);
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Mesure.Indicateur.Objectif.Projet.UserId)
{
context.Succeed(requirement);
}
}
else if (resource.GetType() == typeof(Evaluation))
{
Evaluation model = (Evaluation)resource;
Evaluation Evaluation = _evaluationRepository.GetEvaluationByID(model.Id);
if (Evaluation.OpportuniteId != null)
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Evaluation.Opportunite.Projet.UserId)
{
context.Succeed(requirement);
}
}
else
{
if (new Guid(context.User.FindFirstValue(ClaimTypes.NameIdentifier)) == Evaluation.Risque.Projet.UserId)
{
context.Succeed(requirement);
}
}
}
return(Task.CompletedTask);
}
