public SaveResult Add(PeriodModel entity)
{
try
{
ObjectParameter param1 = new ObjectParameter("periodId", entity.PeriodId);
if (IsReadyToAdd())
{
var result = _context.proc_Period_Insert(param1, entity.YearFrom,
entity.YearTo);
return(new SaveResult
{
Id = (int)param1.Value,
Message = "Period was created and ready to configured.",
Status = "OK"
});
}
else
{
throw new Exception("The transaction hasn't complete at this moment.");
}
}
catch (Exception ex)
{
return(new SaveResult
{
Id = 0,
Message = "Error on Period Add method. " + ex.InnerException != null ? ex.InnerException.Message : ex.Message,
Status = "ERROR"
});
}
}
public PeriodDetailsViewModel(PeriodModel vaccinePeriods)
{
VaccinePeriods = vaccinePeriods;
DeleteCommand = new Command(Delete);
GoToPutPageCommand = new Command(GoToPutPage);
}
private ChartViewModel GetHistoricalOptions(MachineInfoModel machine, PeriodModel period)
{
var options = new ChartViewModel();
var granularity = Common.GetAggregationType(period.StartDate, period.EndDate);
var startDateTrend = Common.GetStartDateTrend(period.EndDate, period.StartDate, granularity);
var periodTrend = new PeriodModel();
periodTrend.StartDate = startDateTrend.ToUniversalTime().Date;
periodTrend.EndDate = period.EndDate.ToUniversalTime().Date.AddDays(1).AddTicks(-1);
periodTrend.Aggregation = granularity;
var data = _pieceService.GetAggregationPieces(machine, periodTrend, enDataType.Historical).OrderBy(o => o.Day).ToList();
if (data.Count == 0)
{
return(null);
}
var days = data.Select(s => s.Day).Distinct().ToList();
var valori = _stateService.GetDayActivity(machine, days);
options.categories = CommonViewService.GetTimeCategories(days, granularity);
options.yTitle = $"{Resource.Efficiency} (%)";
options.yTitle2 = $"{Resource.Productivity} (pz/h)";
options.series = GetSeriesChartProd(valori, false);
return(options);
}
/// <summary>
/// Ritorna l'elenco dei job in base all'aggregazione
/// </summary>
/// <param name="machine"></param>
/// <param name="period"></param>
/// <returns>Lista dei dettagli degli stati</returns>
public List <HistoryJobModel> GetAggregationJobs(MachineInfoModel machine, PeriodModel period)
{
var result = new List <HistoryJobModel>();
try
{
result = _context.Set <HistoryJob>().Where(hb =>
hb.MachineId == machine.Id && hb.Day >= period.StartDate && hb.Day <= period.EndDate).ToList()
.GroupBy(g => new { g.MachineId, g.Code, Day = g.Day.Value.Date })
.Select(n => new HistoryJobModel
{
Id = n.Max(i => i.Id),
Code = n.Key.Code,
Day = n.Key.Day,
MachineId = n.Key.MachineId,
TotalPieces = n.OrderByDescending(i => i.Id).FirstOrDefault()?.TotalPieces,
ElapsedTime = n.Max(i => i.ElapsedTime),
PiecesProduced = GetProdPieces(n.Max(i => i.Id), n.Key.Day),
Period = null
}).ToList();
}
catch (Exception ex)
{
var errMessage = string.Format(ex.GetStringLog(),
machine.Id.ToString(),
string.Concat(period.StartDate.ToString(), " - ", period.EndDate.ToString(), " - ", period.Aggregation.ToString()));
LogService.WriteLog(errMessage, LogService.TypeLevel.Error, ex);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task CreatePeriod(PeriodModel model)
{
try
{
await _connection.OpenAsync();
var cmd = new MySqlCommand("Create_Period", _connection);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("TeacherIdVal", model.TeacherId);
cmd.Parameters.AddWithValue("SubjectIdVal", model.SubjectId);
cmd.Parameters.AddWithValue("DescriptionVal", model.Description);
cmd.Parameters.AddWithValue("StartDateVal", model.StartDate);
cmd.Parameters.AddWithValue("EndDateVal", model.EndDate);
if (model.StudentClasificationId.HasValue)
{
cmd.Parameters.AddWithValue("StudentClasificationIdVal", model.StudentClasificationId.Value);
}
else
{
cmd.Parameters.AddWithValue("StudentClasificationIdVal", DBNull.Value);
}
if (model.OptionalGroupId.HasValue)
{
cmd.Parameters.AddWithValue("OptionalGroupIdVal", model.OptionalGroupId);
}
else
{
cmd.Parameters.AddWithValue("OptionalGroupIdVal", DBNull.Value);
}
cmd.ExecuteNonQuery();
}
catch { throw; }
finally { await _connection.CloseAsync(); }
}
private MessageVueModel GetVueModel(MachineInfoModel machine, PeriodModel period, string actualMachineGroup = null)
{
var result = new MessageVueModel();
var data = _messageService.GetAggregationMessages(machine, period, enDataType.Summary, actualMachineGroup);
if (data.Count == 0)
{
return(result);
}
var messages = data.Select(a => new MessageDataModel()
{
code = a.Code,
type = a.Type != null ? ((enTypeAlarm)a.Type).GetDescription() : "",
parameters = a.Params,
quantity = a.Count ?? 0,
day = a.Day == null ? "-" : a.Day.Value.ToString("t"),
description = a.Description
}).ToList();
messages = messages.OrderByDescending(o => o.quantity).ToList();
var sorting = new SortingViewModel
{
duration = enSorting.Descending.GetDescription()
};
result.messages = messages;
result.sorting = sorting;
return(result);
}
public EditPeriodViewModel(PeriodModel vaccinePeriods)
{
VaccinePeriods = vaccinePeriods;
ValidationRules = new PeriodValidator();
PutCommand = new Command(Put);
}
public IEnumerable <PeriodModel> GetPeriods(Invoice invoice, DateTime lastDate)
{
var result = new List <PeriodModel>();
if (invoice.Payments.Any())
{
var orderedPayments = invoice.Payments
.OrderBy(p => p.Date);
var startDateOfPeriod = orderedPayments.First().Date;
while (startDateOfPeriod <= lastDate)
{
var startDate = startDateOfPeriod;
var endDate = startDateOfPeriod.AddMonths(1).AddDays(-1);
var orderedPaymentsInPeriod = orderedPayments
.Where(p => p.Date >= startDate && p.Date <= endDate)
.Select(p => new PeriodPayment()
{
Payment = p
})
.OrderBy(p => p.Payment.Date);
var period = new PeriodModel()
{
StartDate = startDate,
EndDate = endDate,
Payments = orderedPaymentsInPeriod
};
result.Add(period);
startDateOfPeriod = startDateOfPeriod.AddMonths(1);
}
}
return(result);
}
private ChartViewModel GetKpisOptions(MachineInfoModel machine, PeriodModel period)
{
var options = new ChartViewModel();
var data = _stateService.GetAggregationStates(machine, period, enDataType.Dashboard);
var stateProd = data.FirstOrDefault(w => w.enState == enState.Production);
var stateManual = data.FirstOrDefault(w => w.enState == enState.Manual);
var totalValue = machine.MachineTypeId == (int)enMachineType.Troncatrice || machine.MachineTypeId == (int)enMachineType.CentroLavoro ?
stateProd?.ElapsedTime + stateManual?.ElapsedTime : stateProd?.ElapsedTime;
var totalOn = data.Where(w => w.enState != enState.Offline).Select(s => s.ElapsedTime).Sum();
decimal?percProd = Common.GetPercentage(totalValue, totalOn);
options.series = new List <SerieViewModel>()
{
new SerieViewModel {
stateProductivityGreenThreshold = machine.StateProductivityGreenThreshold ?? 0,
stateProductivityYellowThreshold = machine.StateProductivityYellowThreshold ?? 0,
y = CommonViewService.getKpiViewModel(percProd, machine.StateProductivityGreenThreshold, machine.StateProductivityYellowThreshold).value ?? (decimal)0
}
};
return(options);
}
public static void DeleteYear(int year)
{
TrimesterCommentModel.DeleteAll(year);
TrimesterSubjectCommentModel.DeleteAll(year);
SemiTrimesterCommentModel.DeleteAll(year);
PeriodCommentModel.DeleteAll(year);
MarkModel.DeleteAll(year);
TeacherClassModel.DeleteAll(year);
LevelSubjectModel.DeleteAll(year);
SubjectTeacherModel.DeleteAll(year);
SemiTrimesterModel.DeleteAll(year);
PeriodModel.DeleteAll(year);
StudentModel.DeleteAll(year);
ClassModel.DeleteAll(year);
LevelModel.DeleteAll(year);
SubjectModel.DeleteAll(year);
TeacherModel.DeleteAll(year);
YearParametersModel.DeleteAll(year);
YearModel.Delete(year);
MessageBox.Show("Suppresion de l'année réussie.", "Réussite", MessageBoxButton.OK, MessageBoxImage.Information);
MainViewModel.Instance.LoadYears();
MainViewModel.Instance.SelectedYear = year - 1;
}
public ActionResult AddOrUpdate(PeriodModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var isCreated = model.Id == Guid.Empty;
var period = new Periods();
if (!isCreated)
{
period = PeriodRepository.GetById(model.Id);
}
period.Begin = model.Begin;
period.End = model.End;
period.Years = YearRepository.GetById(model.YearId);
if (isCreated)
{
PeriodRepository.Add(period);
}
PeriodRepository.Save();
return(Redirect(Url.Action("Get", "Period", new { id = period.Id })));
}
/// <summary>
/// Ritorna i dati di barre e spezzoni in base al tipo di aggregazione
/// </summary>
/// <param name="machine"></param>
/// <param name="period"></param>
/// <returns>Lista dei dettagli di barre e spezzoni</returns>
public List <HistoryBarModel> GetAggregationBar(MachineInfoModel machine, PeriodModel period)
{
var result = new List <HistoryBarModel>();
try
{
result = _context.Set <HistoryBar>().Where(hb => hb.MachineId == machine.Id && hb.Day >= period.StartDate && hb.Day <= period.EndDate).GroupBy(g => g.MachineId).Select(n => new HistoryBarModel
{
Count = n.Count(),
Id = n.Max(i => i.Id),
Length = n.Sum(i => i.Length),
Day = n.Max(i => i.Day),
MachineId = n.Key,
OffcutCount = n.Sum(i => i.OffcutCount),
OffcutLength = n.Sum(i => i.OffcutLength),
Period = null,
System = null,
TypeHistory = "d"
}).ToList();
}
catch (Exception ex)
{
string errMessage = string.Format(ex.GetStringLog(),
machine.Id.ToString(),
string.Concat(period.StartDate.ToString(), " - ", period.EndDate.ToString(), " - ", period.Aggregation.ToString()));
LogService.WriteLog(errMessage, LogService.TypeLevel.Error, ex);
}
return(result);
}
public static PeriodModel GetPeriod()
{
var testPeriod = new PeriodModel();
testPeriod.PeriodFrom = DateTime.MinValue;
testPeriod.PeriodTo = DateTime.MaxValue;
return(testPeriod);
}
public AddPeriodViewModel()
{
VaccinePeriod = new PeriodModel();
ValidationRules = new PeriodValidator();
// Command
PostCommand = new Command(Post);
}
public static bool IsPeriodInvalid(PeriodModel period)
{
if (period.Start.HasValue && period.End.HasValue)
{
return(period.Start.Value.CompareTo(period.End.Value) > 0);
}
return(false);
}
public ActionResult AddOrUpdate(Guid?id)
{
var model = new PeriodModel();
if (id.HasValue)
{
model = PeriodModel.ToModel(PeriodRepository.GetById(id.Value));
}
return(View(model));
}
public ReviewInvalidity()
{
PeriodeHospitalise = new PeriodModel(DateModel.CreateNeighboringDateModel(), DateModel.CreateNeighboringDateModel());
PeriodeHospitalise.DeleteRequired = false;
DatePrevue_Chirurgie = DateModel.CreateNeighboringDateModel();
NewMedications = new List <MedicationModel> {
new MedicationModel()
};
NewMedications[0].Index = 0;
ChangeMedications = new List <MedicationModel> {
new MedicationModel()
};
ChangeMedications[0].Index = 0;
StopMedications = new List <MedicationModel> {
new MedicationModel()
};
StopMedications[0].Index = 0;
List <SliderBracket> brackets = new List <SliderBracket>()
{
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_1), MinValue = 0, MaxValue = 4
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_2), MinValue = 5, MaxValue = 7
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_3), MinValue = 8, MaxValue = 10
}
};
IntensiteSymptomes = new SliderModel()
{
Name = nameof(IntensiteSymptomes),
MaxValue = 10,
MinValue = 0,
StepValue = 1,
Value = "0",
BracketResourceManager = UIAccident.ResourceManager,
BracketTitleResource = nameof(UIAccident.IU39_3),
Brackets = brackets
};
InfosNouveauMedecin = new PhysicianModel(true);
InfosMedecinSpecialiste = new SpecialistPhysicianModel();
}
/// <summary>
/// Attempts to save a new or existing Period based n the model provided.
/// </summary>
/// <param name="currentUser">The user attempting to save.</param>
/// <param name="period">The model of data trying to be saved.</param>
/// <exception cref="NullReferenceException">This will be thrown when a period that doesnt seem to be new doesnt exist in the db.</exception>
/// <exception cref="UnauthorizedAccessException">This will be thrown when a user attempts to save a period they dont have access to.</exception>"
/// <exception cref="ArgumentException">This will be thrown when the period overlaps an existing period.</exception>
/// <returns>A period DTO that represents what was saved.</returns>
private async Task <PeriodModel> SavePeriodModel(PortalUser currentUser, PeriodModel period)
{
var existingPeriod = await repository.GetPeriodById(period.PeriodId);
if (existingPeriod == null && period.PeriodId > 0)
{
throw new NullReferenceException("Could not find period with id specified.");
}
else if (existingPeriod == null)
{
existingPeriod = new Period()
{
CreatedBy = currentUser.PortalUsername,
CreatedDate = DateTime.UtcNow,
ModifiedBy = currentUser.PortalUsername,
ModifiedDate = DateTime.UtcNow
};
}
else if (existingPeriod.CompanyId != currentUser.CompanyId)
{
throw new UnauthorizedAccessException("You cannot acces this period as this user.");
}
existingPeriod.Year = period.Year;
existingPeriod.EndDate = period.EndDate;
existingPeriod.StartDate = period.StartDate;
existingPeriod.FrequencyTypeId = period.FrequencyTypeId;
existingPeriod.CompanyId = currentUser.CompanyId;
existingPeriod.IsActive = true;
existingPeriod.FrequencyType = await repository.GetFrequencyTypeById(period.FrequencyTypeId);
if (existingPeriod.PeriodId == 0)
{
// Need to check for non overlapping periods.
if (await repository.IsPeriodOverlapping(existingPeriod.StartDate, existingPeriod.EndDate))
{
throw new ArgumentException("New period overlaps with a previous period.");
}
repository.Insert(existingPeriod);
await repository.SaveChanges();
}
else if (repository.IsChanged(existingPeriod))
{
existingPeriod.ModifiedBy = currentUser.PortalUsername;
existingPeriod.ModifiedDate = DateTime.UtcNow;
repository.Attach(existingPeriod);
await repository.SaveChanges();
}
return(LoadPeriod(existingPeriod));
}
public PeriodModel MapData(Period p)
{
PeriodModel pm = new PeriodModel();
pm.Id = p.Id;
pm.PeriodNr = p.PeriodNr;
pm.DateStart = p.DateStart;
pm.DateEnd = p.DateEnd;
pm.VacId = p.Vacation.Id;
return(pm);
}
public ThirdKnowledgeViewModel(PeriodModel RelatedPeriodModel)
{
AssignedQueries = RelatedPeriodModel.AssignedQueries;
PeriodPublicId = RelatedPeriodModel.PeriodPublicId;
PeriodInitDate = RelatedPeriodModel.InitDate.ToString();
PeriodEndDate = RelatedPeriodModel.EndDate.ToString();
PerIsLimited = RelatedPeriodModel.IsLimited;
TotalQueries = RelatedPeriodModel.TotalQueries;
PeriodEnable = RelatedPeriodModel.Enable;
PeriodLastModify = RelatedPeriodModel.LastModify.ToString();
PeriodCreateDate = RelatedPeriodModel.CreateDate.ToString();
}
public Period MapData(PeriodModel pm, int p)
{
Period period = new Period();
period.Id = pm.Id;
period.PeriodNr = pm.PeriodNr;
period.DateStart = pm.DateStart;
period.DateEnd = pm.DateEnd;
// period.Vacation.Id = p;
return(period);
}
private List <PeriodModel> MapPeriods(List <PeriodInfo> parsedPeriods)
{
var periods = new List <PeriodModel>();
foreach (PeriodInfo parsedPeriod in parsedPeriods)
{
PeriodModel period = MapOnePeriod(parsedPeriod);
periods.Add(period);
}
return(periods);
}
protected void BtnRefresh_Click(object sender, EventArgs e)
{
JavaScriptSerializer json = new JavaScriptSerializer();
PeriodModel input = json.Deserialize <PeriodModel>(this.hfInfo.Value);
string Period = (input.Period == null || input.Period == "-1" || input.Period == "") ? "" : input.Period;
ReportViewerHelper viewerHelper = new ReportViewerHelper();
DataSet ds = SqlHelper.GetDataTablesByStore("select * from HRSQL_V_CombinedData where Period = '" + Period + "'", null);
ReportDataSource rd = viewerHelper.Get("dsHR", ds.Tables[0]);
viewerHelper.ReloadReportViewer(this, this.ReportViewer1, @"HRCombineData.rdlc", rd);
}
public InsuredDisease()
{
MaladieSimilaire_Annee = new YearModel();
ListeMedecin = new List <PhysicianModel> {
new PhysicianModel {
DisplayFirstConsultationDate = true, IsListItem = true
}
};
PeriodeHospitalise = new PeriodModel(DateModel.CreateLastFiveYearsDateModel(), DateModel.CreateLastFiveYearsDateModel());
PeriodeHospitalise.DeleteRequired = false;
DatePremierSymptomes = DateModel.CreatePastDateModel();
List <SliderBracket> brackets = new List <SliderBracket>()
{
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_1), MinValue = 0, MaxValue = 4
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_2), MinValue = 5, MaxValue = 7
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_3), MinValue = 8, MaxValue = 10
}
};
IntensiteSymptomes = new SliderModel()
{
Name = nameof(IntensiteSymptomes),
MaxValue = 10,
MinValue = 0,
StepValue = 1,
Value = "0",
BracketResourceManager = UIAccident.ResourceManager,
BracketTitleResource = nameof(UIAccident.IU39_3),
Brackets = brackets
};
InfosMedecinSpecialiste = new SpecialistPhysicianModel(true);
InfosMedecinMaladieSimilaire = new PhysicianModel();
MedicalConsultations = new List <MedicalConsultationModel> {
new MedicalConsultationModel(true)
};
}
public bool CreatePeriod(PeriodModel model)
{
var entity = _context.Periods.Where(p => p.PeriodName == model.PeriodName).FirstOrDefault();
if (entity != null)
{
throw new Exception("Period already exist");
}
var period = model.Create(model);
_context.Periods.Add(period);
_context.SaveChanges();
return(true);
}
public ActionResult CreatePeriod(PeriodModel model)
{
if (ModelState.IsValid)
{
model.CreatedBy = User.Identity.GetUserName();
var result = _ratMgr.CreatePeriod(model);
if (result == true)
{
TempData["message"] = $"Period{model.PeriodName} was successfully added!";
return(RedirectToAction("Index"));
}
}
return(View(model));
}
// ctor
public PeriodViewModel()
{
// Property
Periods = new ObservableCollection <PeriodModel>();
SelectedPeriod = new PeriodModel();
// Get
Get();
// Command
SaveAsPDFCommand = new Command(SaveAsPDF);
PullRefreshCommand = new Command(Refresh);
GoToPostPageCommand = new Command(GoToPostPage);
GoToDetailsPageCommand = new Command(GoToDetailsPage);
}
private static void CreatePeriods(MainViewModel mainViewModel, int year)
{
foreach (PeriodViewModel period in MainViewModel.Instance.Parameters.Periods)
{
PeriodModel.Save(new PeriodViewModel()
{
FromDate = period.FromDate.AddYears(1),
Number = period.Number,
Order = period.Order,
ToDate = period.ToDate.AddYears(1),
Trimester = period.Trimester,
Year = year,
});
}
mainViewModel.Parameters.LoadPeriods();
}
public async Task <IActionResult> Create(PeriodModel model)
{
var username = ApplicationUtility.GetTokenAttribute(Request.Headers["Authorization"], "sub");
var service = new PeriodRepository(connString);
await service.CreatePeriod(model);
var response = new GenericResponse <string>()
{
IsSuccess = true,
Message = "Period created successfully.",
ResponseCode = 200,
Result = "Success"
};
return(Ok(response));
}
/// <inheritdoc />
protected override Task OnInitializedAsync()
{
if (Period != null)
{
Model = new PeriodModel(Period);
IsEdit = true;
}
else
{
var userId = StoreService.Get <StorageUser>("user")?.Id ?? -1;
Model = new PeriodModel(userId);
}
PeriodContext = new EditContext(Model);
return(base.OnInitializedAsync());
}
