public string ConvertEntityToCSVFormat(WorkingSchedule entity)
{
String days = "";
if (entity.WorkingDays.Count != 0)
{
WorkingDays last = entity.WorkingDays.Last();
foreach (WorkingDays treatment in entity.WorkingDays)
{
if (treatment != null)
{
if (treatment != last)
{
days += treatment.Id + "|";
}
else
{
days += treatment.Id;
}
}
}
}
return(string.Join(_delimiter,
entity.Id,
entity.From.ToString("dd/MM/yyyy"),
entity.To.ToString("dd/MM/yyyy"),
days));
}
public IHttpActionResult Apply(ApplyLeaveCommand command)
{
CheckModelSate();
var workingDays = WorkingDays.Query(new GetWorkingDays {
EndDate = command.EndDate, StartDate = command.StartDate
});
if (workingDays <= 0)
{
throw new ApiException("Cannot apply for 0 working days");
}
var overlappedResult = OverlapWithApprovedLeaves.Query(new OverlapWithApprovedLeaves {
StartDate = command.StartDate, EndDate = command.EndDate
});
if (overlappedResult.Overlaped)
{
throw new ApiException(string.Format("Overlapped with existing Leave: start at: {0}, end at: {1}", overlappedResult.OverlappedLeave.StartDate, overlappedResult.OverlappedLeave.EndDate));
}
command.UserName = User.Identity.Name;
CommandSender.Send(command);
return(Content(HttpStatusCode.OK, 0));
}
public string Create(WorkingDays mast)
{
try
{
var salarymast = new MonthlySalaryMast();
var salarydetails = new List <MonthlySalaryDetail>();
salarymast.Branchid = mast.Branchid;
salarymast.Month = mast.Month;
salarymast.Year = mast.Year;
salarymast.Totaldaysinmonth = mast.Totaldaysinmonth;
var monthlySalaryDetails = mast.WorkingDaysDetails.Select(x =>
new MonthlySalaryDetail
{
EmpId = x.EmpId,
AttendanceDays = x.AttendanceDays,
Holidays = x.Holidays,
LeaveDays = x.LeaveDays,
AbsentDays = x.AbsentDays,
PayDays = x.PayDays,
OTHours = x.OTHours
}
);
salarymast.MonthlySalaryDetails = monthlySalaryDetails.ToList();
Service.Add(salarymast);
return("Working Days Saved Successfully");
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex.Message);
return(ex.Message);
throw new ArgumentException(ex.Message);
}
}
public async Task<ActionResult> UpdateSalary(string newSalary)
{
decimal salary = 0;
var sessionId = _sessionManager.GetSessionId(Request, Response);
if (!decimal.TryParse(newSalary, out salary))
{
ViewBag.Salary = await this.GetCurrentSalary();
ViewBag.ErrorMessage = "Invalid salary input. Try again";
return View("Salary");
}
else
{
var currentWorkingDays = (await _salaryRepository.GetWorkingDays(sessionId)).ToList();
await _salaryRepository.InsertSalaryDetail(sessionId, SalaryType.Annual, salary);
var workingDays = new WorkingDays
{
Monday = currentWorkingDays.Contains(1),
Tuesday = currentWorkingDays.Contains(2),
Wednesday = currentWorkingDays.Contains(3),
Thursday = currentWorkingDays.Contains(4),
Friday = currentWorkingDays.Contains(5),
Saturday = currentWorkingDays.Contains(6),
Sunday = currentWorkingDays.Contains(7)
};
return View("WorkingDays", workingDays);
}
}
private void AtualizarTempoAtividadesPorDia()
{
var diasExecutados = WorkingDays.DiffDays(this.DataInicio, DateTime.Now.Date, this.DiasNaoUteis, false);
var atividadesPorDia = this.Atividades.Where(a => a.ItemCatalogo != null && a.ItemCatalogo.FormaCalculoTempoItemCatalogoId == (int)FormaCalculoTempoItemCatalogoEnum.PredefinidoPorDia).ToList();
atividadesPorDia.ForEach(a => a.AlterarTempoRealizado(diasExecutados * a.TempoPrevistoPorItem));
}
public static PactoTrabalho Criar(Guid planoTrabalhoId, Int64 unidadeId, Int64 pessoaId, Int32 cargaHorariaDiaria, int modalidadeExecucaoId, DateTime dataInicio, DateTime dataFim, String usuarioLogado, List <DateTime> diasNaoUteis, string termoAceite)
{
//Cria o pacto de trabalho para ser ajustado pelo chefe da unidade
var model = new PactoTrabalho()
{
PactoTrabalhoId = Guid.NewGuid(),
PlanoTrabalhoId = planoTrabalhoId,
UnidadeId = unidadeId,
PessoaId = pessoaId,
CargaHorariaDiaria = cargaHorariaDiaria,
ModalidadeExecucaoId = modalidadeExecucaoId,
DataInicio = dataInicio,
DataFim = dataFim,
Historico = new List <PactoTrabalhoHistorico>(),
Atividades = new List <PactoTrabalhoAtividade>(),
TermoAceite = termoAceite
};
model.ValidarDatas(dataInicio, dataFim);
model.DiasNaoUteis = diasNaoUteis;
model.TempoTotalDisponivel = cargaHorariaDiaria * WorkingDays.DiffDays(dataInicio, dataFim, diasNaoUteis, false);
//OK
model.AlterarSituacao((int)SituacaoPactoTrabalhoEnum.Rascunho, usuarioLogado, null);
return(model);
}
public void AdicionarAtividade(ItemCatalogo itemCatalogo, int quantidade, int modalidaExecucaoId, decimal tempoPrevistoPorItem, string descricao, IEnumerable <Guid> idsAssuntos, IEnumerable <Guid> idsObjetos)
{
VerificarPossibilidadeAlteracao();
var atividade = PactoTrabalhoAtividade.Criar(this.PactoTrabalhoId, itemCatalogo.ItemCatalogoId, quantidade, modalidaExecucaoId, tempoPrevistoPorItem, descricao);
if (idsAssuntos != null)
{
foreach (var idAssunto in idsAssuntos)
{
atividade.AdicionarAssunto(idAssunto);
}
}
if (idsObjetos != null)
{
foreach (var idObjeto in idsObjetos)
{
atividade.AdicionarObjeto(idObjeto);
}
}
this.Atividades.Add(atividade);
if (itemCatalogo.FormaCalculoTempoItemCatalogoId == (int)FormaCalculoTempoItemCatalogoEnum.PredefinidoPorDia)
{
atividade.AtualizarTempoPrevistoTotal(WorkingDays.DiffDays(this.DataInicio, this.DataFim, this.DiasNaoUteis, false));
}
}
public void SameDayIsZero()
{
var service = new WorkingDays();
var from = new DateTime(2013, 8, 12);
Assert.AreEqual(0, service.GetWorkingDays(from, from));
}
protected static void AssertProviderHeavy(IWorkingDaysProvider prov, int iterations, bool forward, bool consider, params DateTime[] baseDates)
{
foreach (var baseDate in baseDates)
{
WorkingDays w = new WorkingDays(prov);
int one = forward ? 1 : -1;
DateTime curr = baseDate;
for (int i = 1; i <= iterations; i++)
{
while (!w.IsWorkingDay(curr) || (!consider && curr == baseDate))
{
curr = curr.AddDays(one);
}
if (forward)
{
w.GetInAdvance(i, baseDate, consider).Should().Be(curr);
}
else
{
w.GetBackwards(i, baseDate, consider).Should().Be(curr);
}
curr = curr.AddDays(one);
}
}
}
public IHttpActionResult GetWorkingDays(WorkingDaysModel model)
{
return(Content(HttpStatusCode.OK,
WorkingDays.Query(new GetWorkingDays {
StartDate = model.StartDate, EndDate = model.EndDate
})));
}
public void Print(ITextOutput output, TableFormatter tableFormatter)
{
var table = CreateTable();
foreach (var issueView in Issues)
{
object[] currentRow = table.AddRow(issueView.Name);
for (int i = 1; i < table.Columns.Count; i++)
{
var currentWorkDay = WorkingDays.SingleOrDefault(x => x.Date.Equals(table.Columns[i].Value));
double?totalHoursPerIssue = currentWorkDay?.GetTotalHoursByIssue(issueView);
// TODO: move tostring into formatter it doesn't belongs here
currentRow[i] = totalHoursPerIssue > 0 ? totalHoursPerIssue.Value.ToString("0.##") : null;
}
}
var currentFooterRow = table.AddFooterRow("Total hours:");
for (int i = 1; i < table.Columns.Count; i++)
{
var day = WorkingDays.SingleOrDefault(x => x.Date.Equals(table.Columns[i].Value));
//TODO: move tostring into formatter it doesn't belongs here
currentFooterRow[i] = day?.TotalHours.ToString("0.##");
}
//TODO: move tostring into formatter it doesn't belongs here
table.AddFooterRow($"Total hours for period logged/expected: {TotalHoursInPeriod.ToString("0.##")}" +
$"/{ExpectedTotalHoursInPeriod.ToString("0.##")}");
tableFormatter.Write(table, output);
}
//conBD con = new conBD();
#endregion
//public regViewModel()
//{
// // KARTA = new CardPageOne { Name = "aaaaaaaaaa", Sername = "bbbbbbbbbbb" };
// //CheckConnection();
// DateDoctorAcepting = DateTime.Today;
// ListOfSpecf = con.getList();
// ListOfUsers = con.GetUsers();
// // DateDoctorAcepting = DateTime.Parse("2017-07-07");
// Users = OneTimeUsers;
// foreach (var a in ListOfUsers)
// {
// OneTimeUsers.Add(a.userFIO);
// }
// DoctorTimes = new List<Times>();
// try
// {
// DoctorTimes = con.getDocTimes(SelectedDocNames.docID, SelectedDocNames.docTimeId, DateDoctorAcepting);
// OneTimeDoctorTimes = DoctorTimes;
// }
// catch { }
// // localDB.save2("473", "SUG+", "AL+", "Inf+");
//}
// public DoctorsList.DocNames sas { get; set; }
// WPF_Hospital.MainWindow a = new WPF_Hospital.MainWindow();
#region Helpers method and command
/// <summary>
/// Метод для обновления росписания врача с проверкой на робочи/не робочий день
/// </summary>
public void RefreshDocTimes()
{
//await RefreshAsync();
try
{
//if (con.CheckDoctorList(SelectedDocNames.docTimeId))
//{
//if (TimeHour == true)
//{
// try
// {
// if (WorkingDays.Contains(DateDoctorAcepting) == true)
// {
// List<Times> temp = new List<Times>();
// DoctorTimes = con.getDocTimes(SelectedDocNames.docID, DateDoctorAcepting);
// foreach (var a in DoctorTimes)
// {
// i++;
// temp.Add(new Times { Time = a.Time, Status = a.Status, Label = "Talon №" + i.ToString(), TimeProperties = a.TimeProperties });
// }
// DoctorTimes = temp;
// }
// else
// {
// DoctorTimes = new List<Times>();
// DoctorTimes.Add(new Times { Label = "Не робочій день", Status = "Red" });
// }
// }
// catch (Exception)
// {
// MessageBox.Show("Лікар не вибраний");
// }
//}
//else
//{
WorkingDays = con.GetListOfWorkingDays(Convert.ToInt32(_SelectedDocNames.docID));
if (WorkingDays.Contains(DateDoctorAcepting) == true)
{
DoctorTimes = con.getDocTimes(SelectedDocNames.docID, DateDoctorAcepting);
}
else
{
DoctorTimes = new List <Times>();
DoctorTimes.Add(new Times {
Label = "Не робочій день", Status = "Red"
});
}
//}
}
catch (Exception e)
{
//Розкомнетить для отладки
//MessageBox.Show(e.ToString());
}
}
public void AccountForHolidays()
{
var service = new WorkingDays();
var from = new DateTime(2013, 8, 23);
Assert.AreEqual(0, service.GetWorkingDays(from, new DateTime(2013, 8, 26)), "Fri - Mon = 0");
Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 27)), "Fri - Tues = 1");
}
public void edTimesMethod()
{
EditTime TimeEditing = new EditTime();
EditTimesViewModel VMEditTime = new EditTimesViewModel();
TimeEditing.DataContext = VMEditTime;
VMEditTime.docSelected = SelectedDocNames;
ObservableCollection <Times> BackUPdocTimes = new ObservableCollection <Times>(); // не менять на лист, ибо не будет обновлятся вью расписания
try
{
DoctorTimes = con.getDocTimes(SelectedDocNames.docID, SelectedDocNames.docTimeId, DateDoctorAcepting);
foreach (var a in DoctorTimes)
{
BackUPdocTimes.Add(new Times {
Time = a.Time, Status = a.Status
});
}
VMEditTime.docTimes = DoctorTimes;
//DoctorTimes = VMEditTime.temperory;
}
catch (Exception) { }
try { TimeEditing.ShowDialog(); }
catch { }
//следующая команда срабатывает после закрытия диалогового окна
// СУПЕР КОСТЫЛЬ СДЕЛАТЬ БЫ ПОЛЮДСКИ (роботает по принцыпу - строчка выполняеться после того как закрлось окно редактирвоанья)
// сделать бы нормлаьную передачу данных и команд между формами.
try
{
WorkingDays = con.GetListOfWorkingDays(Convert.ToInt32(SelectedDocNames.docID));
if (con.CheckDoctorList(SelectedDocNames.docTimeId))
{
if (SelectedDocNames.docTimeId == "0" || WorkingDays.Contains(DateDoctorAcepting) == false)
{
DoctorTimes = new ObservableCollection <Times>();
DoctorTimes.Add(new Times {
Time = "Не робочий день", Status = "Red"
});
}
else
{
DoctorTimes = con.getDocTimes(SelectedDocNames.docID, SelectedDocNames.docTimeId, DateDoctorAcepting);
}
}
else
{
DoctorTimes = null;
}
TimeHour = SelectedDocNames.docBool;
//DoctorTimes = con.getDocTimes(SelectedDocNames.docID, SelectedDocNames.docTimeId, DateDoctorAcepting);
}
catch (Exception) { }
}
public void CalculateDaysInWorkingWeek()
{
var service = new WorkingDays();
var from = new DateTime(2013, 8, 12);
var to = new DateTime(2013, 8, 16);
Assert.AreEqual(4, service.GetWorkingDays(from, to), "Mon - Fri = 4");
Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 13)), "Mon - Tues = 1");
}
public void NotIncludeWeekends()
{
var service = new WorkingDays();
var from = new DateTime(2013, 8, 9);
var to = new DateTime(2013, 8, 16);
Assert.AreEqual(5, service.GetWorkingDays(from, to), "Fri - Fri = 5");
Assert.AreEqual(2, service.GetWorkingDays(from, new DateTime(2013, 8, 13)), "Fri - Tues = 2");
Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 12)), "Fri - Mon = 1");
}
public void UpdateSettings(ISettingsCollection settings, IVersionControl versionControl)
{
//AppSettings
settings.AppSettings.AlertWhenNotRunning = AlertWhenIdle;
settings.AppSettings.AlertTimeMilliseconds = AlertMinutes * 60 * 1000;
settings.AppSettings.KeepTimersForDays = KeepTimersForDays;
settings.AppSettings.AutoUpdate = AutoUpdate;
settings.AppSettings.UsageTracking = AllowTracking;
settings.AppSettings.TargetLogPerDay = new TimeSpan(TargetHoursPerDay, TargetMinutesPerDay, 0);
settings.AppSettings.ExportDays = WorkingDays.Where(x => x.IsChecked).Select(x => x.DayOfWeek).ToList();
settings.AppSettings.StartOfWeek = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), StartOfWeek, true);
//UI Settings
settings.UiSettings.Theme = Theme.Name;
settings.UiSettings.Accent = Accent.Name;
if (versionControl.IsAutomatedDeploy)
{
if (StartOnBoot)
{
var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Programs), "Gallifrey", $"{versionControl.AppName}.appref-ms");
registryKey.SetValue(versionControl.AppName, path);
}
else
{
registryKey.DeleteValue(versionControl.AppName, false);
}
}
//Jira Settings
if (settings.JiraConnectionSettings.JiraUrl != JiraUrl ||
settings.JiraConnectionSettings.JiraUsername != JiraUsername ||
settings.JiraConnectionSettings.JiraPassword != JiraPassword)
{
JiraSettingsChanged = true;
}
else if (string.IsNullOrWhiteSpace(JiraUrl) || string.IsNullOrWhiteSpace(JiraUsername) || string.IsNullOrWhiteSpace(JiraPassword))
{
JiraSettingsChanged = true;
}
settings.JiraConnectionSettings.JiraUrl = JiraUrl;
settings.JiraConnectionSettings.JiraUsername = JiraUsername;
settings.JiraConnectionSettings.JiraPassword = JiraPassword;
//Export Settings
settings.ExportSettings.ExportPrompt.OnAddIdle = ExportPrompts.First(x => x.Key == "Idle").IsChecked;
settings.ExportSettings.ExportPrompt.OnManualAdjust = ExportPrompts.First(x => x.Key == "Manual").IsChecked;
settings.ExportSettings.ExportPrompt.OnStop = ExportPrompts.First(x => x.Key == "Stop").IsChecked;
settings.ExportSettings.ExportPrompt.OnCreatePreloaded = ExportPrompts.First(x => x.Key == "Pre").IsChecked;
settings.ExportSettings.ExportPromptAll = ExportAll;
settings.ExportSettings.DefaultRemainingValue = SelectedRemainingAdjustmentValue.Remaining;
settings.ExportSettings.ExportCommentPrefix = CommentPrefix;
settings.ExportSettings.EmptyExportComment = DefaultComment;
}
public void Parse(byte[] parameters)
{
Enabled = parameters[0].ToBool();
StartTime = parameters[1] == TIMESPAN_NULL_VALUE?TimeSpan.FromSeconds(0) : new TimeSpan(parameters[1], parameters[2], 0);
EndTime = parameters[3] == TIMESPAN_NULL_VALUE?TimeSpan.FromSeconds(0) : new TimeSpan(parameters[3], parameters[4], 0);
InputSource = (InputSource)parameters[5];
WorkingDays = (WorkingDays)parameters[6];
Playlist = (Playlist)parameters[7];
}
static void Main()
{
DateTime date = DateTime.Parse(Console.ReadLine());
var specialHolidays = new List <DateTime>();
specialHolidays = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(DateTime.Parse).ToList();
int offDays = WorkingDays.GetWorkDays(date, specialHolidays);
Console.WriteLine(offDays);
}
private void AtualizarPercentualExecucao()
{
this.AtualizarTempoAtividadesPorDia();
#region Atividades por tarefa
//Recupera somente as atividades por tarefa
var atividadesPorItem = this.Atividades.Where(a => a.ItemCatalogo == null || a.ItemCatalogo.FormaCalculoTempoItemCatalogoId == (int)Enums.FormaCalculoTempoItemCatalogoEnum.PredefinidoPorTarefa);
var tempoPrevistoTotal = atividadesPorItem.Sum(a => a.TempoPrevistoPorItem);
var tempoPrevistoAtividadesConcluidas = atividadesPorItem.Where(a => a.DataFim.HasValue).Sum(a => a.TempoPrevistoPorItem);
//No tempo realizado considera as seguintes regras:
// 1. Se o tempo tiver sido homologado e não tiver sido zero, considera o tempo homologado
// 2. Se tiver sido homologado como zero, considera o tempo que estava previsto
// 3. Se ainda não tiver sido homologado, considera o tempo realizado
var tempoRealizadoAtividadesConcluidas = atividadesPorItem.Where(a => a.DataFim.HasValue).Sum(a => a.TempoHomologado.HasValue ? (a.TempoHomologado.Value > 0 ? a.TempoHomologado.Value : a.TempoPrevistoPorItem) : (a.TempoRealizado.HasValue ? a.TempoRealizado.Value : 0));
#endregion
#region Atividades por dia
var atividadesPorDia = this.Atividades.Except(atividadesPorItem);
//Calcula a quantidade total de dias do pacto
var diasTotaisPacto = this.TempoTotalDisponivel / this.CargaHorariaDiaria;
tempoPrevistoTotal += (diasTotaisPacto * atividadesPorDia.Sum(a => a.TempoPrevistoPorItem));
//Se tiver alguma atividade concluída, usa a quantidade total de dias para calcular
// Caso contrário, usa o número de dias já executado
var diasExecutadosPacto = diasTotaisPacto;
if (this.Atividades.Any(a => !a.DataFim.HasValue))
{//Para esse cálculo desconsidera os feriados
diasExecutadosPacto = WorkingDays.DiffDays(this.DataInicio, DateTime.Now.Date > this.DataFim.Date ? this.DataFim.Date : DateTime.Now.Date, null, false);
}
tempoPrevistoAtividadesConcluidas += (diasExecutadosPacto * atividadesPorDia.Sum(a => a.TempoPrevistoPorItem));
tempoRealizadoAtividadesConcluidas += (diasExecutadosPacto * atividadesPorDia.Sum(a => a.TempoHomologado.HasValue ? (a.TempoHomologado.Value > 0 ? a.TempoHomologado.Value : a.TempoPrevistoPorItem) : a.TempoPrevistoPorItem));
#endregion
this.PercentualExecucao = 0;
if (tempoPrevistoTotal > 0)
{
this.PercentualExecucao = Decimal.Round(Decimal.Divide(tempoPrevistoAtividadesConcluidas, tempoPrevistoTotal) * 100, 2);
}
this.RelacaoPrevistoRealizado = null;
if (tempoRealizadoAtividadesConcluidas > 0)
{
this.RelacaoPrevistoRealizado = Decimal.Round(Decimal.Divide(tempoPrevistoAtividadesConcluidas, tempoRealizadoAtividadesConcluidas) * 100, 2);
}
}
public void AlterarPeriodo(DateTime dataInicio, DateTime dataFim)
{
ValidarDatas(dataInicio, dataFim);
this.DataInicio = dataInicio;
this.DataFim = dataFim;
this.TempoTotalDisponivel = this.CargaHorariaDiaria * WorkingDays.DiffDays(dataInicio, dataFim, DiasNaoUteis, false);
var atividadesDiarias = this.Atividades.Where(it => it.ItemCatalogo.FormaCalculoTempoItemCatalogoId == (int)FormaCalculoTempoItemCatalogoEnum.PredefinidoPorDia).ToList();
var quantidadeDias = WorkingDays.DiffDays(this.DataInicio, this.DataFim, this.DiasNaoUteis, false);
atividadesDiarias.ForEach(it => it.AtualizarTempoPrevistoTotal(quantidadeDias, it.TempoPrevistoPorItem));
this.AtualizarPercentualExecucao();
}
protected DateTime GeneralTest(bool referenceIsBus, bool ref2IsBus, bool fromBack, bool toBack, bool considerCurrent)
{
DateTime ref1 = referenceIsBus ? new DateTime(2008, 01, 16) : new DateTime(2008, 01, 17);
DateTime ref2 = fromBack ?
(ref2IsBus == referenceIsBus ? ref1.AddDays(-6) : ref1.AddDays(-7)) :
(ref2IsBus == referenceIsBus ? ref1.AddDays(6) : ref1.AddDays(7));
if (toBack)
{
return(WorkingDays.Get(new TestProvider()).GetBackwards(2, ref2, considerCurrent));
}
else
{
return(WorkingDays.Get(new TestProvider()).GetInAdvance(2, ref2, considerCurrent));
}
}
public static DaylightInfoModel BuildDaylightInfoModel(DateTime today, DaylightInfo daylightInfo, Commute commuteType, WorkingDays workingDays)
{
var daysToTransition = 0;
DateTime? nextWorkingDayDaylightTransition = null;
if (daylightInfo.NextDaylightTransition.HasValue)
{
var day = today;
if (day >= daylightInfo.NextDaylightTransition.Value)
{
throw new InvalidOperationException(string.Format("daylightInfo.NextDaylightTransition.Value equals {0}; but it should be in the future.", daylightInfo.NextDaylightTransition.Value));
}
var days = new List<DateTime>();
while (day < daylightInfo.NextDaylightTransition.Value)
{
day = day.AddDays(1);
days.Add(day);
}
// Nudge to the first working day, if necessary
// TODO: Get rid of the flags variable here
var workingDayFlags = new[] { workingDays.HasFlag(WorkingDays.Sunday), workingDays.HasFlag(WorkingDays.Monday), workingDays.HasFlag(WorkingDays.Tuesday), workingDays.HasFlag(WorkingDays.Wednesday), workingDays.HasFlag(WorkingDays.Thursday), workingDays.HasFlag(WorkingDays.Friday), workingDays.HasFlag(WorkingDays.Saturday) };
while (!workingDayFlags[(int)days.Last().DayOfWeek])
{
days.Add(days.Last().AddDays(1));
}
daysToTransition = days.Count(d => workingDayFlags[(int)d.DayOfWeek]);
nextWorkingDayDaylightTransition = days.Last();
}
return new DaylightInfoModel
{
IsCurrentlyInDaylight = daylightInfo.IsCurrentlyInDaylight,
PercentOfTheYearInTheDark = GetPercentOfTheYearInTheDark(daylightInfo.CommutesInDaylightPerYear),
NextWorkingDayDaylightTransition = nextWorkingDayDaylightTransition,
CommuteType = commuteType,
NumberOfDaysToTransition = daysToTransition,
};
}
public void AprovarNovaAtividade(ItemCatalogo itemCatalogo, int quantidade, int modalidaExecucaoId, decimal tempoPrevistoPorItem, Int32 situacaoId, DateTime?dataInicio, DateTime?dataFim, Decimal?tempoRealizado, string descricao, bool atualizarPrazo)
{
var atividade = PactoTrabalhoAtividade.Criar(this, itemCatalogo, quantidade, modalidaExecucaoId, tempoPrevistoPorItem, descricao);
atividade.AlterarAndamento(situacaoId, dataInicio, dataFim, tempoRealizado, ignorarValidacoes: true);
this.Atividades.Add(atividade);
if (itemCatalogo.FormaCalculoTempoItemCatalogoId == (int)FormaCalculoTempoItemCatalogoEnum.PredefinidoPorDia)
{
atividade.AtualizarTempoPrevistoTotal(WorkingDays.DiffDays(this.DataInicio, this.DataFim, this.DiasNaoUteis, false));
}
if (atualizarPrazo)
{
var novaDataFim = atividade.CalcularAjusteNoPrazo(this.DataFim, DiasNaoUteis, tempoPrevistoPorItem);
this.AlterarPeriodo(novaDataFim);
}
this.AtualizarPercentualExecucao();
}
/// <summary>
/// Give me an Array of WorkingDays and the Id of the Worker That you want to save the days in
/// </summary>
/// <param name="tosave"></param>
/// <param name="id"></param>
public void SaveWorkingDays(WorkingDays[] tosave, int id)
{
if (tosave.Length > 0 && tosave != null)
{
foreach (var day in tosave)
{
WorkingDays saveme = new WorkingDays()
{
Start = day.Start,
Title = day.Title,
BackgroundColor = day.BackgroundColor,
Display = day.Display
};
var worker = _db.Workers.Find(id);
saveme.Worker = worker;
if (worker.Days.SingleOrDefault(s => s.Start == saveme.Start) is null)
{
_db.CaldendarDays.Add(saveme);
_db.SaveChanges();
}
}
}
}
public void AlterarAtividade(Guid pactoTrabalhoAtividadeId, ItemCatalogo itemCatalogo, int quantidade, int modalidaExecucaoId, decimal tempoPrevistoPorItem, string descricao, IEnumerable <Guid> idsAssuntos, IEnumerable <Guid> idsObjetos)
{
VerificarPossibilidadeAlteracao();
var atividade = this.Atividades.FirstOrDefault(r => r.PactoTrabalhoAtividadeId == pactoTrabalhoAtividadeId);
atividade.Alterar(itemCatalogo.ItemCatalogoId, quantidade, modalidaExecucaoId, tempoPrevistoPorItem, descricao);
if (idsAssuntos != null)
{
var idsAssuntosARemover = atividade.Assuntos.Select(a => a.AssuntoId).Where(id => !idsAssuntos.Contains(id)).ToList();
var idsAssuntosAIncluir = idsAssuntos.Where(id => !atividade.Assuntos.Select(a => a.AssuntoId).Contains(id)).ToList();
foreach (var id in idsAssuntosARemover)
{
atividade.RemoverAssunto(id);
}
foreach (var id in idsAssuntosAIncluir)
{
atividade.AdicionarAssunto(id);
}
}
if (idsObjetos != null)
{
var idsObjetosARemover = atividade.Objetos.Select(a => a.PlanoTrabalhoObjetoId).Where(id => !idsObjetos.Contains(id)).ToList();
var idsObjetosAIncluir = idsObjetos.Where(id => !atividade.Objetos.Select(a => a.PlanoTrabalhoObjetoId).Contains(id)).ToList();
foreach (var id in idsObjetosARemover)
{
atividade.RemoverObjeto(id);
}
foreach (var id in idsObjetosAIncluir)
{
atividade.AdicionarObjeto(id);
}
}
if (itemCatalogo.FormaCalculoTempoItemCatalogoId == (int)FormaCalculoTempoItemCatalogoEnum.PredefinidoPorDia)
{
atividade.AtualizarTempoPrevistoTotal(WorkingDays.DiffDays(this.DataInicio, this.DataFim, this.DiasNaoUteis, false));
}
}
static void Main(string[] args)
{
#region ENUMMERATIE
//WorkingDays d = (WorkingDays)1;
//Console.WriteLine(d);
//WorkingDays d = WorkingDays.Wednesday;
//Console.WriteLine(d);
//WorkingDays a = WorkingDays.Friday;
//Console.WriteLine((int)a);
foreach (int i in Enum.GetValues(typeof(WorkingDays))) //Enum.GetValues(typof Toont alle plaatsen 0,1,2,3,4(int) ENUMARATE VALUES
{
Console.WriteLine(i);
}
foreach (string j in Enum.GetNames(typeof(WorkingDays))) //Enum.GetNames(typeof Toont alle dagen(strings) ENUMARATE NAMES
{
Console.WriteLine(j);
}
#endregion
Console.WriteLine("Select day please");
WorkingDays d = WorkingDays.Thuesday;
int naam = (int)d;
Console.WriteLine();
Console.WriteLine("Select day please");
var input = Enum.Parse(typeof(WorkingDays), Console.ReadLine());
Console.WriteLine(input);
}
public void UpdateSettings(ISettingsCollection settings)
{
//AppSettings
settings.AppSettings.AlertWhenNotRunning = AlertWhenIdle;
settings.AppSettings.AlertTimeMilliseconds = AlertMinutes * 60 * 1000;
settings.AppSettings.KeepTimersForDays = KeepTimersForDays;
settings.AppSettings.AutoUpdate = AutoUpdate;
settings.AppSettings.UsageTracking = AllowTracking;
settings.AppSettings.TargetLogPerDay = new TimeSpan(TargetHoursPerDay, TargetMinutesPerDay, 0);
settings.AppSettings.ExportDays = WorkingDays.Where(x => x.IsChecked).Select(x => x.DayOfWeek);
settings.AppSettings.StartOfWeek = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), StartOfWeek, true);
//UI Settings
settings.UiSettings.Theme = Theme;
//Jira Settings
if (settings.JiraConnectionSettings.JiraUrl != JiraUrl ||
settings.JiraConnectionSettings.JiraUsername != JiraUsername ||
settings.JiraConnectionSettings.JiraPassword != JiraPassword)
{
JiraSettingsChanged = true;
}
settings.JiraConnectionSettings.JiraUrl = JiraUrl;
settings.JiraConnectionSettings.JiraUsername = JiraUsername;
settings.JiraConnectionSettings.JiraPassword = JiraPassword;
//Export Settings
settings.ExportSettings.ExportPrompt.OnAddIdle = ExportPrompts.First(x => x.Key == "Idle").IsChecked;
settings.ExportSettings.ExportPrompt.OnManualAdjust = ExportPrompts.First(x => x.Key == "Manual").IsChecked;
settings.ExportSettings.ExportPrompt.OnStop = ExportPrompts.First(x => x.Key == "Stop").IsChecked;
settings.ExportSettings.ExportPrompt.OnCreatePreloaded = ExportPrompts.First(x => x.Key == "Pre").IsChecked;
settings.ExportSettings.ExportPromptAll = ExportAll;
settings.ExportSettings.DefaultRemainingValue = SelectedRemainingAdjustmentValue.Remaining;
settings.ExportSettings.ExportCommentPrefix = CommentPrefix;
settings.ExportSettings.EmptyExportComment = DefaultComment;
}
/// <summary>
/// Calculate the NonWorking days for the range
/// </summary>
/// <param name="range"></param>
private void CalculateNonWorkingDays(DoubleRange range)
{
var days = new string[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
NonWorkingDays = new List <string>();
if (double.IsNaN(range.Start))
{
return;
}
var startDate = range.Start.FromOADate();
var endDate = range.End.FromOADate();
InternalWorkingDays = WorkingDays.ToString();
foreach (var day in days)
{
if (!InternalWorkingDays.Contains(day))
{
NonWorkingDays.Add(day);
}
}
nonWorkingHoursPerDay = 24 - (CloseTime - OpenTime);
TotalNonWorkingHours = CalcNonWorkingHours(startDate, endDate, InternalWorkingDays, nonWorkingHoursPerDay);
}
/// <summary>
/// 获取节假日信息
/// </summary>
/// <returns></returns>
public static CalendarInfo GetWorkingDays(string dateTime)
{
CalendarInfo calendarInfo = null;
//获取当前工作站
string url = ConfigurationManager.AppSettings["serverUrl"].ToString();
string authCode = CommHelper.Str(6);
string token = CommHelper.Md5(CommHelper.StringToHexString(authCode)).ToUpper();
string data = "authCode=" + authCode + "&token=" + token + "&dateTime=" + dateTime;
string result = CommHelper.Post(url + "/workingDaysVal.eif?", data);
WorkingDays workDay = CommHelper.FromJsonTo <WorkingDays>(result);
if (workDay != null)
{
if (workDay.resStatus == 1)
{
calendarInfo = workDay.calendarInfo;
}
else
{
LogHelper.Log.Error(workDay.resRemark);
}
}
return(calendarInfo);
}
/// <summary>
/// Implementación para asignar los elementos en las bolsas.
/// Se ordena los elementos de menor a mayor.
/// Se obtiene el primero (El más pesado) y se le saca cuántas veces está en el Peso mínimo a cargar
/// Y dependiendo el # se toma del final de la lista (Los menos Pesados) los elementos.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public Response <List <ProcessInformationResponse> > Execute(WorkingDays model)
{
Response <List <ProcessInformationResponse> > response = new Response <List <ProcessInformationResponse> >
{
IsSuccess = true
};
List <ProcessInformationResponse> processInformationResponse = new List <ProcessInformationResponse>();
try
{
for (int i = 0; i < model.DayToWork; i++)
{
processInformationResponse.Add(new ProcessInformationResponse
{
Case = i + 1,
});
processInformationResponse.LastOrDefault().Detail = new List <ProcessDetailInformationResponse>();
List <WeightLastElement> data = new List <WeightLastElement>();
List <WeightLastElement> weightLastElementDesc = new List <WeightLastElement>();
weightLastElementDesc = model.Elements[i].WeightLastElements.OrderByDescending(c => c.Weight).ToList();
data = model.Elements[i].WeightLastElements.OrderByDescending(c => c.Weight).ToList();
int processCount = data.Count;
for (int t = 0; t < processCount; t++)
{
int disponibles = data.Count();
int topItemWeight = 0;
if (disponibles == 0)
{
break;
}
if (data.FirstOrDefault().Weight > Convert.ToDecimal(this.configuration["FileValidations:GuaranteedWeight"]))
{
topItemWeight = data.FirstOrDefault().Weight;
processInformationResponse.LastOrDefault().Detail.Add(new ProcessDetailInformationResponse {
TopItemWeight = topItemWeight, Quantity = 1
});
data.Remove((data.FirstOrDefault()));
continue;
}
decimal divide = (Convert.ToDecimal(this.configuration["FileValidations:GuaranteedWeight"]) / (decimal)data.FirstOrDefault().Weight) * 1;
decimal redondeado = Math.Ceiling(divide);
for (int f = 0; f < redondeado; f++)
{
if (f == 0)
{
topItemWeight = data.FirstOrDefault().Weight;
data.Remove(data.FirstOrDefault());
}
else
{
data.Remove(data.LastOrDefault());
}
}
if (data?.FirstOrDefault()?.Weight *data.Count < Convert.ToDecimal(this.configuration["FileValidations:GuaranteedWeight"]))
{
for (int p = 0; p < data.Count; p++)
{
data.Remove(data.LastOrDefault());
redondeado++;
}
}
processInformationResponse.LastOrDefault().Detail.Add(new ProcessDetailInformationResponse {
TopItemWeight = topItemWeight, Quantity = (int)redondeado
});
}
}
response.Result = processInformationResponse;
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message.Add(new MessageResult
{
Message = string.Format("Ocurrió un error procesando el informe, error Capturado: {0}", Convert.ToString(ex))
});
}
return(response);
}
public void SetUp()
{
_daylights = new DaylightInfo { TransitionType = DaylightTransition.SunRise };
_workingDays = WorkingDays.Monday | WorkingDays.Tuesday | WorkingDays.Wednesday | WorkingDays.Thursday | WorkingDays.Friday;
}