private SeasonalityDefinition(DoubleArray seasonalityMonthOnMonth, ShiftType adjustmentType)
{
JodaBeanUtils.notNull(seasonalityMonthOnMonth, "seasonalityMonthOnMonth");
JodaBeanUtils.notNull(adjustmentType, "adjustmentType");
this.seasonalityMonthOnMonth = seasonalityMonthOnMonth;
this.adjustmentType = adjustmentType;
}
public OpCode32AluRsImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rm = (opCode >> 0) & 0xf;
Immediate = (opCode >> 7) & 0x1f;
ShiftType = (ShiftType)((opCode >> 5) & 3);
}
/// <summary>
/// Prevents a default instance of the <see cref="Operand"/> class from being created.
/// </summary>
/// <param name="shiftType">Type of the shift.</param>
private Operand(ShiftType shiftType)
: this()
{
ShiftType = shiftType;
IsShift = true;
IsResolved = true;
}
private ShiftType GetSelectedShiftType()
{
int rowindex = 0;
int columnindex = 0;
if (dgvSchedule.CurrentCell.RowIndex > -1 && dgvSchedule.CurrentCell.ColumnIndex > -1)
{
rowindex = dgvSchedule.CurrentCell.RowIndex;
columnindex = dgvSchedule.CurrentCell.ColumnIndex;
if (rowindex == 1)
{
selectedshift = ShiftType.Morning;
}
if (rowindex == 2)
{
selectedshift = ShiftType.Afternoon;
}
if (rowindex == 3)
{
selectedshift = ShiftType.Evening;
}
}
else
{
MessageBox.Show("Please select a cell first");
}
return(selectedshift);
}
private void AddOrRemoveShift(ShiftType shiftType, bool isToggled)
{
var workShift = _workShiftsRepository.Get(SelectedDate, shiftType);
if (isToggled)
{
if (workShift == null)
{
var newWorkShift = new WorkShift {
Date = SelectedDate, ShiftType = shiftType
};
var inlineCalendarEvent = WorkShiftConverter.ToCalendarInlineEvent(newWorkShift);
_workShiftsRepository.Insert(newWorkShift);
WorkShifts.Add(inlineCalendarEvent);
_workshiftCalendar.Add(newWorkShift, inlineCalendarEvent);
}
}
else
{
if (workShift != null)
{
var foundCalendarItem = _workshiftCalendar[workShift];
_workShiftsRepository.Delete(workShift);
WorkShifts.Remove(foundCalendarItem);
_workshiftCalendar.Remove(workShift);
}
}
}
public OpCode32AluRsReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rm = (opCode >> 0) & 0xf;
Rs = (opCode >> 8) & 0xf;
ShiftType = (ShiftType)((opCode >> 5) & 3);
}
public OpCodeT32AluRsImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rm = (opCode >> 0) & 0xf;
Immediate = ((opCode >> 6) & 3) | ((opCode >> 10) & 0x1c);
ShiftType = (ShiftType)((opCode >> 4) & 3);
}
public void Shift(bool reverse, ShiftType shiftType = ShiftType.OneTube)
{
Logger.Debug($"[{nameof(ConveyorUnit)}] - Start shift.");
List <ICommand> commands = new List <ICommand>();
commands.Add(new SetSpeedCommand(Options.ConveyorStepper, (uint)Options.ConveyorSpeed));
int steps = Options.ConveyorStepsPerSingleTube;
if (shiftType == ShiftType.HalfTube)
{
steps /= 2;
}
if (reverse)
{
steps *= -1;
}
steppers = new Dictionary <int, int>()
{
{ Options.ConveyorStepper, steps }
};
commands.Add(new MoveCncCommand(steppers));
executor.WaitExecution(commands);
Logger.Debug($"[{nameof(ConveyorUnit)}] - Shift finished.");
}
public Shift(EmployeeDepartment employeeDepartment, DateTime datetime, ShiftType shiftType, int shiftnum) // this is for reading shifts from the DB
{
EmployeeDepartment = employeeDepartment;
this.DateTime = datetime;
ShiftType = shiftType;
ShiftNumber = shiftnum;
}
public OpCodeT16ShiftImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rd = (opCode >> 0) & 0x7;
Rm = (opCode >> 3) & 0x7;
Immediate = (opCode >> 6) & 0x1F;
ShiftType = (ShiftType)((opCode >> 11) & 3);
}
/* #impl-aarch64.ShiftReg.3 */
public static Bits ShiftReg(int N, int reg, ShiftType type, int amount)
{
Bits result = X(N, reg);
switch (type)
{
default:
case ShiftType.ShiftType_LSL:
result = LSL(result, amount);
break;
case ShiftType.ShiftType_LSR:
result = LSR(result, amount);
break;
case ShiftType.ShiftType_ASR:
result = ASR(result, amount);
break;
case ShiftType.ShiftType_ROR:
result = ROR(result, amount);
break;
}
return(result);
}
/// <summary>
/// Prevents a default instance of the <see cref="Operand"/> class from being created.
/// </summary>
/// <param name="shiftType">Type of the shift.</param>
private Operand(ShiftType shiftType)
: this()
{
ShiftType = shiftType;
IsShift = true;
IsResolved = true;
}
public OpCode32AluRsImm(Inst inst, long position, int opCode) : base(inst, position, opCode)
{
Rm = (opCode >> 0) & 0xf;
Imm = (opCode >> 7) & 0x1f;
ShiftType = (ShiftType)((opCode >> 5) & 3);
}
private CurveParallelShifts(ShiftType shiftType, DoubleArray shiftAmounts)
{
JodaBeanUtils.notNull(shiftType, "shiftType");
JodaBeanUtils.notNull(shiftAmounts, "shiftAmounts");
this.shiftType = shiftType;
this.shiftAmounts = shiftAmounts;
}
public async Task <IActionResult> Edit(int id, [Bind("ShiftTypeId,Name,StartOffsetHrs,StartOffsetMins,RoasterSequence,ShiftSequence,ColorString")] ShiftType shiftType)
{
if (id != shiftType.ShiftTypeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(shiftType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ShiftTypeExists(shiftType.ShiftTypeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(shiftType));
}
public ButtonConfig()
{
_isEnabled = false;
_physicalNumber = 0;
_shiftModificator = 0;
_type = ButtonType.Button_Normal;
}
public ButtonConfig(ButtonType type)
{
_isEnabled = false;
_physicalNumber = 0;
_shiftModificator = 0;
_type = type;
}
//Constructor
public Shift(EmployeeDepartment employeeDepartment, Employee employee, DateTime datetime, ShiftType shiftType) // this is for getting day as an input string (one week)
{
EmployeeDepartment = employeeDepartment;
this.DateTime = datetime;
ShiftType = shiftType;
employees = new List <Employee>();
employees.Add(employee);
}
public OpCodeT16ShiftReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rd = (opCode >> 0) & 7;
Rm = (opCode >> 0) & 7;
Rn = (opCode >> 3) & 7;
Rs = (opCode >> 3) & 7;
ShiftType = (ShiftType)(((opCode >> 6) & 1) | ((opCode >> 7) & 2));
}
private ParallelShiftedCurve(Curve underlyingCurve, ShiftType shiftType, double shiftAmount)
{
JodaBeanUtils.notNull(underlyingCurve, "underlyingCurve");
JodaBeanUtils.notNull(shiftType, "shiftType");
JodaBeanUtils.notNull(shiftAmount, "shiftAmount");
this.underlyingCurve = underlyingCurve;
this.shiftType = shiftType;
this.shiftAmount = shiftAmount;
}
public OpCode32Sat(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
{
Rn = (opCode >> 0) & 0xf;
Imm5 = (opCode >> 7) & 0x1f;
Rd = (opCode >> 12) & 0xf;
SatImm = (opCode >> 16) & 0x1f;
ShiftType = (ShiftType)((opCode >> 5) & 2);
}
/// <summary>
/// Creates an instance. </summary>
/// <param name="shiftType"> the value of the property, not null </param>
/// <param name="shifts"> the value of the property, not null </param>
/// <param name="nodeIndices"> the value of the property, not null </param>
internal PointShifts(ShiftType shiftType, DoubleMatrix shifts, IDictionary <object, int> nodeIndices)
{
JodaBeanUtils.notNull(shiftType, "shiftType");
JodaBeanUtils.notNull(shifts, "shifts");
JodaBeanUtils.notNull(nodeIndices, "nodeIndices");
this.shiftType = shiftType;
this.shifts = shifts;
this.nodeIndices = ImmutableMap.copyOf(nodeIndices);
}
private void Shift(OperationDirection direction, ShiftType shiftType)
{
byte result = ALURightBuffer;
bool leftmostBitIsSet = (result & B10000000) != 0;
// Shift 1 bit to the left or to the right
if (direction == OperationDirection.Left)
{
result <<= 1;
if (shiftType == ShiftType.Logical)
{
result |= B00000001;
}
CF = leftmostBitIsSet;
}
else if (direction == OperationDirection.Right)
{
bool rightmostBitIsSet = (result & B00000001) != 0;
result >>= 1;
if (shiftType == ShiftType.Arithmetic && leftmostBitIsSet)
{
result |= B10000000;
}
CF = rightmostBitIsSet;
}
// Send result to the data bus
InternalDataBus = result;
// Compute flags
// HF an NF are always reset
// SF, ZF, PF, XF and YF will be updated
F &= B00000001;
// Flags bit 5 - YF flag - A copy of bit 5 of the result.
// Flags bit 3 - XF flag - A copy of bit 3 of the result.
F |= (byte)(result & B00101000);
// Flags bit 7 - SF flag - Set if the 2-complement value is negative. It's simply a copy of the most signifcant bit of the result.
F |= (byte)(result & B10000000);
// Flags bit 6 - ZF flag Set if the result is zero.
if (result == 0)
{
F |= B01000000;
}
// PF : parity of the result
PF = numberOfBitsInByteParityTable[result];
if (TraceMicroInstructions)
{
TraceMicroInstruction(new MicroInstruction(Z80MicroInstructionTypes.BitOperationShift, direction, shiftType));
}
}
//-------------------------------------------------------------------------
// restricted constructor
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutableConstructor private InflationNodalCurve(NodalCurve curve, com.opengamma.strata.collect.array.DoubleArray seasonality, com.opengamma.strata.market.ShiftType adjustmentType)
private InflationNodalCurve(NodalCurve curve, DoubleArray seasonality, ShiftType adjustmentType)
{
this.underlying = curve;
this.seasonality = seasonality;
this.xFixing = curve.XValues.get(0);
this.yFixing = curve.YValues.get(0);
int i = seasonalityIndex(xFixing);
ArgChecker.isTrue(adjustmentType.applyShift(yFixing, seasonality.get(i)) - yFixing < 1.0E-10, "Fixing value should be unadjusted");
this.adjustmentType = adjustmentType;
}
public static byte GetShiftTypeCode(ShiftType shiftType)
{
switch (shiftType)
{
case ShiftType.LogicalLeft: return Bits.b00;
case ShiftType.LogicalRight: return Bits.b01;
case ShiftType.ArithmeticRight: return Bits.b10;
case ShiftType.RotateRight: return Bits.b11;
default: throw new NotSupportedException();
}
}
public async Task <IActionResult> Create([Bind("ShiftTypeId,Name,StartOffsetHrs,StartOffsetMins,RoasterSequence,ShiftSequence,ColorString")] ShiftType shiftType)
{
if (ModelState.IsValid)
{
_context.Add(shiftType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(shiftType));
}
private void AddShift(List <Shift> shifts, int index, string last, ShiftType type)
{
if (last != "")
{
var lastShift = shifts.Last();
lastShift.Interval.End = TimeByIndex(index);
}
var interval = new TimeInterval(TimeByIndex(index), TimeByIndex(48));
var shift = new Shift(interval, CurrentDate, type);
shifts.Add(shift);
}
public ButtonConfig(ButtonType type)
{
_isEnabled = false;
_isInverted = false;
_isDisabled = false;
_physicalNumber = 0;
_shiftModificator = ShiftType.NoShift;
_buttonDelayNumber = TimerType.No;
_buttonToggleNumber = TimerType.No;
_type = type;
}
private static DateTime AddShiftEntries(Staff s, DateTime t, int working, ShiftType shiftType, IList <ShiftPlanEntry> entries)
{
for (int d = 0; d < working; d++)
{
if (IsValidWish(s, t))
{
t = AddShiftEntry(entries, t, s, shiftType);
}
}
return(t);
}
public static bool isHolidayDate(DateTime punchDate, ShiftType shift)
{
try
{
bool isHol;
using (var db = new iTimeServiceContext())
{
isHol = db.Set <Holiday>()
.Where(x => DbFunctions.TruncateTime(x.holdate) == punchDate.Date)
.Where(x => x.compid == _compId && x.isactive == true && x.isdeleted == false)
.Count() > 0;
}
if (!isHol)
{
if (punchDate.DayOfWeek == DayOfWeek.Saturday && shift.issatwkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Sunday && shift.issunwkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Monday && shift.ismonwkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Tuesday && shift.istuewkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Wednesday && shift.iswedwkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Thursday && shift.isthuwkday != true)
{
isHol = true;
}
else if (punchDate.DayOfWeek == DayOfWeek.Friday && shift.isfriwkday != true)
{
isHol = true;
}
}
return(isHol);
}
catch (Exception ex)
{
_processedOk = false;
_exception = ex;
return(false);
}
}
public async Task <List <EmployeeNightStatsDTO> > Handle(GetAllEmployeeNightStatsQuery request, CancellationToken cancellationToken)
{
List <EmployeeNightStatsDTO> vm = new List <EmployeeNightStatsDTO>();
// get all the shift participations
List <ShiftParticipation> shiftParts = await _context.ShiftParticipations.Where(sp => sp.Shift.ShiftDate >= request.StartDate.Date && sp.Shift.ShiftDate <= request.EndDate.Date)
.Include(sp => sp.ShiftParticipationType)
.Include(sp => sp.Shift)
.ThenInclude(s => s.ShiftType)
.ToListAsync();
ShiftType nShiftType = (await _context.ShiftTypes.Where(s => s.Name.ToLower().Contains("night shift")).ToListAsync()).ElementAt(0);
List <ShiftParticipationType> shiftPartTypes = await _context.ShiftParticipationTypes.ToListAsync();
List <ApplicationUser> employees = await _userManager.Users
.Include(e => e.ShiftGroup)
.Include(e => e.ShiftRole)
.Include(e => e.Gender)
.ToListAsync();
// compute stats for each employee
foreach (ApplicationUser emp in employees)
{
string userRole = "";
IList <string> existingRoles = await _userManager.GetRolesAsync(emp);
if (existingRoles.Count > 0)
{
userRole = existingRoles.ElementAt(0);
}
if (userRole != SecurityConstants.AdminRoleString)
{
UserDTO uDTO = _mapper.Map <UserDTO>(emp);
uDTO.UserRole = userRole;
EmployeeNightStatsDTO stats = new EmployeeNightStatsDTO
{
Employee = uDTO
};
int numEmpShiftsOfThisType = shiftParts.Count(sp => sp.EmployeeId == emp.Id && sp.Shift.ShiftTypeId == nShiftType.Id);
stats.NumNightShiftsAllotted = numEmpShiftsOfThisType;
List <ShiftParticipation> attendedNightShiftParts = shiftParts.Where(sp => sp.EmployeeId == emp.Id && sp.Shift.ShiftTypeId == nShiftType.Id && !sp.ShiftParticipationType.IsAbsence).ToList();
string nightShiftDates = String.Join(", ", attendedNightShiftParts.Select(p => p.Shift.ShiftDate.Day).OrderBy(x => x).ToArray());
stats.NightShiftDates = nightShiftDates;
stats.NumNightShiftsAttended = attendedNightShiftParts.Count;
vm.Add(stats);
}
}
return(vm);
}
public List <Shift> GetSpecificShifts(Days day, ShiftType ShiftType)
{
List <Shift> SpesShifts = new List <Shift>();
foreach (Shift s in shifts)
{
if (s.WeeklyDay == day && s.ShiftType == ShiftType)
{
SpesShifts.Add(s);
}
}
return(SpesShifts);
}
/// <summary>
/// Parses a shift instruction
/// </summary>
/// <param name="op">The ShiftType for this instruction</param>
private void ParseShift(ShiftType op)
{
// Parse left side
byte reg;
ParseSmallSymbol(SymbolType.Register, out reg);
// Create the shift statement based on register
AddInstruction(new Shift(op, reg));
}
/// <summary>
/// Creates the shifter.
/// </summary>
/// <param name="shiftType">Type of the shift.</param>
/// <returns></returns>
public static Operand CreateShifter(ShiftType shiftType)
{
var operand = new Operand(shiftType);
return operand;
}
/// <summary>
/// Creates a new Shift instruction
/// </summary>
/// <param name="type">the type of the instruction</param>
/// <param name="reg">the register (must be less than 16)</param>
public Shift(ShiftType type, byte reg)
{
this.Type = type;
this.Register = reg;
}
/// <summary>
/// Prevents a default instance of the <see cref="Operand"/> class from being created.
/// </summary>
/// <param name="shiftType">Type of the shift.</param>
private Operand(ShiftType shiftType)
: this()
{
this.ShiftType = shiftType;
this.IsShift = true;
}
private void Shift(OperationDirection direction, ShiftType shiftType)
{
byte result = ALURightBuffer;
bool leftmostBitIsSet = (result & B10000000) != 0;
// Shift 1 bit to the left or to the right
if (direction == OperationDirection.Left)
{
result <<= 1;
if (shiftType == ShiftType.Logical) result |= B00000001;
CF = leftmostBitIsSet;
}
else if (direction == OperationDirection.Right)
{
bool rightmostBitIsSet = (result & B00000001) != 0;
result >>= 1;
if (shiftType == ShiftType.Arithmetic && leftmostBitIsSet) result |= B10000000;
CF = rightmostBitIsSet;
}
// Send result to the data bus
InternalDataBus = result;
// Compute flags
// HF an NF are always reset
// SF, ZF, PF, XF and YF will be updated
F &= B00000001;
// Flags bit 5 - YF flag - A copy of bit 5 of the result.
// Flags bit 3 - XF flag - A copy of bit 3 of the result.
F |= (byte)(result & B00101000);
// Flags bit 7 - SF flag - Set if the 2-complement value is negative. It's simply a copy of the most signifcant bit of the result.
F |= (byte)(result & B10000000);
// Flags bit 6 - ZF flag Set if the result is zero.
if (result == 0) F |= B01000000;
// PF : parity of the result
PF = numberOfBitsInByteParityTable[result];
if (TraceMicroInstructions)
{
TraceMicroInstruction(new MicroInstruction(Z80MicroInstructionTypes.BitOperationShift, direction, shiftType));
}
}
public void EmitInstructionWithRegister(ConditionCode conditionCode, byte opcode, bool setCondition, int firstRegister, int destinationRegister, ShiftType secondShiftType, int secondRegister)
{
Debug.Assert(opcode <= 0xF);
Debug.Assert(destinationRegister <= 0xF);
Debug.Assert(firstRegister <= 0xF);
Debug.Assert(secondRegister <= 0xF);
uint value = 0;
value |= (uint)(GetConditionCode(conditionCode) << 28);
value |= (uint)(0x0 << 25);
value |= (uint)(opcode << 21);
value |= (uint)(setCondition ? 1 : 0 << 20);
value |= (uint)(firstRegister << 16);
value |= (uint)(destinationRegister << 12);
value |= (uint)(GetShiftTypeCode(secondShiftType) << 4);
value |= (uint)secondRegister;
Write(value);
}
public void EmitSingleDataTransfer(ConditionCode conditionCode, Indexing indexing, OffsetDirection offsetDirection, TransferSize transferSize, WriteBack writeBack, TransferType transferType, int firstRegister, int destinationRegister, ShiftType secondShiftType, int secondRegister)
{
Debug.Assert(destinationRegister <= 0xF);
Debug.Assert(firstRegister <= 0xF);
Debug.Assert(secondRegister <= 0xF);
uint value = 0;
value |= (uint)(GetConditionCode(conditionCode) << 28);
value |= (uint)(1 << 26);
value |= (uint)(1 << 25);
value |= (uint)((indexing == Indexing.Post ? 0 : 1) << 24);
value |= (uint)((transferSize == TransferSize.Word ? 0 : 1) << 23);
value |= (uint)((offsetDirection == OffsetDirection.Down ? 0 : 1) << 22);
value |= (uint)((writeBack == WriteBack.NoWriteBack ? 0 : 1) << 21);
value |= (uint)((transferType == TransferType.Store ? 0 : 1) << 20);
value |= (uint)(destinationRegister << 12);
value |= (uint)(firstRegister << 16);
value |= (uint)(GetShiftTypeCode(secondShiftType) << 4);
value |= (uint)secondRegister;
Write(value);
}