Lyndon Jetten
682e4b9222
- Nach Mitarbeitern, Ressourcen, und Klienten filtern
- Ziele in Modal-Popup mit PartialView gepackt
2821 lines
121 KiB
C#
2821 lines
121 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Web.Mvc;
|
|
using System.Windows.Forms;
|
|
using BeWo.Service.ServiceImplementations;
|
|
using BeWo.View.Navigation.Filter;
|
|
using BeWoPlanerMobil.Models;
|
|
using BeWoPlanerMobil.Service;
|
|
using BeWoPlanerMobil.Util;
|
|
|
|
using static BeWoPlanerMobil.Util.MobileUtils;
|
|
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Services;
|
|
using Newtonsoft.Json;
|
|
using static BS.Shared.ServiceRecordValidationResult;
|
|
using FormCollection = System.Web.Mvc.FormCollection;
|
|
using ServiceRecordDC = BS.Shared.DataContracts.ServiceRecordDC;
|
|
|
|
namespace BeWoPlanerMobil.Controllers
|
|
{
|
|
public class MainController : AbstractBaseController
|
|
{
|
|
private MainModel _Model;
|
|
public MainModel Model
|
|
{
|
|
get
|
|
{
|
|
if(!MobileSessionFacade.IsUserLoggedIn())
|
|
{
|
|
RedirectToActionPermanent("Index", "Login");
|
|
return null;
|
|
}
|
|
|
|
if(((MainModel) Session[ModelSessionConstants.MainModelKey])?.Employee is null)
|
|
{
|
|
_Model = new MainModel { Employee = MobileSessionFacade.LoggedInEmployee };
|
|
Session[ModelSessionConstants.MainModelKey] = _Model;
|
|
}
|
|
else
|
|
{
|
|
_Model = (MainModel) Session[ModelSessionConstants.MainModelKey];
|
|
}
|
|
|
|
return _Model;
|
|
}
|
|
}
|
|
|
|
private Dictionary<long, ValueListEntryDC> _ParentGoals;
|
|
|
|
private static readonly List<ValueListEntryType> _Zieltypen = new List<ValueListEntryType> { ValueListEntryType.SupportConceptGoalCategoryType, ValueListEntryType.SupportConceptIndividualGoalCategoryType };
|
|
private static readonly List<ValueListEntryType> _Massnahmentypen = new List<ValueListEntryType> { ValueListEntryType.SupportConceptGoalType, ValueListEntryType.SupportConceptIndividualGoalType };
|
|
|
|
private MandatorDC GetMandator()
|
|
{
|
|
var mandator = (MandatorDC) HttpContext.Session["mandator"];
|
|
|
|
if(mandator is null)
|
|
{
|
|
mandator = OperationsService.GetMandator();
|
|
HttpContext.Session["mandator"] = mandator;
|
|
}
|
|
|
|
return mandator;
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult Main()
|
|
{
|
|
try
|
|
{
|
|
if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.HasRightToSeeServiceRecords)
|
|
{
|
|
var isNewSession = Session.IsNewSession;
|
|
|
|
if(isNewSession)
|
|
{
|
|
TempData["ein_schluessel"] = "Sie wurden automatisch abgemeldet, da Ihre Session abgelaufen ist.";
|
|
}
|
|
|
|
return Logout();
|
|
}
|
|
|
|
var mandator = GetMandator();
|
|
var mandatorSettings = mandator.Settings;
|
|
|
|
var userSettings = AbstractModel.UserSettings;
|
|
|
|
Model.ShowExpiredSupportConcepts = UserSettingsUtils.GetSettingValueAsBool(userSettings, SettingsKeys.ShowExpiredSupportConcepts);
|
|
Model.ShowOnlyOwnSupportConcepts = UserSettingsUtils.GetSettingValueAsBool(userSettings, SettingsKeys.ShowOnlyMySupportConcepts);
|
|
|
|
if(Model.Zeitraum < 0)
|
|
{
|
|
int zeitraum;
|
|
var serviceRecordTimeInterval = MobileUserSettingsUtils.GetSettingValueAsEnum(userSettings, SettingsKeys.LastSelectedServiceRecordTimeInterval, ServiceRecordTimeInterval.LastWeek);
|
|
|
|
switch(serviceRecordTimeInterval)
|
|
{
|
|
case ServiceRecordTimeInterval.LastWeek:
|
|
zeitraum = 7;
|
|
break;
|
|
case ServiceRecordTimeInterval.LastMonth:
|
|
zeitraum = 30;
|
|
break;
|
|
case ServiceRecordTimeInterval.Last3Month:
|
|
zeitraum = 7;
|
|
break;
|
|
case ServiceRecordTimeInterval.All:
|
|
zeitraum = 7;
|
|
break;
|
|
case ServiceRecordTimeInterval.ZeitraumWaehlen:
|
|
zeitraum = -1;
|
|
break;
|
|
default:
|
|
zeitraum = 7;
|
|
break;
|
|
}
|
|
|
|
Model.Zeitraum = zeitraum;
|
|
}
|
|
|
|
var customerFilter = MobileUserSettingsUtils.GetSettingValueAsEnum(userSettings, SettingsKeys.CustomerFilterInZeiterfassung, CustomerFilterEnum.MyCustomer);
|
|
|
|
Model.SelectedSupportConceptFilter = customerFilter;
|
|
|
|
BS.Shared.Settings.ApplicationSettings.SupportConceptExpirationLimitInMonths = UserSettingsUtils.GetSettingValueAsInteger(mandatorSettings, SettingsKeys.HilfeplanAuslaufAuswahl, 3);
|
|
BS.Shared.Settings.ApplicationSettings.AnzTageZeiterfassErfolgt = UserSettingsUtils.GetSettingValueAsInteger(mandatorSettings, SettingsKeys.AnzTageZeiterfassErfolgt);
|
|
BS.Shared.Settings.ApplicationSettings.MaxDaysEditServiceRecordsAllowed = UserSettingsUtils.GetSettingValueAsInteger(mandatorSettings, SettingsKeys.MaxDaysEditServiceRecordsAllowed);
|
|
BS.Shared.Settings.ApplicationSettings.TimeUntilUILock = UserSettingsUtils.GetSettingValueAsInteger(mandatorSettings, SettingsKeys.TimeUntilUILock);
|
|
|
|
Model.ShowSignature = UserSettingsUtils.GetSettingValueAsBool(mandatorSettings, SettingsKeys.ShowSignature);
|
|
|
|
#if DEBUG
|
|
Model.ShowSignature = true;
|
|
#endif
|
|
|
|
Model.GroupsOfPeople = EmployeeService.GetAllGroups(GetUser().Employee.EmployeeOid).OrderBy(gop => gop.Name).ToList();
|
|
|
|
if (!Model.IsInEditingMode)
|
|
{
|
|
Model.SelectedGoals.Clear();
|
|
}
|
|
|
|
Model.ShowDistanceField = UserSettingsUtils.GetSettingValueAsBool(mandatorSettings, SettingsKeys.ShowDistanceFields);
|
|
|
|
Model.Dokutypes = ValueListService.GetAllValueListEntrysByType(ValueListEntryType.DocumentType);
|
|
if(!(Model.Dokutypes is null))
|
|
{
|
|
Model.Dokutypes = Model.Dokutypes.OrderBy(s => s.ValueListEntryOid).ToArray();
|
|
}
|
|
|
|
if(MainModel.AllEmployees is null)
|
|
{
|
|
MainModel.AllEmployees = EmployeeService.GetAllActiveEmployeesCompact().OrderBy(e => e.LastName).ToList();
|
|
}
|
|
|
|
if (MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreationForOtherEmployees))
|
|
{
|
|
Model.Employees = EmployeeService.GetAllActiveEmployeesCompact();
|
|
}
|
|
else if(MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreationForOtherTeamMember) && Model.Employee?.EmployeeOid != null)
|
|
{
|
|
Model.Employees = EmployeeService.GetAllTeamMember(MobileSessionFacade.LoggedInCompactEmployee);
|
|
}
|
|
else
|
|
{
|
|
Model.Employees = new List<CompactEmployeeDC> { MobileSessionFacade.LoggedInCompactEmployee };
|
|
}
|
|
|
|
Model.Employees = Model.Employees.OrderBy(e => e.LastName).ThenBy(e => e.FirstName).ToList();
|
|
|
|
if(Model?.Employee?.EmployeeOid.HasValue ?? false)
|
|
{
|
|
Model.SupportConcepts = EmployeeService.GetActiveSupportConceptsForEmployee(Model.Employee.EmployeeOid, Model.SelectedSupportConceptFilter);
|
|
}
|
|
else
|
|
{
|
|
Model.SupportConcepts = new List<SupportConceptDC>();
|
|
}
|
|
|
|
if(!Model.ShowExpiredSupportConcepts)
|
|
{
|
|
Model.SupportConcepts = Model.SupportConcepts.Where(supportConcept =>
|
|
{
|
|
var endDate = MainModel.GetEndDateOfSupportConcept(supportConcept);
|
|
|
|
return endDate is null || endDate.Value >= DateTime.Now.Date;
|
|
}).ToList();
|
|
}
|
|
|
|
if(Model.ServiceCategories is null)
|
|
{
|
|
Model.ServiceCategories = new List<ServiceCategoryModel>();
|
|
}
|
|
|
|
if(Model.SelectedConceptCostBearerRelations is null)
|
|
{
|
|
Model.SelectedConceptCostBearerRelations = new List<SupportConceptCostBearerRelDC>();
|
|
}
|
|
|
|
|
|
if(Model.SelectedEmployee is null)
|
|
{
|
|
Model.SelectedEmployee = MobileSessionFacade.LoggedInCompactEmployee;
|
|
}
|
|
|
|
Model.IsServiceRecordNoticeMandatory = UserSettingsUtils.GetSettingValueAsBool(mandatorSettings, SettingsKeys.IsServiceRecordNoticeMandatory);
|
|
|
|
var isInList = !(Model.SelectedSupportConceptListObject is null) && Model.SupportConceptListObjects.Contains(Model.SelectedSupportConceptListObject);
|
|
|
|
if(Model.SelectedSupportConceptListObject is null || !isInList)
|
|
{
|
|
if(!(Model.SelectedSupportConceptListObject is null) && !isInList)
|
|
{
|
|
Log.Info($"Model.SelectedSupportConceptListObject.Oid = {Model.SelectedSupportConceptListObject.CostBearer2SupportConceptOid} is not in list !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
|
|
|
|
var sb = new StringBuilder();
|
|
foreach(var o in Model.SupportConceptListObjects)
|
|
{
|
|
if (sb.Length > 0)
|
|
{
|
|
sb.Append(", ");
|
|
}
|
|
|
|
sb.Append(o.CostBearer2SupportConceptOid);
|
|
}
|
|
Log.Info($"Model.SupportConceptListObjects Oids = {sb}");
|
|
|
|
}
|
|
//Log.Info(String.Format("Main() Set CostBearer2SupportConceptOid = -1: Model.SelectedSupportConceptListObject is null {0}, isInList {1}", Model.SelectedSupportConceptListObject is null, isInList));
|
|
|
|
Model.SelectedSupportConceptListObject = Model.SupportConceptListObjects.FirstOrDefault(f => f.CostBearer2SupportConceptOid == "-1") ?? Model.SupportConceptListObjects.First();
|
|
Model.CostBearer2SupportConceptOid = -1;
|
|
|
|
Model.HasAnyRatingTypes = OperationsService.GetAllRatingTypes().Any();
|
|
}
|
|
|
|
if(!(Model.CostBearer2SupportConceptOid is null))
|
|
{
|
|
LoadRecordsToModel();
|
|
}
|
|
|
|
Model.IsEndDateVisible = UserSettingsUtils.GetSettingValueAsBool(mandatorSettings, SettingsKeys.IsEndDateVisible);
|
|
|
|
Model.IsZeiterfassungInStdMin = UserSettingsUtils.GetSettingValueAsBool(mandatorSettings, SettingsKeys.IsZeiterfassungInStdMin);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
}
|
|
|
|
return View(Model);
|
|
}
|
|
|
|
[Authorize]
|
|
public void LoadGoalRatings()
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var ratingTypes = OperationsService.GetAllRatingTypes().OrderBy(o => o.Position); ;
|
|
|
|
Model.GoalRatingTypes = ratingTypes.ToList();
|
|
}
|
|
|
|
[Authorize]
|
|
public string RateSelectedGoal(long? ratingTypeOid, long? goalOid)
|
|
{
|
|
if(Model is null || ratingTypeOid is null || goalOid is null)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
if(!Model.IsInGroupBookingMode)
|
|
{
|
|
var rating = Model.GoalRatingTypes.FirstOrDefault(ratingType => ratingType.RatingTypeOid == ratingTypeOid);
|
|
|
|
var goal = Model.GetGoalByOid(goalOid.Value);
|
|
|
|
goal.RatingTypeOid = ratingTypeOid;
|
|
|
|
if(Model.IsInEditingMode && Model.SelectedGoals.Any(a => a.ValueListEntryOid.HasValue && a.ValueListEntryOid.Value == goal.ValueListEntryOid))
|
|
{
|
|
var selectedGoal = Model.SelectedGoals.FirstOrDefault(a => a.ValueListEntryOid.HasValue && a.ValueListEntryOid.Value == goal.ValueListEntryOid);
|
|
if(!(selectedGoal is null))
|
|
{
|
|
selectedGoal.RatingTypeOid = ratingTypeOid;
|
|
}
|
|
}
|
|
|
|
return SerializeObject(new GoalRating(rating?.DisplayName ?? string.Empty, goal.ValueListEntryOid ?? 0));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult SetShowExpiredSupportConcepts(FormCollection pCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var newValue = "true,false" == pCollection[FormCollectionConstants.ShowExpiredSupportConceptsKey];
|
|
|
|
Model.ShowExpiredSupportConcepts = newValue;
|
|
|
|
return UpdateSettings(SettingsKeys.ShowExpiredSupportConcepts, newValue ? "1" : "0");
|
|
}
|
|
|
|
[HttpPost]
|
|
public new ActionResult Logout()
|
|
{
|
|
return base.Logout();
|
|
}
|
|
|
|
[Authorize]
|
|
public void LoadGoals()
|
|
{
|
|
if((!Model.CostBearer2SupportConceptOid.HasValue || Model.CostBearer2SupportConceptOid.Value > 0) && Model.SelectedSupportConcept is null)
|
|
{
|
|
Logout();
|
|
}
|
|
|
|
var supportConcept = Model.SupportConcepts.FirstOrDefault(sc => sc.CostBearerRelations.Any(sc2Cb => sc2Cb.CostBearer2SupportConceptOid.HasValue && sc2Cb.CostBearer2SupportConceptOid.Value.Equals(Model.CostBearer2SupportConceptOid.Value)));
|
|
|
|
if (supportConcept is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Model.SelectedSupportConcept = supportConcept;
|
|
|
|
var selectedGoals = supportConcept.Goals;
|
|
|
|
var missingParents = selectedGoals.Where(w => w.ParentOid != null && false == selectedGoals.Any(a => a.ValueListEntryOid.Equals(w.ParentOid))).Select(s => s.ParentOid).ToList();
|
|
|
|
_ParentGoals = new Dictionary<long, ValueListEntryDC>();
|
|
foreach (var oid in missingParents)
|
|
{
|
|
if(oid.HasValue)
|
|
{
|
|
LoadMissingParents(oid.Value);
|
|
}
|
|
}
|
|
|
|
var allGoals = selectedGoals.Union(_ParentGoals.Values).ToList();
|
|
|
|
Model.GoalTree = BuildGoalTree(allGoals);
|
|
}
|
|
|
|
private List<GoalTreeItem> BuildGoalTree(IReadOnlyCollection<ValueListEntryDC> goals)
|
|
{
|
|
var ziele = goals.Where(w => _Zieltypen.Contains(w.Type)).OrderBy(s => s.DisplayName).ToList();
|
|
var massnahmen = goals.Where(w => _Massnahmentypen.Contains(w.Type)).OrderBy(s => s.DisplayName).ToList();
|
|
var goalTree = new List<GoalTreeItem>();
|
|
var goalTreeDic = new Dictionary<long, GoalTreeItem>();
|
|
var goalsWithRating = Model.SelectedServiceRecord?.Goals.Where(goal => goal.RatingTypeOid.HasValue).ToList() ?? new List<ValueListEntryDC>();
|
|
var ratingTypes = OperationsService.GetRatingTypesByOids(goalsWithRating.Where(goal => goal.RatingTypeOid.HasValue).Select(goal => goal.RatingTypeOid.Value).Distinct().ToList());
|
|
|
|
foreach (var ziel in ziele.Where(z => z.ValueListEntryOid.HasValue))
|
|
{
|
|
var treeItem = new GoalTreeItem { Children = new List<GoalTreeItem>(), Header = ziel.DisplayName ?? string.Empty, ParentOid = ziel.ParentOid, ValueListEntryOid = ziel.ValueListEntryOid };
|
|
|
|
goalTreeDic.Add(ziel.ValueListEntryOid.Value, treeItem);
|
|
|
|
if(ziel.ParentOid is null)
|
|
{
|
|
goalTree.Add(treeItem);
|
|
}
|
|
}
|
|
|
|
foreach(var zielMitEltern in goalTreeDic.Values.Where(zielMitEltern => zielMitEltern.ParentOid != null))
|
|
{
|
|
goalTreeDic[zielMitEltern.ParentOid.Value].Children.Add(zielMitEltern);
|
|
}
|
|
|
|
foreach(var ziel in massnahmen)
|
|
{
|
|
var ratingName = Model.HasAnyRatingTypes ? "Bewerten" : string.Empty;
|
|
var goalWithRating = goalsWithRating.FirstOrDefault(g => g.ValueListEntryOid == ziel.ValueListEntryOid);
|
|
|
|
if(Model.HasAnyRatingTypes && Model.IsInEditingMode && goalWithRating != null && ratingTypes.Any())
|
|
{
|
|
var ratingType = ratingTypes.FirstOrDefault(rt => rt.RatingTypeOid == goalWithRating.RatingTypeOid);
|
|
|
|
if(ratingType != null)
|
|
{
|
|
ratingName = ratingType.DisplayName;
|
|
}
|
|
}
|
|
|
|
var kind = new GoalTreeItem { Children = new List<GoalTreeItem>(), Header = ziel.DisplayName ?? string.Empty, IsLeaf = true, ValueListEntryOid = ziel.ValueListEntryOid, RatingName = ratingName};
|
|
|
|
if(ziel.ParentOid != null && goalTreeDic.ContainsKey(ziel.ParentOid.Value))
|
|
{
|
|
kind.ParentOid = goalTreeDic[ziel.ParentOid.Value].ParentOid;
|
|
goalTreeDic[ziel.ParentOid.Value].Children.Add(kind);
|
|
}
|
|
}
|
|
|
|
foreach(var item in goalTreeDic.Values)
|
|
{
|
|
if(item.Children.Count == 0)
|
|
{
|
|
item.IsLeaf = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* var hasRatingTypes = Model.GoalRatingTypes.Any();
|
|
|
|
// TODO: Beim Editieren die Bewertungen laden!
|
|
if(hasRatingTypes && Model.IsInEditingMode && Model.SelectedServiceRecord != null)
|
|
{
|
|
var goalsWithRating = Model.SelectedServiceRecord.Goals.Where(goal => goal.RatingTypeOid.HasValue).ToList();
|
|
|
|
var ratingTypes = OperationsService.GetRatingTypesByOids(goalsWithRating.Where(goal => goal.RatingTypeOid.HasValue).Select(goal => goal.RatingTypeOid.Value).Distinct().ToList());
|
|
|
|
goalTree.DoForEach(treeItem =>
|
|
{
|
|
var goal = goalsWithRating.FirstOrDefault(g => g.ValueListEntryOid == treeItem.ValueListEntryOid);
|
|
|
|
if(goal != null)
|
|
{
|
|
var ratingType = ratingTypes.FirstOrDefault(rt => rt.RatingTypeOid == goal.RatingTypeOid);
|
|
|
|
if(ratingType != null)
|
|
{
|
|
treeItem.RatingName = ratingType.DisplayName;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
*/
|
|
|
|
goalTree = goalTree.OrderBy(o => o.ValueListEntryOid).ToList();
|
|
foreach(var item in goalTree)
|
|
{
|
|
SortGoals(item);
|
|
}
|
|
|
|
return goalTree;
|
|
}
|
|
|
|
private void SortGoals(GoalTreeItem goalTreeItem)
|
|
{
|
|
goalTreeItem.Children = goalTreeItem.Children.OrderBy(s => s.ValueListEntryOid).ToList();
|
|
foreach(var test in goalTreeItem.Children)
|
|
{
|
|
SortGoals(test);
|
|
}
|
|
}
|
|
|
|
private void LoadMissingParents(long pParentOid)
|
|
{
|
|
while(true)
|
|
{
|
|
var parentDC = ValueListService.GetValueListEntryByOid(pParentOid);
|
|
|
|
if(!_ParentGoals.ContainsKey(parentDC.ValueListEntryOid.Value))
|
|
{
|
|
_ParentGoals.Add(parentDC.ValueListEntryOid.Value, parentDC);
|
|
|
|
if(parentDC.ParentOid != null)
|
|
{
|
|
pParentOid = parentDC.ParentOid.Value;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string LoadStatistics(long oid)
|
|
{
|
|
try
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var isLoaded = false;
|
|
|
|
foreach(var supportConcept in Model.SupportConcepts)
|
|
{
|
|
if(supportConcept.CostBearerRelations.Any(supportConceptCostBearerRel => supportConceptCostBearerRel.CostBearer2SupportConceptOid == oid))
|
|
{
|
|
isLoaded = true;
|
|
}
|
|
|
|
if(isLoaded)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!isLoaded)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var statisticsInfo = OperationsService.GetServiceRecordStatisticInfo(oid, DateTime.Now);
|
|
|
|
var supportConceptStatisticsData = new SupportConceptStatisticsData();
|
|
|
|
if(statisticsInfo != null)
|
|
{
|
|
var count = 0;
|
|
supportConceptStatisticsData.ShowDiagram = false;
|
|
|
|
foreach(var period in statisticsInfo.PeriodStatisticInfos)
|
|
{
|
|
var statisticPeriod = new StatisticPeriod();
|
|
|
|
for(var i = 0; i < period.LeftValues.Length; i++)
|
|
{
|
|
var skipFirstHeader = count > 0 && i == 0;
|
|
|
|
var left = period.LeftValues[i] ?? string.Empty;
|
|
var right = period.RightValues[i] ?? string.Empty;
|
|
|
|
var seperator = !string.IsNullOrWhiteSpace(left) && !string.IsNullOrWhiteSpace(right) ? "/" : string.Empty;
|
|
|
|
var value = $"{left}{seperator}{right}";
|
|
|
|
var header = skipFirstHeader ? value : statisticsInfo.Header[i];
|
|
value = header == value ? string.Empty : value;
|
|
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values(header, value));
|
|
}
|
|
|
|
supportConceptStatisticsData.StatisticPeriods.Add(statisticPeriod);
|
|
count++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var supportConceptStatistics = OperationsService.CreateSupportConceptStatistics(oid, DateTime.Now);
|
|
|
|
var provided = supportConceptStatistics.MinutesProvidedThisWeek / 60;
|
|
var approved = supportConceptStatistics.MinutesApprovedPerWeek / 60;
|
|
var freePerWeek = supportConceptStatistics.MinutesFreePerWeekAverage / 60;
|
|
|
|
var providedTotal = supportConceptStatistics.MinutesProvidedTotalRounded / 60;
|
|
var approvedTotal = supportConceptStatistics.MinutesApprovedTotal / 60;
|
|
var freePerWeekTotal = (approvedTotal - providedTotal);
|
|
|
|
decimal percentage = 0;
|
|
|
|
if(approvedTotal > 0)
|
|
{
|
|
percentage = providedTotal / approvedTotal * 100;
|
|
}
|
|
|
|
if(percentage > 100)
|
|
{
|
|
percentage = 100;
|
|
}
|
|
|
|
supportConceptStatisticsData.Percentage = percentage;
|
|
|
|
var statisticPeriod = new StatisticPeriod();
|
|
|
|
if(supportConceptStatistics.PeriodStatistics.Count != 1)
|
|
{
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Bewilligungszeitraum:", "Gesamt"));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Geleistet diese Woche/gesamt:", $"{provided:0.00}/{providedTotal:0.00}"));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Bewilligt pro Woche/gesamt:", $"{approved:0.00}/{approvedTotal:0.00}"));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Frei pro Woche(Ø)/gesamt:", $"{freePerWeek:0.00}/{freePerWeekTotal:0.00}"));
|
|
|
|
supportConceptStatisticsData.StatisticPeriods.Add(statisticPeriod);
|
|
}
|
|
|
|
foreach(var periodStatistics in supportConceptStatistics.PeriodStatistics)
|
|
{
|
|
provided = periodStatistics.MinutesProvidedThisWeek / 60;
|
|
approved = periodStatistics.MinutesApprovedPerWeek / 60;
|
|
freePerWeek = periodStatistics.MinutesFreePerWeek / 60;
|
|
|
|
providedTotal = periodStatistics.MinutesProvidedTotalRounded / 60;
|
|
approvedTotal = periodStatistics.MinutesApprovedTotal / 60;
|
|
freePerWeekTotal = (approvedTotal - providedTotal);
|
|
|
|
var supportConceptApprovalPeriodSpan = periodStatistics.SupportConceptApprovalPeriod.Span;
|
|
var minVal = DateTime.Now.AddYears(-50);
|
|
var maxVal = DateTime.Now.AddYears(50);
|
|
|
|
var sd = supportConceptApprovalPeriodSpan.StartDate;
|
|
var ed = supportConceptApprovalPeriodSpan.EndDate;
|
|
|
|
var start = sd > minVal && sd < maxVal ? $"{sd:dd.MM.yy} " : string.Empty;
|
|
var end = ed > minVal && ed < maxVal ? $" {ed:dd.MM.yy}" : string.Empty;
|
|
|
|
var span = $"{start}-{end}";
|
|
var serviceCategoryName = periodStatistics.SupportConceptApprovalPeriod.ServiceCategory != null ? periodStatistics.SupportConceptApprovalPeriod.ServiceCategory.Name + ":" : "Bewilligungszeitraum:";
|
|
|
|
statisticPeriod = new StatisticPeriod();
|
|
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values(serviceCategoryName, span));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Geleistet diese Woche/gesamt:", $"{provided:0.00}/{providedTotal:0.00}"));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Bewilligt pro Woche/gesamt:", $"{approved:0.00}/{approvedTotal:0.00}"));
|
|
statisticPeriod.Header2Values.AddIfNotIn(new Header2Values("Frei pro Woche(Ø)/gesamt:", $"{freePerWeek:0.00}/{freePerWeekTotal:0.00}"));
|
|
|
|
supportConceptStatisticsData.StatisticPeriods.Add(statisticPeriod);
|
|
}
|
|
}
|
|
|
|
return SerializeObject(supportConceptStatisticsData);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
return SerializeObject("Fehler 560");
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string SaveUnterschrift(string blob, string timeStamp, long? serviceRecordOid)
|
|
{
|
|
try
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
using (var signatureBitmap = SignatureUtils.Base64StringToBitmap(blob.Split(',')[1]))
|
|
{
|
|
var isValid = SignatureUtils.ValidateSignature(signatureBitmap);
|
|
|
|
if(!isValid)
|
|
{
|
|
return SerializeObject("Das Unterschriftenfeld darf nicht leer sein.");
|
|
}
|
|
|
|
var date = DateTime.Parse(timeStamp);
|
|
|
|
OperationsService.InsertSignature(new SignatureDC
|
|
{
|
|
DataBild = blob,
|
|
Zeitstempel = date,
|
|
ServiceRecordOid = serviceRecordOid
|
|
});
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
return SerializeObject("Fehler 540");
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public static string ApplyWatermark(string blob, string watermarkImagePath)
|
|
{
|
|
if(string.IsNullOrWhiteSpace(blob))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var watermarkImage = Image.FromFile(watermarkImagePath);
|
|
|
|
var signatureImage = SignatureUtils.Base64StringToBitmap(blob);
|
|
|
|
var hasTransparentBackground = SignatureUtils.HasTransparentBackground(blob);
|
|
|
|
if(hasTransparentBackground)
|
|
{
|
|
signatureImage = SignatureUtils.AddBackgroundToBitmap(signatureImage, Color.White);
|
|
}
|
|
|
|
var watermarker = new Watermarker(signatureImage);
|
|
|
|
for(var y = 0; y < signatureImage.Height; y++)
|
|
{
|
|
for(var x = 0; x < signatureImage.Width; x++)
|
|
{
|
|
watermarker.Position = WatermarkPosition.Absolute;
|
|
watermarker.PositionX = x;
|
|
watermarker.PositionY = y;
|
|
watermarker.Margin = new Padding(20);
|
|
watermarker.Opacity = .1f;
|
|
watermarker.TransparentColor = Color.White;
|
|
watermarker.DrawImage(watermarkImage);
|
|
|
|
x += watermarkImage.Width;
|
|
}
|
|
|
|
y += watermarkImage.Height;
|
|
}
|
|
|
|
return "data:image/png;base64," + SignatureUtils.ConvertImageToBase64String(watermarker.Image);
|
|
}
|
|
|
|
[Authorize]
|
|
public string LoadServiceCategories(long pServiceCategoryOid)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
try
|
|
{
|
|
var scm = Model.ServiceCategories.FirstOrDefault(s => s.ServiceCategoryOid.HasValue && s.ServiceCategoryOid.Value == pServiceCategoryOid);
|
|
|
|
if (scm != null)
|
|
{
|
|
Model.SelectedServiceCategoryOid = scm.ServiceCategoryOid;
|
|
}
|
|
|
|
return SerializeObject(scm != null ? scm.ServiceDescriptions.OrderBy(serviceDescription => serviceDescription.Position).ToList() : new List<ServiceDescriptionDC>());
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
Debug.WriteLine(exception);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string LoadTextbausteineForServiceCategory(long pServiceCategoryOid)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!MobileSessionFacade.CheckForUserRight(UserRightType.TextbausteineNurEigeneAnsehen) && !MobileSessionFacade.CheckForUserRight(UserRightType.TextbausteineAlleAnsehen))
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
// Damit sind die allgemeinen gemeint!
|
|
var textbausteine = OperationsService.GetAllTextModules();
|
|
foreach (var tm in textbausteine.Where(textModule => textModule.IsParent == false))
|
|
{
|
|
if (string.IsNullOrWhiteSpace(tm.Text))
|
|
{
|
|
tm.Text = tm.Name;
|
|
}
|
|
}
|
|
|
|
if(!MobileSessionFacade.CheckForUserRight(UserRightType.TextbausteineAlleAnsehen))
|
|
{
|
|
textbausteine = textbausteine.Where(w => w.Employee.EmployeeOid == Model.Employee.EmployeeOid && w.IsOnlyForEmployee).ToList();
|
|
}
|
|
|
|
Model.Textbausteine = textbausteine.Where(
|
|
w => (w.ServiceCategory is null || w.ServiceCategory.ServiceCategoryOid == pServiceCategoryOid) && !string.IsNullOrEmpty(w.Text)
|
|
&& (w.IsOnlyForEmployee && w.Employee.EmployeeOid.Equals(Model.Employee.EmployeeOid) || !w.IsOnlyForEmployee)).OrderBy(t => t.Text).ToList();
|
|
|
|
Model.Textbausteine.AddRangeIfElementsNotIn(Utils.GetParentTextModules(Model.Textbausteine));
|
|
|
|
var newItems = Model.Textbausteine.Where(tb => tb.TextModuleOid.HasValue).Select(tb => new TextbausteinDisplayItem(tb.Name, tb.Text, tb.Parent?.TextModuleOid, tb.TextModuleOid.Value, tb.IsExpanded)).ToList();
|
|
|
|
foreach(var item in newItems)
|
|
{
|
|
if(item.ParentOid != null)
|
|
{
|
|
var parent = newItems.FirstOrDefault(p => p.Oid == item.ParentOid);
|
|
|
|
parent?.Children.AddIfNotIn(item);
|
|
}
|
|
}
|
|
|
|
var test = newItems.Where(item => item.ParentOid is null).ToList();
|
|
|
|
if(test.Count == 0)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
_TextModuleTreeHtml = "<div class=\"list-group\">";
|
|
|
|
foreach(var item in test)
|
|
{
|
|
BuildTextModuleTreeBranch(item);
|
|
}
|
|
|
|
_TextModuleTreeHtml += "</div>";
|
|
|
|
return _TextModuleTreeHtml;
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
Debug.WriteLine(exception);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private string _TextModuleTreeHtml = "";
|
|
|
|
private void BuildTextModuleTreeBranch(TextbausteinDisplayItem textModuleItem)
|
|
{
|
|
if(textModuleItem.IsParent)
|
|
{
|
|
_TextModuleTreeHtml += $"<a href=\"#\" class=\"list-group-item list-group-item-action mx-0 px-1\" onclick=\"textCategoryOnClick('{textModuleItem.Oid}')\">" +
|
|
$"<span id=\"{textModuleItem.Oid}-icon-span\" class=\"fas fa-angle-up mr-1\"></span>" +
|
|
$"{textModuleItem.Name}" +
|
|
"</a>" +
|
|
$"<div id=\"{textModuleItem.Oid}-children-container\" style=\"display: none;\" class=\"list-group list-group-item mx-0 px-1\">";
|
|
|
|
foreach(var child in textModuleItem.Children)
|
|
{
|
|
BuildTextModuleTreeBranch(child);
|
|
}
|
|
|
|
_TextModuleTreeHtml += "</div>";
|
|
}
|
|
else
|
|
{
|
|
_TextModuleTreeHtml += $"<a href=\"#\" id=\"{textModuleItem.Oid}\" class=\"list-group-item list-group-item-action mx-0 px-1\" onclick=\"textModuleOnClick('{textModuleItem.Oid}')\">{textModuleItem.Name}</a>";
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string LoadCompleteTextbausteinByOid(long pTextbausteinOid)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var textModule = Model.Textbausteine.FirstOrDefault(f => f.TextModuleOid.HasValue && f.TextModuleOid.Value == pTextbausteinOid);
|
|
|
|
return textModule is null ? null : string.IsNullOrWhiteSpace(textModule.Text) ? textModule.Name : textModule.Text;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult CreateOrUpdateServiceRecord(FormCollection collection)
|
|
{
|
|
try
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
string doku1;
|
|
|
|
if(Model.Dokutypes != null && Model.Dokutypes.Length > 0)
|
|
{
|
|
doku1 = collection[FormCollectionConstants.Dokumentation1Key];
|
|
}
|
|
else
|
|
{
|
|
doku1 = collection[FormCollectionConstants.Dokumentation6Key];
|
|
}
|
|
|
|
Log.Info($"CreateOrUpdateServiceRecord: datum:{collection[FormCollectionConstants.DateKey]}; start:{collection[FormCollectionConstants.StartKey]}; ende:{collection[FormCollectionConstants.EndKey]}; dauer:{collection[FormCollectionConstants.DurationKey]}; doku:{doku1}; aktion:{(Model.IsInEditingMode ? "Speichern" : "Anlegen")}");
|
|
|
|
if(string.IsNullOrEmpty(collection[FormCollectionConstants.DateKey]))
|
|
{
|
|
return View("Main", Model);
|
|
}
|
|
|
|
var distanz = collection[FormCollectionConstants.DistanceKey];
|
|
var distanceInMeters = 0;
|
|
|
|
if(!string.IsNullOrEmpty(distanz))
|
|
{
|
|
if(int.TryParse(distanz, out var parsedDistance))
|
|
{
|
|
distanceInMeters = parsedDistance;
|
|
}
|
|
}
|
|
|
|
var selectedCostbearerSCRelOid = Model.CostBearer2SupportConceptOid < 1 ? null : Model.CostBearer2SupportConceptOid;
|
|
var datum = Convert.ToDateTime(collection[FormCollectionConstants.DateKey]);
|
|
|
|
var enddatum = datum;
|
|
|
|
var endDateString = collection[FormCollectionConstants.EndDateKey];
|
|
if(endDateString != null)
|
|
{
|
|
enddatum = Convert.ToDateTime(endDateString);
|
|
}
|
|
|
|
var start = collection[FormCollectionConstants.StartKey];
|
|
var ende = collection[FormCollectionConstants.EndKey];
|
|
var dauer = 0;
|
|
|
|
if(datum > enddatum)
|
|
{
|
|
enddatum = datum;
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(collection[FormCollectionConstants.DurationKey]))
|
|
{
|
|
int.TryParse(collection[FormCollectionConstants.DurationKey], out dauer);
|
|
}
|
|
|
|
var doku2 = collection[FormCollectionConstants.Dokumentation2Key];
|
|
var doku3 = collection[FormCollectionConstants.Dokumentation3Key];
|
|
var doku4 = collection[FormCollectionConstants.Dokumentation4Key];
|
|
var doku5 = collection[FormCollectionConstants.Dokumentation5Key];
|
|
|
|
var zeitenFeld = new DateTime[2];
|
|
|
|
if(start == string.Empty && ende == string.Empty)
|
|
{
|
|
zeitenFeld[0] = new DateTime(datum.Year, datum.Month, datum.Day, 0, 0, 1);
|
|
|
|
if(enddatum == datum)
|
|
{
|
|
zeitenFeld[1] = new DateTime(datum.Year, datum.Month, datum.Day, 0, 0, 1).AddMinutes(dauer);
|
|
}
|
|
else
|
|
{
|
|
zeitenFeld[1] = new DateTime(enddatum.Year, enddatum.Month, enddatum.Day, 0, 0, 1).AddMinutes(dauer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
zeitenFeld = enddatum == datum ? ConvertRecordTimes(start, ende, datum, dauer) : ConvertRecordTimesWithEndDate(start, ende, datum, enddatum, dauer);
|
|
}
|
|
|
|
if(dauer == 0 || zeitenFeld[1] != zeitenFeld[0])
|
|
{
|
|
dauer = (int)(zeitenFeld[1] - zeitenFeld[0]).TotalMinutes;
|
|
}
|
|
|
|
if(Model.IsInEditingMode)
|
|
{
|
|
var selectedRecordOid = Model.SelectedServiceRecordOid ?? Model.SelectedServiceRecord.ServiceRecordOid;
|
|
Model.NewServiceRecord = Model.GetServiceRecord(selectedRecordOid.Value);
|
|
}
|
|
|
|
if(Model.NewServiceRecord is null)
|
|
{
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
Model.NewServiceRecord.IP = Request.UserHostAddress;
|
|
// ToDo: Funktioniert noch nicht zu 100 %
|
|
Model.NewServiceRecord.Goals = Model.SelectedGoals;
|
|
Model.NewServiceRecord.Start = zeitenFeld[0];
|
|
Model.NewServiceRecord.End = zeitenFeld[1];
|
|
|
|
Model.NewServiceRecord.DistanceInMeter = distanceInMeters;
|
|
|
|
if(Model.Employee.EmployeeOid != null)
|
|
{
|
|
if(!Model.IsInEditingMode)
|
|
{
|
|
Model.NewServiceRecord.Employee = Model.SelectedEmployee ?? MobileSessionFacade.LoggedInCompactEmployee;
|
|
}
|
|
else
|
|
{
|
|
if(Model.SelectedEmployee != null)
|
|
{
|
|
Model.NewServiceRecord.Employee = Model.SelectedEmployee;
|
|
}
|
|
}
|
|
|
|
var sc = Model.SupportConcepts.FirstOrDefault(fod => fod.CostBearerRelations.Any(a => a.CostBearer2SupportConceptOid.HasValue && a.CostBearer2SupportConceptOid.Value.Equals(selectedCostbearerSCRelOid)));
|
|
|
|
if(sc != null)
|
|
{
|
|
if(sc.SupportConceptOid != null)
|
|
{
|
|
Model.NewServiceRecord.SupportConcept = CustomerService.LoadCompactSupportConceptDC(sc.SupportConceptOid.Value, Model.Employee.EmployeeOid);
|
|
}
|
|
|
|
Model.NewServiceRecord.Customer = sc.Customer;
|
|
|
|
var cb2ScRel = sc.CostBearerRelations.First(f => f.CostBearer2SupportConceptOid.HasValue && f.CostBearer2SupportConceptOid.Equals(selectedCostbearerSCRelOid));
|
|
Model.NewServiceRecord.CostBearer = cb2ScRel.CostBearer;
|
|
|
|
var intervall = Model.NewServiceRecord.CostBearer.ActualMinuteIntervall;
|
|
|
|
if(intervall > 0)
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer % intervall != 0 ? dauer + (intervall - dauer % intervall) : dauer;
|
|
}
|
|
else
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
|
|
Model.NewServiceRecord.CostBearer2SupportConceptOid = selectedCostbearerSCRelOid;
|
|
}
|
|
else
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
}
|
|
|
|
Model.NewServiceRecord.DurationInStunden = ZeiterfassungsDauer.Minuten;
|
|
|
|
Model.NewServiceRecord.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
|
|
|
|
Model.NewServiceRecord.Notice = string.IsNullOrEmpty(doku1) ? null : doku1;
|
|
|
|
Model.NewServiceRecord.Notice2 = string.IsNullOrEmpty(doku2) ? null : doku2;
|
|
Model.NewServiceRecord.Notice3 = string.IsNullOrEmpty(doku3) ? null : doku3;
|
|
Model.NewServiceRecord.Notice4 = string.IsNullOrEmpty(doku4) ? null : doku4;
|
|
Model.NewServiceRecord.Notice5 = string.IsNullOrEmpty(doku5) ? null : doku5;
|
|
|
|
var serviceDescOid = 0L;
|
|
|
|
if(!string.IsNullOrEmpty(collection[FormCollectionConstants.ServiceDescriptionKey]))
|
|
{
|
|
serviceDescOid = Convert.ToInt64(collection[FormCollectionConstants.ServiceDescriptionKey]);
|
|
}
|
|
else if(Model.SelectedServiceDescriptionOid.HasValue)
|
|
{
|
|
serviceDescOid = Model.SelectedServiceDescriptionOid.Value;
|
|
}
|
|
|
|
if(serviceDescOid > 0)
|
|
{
|
|
Model.NewServiceRecord.ServiceDescription = OperationsService.GetServiceDescription(serviceDescOid);
|
|
}
|
|
|
|
if(Model.NewServiceRecord.RoundedDuration == 0)
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
|
|
Model.NewServiceRecord.IP = Request.UserHostAddress;
|
|
Model.NewServiceRecord.InsertedOn = DateTime.Now;
|
|
Model.NewServiceRecord.InsUser = $"{MobileSessionFacade.LoggedInEmployee.FirstName} {MobileSessionFacade.LoggedInEmployee.LastName}";
|
|
Model.NewServiceRecord.IsCreatedInMobileClient = true;
|
|
|
|
if(Model.IsInGroupBookingMode && Model.SelectedSupportConcepts.Count > 1)
|
|
{
|
|
return Model.NewServiceRecord.ServiceRecordOid.HasValue ? SaveGroupBooking() : UpdateGroupBooking();
|
|
}
|
|
|
|
if(!Model.IsInEditingMode)
|
|
{
|
|
var oidList = OperationsService.InsertNewServiceRecords(new List<ServiceRecordDC> { Model.NewServiceRecord });
|
|
|
|
Model.ServiceRecordOid = oidList[0];
|
|
|
|
if(Model.NewServiceRecord.CostBearer != null && Model.ShowSignature)
|
|
{
|
|
TempData[FormCollectionConstants.ShowSignatureSuggestionPopup] = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OperationsService.UpdateServiceRecords(new List<ServiceRecordDC> { Model.NewServiceRecord });
|
|
}
|
|
|
|
Model.NewServiceRecord = new ServiceRecordDC();
|
|
|
|
if(selectedCostbearerSCRelOid.HasValue)
|
|
{
|
|
Model.ServiceRecords = OperationsService.FindServiceRecordsForLastDays(selectedCostbearerSCRelOid, Model.Zeitraum, Model.Employee.EmployeeOid).ToList();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
}
|
|
|
|
ResetGroupBookingMode(Model.IsInGroupBookingMode);
|
|
|
|
return ResetEditingMode();
|
|
}
|
|
|
|
[Authorize]
|
|
private ActionResult SaveGroupBooking()
|
|
{
|
|
var employeeCount = Model.SelectedEmployees.Count;
|
|
var personCount = Model.SelectedSupportConcepts.Count;
|
|
|
|
var cb2ScOids = (from scDc in Model.SelectedSupportConcepts
|
|
where scDc.CostBearerRelations != null && scDc.CostBearerRelations.Count > 0 let costBearer2SupportConceptOid = scDc.CostBearerRelations[0].CostBearer2SupportConceptOid
|
|
where costBearer2SupportConceptOid != null select costBearer2SupportConceptOid.Value).ToList();
|
|
|
|
var list = CalculateGroupBookingDuration(employeeCount, personCount, cb2ScOids);
|
|
|
|
var newDCList = new List<ServiceRecordDC>();
|
|
|
|
foreach(var dc in list)
|
|
{
|
|
foreach(var emp in Model.SelectedEmployees)
|
|
{
|
|
var newDC = CloneServiceRecordForGroupBooking(dc);
|
|
|
|
newDC.Employee = emp;
|
|
newDC.InsertedOn = DateTime.Now;
|
|
newDCList.Add(newDC);
|
|
}
|
|
}
|
|
|
|
if(newDCList.Count > 0)
|
|
{
|
|
if(newDCList.Count == 1)
|
|
{
|
|
OperationsService.InsertNewServiceRecords(newDCList);
|
|
}
|
|
else
|
|
{
|
|
var groupDC = new ServiceRecordGroupDC
|
|
{
|
|
EmployeeCount = employeeCount,
|
|
CustomerCount = personCount,
|
|
StartDate = Model.NewServiceRecord.Start,
|
|
EndDate = Model.NewServiceRecord.End,
|
|
Notice = Model.NewServiceRecord.Notice,
|
|
Notice2 = Model.NewServiceRecord.Notice2,
|
|
Notice3 = Model.NewServiceRecord.Notice3,
|
|
Notice4 = Model.NewServiceRecord.Notice4,
|
|
Notice5 = Model.NewServiceRecord.Notice5,
|
|
ServiceRecordList = newDCList
|
|
};
|
|
|
|
if(Model.NewServiceRecord.GroupRoundedDuration != null)
|
|
{
|
|
groupDC.RoundedDuration = Model.NewServiceRecord.GroupRoundedDuration.Value;
|
|
}
|
|
|
|
OperationsService.InsertNewServiceRecordGroup(groupDC);
|
|
}
|
|
}
|
|
|
|
return ResetEditingMode();
|
|
}
|
|
|
|
[Authorize]
|
|
private ActionResult UpdateGroupBooking()
|
|
{
|
|
var dc = Model.SelectedServiceRecord;
|
|
|
|
var group = OperationsService.GetServiceRecordGroup(dc.GroupOid.Value);
|
|
|
|
UpdateServiceRecordGroup(group);
|
|
var employeeCount = Model.SelectedEmployees.Count;
|
|
var customerCount = Model.SelectedSupportConcepts.Count;
|
|
|
|
group.EmployeeCount = employeeCount;
|
|
group.CustomerCount = customerCount;
|
|
|
|
var roundDuration = true;
|
|
var minuteInterval = 0;
|
|
|
|
CompactOrganisationDC org = null;
|
|
|
|
var cb2ScOids = new List<long>();
|
|
|
|
foreach(var scdc in Model.SelectedSupportConcepts)
|
|
{
|
|
if(scdc.CostBearerRelations.Count > 0)
|
|
{
|
|
cb2ScOids.Add(scdc.CostBearerRelations.ElementAt(0).CostBearer2SupportConceptOid.Value);
|
|
|
|
if(org is null)
|
|
{
|
|
org = scdc.CostBearerRelations.ElementAt(0).CostBearer;
|
|
if(org != null)
|
|
{
|
|
minuteInterval = org.ActualMinuteIntervall;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(scdc.CostBearerRelations.ElementAt(0).CostBearer is null || !org.Equals(scdc.CostBearerRelations.ElementAt(0).CostBearer))
|
|
{
|
|
roundDuration = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var duration = (decimal) (Model.NewServiceRecord.End.Value - Model.NewServiceRecord.Start.Value).TotalMinutes;
|
|
|
|
var lRoundedDuration = duration;
|
|
decimal groupDuration;
|
|
decimal roundedDuration;
|
|
|
|
var gd = OperationsService.CalculateGroupDuration2(customerCount, employeeCount, duration, cb2ScOids.ToArray());
|
|
|
|
if(gd != null)
|
|
{
|
|
groupDuration = gd.TotalDuration;
|
|
roundedDuration = gd.SingleDuration;
|
|
}
|
|
else
|
|
{
|
|
if(minuteInterval > 0 && roundDuration)
|
|
{
|
|
lRoundedDuration = duration % minuteInterval != 0 ? duration + (minuteInterval - duration % minuteInterval) : duration;
|
|
}
|
|
|
|
groupDuration = lRoundedDuration;
|
|
roundedDuration = Math.Round(groupDuration / Model.SelectedSupportConcepts.Count, 0 , MidpointRounding.AwayFromZero);
|
|
}
|
|
|
|
Model.NewServiceRecord.RoundedDuration = roundedDuration;
|
|
Model.NewServiceRecord.GroupRoundedDuration = groupDuration;
|
|
|
|
group.Notice = Model.NewServiceRecord.Notice;
|
|
group.Notice2 = Model.NewServiceRecord.Notice2;
|
|
group.Notice3 = Model.NewServiceRecord.Notice3;
|
|
group.Notice4 = Model.NewServiceRecord.Notice4;
|
|
group.Notice5 = Model.NewServiceRecord.Notice5;
|
|
group.RoundedDuration = groupDuration;
|
|
group.StartDate = Model.NewServiceRecord.Start;
|
|
group.EndDate = Model.NewServiceRecord.End;
|
|
|
|
foreach(var item in group.ServiceRecordList)
|
|
{
|
|
item.Notice = Model.NewServiceRecord.Notice;
|
|
item.Notice2 = Model.NewServiceRecord.Notice2;
|
|
item.Notice3 = Model.NewServiceRecord.Notice3;
|
|
item.Notice4 = Model.NewServiceRecord.Notice4;
|
|
item.Notice5 = Model.NewServiceRecord.Notice5;
|
|
item.End = Model.NewServiceRecord.End;
|
|
item.Start = Model.NewServiceRecord.Start;
|
|
item.RoundedDuration = roundedDuration;
|
|
item.DistanceInMeter = Model.NewServiceRecord.DistanceInMeter;
|
|
item.ServiceDescription = Model.NewServiceRecord.ServiceDescription;
|
|
|
|
item.ServiceRecordFormat = Model.NewServiceRecord.ServiceRecordFormat;
|
|
item.DurationInStunden = Model.NewServiceRecord.DurationInStunden;
|
|
|
|
item.ServiceDescription = item.ServiceDescription ?? Model.NewServiceRecord.ServiceDescription;
|
|
|
|
item.GroupEmployeeCount = group.EmployeeCount;
|
|
item.GroupPersonCount = group.CustomerCount;
|
|
item.GroupOid = Model.NewServiceRecord.GroupOid;
|
|
item.GroupRoundedDuration = groupDuration;
|
|
|
|
if(item.CostBearer != null && item.CostBearer.CostBearerOid is null && item.SupportConcept != null && item.SupportConcept.CostBearerList.Count > 0)
|
|
{
|
|
item.CostBearer.CostBearerOid = item.SupportConcept.CostBearerList[0].CostBearerOid;
|
|
}
|
|
}
|
|
|
|
if(Model.NewServiceRecord.GroupOid.HasValue)
|
|
{
|
|
OperationsService.UpdateServiceRecordGroup(group);
|
|
}
|
|
|
|
Model.NewServiceRecord = null;
|
|
Model.SelectedServiceRecord = null;
|
|
Model.SelectedSupportConcepts = new List<SupportConceptDC>();
|
|
Model.SelectedEmployees = new List<CompactEmployeeDC>();
|
|
|
|
ResetGroupBookingMode(false);
|
|
Model.IsInEditingMode = false;
|
|
|
|
return ResetEditingMode();
|
|
}
|
|
|
|
[Authorize]
|
|
private IEnumerable<ServiceRecordDC> CalculateGroupBookingDuration(int pEmployeeCount, int pCustomerCount, ICollection<long> cb2ScOids)
|
|
{
|
|
var compactSupportConcepts = CustomerServiceImp.GetCompactSupportConcepts((from sc in Model.SelectedSupportConcepts where sc.SupportConceptOid != null select sc.SupportConceptOid.Value).ToList(), GetUser().Employee.EmployeeOid);
|
|
|
|
var nodes = (from supportConcept in Model.SelectedSupportConcepts let cb = supportConcept.CostBearerRelations.FirstOrDefault(f => cb2ScOids.Contains(f.CostBearer2SupportConceptOid.Value)) let sc = compactSupportConcepts.FirstOrDefault(f => f.SupportConceptOid == supportConcept.SupportConceptOid) where cb != null && sc != null select SupportConceptService.CreateFlatSupportConceptItem(sc, CustomerService.LoadOrganisationCompact(cb.CostBearer.OrganisationOid))).ToList();
|
|
|
|
var list = new List<ServiceRecordDC>();
|
|
foreach(var node in nodes)
|
|
{
|
|
var sc = CloneServiceRecordForGroupBooking(Model.NewServiceRecord);
|
|
|
|
if(Model.NewServiceRecord.RoundedDuration == 0)
|
|
{
|
|
if(Model.NewServiceRecord.Start.HasValue && Model.NewServiceRecord.End.HasValue)
|
|
{
|
|
var minutes = Model.NewServiceRecord.End.Value.Subtract(Model.NewServiceRecord.Start.Value).TotalMinutes;
|
|
|
|
Model.NewServiceRecord.RoundedDuration = (decimal)minutes;
|
|
}
|
|
}
|
|
|
|
sc.GroupRoundedDuration = Model.NewServiceRecord.RoundedDuration;
|
|
|
|
sc.CostBearer2SupportConceptOid = node.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid;
|
|
|
|
sc.SupportConcept = node.SupportConceptTreeNodeDC.SupportConcept;
|
|
|
|
sc.CostBearer = node.SupportConceptTreeNodeDC.CostBearer;
|
|
|
|
sc.Customer = node.SupportConceptTreeNodeDC.Customer;
|
|
|
|
sc.GroupEmployeeCount = pEmployeeCount;
|
|
|
|
sc.GroupPersonCount = pCustomerCount;
|
|
|
|
list.Add(sc);
|
|
}
|
|
|
|
var roundDuration = false;
|
|
var minuteInterval = 0;
|
|
string calcdId = null;
|
|
var lastMinuteInterval = -1;
|
|
|
|
if(Model.SelectedServiceDescriptionOid.HasValue && IsBillable(Model.SelectedServiceDescriptionOid.Value, Model.GetServiceDesctiptions()))
|
|
{
|
|
roundDuration = true;
|
|
|
|
foreach(var org in from dc in Model.SelectedSupportConcepts where dc.CostBearerRelations.Count > 0 select dc.CostBearerRelations.First().CostBearer)
|
|
{
|
|
if(org != null)
|
|
{
|
|
minuteInterval = org.ActualMinuteIntervall;
|
|
|
|
if(lastMinuteInterval == -1)
|
|
{
|
|
lastMinuteInterval = minuteInterval;
|
|
calcdId = org.CostBearerID;
|
|
}
|
|
else if(lastMinuteInterval != minuteInterval)
|
|
{
|
|
roundDuration = false;
|
|
}
|
|
}
|
|
else if(minuteInterval >= 0)
|
|
{
|
|
roundDuration = false;
|
|
}
|
|
else
|
|
{
|
|
minuteInterval = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
var duration = Model.NewServiceRecord.RoundedDuration;
|
|
var totalDuration = duration;
|
|
|
|
var groupDuration = OperationsService.CalculateGroupDuration2(pCustomerCount, pEmployeeCount, Model.NewServiceRecord.RoundedDuration, nodes.Select(s => s.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value).ToArray());
|
|
|
|
if(groupDuration != null)
|
|
{
|
|
Model.NewServiceRecord.GroupRoundedDuration = groupDuration.TotalDuration;
|
|
Model.NewServiceRecord.RoundedDuration = groupDuration.SingleDuration;
|
|
}
|
|
else
|
|
{
|
|
if(minuteInterval > 0 && roundDuration)
|
|
{
|
|
var calc = Calculations.GetInstance(calcdId);
|
|
totalDuration = calc.GetRoundedDuration(minuteInterval, duration);
|
|
}
|
|
|
|
Model.NewServiceRecord.RoundedDuration = Math.Round(totalDuration / pCustomerCount, 0, MidpointRounding.AwayFromZero);
|
|
Model.NewServiceRecord.GroupRoundedDuration = totalDuration;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void UpdateServiceRecordGroup(ServiceRecordGroupDC pGroupDC)
|
|
{
|
|
var newCount = 0;
|
|
|
|
foreach(var serviceRecord in pGroupDC.ServiceRecordList)
|
|
{
|
|
if(!serviceRecord.ServiceRecordOid.HasValue)
|
|
{
|
|
newCount++;
|
|
}
|
|
}
|
|
|
|
if(newCount == pGroupDC.ServiceRecordList.Count)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var dcsToChange = new List<ServiceRecordDC>();
|
|
var oldSCs = new Dictionary<long, CompactSupportConceptDC>();
|
|
var oldEmps = new Dictionary<long, CompactEmployeeDC>();
|
|
var newKeys = new Dictionary<string, string>();
|
|
|
|
foreach(var sc in Model.SelectedSupportConcepts)
|
|
{
|
|
foreach(var emp in Model.SelectedEmployees)
|
|
{
|
|
var key = emp.EmployeeOid + "_" + sc.SupportConceptOid;
|
|
if(sc.CostBearerRelations != null && sc.CostBearerRelations.Count > 0)
|
|
{
|
|
var costBearer2SupportConceptOid = sc.CostBearerRelations.ElementAt(0).CostBearer2SupportConceptOid;
|
|
if(costBearer2SupportConceptOid != null)
|
|
{
|
|
key += "_" + costBearer2SupportConceptOid.Value;
|
|
}
|
|
|
|
newKeys.Add(key, key);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach(var item in pGroupDC.ServiceRecordList)
|
|
{
|
|
var key = item.Employee.EmployeeOid + "_" + item.SupportConcept.SupportConceptOid;
|
|
if(item.CostBearer2SupportConceptOid.HasValue)
|
|
{
|
|
key += "_" + item.CostBearer2SupportConceptOid.Value;
|
|
}
|
|
|
|
if(newKeys.ContainsKey(key))
|
|
{
|
|
newKeys.Remove(key);
|
|
}
|
|
else
|
|
{
|
|
dcsToChange.Add(item);
|
|
}
|
|
|
|
if(!oldEmps.ContainsKey(item.Employee.EmployeeOid))
|
|
{
|
|
oldEmps.Add(item.Employee.EmployeeOid, item.Employee);
|
|
}
|
|
|
|
if(!oldSCs.ContainsKey(item.SupportConcept.SupportConceptOid))
|
|
{
|
|
oldSCs.Add(item.SupportConcept.SupportConceptOid, item.SupportConcept);
|
|
}
|
|
}
|
|
|
|
if(newKeys.Count != 0 || dcsToChange.Count != 0)
|
|
{
|
|
if(newKeys.Count > 0)
|
|
{
|
|
foreach(var sc in Model.SelectedSupportConcepts)
|
|
{
|
|
foreach(var emp in Model.SelectedEmployees)
|
|
{
|
|
var key = emp.EmployeeOid + "_" + sc.SupportConceptOid;
|
|
|
|
if(sc.CostBearerRelations != null && sc.CostBearerRelations.Count > 0)
|
|
{
|
|
key += "_" + sc.CostBearerRelations.ElementAt(0).CostBearer2SupportConceptOid;
|
|
}
|
|
|
|
if(!newKeys.ContainsKey(key))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ServiceRecordDC newServiceRecord;
|
|
if(dcsToChange.Count > 0)
|
|
{
|
|
newServiceRecord = dcsToChange[0];
|
|
dcsToChange.Remove(newServiceRecord);
|
|
}
|
|
else
|
|
{
|
|
newServiceRecord = CloneServiceRecordForGroupBooking(Model.NewServiceRecord);
|
|
pGroupDC.ServiceRecordList.Add(newServiceRecord);
|
|
}
|
|
|
|
newServiceRecord.Employee = emp;
|
|
newServiceRecord.SupportConcept = CustomerService.LoadCompactSupportConceptDC(sc.SupportConceptOid.Value, null);
|
|
newServiceRecord.CostBearer = sc.CostBearerRelations.ElementAt(0).CostBearer;
|
|
newServiceRecord.Customer = sc.Customer;
|
|
newServiceRecord.CostBearer2SupportConceptOid = sc.CostBearerRelations.ElementAt(0).CostBearer2SupportConceptOid;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach(var item in dcsToChange)
|
|
{
|
|
pGroupDC.ServiceRecordList.Remove(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult SelectSupportConcept(FormCollection formCollection)
|
|
{
|
|
try
|
|
{
|
|
if (Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
long? cb2ScOid = Convert.ToInt64(formCollection[FormCollectionConstants.CostBearer2SupportConceptOidKey]);
|
|
Log.Info($"SelectSupportConcept: {cb2ScOid}");
|
|
|
|
LoadServiceCategoriesToModel(cb2ScOid);
|
|
|
|
LoadRecordsToModel();
|
|
|
|
LoadGoalRatings();
|
|
|
|
// ToDo: Hier LoadGoals aufrufen!
|
|
LoadGoals();
|
|
|
|
return ResetEditingMode();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error($"ERROR SelectSupportConcept: {e.Message}\n{e.StackTrace}");
|
|
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private void LoadServiceCategoriesToModel(long? cb2ScOid)
|
|
{
|
|
if (cb2ScOid is null)
|
|
{
|
|
Log.Info("cb2ScOid is null !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
|
|
}
|
|
|
|
if (cb2ScOid is null && Model.IsInGroupBookingMode)
|
|
{
|
|
Model.ServiceCategories = CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
|
|
return;
|
|
}
|
|
|
|
Model.CostBearer2SupportConceptOid = cb2ScOid;
|
|
Model.SelectedSupportConcept =
|
|
Model.SupportConcepts.FirstOrDefault(
|
|
f =>
|
|
f.CostBearerRelations.Any(
|
|
a =>
|
|
a.CostBearer2SupportConceptOid.HasValue &&
|
|
a.CostBearer2SupportConceptOid.Value.Equals(Model.CostBearer2SupportConceptOid)));
|
|
|
|
if(Model.SelectedSupportConcept != null)
|
|
{
|
|
Model.SelectedSupportConceptListObject = Model.SupportConceptListObjects.First(f => long.Parse(f.CostBearer2SupportConceptOid) == cb2ScOid);
|
|
|
|
var details = OperationsService.GetSupportConceptTreeNodeDetailInfo(Model.SelectedSupportConcept.Customer.CustomerOid, Model.SelectedSupportConcept.SupportConceptOid, Model.CostBearer2SupportConceptOid);
|
|
|
|
Model.ServiceCategories = details.ServiceAccountings.Count > 0
|
|
? CreateServiceCategoryModels(details.ServiceAccountings.Select(sa => sa.ServiceDescription).ToList())
|
|
: CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
|
|
Model.ServiceCategories = Model.ServiceCategories.Where(c => !c.OhneHilfeplan.HasValue || c.OhneHilfeplan.Value == AccountingvisibilityType.Beides || c.OhneHilfeplan.Value == AccountingvisibilityType.NurKlientenbezogen).ToList();
|
|
}
|
|
else if(cb2ScOid == -2)
|
|
{
|
|
Model.SelectedSupportConceptListObject = Model.SupportConceptListObjects.First(f => f.CostBearer2SupportConceptOid.Equals(cb2ScOid.ToString()));
|
|
Model.ServiceCategories = CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
Model.ServiceCategories = Model.ServiceCategories.Where(c => !c.OhneHilfeplan.HasValue || c.OhneHilfeplan.Value == AccountingvisibilityType.Beides || c.OhneHilfeplan.Value == AccountingvisibilityType.NichtKlientenbezogen).ToList();
|
|
}
|
|
else if(cb2ScOid == -1)
|
|
{
|
|
Model.SelectedSupportConceptListObject = Model.SupportConceptListObjects.First(f => f.CostBearer2SupportConceptOid.Equals(cb2ScOid.ToString()));
|
|
Model.ServiceCategories.Clear();
|
|
}
|
|
else
|
|
{
|
|
Log.Info("Model.SelectedSupportConcept is null !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
|
|
|
|
}
|
|
|
|
if (Model.SelectedSupportConceptListObject is null ||
|
|
Model.SelectedSupportConceptListObject.CostBearer2SupportConceptOid == "-1")
|
|
{
|
|
Log.Info($"LoadServiceCategoriesToModel() Model.SelectedSupportConceptListObject is null {Model.SelectedSupportConceptListObject is null}, Model.SelectedSupportConceptListObject.CostBearer2SupportConceptOid == {Model.SelectedSupportConceptListObject?.CostBearer2SupportConceptOid}");
|
|
}
|
|
|
|
if (Model.ServiceCategories != null)
|
|
{
|
|
Model.ServiceCategories = Model.ServiceCategories.OrderBy(serviceCategory => serviceCategory.Position).ToList();
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult DeleteServiceRecord(FormCollection formCollection)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
Model.ServiceRecordOidToDelete = long.Parse(formCollection[FormCollectionConstants.ServiceRecordOidHolderKey]);
|
|
|
|
if (Model.ServiceRecordOidToDelete != null && Model.ServiceRecordOidToDelete > 0 && MobileSessionFacade.LoggedInUser.UserGroups.Any(a => a.Rights.Any(f => f.RightType.Equals(UserRightType.ServiceRecordView_Delete))))
|
|
{
|
|
var serviceRecordDC = Model.ServiceRecords.FirstOrDefault(f => f.ServiceRecordOid != null && f.ServiceRecordOid.Value.Equals(Model.ServiceRecordOidToDelete));
|
|
var version = serviceRecordDC?.ServiceRecordVersion;
|
|
|
|
if (version != null && MainModel.IsAllowedToDeleteServiceRecord(serviceRecordDC))
|
|
{
|
|
OperationsService.DeleteServiceRecord(Model.ServiceRecordOidToDelete.Value, version.Value);
|
|
|
|
Model.ServiceRecords = Model.ServiceRecords.Where(sr => sr.ServiceRecordOid != null && !sr.ServiceRecordOid.Value.Equals(serviceRecordDC.ServiceRecordOid)).ToList();
|
|
}
|
|
}
|
|
|
|
ResetEditingMode();
|
|
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
[Authorize]
|
|
public string UpdateGoals(string pGoalOids)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var sc = Model.SelectedSupportConcept;
|
|
if (sc is null)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
if(string.IsNullOrEmpty(pGoalOids))
|
|
{
|
|
Model.SelectedGoals.Clear();
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var splitOids = pGoalOids.Trim(';').Split(';');
|
|
var selectedGoalOids = splitOids.Select(long.Parse).ToList();
|
|
|
|
var goals = sc.Goals.Where(w => w.ValueListEntryOid.HasValue && selectedGoalOids.Contains(w.ValueListEntryOid.Value)).ToList();
|
|
|
|
// ToDo: Hier liegt der Bug!
|
|
// ToDo: vorhandene Bewertungen beachten!
|
|
var stillSelectedGoals = Model.SelectedGoals.Where(s => goals.Any(a => a.ValueListEntryOid.HasValue && a.ValueListEntryOid.Value == s.ValueListEntryOid)).ToList();
|
|
|
|
Model.SelectedGoals = stillSelectedGoals;
|
|
Model.SelectedGoals.AddRangeIfElementsNotIn(goals);
|
|
|
|
//Model.SelectedGoals = goals;
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[Authorize]
|
|
public string SetServiceDescription(long pServiceDescriptionOid)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
Model.SelectedServiceDescriptionOid = pServiceDescriptionOid;
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult LoadServiceRecords(FormCollection formCollection)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var zeitraum = int.Parse(formCollection[FormCollectionConstants.RecordsKey]);
|
|
if (zeitraum < 0)
|
|
{
|
|
zeitraum = 7;
|
|
}
|
|
|
|
Model.Zeitraum = zeitraum;
|
|
|
|
LoadRecordsToModel();
|
|
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
private void LoadRecordsToModel()
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return;
|
|
}
|
|
|
|
Model.ServiceRecords = new List<ServiceRecordDC>();
|
|
|
|
if (Model.Zeitraum < 0 || Model.CostBearer2SupportConceptOid.HasValue && Model.CostBearer2SupportConceptOid.Value == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var records = OperationsService.FindServiceRecordsForLastDays(Model.CostBearer2SupportConceptOid < 1 ? null : Model.CostBearer2SupportConceptOid, Model.Zeitraum, Model.Employee.EmployeeOid);
|
|
var recordsOhneDuplikate = new List<ServiceRecordDC>();
|
|
|
|
foreach(var r in records.Where(r => !recordsOhneDuplikate.Any(a => a.GroupOid.HasValue && a.GroupOid.Value.Equals(r.GroupOid))))
|
|
{
|
|
recordsOhneDuplikate.Add(r);
|
|
}
|
|
|
|
Model.ServiceRecords = recordsOhneDuplikate.Where(serviceRecord => serviceRecord.Start.HasValue && serviceRecord.End.HasValue)
|
|
.OrderBy(serviceRecord => serviceRecord.Start.Value.Date)
|
|
.ThenBy(serviceRecord => serviceRecord.Start.Value.Hour)
|
|
.ThenBy(serviceRecord => serviceRecord.Start.Value.Minute)
|
|
.ThenBy(serviceRecord => serviceRecord.End.Value.Date)
|
|
.ThenBy(serviceRecord => serviceRecord.End.Value.Hour)
|
|
.ThenBy(serviceRecord => serviceRecord.End.Value.Minute)
|
|
.ThenByDescending(serviceRecord => serviceRecord.InsertedOn.Value).ToList();
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult SelectRecordToEdit(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var oidString = formCollection[FormCollectionConstants.ServiceRecordOidHolder2Key];
|
|
|
|
var wasSuccessful = long.TryParse(oidString, out var serviceRecordOid);
|
|
|
|
if (!wasSuccessful)
|
|
{
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
Model.SelectedServiceRecordOid = serviceRecordOid;
|
|
|
|
var selectedServiceRecord = Model.GetServiceRecord(serviceRecordOid);
|
|
|
|
if(selectedServiceRecord is null)
|
|
{
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
Model.SelectedServiceRecord = selectedServiceRecord;
|
|
Model.SelectedGoals = selectedServiceRecord.Goals;
|
|
|
|
Model.SelectedServiceDescriptionOid = selectedServiceRecord.ServiceDescription.ServiceDescriptionOid;
|
|
Model.SelectedServiceCategoryOid = selectedServiceRecord.ServiceDescription.Category.ServiceCategoryOid;
|
|
|
|
Model.PreviouslySelectedEmployee = Model.SelectedEmployee;
|
|
Model.SelectedEmployee = selectedServiceRecord.Employee;
|
|
|
|
Model.IsInEditingMode = true;
|
|
|
|
Model.PreviouslySelectedSupportConcept = Model.SelectedSupportConcept;
|
|
|
|
if (selectedServiceRecord.GroupOid.HasValue)
|
|
{
|
|
Model.IsInGroupBookingMode = true;
|
|
|
|
Model.SelectedSupportConcept = null;
|
|
Model.SelectedEmployee = null;
|
|
|
|
Model.ServiceCategories = CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
|
|
var group = OperationsService.GetServiceRecordGroup(selectedServiceRecord.GroupOid.Value);
|
|
|
|
var employees = group.ServiceRecordList.Select(serviceRecord => serviceRecord.Employee).Distinct().ToList();
|
|
|
|
Model.SelectedEmployees = employees;
|
|
var cb2ScOids = group.ServiceRecordList.Where(w => w.CostBearer2SupportConceptOid.HasValue).Select(s => s.CostBearer2SupportConceptOid.Value).ToList();
|
|
|
|
Model.SelectedConceptCostBearerRelations.AddRangeIfElementsNotIn(OperationsService.GetSupportConceptCostBearerRelDCsByOids(cb2ScOids));
|
|
|
|
var selectedSupportConcepts = new List<SupportConceptDC>();
|
|
selectedSupportConcepts.AddRangeIfElementsNotIn(OperationsService.GetSupportConceptsById(group.ServiceRecordList.Select(s => s.SupportConcept.SupportConceptOid)));
|
|
|
|
Model.SelectedSupportConcepts = selectedSupportConcepts;
|
|
}
|
|
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
[Authorize]
|
|
public string GetSelectedRecordInformation()
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var result = _LeerzeichenFuerGetMethoden;
|
|
|
|
if (Model.SelectedServiceRecordOid.HasValue)
|
|
{
|
|
result = SerializeObject(Model.ServiceRecords.First(f => f.ServiceRecordOid == Model.SelectedServiceRecordOid));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[Authorize]
|
|
public string GetSelectedRecordInformationWithOid(long oid)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
LoadRecordsToModel();
|
|
|
|
return SerializeObject(Model.ServiceRecords.First(f => f.ServiceRecordOid == oid));
|
|
}
|
|
|
|
[Authorize]
|
|
public string CheckRights(string von, string bis, bool inEditMode, string dateString, string startString, string endString)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
Log.Info($"CheckRights: von:{von};bis:{bis};inEditMode:{inEditMode};dateString:{dateString};startString:{startString};endString:{endString}");
|
|
|
|
var startHoursDt = ConvertTimeStringToDateTime(startString);
|
|
var endHoursDt = ConvertTimeStringToDateTime(endString);
|
|
|
|
if(!DateTime.TryParse(von, out var startDate))
|
|
{
|
|
startDate = DateTime.Now.Date;
|
|
}
|
|
|
|
if(!DateTime.TryParse(bis, out var endDate))
|
|
{
|
|
endDate = DateTime.Now.Date;
|
|
}
|
|
|
|
var startDt = startDate.AddHours(startHoursDt.Hour).AddMinutes(startHoursDt.Minute);
|
|
var endDt = endDate.AddHours(endHoursDt.Hour).AddMinutes(endHoursDt.Minute);
|
|
|
|
if (startDt > endDt)
|
|
{
|
|
return "StartGreaterEnd";
|
|
}
|
|
var dauer = (int)(endDt - startDt).TotalMinutes;
|
|
|
|
if (dauer == 0)
|
|
{
|
|
startDt = startDt.AddSeconds(1);
|
|
endDt = endDt.AddSeconds(1);
|
|
}
|
|
|
|
var checkServiceRecord = new ServiceRecordDC();
|
|
if (inEditMode)
|
|
{
|
|
checkServiceRecord = Model.ServiceRecords.FirstOrDefault(f => f.ServiceRecordOid.HasValue && f.ServiceRecordOid.Value.Equals(Model.SelectedServiceRecordOid));
|
|
}
|
|
|
|
if (checkServiceRecord is null)
|
|
{
|
|
checkServiceRecord = new ServiceRecordDC();
|
|
}
|
|
|
|
checkServiceRecord.Goals = Model.SelectedGoals;
|
|
|
|
checkServiceRecord.Start = startDt;
|
|
checkServiceRecord.End = endDt;
|
|
|
|
checkServiceRecord.IP = Request.UserHostAddress;
|
|
|
|
checkServiceRecord.ServiceDescription = OperationsService.GetServiceDescription(Model.SelectedServiceDescriptionOid.Value);
|
|
|
|
checkServiceRecord.Employee = Model.SelectedEmployee ?? MobileSessionFacade.LoggedInCompactEmployee;
|
|
|
|
if (Model.SelectedEmployee != null && !Model.IsInGroupBookingMode)
|
|
{
|
|
var sc = Model.SupportConcepts.FirstOrDefault(fod => fod.CostBearerRelations.Any(a => a.CostBearer2SupportConceptOid.HasValue && a.CostBearer2SupportConceptOid.Value.Equals(Model.CostBearer2SupportConceptOid)));
|
|
|
|
if (sc != null)
|
|
{
|
|
if (sc.SupportConceptOid != null)
|
|
{
|
|
checkServiceRecord.SupportConcept = CustomerService.LoadCompactSupportConceptDC(sc.SupportConceptOid.Value, Model.Employee.EmployeeOid);
|
|
}
|
|
|
|
checkServiceRecord.Customer = sc.Customer;
|
|
var cb2ScRel = sc.CostBearerRelations.First(f => f.CostBearer2SupportConceptOid.HasValue && f.CostBearer2SupportConceptOid.Equals(Model.CostBearer2SupportConceptOid));
|
|
checkServiceRecord.CostBearer = cb2ScRel.CostBearer;
|
|
var intervall = checkServiceRecord.CostBearer.ActualMinuteIntervall;
|
|
|
|
if (intervall > 0)
|
|
{
|
|
checkServiceRecord.RoundedDuration = dauer % intervall != 0 ? dauer + (intervall - dauer % intervall) : dauer;
|
|
}
|
|
|
|
checkServiceRecord.CostBearer2SupportConceptOid = Model.CostBearer2SupportConceptOid;
|
|
}
|
|
}
|
|
|
|
var mandator = GetMandator();
|
|
|
|
var maxDaysEditSRsAllowedString = GetSettingValue(mandator.Settings, SettingsKeys.MaxDaysEditServiceRecordsAllowed);
|
|
var limitFuerZeiterfassungString = GetSettingValue(mandator.Settings, SettingsKeys.AnzTageZeiterfassErfolgt);
|
|
|
|
if (!int.TryParse(maxDaysEditSRsAllowedString, out var maxDaysEditSRsAllowed))
|
|
{
|
|
maxDaysEditSRsAllowed = 0;
|
|
}
|
|
|
|
if(!int.TryParse(limitFuerZeiterfassungString, out var limitFuerZeiterfassung))
|
|
{
|
|
limitFuerZeiterfassung = 0;
|
|
}
|
|
|
|
if (MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowEditAfterMaxDaysInNextMonth))
|
|
{
|
|
maxDaysEditSRsAllowed = -1;
|
|
}
|
|
|
|
SupportConceptStatisticsDC stats = null;
|
|
|
|
if (Model.CostBearer2SupportConceptOid != null && Model.CostBearer2SupportConceptOid > 0)
|
|
{
|
|
stats = OperationsService.CreateSupportConceptStatistics(Model.CostBearer2SupportConceptOid.Value, DateTime.Now);
|
|
}
|
|
|
|
var employees = new List<long> {checkServiceRecord.Employee.EmployeeOid};
|
|
|
|
var validationResults = new List<ServiceRecord2Validation>();
|
|
|
|
checkServiceRecord.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
|
|
checkServiceRecord.DurationInStunden = ZeiterfassungsDauer.Minuten;
|
|
|
|
string dateRangeString = null;
|
|
|
|
if(Model.IsInGroupBookingMode)
|
|
{
|
|
if (checkServiceRecord.GroupOid.HasValue)
|
|
{
|
|
var serviceRecordGroup = OperationsService.GetServiceRecordGroup(checkServiceRecord.GroupOid.Value);
|
|
|
|
serviceRecordGroup.ServiceRecordList.DoForEach(sr => employees.AddIfNotIn(sr.Employee.EmployeeOid));
|
|
}
|
|
else
|
|
{
|
|
Model.SelectedEmployees.DoForEach(e => employees.AddIfNotIn(e.EmployeeOid));
|
|
}
|
|
|
|
var cb2ScOids = Model.SelectedConceptCostBearerRelations.Where(w => w.CostBearer2SupportConceptOid.HasValue).Select(s => s.CostBearer2SupportConceptOid.Value).ToList();
|
|
|
|
var relations = CustomerService.GetSupportConceptCostBearerRelationsById(cb2ScOids);
|
|
|
|
foreach (var rel in relations)
|
|
{
|
|
var sr = CloneServiceRecordForGroupBooking(checkServiceRecord);
|
|
|
|
sr.SupportConcept = rel.SupportConcept;
|
|
sr.CostBearer = rel.CostBearer;
|
|
sr.CostBearer2SupportConceptOid = rel.CostBearer2SupportConceptOid;
|
|
|
|
|
|
var result = OperationsService.ValidateServiceRecord(sr, null, maxDaysEditSRsAllowed, employees, cb2ScOids);
|
|
dateRangeString = rel.DateRangeString;
|
|
|
|
validationResults.Add(new ServiceRecord2Validation(sr, result, dateRangeString));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Model.SelectedSupportConcept != null)
|
|
{
|
|
var node = CreateFlatSupportConceptItem(CustomerService.LoadCompactSupportConceptDC(Model.SelectedSupportConcept.SupportConceptOid.Value, Model.SelectedEmployee.EmployeeOid), null);
|
|
dateRangeString = node?.SupportConceptTreeNodeDC != null ? node.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.DateRangeString : "";
|
|
}
|
|
|
|
var result = OperationsService.ValidateServiceRecordEntry(checkServiceRecord, stats, maxDaysEditSRsAllowed, checkServiceRecord.GroupOid.HasValue, employees);
|
|
validationResults.Add(new ServiceRecord2Validation(checkServiceRecord, result, dateRangeString ?? ""));
|
|
}
|
|
|
|
var allowOverlappingFLS = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreateOverlappingFLS);
|
|
var allowOverlappingFLSForEmployee = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreateOverlappingFLSForEmployee);
|
|
var allowMoreFLSThanApproved = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreateMoreFLSThanApproved);
|
|
var bookAfterSettlementInvoice = MobileSessionFacade.CheckForUserRight(UserRightType.BookServiceRecordAfterSettlementInvoice);
|
|
var bookServiceRecordOutOfSupportConcept = MobileSessionFacade.CheckForUserRight(UserRightType.BookServiceRecordOutOfSupportConcept);
|
|
var allowCreateAfterEmployeeSignature = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowCreateAfterEmployeeSignature);
|
|
var allowEditAfterEmployeeSignature = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowEditAfterEmployeeSignature);
|
|
|
|
var allowCreateAll = MobileSessionFacade.CheckForUserRight(UserRightType.CreateAll);
|
|
var allowEditAll = MobileSessionFacade.CheckForUserRight(UserRightType.CreateAll);
|
|
|
|
var newResult = new ValidationResult();
|
|
var exitLoop = false;
|
|
|
|
if(Model.SelectedSupportConcept != null && Model.SelectedSupportConcept.Goals.Any() && Model.SelectedGoals.Count == 0)
|
|
{
|
|
newResult.Message += "Es wurden keine Ziele zugeordnet.<br/><br/>";
|
|
newResult.KannTrotzdemGespeichertWerden = true;
|
|
exitLoop = false;
|
|
}
|
|
|
|
foreach (var sr2V in validationResults)
|
|
{
|
|
if(exitLoop)
|
|
{
|
|
break;
|
|
}
|
|
|
|
foreach (var vr in sr2V.ValidationResults)
|
|
{
|
|
if (exitLoop)
|
|
{
|
|
break;
|
|
}
|
|
|
|
switch(vr.ResultType)
|
|
{
|
|
case ServiceRecordOverlapping:
|
|
newResult.Message += "An dem gewählten Datum '" + von + "' existiert bereits ein Eintrag (" + vr.Message + " bei Klient/in " + vr.CustomerName + ").<br /><br />";
|
|
newResult.KannTrotzdemGespeichertWerden = allowOverlappingFLS;
|
|
|
|
exitLoop = !allowOverlappingFLS;
|
|
|
|
break;
|
|
case EmployeeOverlapping:
|
|
newResult.Message += "An dem gewählten Datum " + von + " existiert bereits ein Eintrag von " + vr.EmployeeName + " (" + vr.Message + ").<br /><br />";
|
|
newResult.KannTrotzdemGespeichertWerden = allowOverlappingFLSForEmployee;
|
|
exitLoop = !allowOverlappingFLSForEmployee;
|
|
|
|
|
|
break;
|
|
case OutsideOfSupportConcept:
|
|
newResult.Message += "Das gewählte Datum " + von.Substring(0, 10) + " liegt außerhalb des Zeitraumes des gewählten Hilfeplans (" + sr2V.HilfePlanZeitraum + ").<br /><br />";
|
|
newResult.KannTrotzdemGespeichertWerden = bookServiceRecordOutOfSupportConcept;
|
|
|
|
exitLoop = !bookServiceRecordOutOfSupportConcept;
|
|
|
|
break;
|
|
case ApprovedFLSOverspending:
|
|
var klient = "diesen Hilfeplan";
|
|
if (!string.IsNullOrEmpty(vr.CustomerName))
|
|
{
|
|
klient = "Klient/in " + vr.CustomerName;
|
|
}
|
|
|
|
var msg = "Die für " + klient + " genehmigten FLS (" + vr.ApprovedHours + ") werden mit diesem Eintrag überschritten. (" + vr.HoursNew + ").";
|
|
|
|
newResult.Message += msg + "<br /><br />";
|
|
newResult.KannTrotzdemGespeichertWerden = allowMoreFLSThanApproved;
|
|
|
|
exitLoop = !allowMoreFLSThanApproved;
|
|
|
|
break;
|
|
case OutOfEditLimit:
|
|
newResult.Message += "Sie können keine neuen Leistungen für den " + von + " dokumentieren, da bereits der " + maxDaysEditSRsAllowed + ". des nachfolgenden Monats überschritten ist.<br /><br />";
|
|
exitLoop = true;
|
|
newResult.KannTrotzdemGespeichertWerden = false;
|
|
|
|
break;
|
|
case Error:
|
|
newResult.Message += "Beim Speichern ist ein Fehler aufgetreten.<br /><br />";
|
|
exitLoop = true;
|
|
newResult.KannTrotzdemGespeichertWerden = false;
|
|
|
|
break;
|
|
case SettlementInvoiceAlreadyExisting:
|
|
var klient2 = "diesen Hilfeplan";
|
|
if(!string.IsNullOrEmpty(vr.CustomerName))
|
|
{
|
|
klient2 = "Klient/in " + vr.CustomerName;
|
|
}
|
|
|
|
newResult.KannTrotzdemGespeichertWerden = bookAfterSettlementInvoice;
|
|
exitLoop = !bookAfterSettlementInvoice;
|
|
|
|
if (bookAfterSettlementInvoice)
|
|
{
|
|
newResult.Message += "Es existiert bereits eine Spitzabrechnung für " + klient2 + ". Um diesen Eintrag zu berücksichtigen, muss eventuell eine neue Spitzabrechnung erstellt werden.<br /><br />";
|
|
}
|
|
else
|
|
{
|
|
newResult.Message += "Sie können den Eintrag nicht bearbeiten, da bereits eine Spitzabrechnung für " + klient2 + "<br /><br />";
|
|
}
|
|
|
|
break;
|
|
case FristAbgelaufen:
|
|
var intervall = "einem Tag";
|
|
if (limitFuerZeiterfassung != 1)
|
|
{
|
|
intervall = "" + limitFuerZeiterfassung + " Tagen";
|
|
}
|
|
|
|
newResult.Message += "Sie können keine neuen Leistungen für den " + von + " dokumentieren, da die Zeiterfassung innerhalb von " + intervall + " erfolgen muss.<br /><br />";
|
|
exitLoop = true;
|
|
newResult.KannTrotzdemGespeichertWerden = false;
|
|
|
|
break;
|
|
case Custom:
|
|
newResult.Message += vr.Message + "<br /><br />";
|
|
|
|
exitLoop = true;
|
|
newResult.KannTrotzdemGespeichertWerden = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var signatureValidationResult = OperationsService.CheckForExistingSignature(checkServiceRecord);
|
|
if(signatureValidationResult != null && newResult.KannTrotzdemGespeichertWerden)
|
|
{
|
|
newResult.Message += $"<br />{signatureValidationResult.Message}<br /><br />";
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(newResult.Message))
|
|
{
|
|
newResult.Message += newResult.KannTrotzdemGespeichertWerden ? "<br />Möchten Sie trotzdem speichern?<br /><br />" : "<br />Speichern nicht möglich.<br /><br />";
|
|
}
|
|
|
|
Model.NewServiceRecord = new ServiceRecordDC();
|
|
|
|
return SerializeObject(newResult);
|
|
}
|
|
|
|
[Authorize]
|
|
public string ValidateServiceRecordDeletion(string serviceRecordOidString)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var isSuccessful = long.TryParse(serviceRecordOidString, out var serviceRecordOid);
|
|
|
|
if(!isSuccessful)
|
|
{
|
|
return "Error";
|
|
}
|
|
|
|
var newResult = new ValidationResult();
|
|
|
|
var serviceRecord = Model.GetServiceRecord(serviceRecordOid);
|
|
|
|
if(serviceRecord is null)
|
|
{
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var allowDeleteAfterEmployeeSignature = MobileSessionFacade.CheckForUserRight(UserRightType.ServiceRecord_AllowDeleteAfterEmployeeSignature);
|
|
|
|
var allowDeleteAll = MobileSessionFacade.CheckForUserRight(UserRightType.CreateAll);
|
|
|
|
var validationResultList = OperationsService.ValidateServiceRecordDeletion(serviceRecord, Model.Employee.EmployeeOid.Value);
|
|
|
|
if(validationResultList.Count > 0)
|
|
{
|
|
foreach(var result in validationResultList)
|
|
{
|
|
switch(result.ResultType)
|
|
{
|
|
case Custom:
|
|
newResult.KannTrotzdemGespeichertWerden = true;
|
|
newResult.Message += "Dieser Eintrag wurde bereits unterschrieben.<br/>Möchten Sie ihn trotzdem löschen?<br/><br/>";
|
|
break;
|
|
}
|
|
}
|
|
|
|
return SerializeObject(newResult);
|
|
}
|
|
|
|
return serviceRecord.GroupOid != null
|
|
? SerializeObject(new ValidationResult{KannTrotzdemGespeichertWerden = true, Message = "ACHTUNG, wenn Sie fortfahren, löschen Sie die gesamte Gruppenbuchung.<br/>Wenn Sie nur einzelne Klienten aus der Gruppe entfernen möchten, editieren Sie die Gruppe und entfernen den Klienten aus der Liste der Hilfepläne.<br/>Sind Sie sicher, dass Sie den gesamten Gruppeneintrag löschen möchten?<br/><br/>" })
|
|
: SerializeObject(new ValidationResult {KannTrotzdemGespeichertWerden = true, Message = null});
|
|
}
|
|
|
|
[Authorize]
|
|
public string SetServiceRecordEmployee(long employeeOid)
|
|
{
|
|
try
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
Model.SelectedEmployee = MainModel.AllEmployees.First(f => f.EmployeeOid.Equals(employeeOid));
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Info("Error in SetServiceRecordEmployee:");
|
|
Log.Error(e.Message, e);
|
|
|
|
if (MainModel.AllEmployees is null)
|
|
{
|
|
Log.Info("Weitere Infos: AllEmployees = null!");
|
|
}
|
|
else
|
|
{
|
|
Log.Info($"Weitere Infos: AllEmployees enthält {MainModel.AllEmployees.Count} Elemente: ");
|
|
var stringBuilder = new StringBuilder();
|
|
foreach (var ce in MainModel.AllEmployees)
|
|
{
|
|
if (stringBuilder.Length > 0)
|
|
{
|
|
stringBuilder.Append(",");
|
|
}
|
|
|
|
stringBuilder.Append(ce.EmployeeOid);
|
|
|
|
}
|
|
|
|
Log.Info(stringBuilder.ToString());
|
|
}
|
|
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string CheckToken(string token)
|
|
{
|
|
if(token != null && token.Equals("abcd"))
|
|
{
|
|
return SerializeObject("localhost;demo");
|
|
}
|
|
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
// Menünavigation
|
|
[Authorize]
|
|
public ActionResult RedirectToScheduler()
|
|
{
|
|
return RedirectToActionPermanent("Scheduler", "Scheduler");
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult RedirectToCustomer()
|
|
{
|
|
if(Model?.SelectedSupportConcept?.Customer?.Oid.HasValue ?? false)
|
|
{
|
|
return RedirectToActionPermanent("PreselectCustomer", "Customer", new {Model.SelectedSupportConcept.Customer.CustomerOid});
|
|
}
|
|
|
|
if(Model?.SelectedSupportConcept is null && (CustomerModel)Session[ModelSessionConstants.CustomerModelKey] != null)
|
|
{
|
|
var customerModel = (CustomerModel) Session[ModelSessionConstants.CustomerModelKey];
|
|
customerModel.SelectedCustomerOid = null;
|
|
customerModel.SelectedCustomer = null;
|
|
}
|
|
|
|
return RedirectToActionPermanent("Customer", "Customer");
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult RedirectToReportView()
|
|
{
|
|
return AbstractModel.IsAllowedToSeeBills ? RedirectToActionPermanent("InitReports", "Report") : RedirectToMain();
|
|
}
|
|
|
|
public ActionResult RedirectToMain()
|
|
{
|
|
return RedirectToActionPermanent("Main", "Main");
|
|
}
|
|
|
|
[Authorize]
|
|
public ActionResult RedirectToDevExpressScheduler()
|
|
{
|
|
#if DEBUG
|
|
return RedirectToActionPermanent("DevExpressScheduler", "DevExpressScheduler");
|
|
#endif
|
|
|
|
return RedirectToMain();
|
|
}
|
|
|
|
// Gruppenbuchungen
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult SetGroupBookingMode(FormCollection pFormCollection)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var isInGroupBookingMode = "true,false" == pFormCollection[FormCollectionConstants.IsInGroupBookingModeKey];
|
|
|
|
ResetGroupBookingMode(isInGroupBookingMode);
|
|
|
|
return RedirectToAction("Main");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setzt die getroffenen Auswahlen zurück
|
|
/// </summary>
|
|
/// <param name="pIsInGroupBookingMode">
|
|
/// Wenn true, wird davon ausgegangen, dass man von der Einzelbuchung in eine Gruppenbuchung wechselt und es wird sich der vorher ausgewählte Mitarbeiter und Hilfeplan gemerkt.
|
|
/// Bei false wird davon ausgegangen, dass man von der Gruppenbuchung in eine Einzelbuchung wechselt und der vorher ausgewählte Mitarbeiter und Hilfeplan wird automatisch ausgewählt.</param>
|
|
private void ResetGroupBookingMode(bool pIsInGroupBookingMode)
|
|
{
|
|
if (Model is null)
|
|
{
|
|
Logout();
|
|
return;
|
|
}
|
|
|
|
Model.IsInGroupBookingMode = pIsInGroupBookingMode;
|
|
|
|
if (pIsInGroupBookingMode)
|
|
{
|
|
Model.PreviouslySelectedEmployee = Model.SelectedEmployee;
|
|
Model.PreviouslySelectedSupportConcept = Model.SelectedSupportConcept;
|
|
|
|
Model.SelectedSupportConcept = null;
|
|
Model.SelectedEmployee = null;
|
|
|
|
Model.ServiceCategories = CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
|
|
Model.SelectedEmployees.AddIfNotIn(MobileSessionFacade.LoggedInCompactEmployee);
|
|
|
|
Model.IsInEditingMode = false;
|
|
Model.SelectedServiceRecord = null;
|
|
}
|
|
else
|
|
{
|
|
Model.SelectedEmployee = Model.PreviouslySelectedEmployee;
|
|
Model.SelectedSupportConcept = Model.PreviouslySelectedSupportConcept;
|
|
|
|
Model.ServiceCategories.Clear();
|
|
Model.SelectedCostbearerRelOids.Clear();
|
|
Model.SelectedEmployees.Clear();
|
|
Model.SelectedSupportConcepts.Clear();
|
|
Model.SelectedConceptCostBearerRelations.Clear();
|
|
|
|
Model.SelectedEmployee = MobileSessionFacade.LoggedInCompactEmployee;
|
|
|
|
if (Model.SelectedSupportConcept != null)
|
|
{
|
|
var details = OperationsService.GetSupportConceptTreeNodeDetailInfo(Model.SelectedSupportConcept.Customer.CustomerOid, Model.SelectedSupportConcept.SupportConceptOid, Model.CostBearer2SupportConceptOid);
|
|
|
|
Model.ServiceCategories = details.ServiceAccountings.Count > 0
|
|
? CreateServiceCategoryModels(details.ServiceAccountings.Select(sa => sa.ServiceDescription).ToList())
|
|
: CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
|
|
Model.ServiceCategories = Model.ServiceCategories.Where(c => !c.OhneHilfeplan.HasValue || c.OhneHilfeplan.Value == AccountingvisibilityType.Beides || c.OhneHilfeplan.Value == AccountingvisibilityType.NurKlientenbezogen).ToList();
|
|
}
|
|
else if (Model.CostBearer2SupportConceptOid == -2)
|
|
{
|
|
Model.ServiceCategories = CreateServiceCategoryModels(OperationsService.GetAllServiceDescriptions());
|
|
Model.ServiceCategories = Model.ServiceCategories.Where(c => !c.OhneHilfeplan.HasValue || c.OhneHilfeplan.Value == AccountingvisibilityType.Beides || c.OhneHilfeplan.Value == AccountingvisibilityType.NichtKlientenbezogen).ToList();
|
|
}
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult ResetEditingMode()
|
|
{
|
|
if (Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
Model.NewServiceRecord = new ServiceRecordDC();
|
|
Model.SelectedServiceRecord = null;
|
|
Model.IsInEditingMode = false;
|
|
Model.SelectedSupportConcepts.Clear();
|
|
Model.SelectedConceptCostBearerRelations.Clear();
|
|
Model.SelectedCostbearerRelOids.Clear();
|
|
Model.SelectedGroupOfPeopleOids.Clear();
|
|
Model.SelectedEmployees = new List<CompactEmployeeDC> { MobileSessionFacade.LoggedInCompactEmployee };
|
|
Model.SelectedEmployee = MobileSessionFacade.LoggedInCompactEmployee;
|
|
|
|
LoadServiceCategoriesToModel(Model.CostBearer2SupportConceptOid);
|
|
|
|
var serviceDescriptions = Model.GetServiceDesctiptions();
|
|
|
|
if (Model.ServiceCategories.Any() && serviceDescriptions.Any())
|
|
{
|
|
var firstServiceDescription = serviceDescriptions.First();
|
|
|
|
Model.SelectedServiceDescriptionOid = firstServiceDescription.ServiceDescriptionOid;
|
|
Model.SelectedServiceCategoryOid = firstServiceDescription.Category.ServiceCategoryOid;
|
|
}
|
|
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
[Authorize]
|
|
public string AddSupportConceptCostBearerRelationsToGroupBooking(string pRelOids, string pGroupOids)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var rawRelOids = string.IsNullOrEmpty(pRelOids) ? new string[0] : pRelOids.Split(',');
|
|
var rawGroupOids = string.IsNullOrEmpty(pGroupOids) ? new string[0] : pGroupOids.Split(',');
|
|
|
|
var relOids = new List<long>();
|
|
var groups = new List<GroupOfPeopleDC>();
|
|
|
|
rawRelOids.DoForEach(s => relOids.AddIfNotIn(long.Parse(s)));
|
|
|
|
Model.SelectedGroupOfPeopleOids.Clear();
|
|
|
|
rawGroupOids.DoForEach(s =>
|
|
{
|
|
var group = Model.GroupsOfPeople.FirstOrDefault(f => f.GroupOfPeopleOid.HasValue && f.GroupOfPeopleOid.Value.Equals(long.Parse(s)));
|
|
if(group is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
groups.AddIfNotIn(group);
|
|
group.SupportConceptList.DoForEach(f => relOids.AddRangeIfElementsNotIn(f.CostBearerRelOids));
|
|
});
|
|
|
|
Model.SelectedSupportConcepts.Clear();
|
|
|
|
Model.SelectedCostbearerRelOids.Clear();
|
|
Model.SelectedCostbearerRelOids.AddRangeIfElementsNotIn(relOids);
|
|
|
|
var selectedSupportConcepts = Model.SupportConcepts.Where(w => w != null && w.CostBearerRelations.Any(a => a.CostBearer2SupportConceptOid.HasValue && relOids.Contains(a.CostBearer2SupportConceptOid.Value))).ToList();
|
|
|
|
var groupCostBearerRelations = CustomerService.GetSupportConceptCostBearerRelationsById(relOids);
|
|
|
|
Model.SelectedConceptCostBearerRelations.Clear();
|
|
Model.SelectedConceptCostBearerRelations.AddRangeIfElementsNotIn(groupCostBearerRelations);
|
|
|
|
Model.SelectedSupportConcepts.AddRangeIfElementsNotIn(selectedSupportConcepts);
|
|
|
|
foreach (var gruppe in groups.Where(g => g.GroupOfPeopleOid.HasValue))
|
|
{
|
|
var groupRelOids = new List<long>();
|
|
gruppe.SupportConceptList.ForEach(f => groupRelOids.AddRange(f.CostBearerRelOids));
|
|
|
|
if (!gruppe.GroupOfPeopleOid.HasValue)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var groupOid = gruppe.GroupOfPeopleOid.Value;
|
|
|
|
if (relOids.ContainsItems(groupRelOids))
|
|
{
|
|
Model.SelectedGroupOfPeopleOids.AddIfNotIn(groupOid);
|
|
}
|
|
else if (Model.SelectedGroupOfPeopleOids.Contains(groupOid))
|
|
{
|
|
Model.SelectedGroupOfPeopleOids.Remove(groupOid);
|
|
}
|
|
}
|
|
|
|
return SerializeObject(Model.GroupBookingSelectionObject);
|
|
}
|
|
|
|
[Authorize]
|
|
public string RemoveSupportConceptCostBearerRelationFromGroupBooking(string pRelOid)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
long.TryParse(pRelOid, out var supportConceptCostBearerRelationOid);
|
|
|
|
var supportConcept = Model.SelectedSupportConcepts.FirstOrDefault(f => f.CostBearerRelations.Any(a => a.CostBearer2SupportConceptOid == supportConceptCostBearerRelationOid));
|
|
|
|
var relation = Model.SelectedConceptCostBearerRelations.FirstOrDefault(f => f.CostBearer2SupportConceptOid == supportConceptCostBearerRelationOid);
|
|
|
|
Model.SelectedSupportConcepts.Remove(supportConcept);
|
|
Model.SelectedConceptCostBearerRelations.Remove(relation);
|
|
|
|
var selectedGroups = Model.GroupsOfPeople.Where(group => group.GroupOfPeopleOid.HasValue && Model.SelectedGroupOfPeopleOids.Contains(group.GroupOfPeopleOid.Value)).ToList();
|
|
|
|
var groups = selectedGroups.Where(group => group.SupportConceptList.All(a => Model.SelectedSupportConcepts.Where(w => w.SupportConceptOid.HasValue).Select(s => s.SupportConceptOid.Value).Contains(a.SupportConceptOid)));
|
|
|
|
Model.SelectedGroupOfPeopleOids = groups.Where(group => group.GroupOfPeopleOid.HasValue).Select(group => group.GroupOfPeopleOid.Value).ToList();
|
|
|
|
return SerializeObject(Model.GroupBookingSelectionObject);
|
|
}
|
|
|
|
[Authorize]
|
|
public string AddEmployeesToGroupBooking(string pEmployeeOids)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
if(string.IsNullOrEmpty(pEmployeeOids))
|
|
{
|
|
Model.SelectedEmployees.Clear();
|
|
return JsonConvert.SerializeObject(Model.SelectedEmployees.Count);
|
|
}
|
|
|
|
var rawEmployeeOids = pEmployeeOids.Split(',');
|
|
var oids = new List<long>();
|
|
|
|
rawEmployeeOids.DoForEach(s => oids.AddIfNotIn(long.Parse(s)));
|
|
|
|
var employees = Model.Employees.Where(w => oids.Contains(w.EmployeeOid));
|
|
|
|
Model.SelectedEmployees.Clear();
|
|
Model.SelectedEmployees.AddRangeIfElementsNotIn(employees);
|
|
|
|
return JsonConvert.SerializeObject(Model.SelectedEmployees.Count);
|
|
}
|
|
|
|
[Authorize]
|
|
public string GetSignatureImage(long serviceRecordOid, long signatureOid)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
Logout();
|
|
return _LeerzeichenFuerGetMethoden;
|
|
}
|
|
|
|
var signatureServiceRecord = Model.GetServiceRecord(serviceRecordOid);
|
|
var signatureServiceRecordHeader = MainModel.GetServiceRecordTimeHeader(signatureServiceRecord, false);
|
|
|
|
var signatureImage = OperationsService.GetSignature(signatureOid).DataBild;
|
|
|
|
return signatureServiceRecordHeader + ";" + ApplyWatermark(signatureImage, Server.MapPath("../Content/images/bewoplaner_logo_big.png"));
|
|
}
|
|
|
|
[HttpPost]
|
|
public ActionResult LogOutAfterSessionTimeout()
|
|
{
|
|
Logout();
|
|
|
|
return RedirectToActionPermanent("Index", "Login", new { isSessionTimedOut = true});
|
|
}
|
|
|
|
[HttpPost]
|
|
[Authorize]
|
|
public ActionResult SetSupportConceptFilter(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
var selectedSupportConceptFilter = formCollection[nameof(Model.SelectedSupportConceptFilter)];
|
|
|
|
if(!Enum.TryParse(selectedSupportConceptFilter, out CustomerFilterEnum customerFilter))
|
|
{
|
|
customerFilter = CustomerFilterEnum.MyCustomer;
|
|
}
|
|
|
|
UpdateSettings(SettingsKeys.CustomerFilterInZeiterfassung, customerFilter.ToString());
|
|
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
[Authorize]
|
|
[HttpPost]
|
|
public ActionResult CreateOrUpdateGroupBooking(FormCollection formCollection)
|
|
{
|
|
if(Model is null)
|
|
{
|
|
return Logout();
|
|
}
|
|
|
|
try
|
|
{
|
|
if(!Model.IsInEditingMode)
|
|
{
|
|
if(Model.SelectedConceptCostBearerRelations.Count == 1)
|
|
{
|
|
var cb2ScOids = (from scDc in Model.SelectedSupportConcepts
|
|
where scDc.CostBearerRelations != null && scDc.CostBearerRelations.Count > 0
|
|
let costBearer2SupportConceptOid = scDc.CostBearerRelations[0].CostBearer2SupportConceptOid
|
|
where costBearer2SupportConceptOid != null
|
|
select costBearer2SupportConceptOid.Value).ToList();
|
|
|
|
var cb2ScOidsCount = cb2ScOids.Count;
|
|
|
|
if(cb2ScOidsCount == 1)
|
|
{
|
|
Model.CostBearer2SupportConceptOid = cb2ScOids[0];
|
|
}
|
|
else
|
|
{
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var selectedRecordOid = Model.SelectedServiceRecordOid ?? Model.SelectedServiceRecord.ServiceRecordOid;
|
|
Model.NewServiceRecord = OperationsService.GetServiceRecordById(selectedRecordOid.Value);
|
|
}
|
|
|
|
string doku1;
|
|
|
|
if(Model.Dokutypes != null && Model.Dokutypes.Length > 0)
|
|
{
|
|
doku1 = formCollection[FormCollectionConstants.Dokumentation1Key];
|
|
}
|
|
else
|
|
{
|
|
doku1 = formCollection[FormCollectionConstants.Dokumentation6Key];
|
|
}
|
|
|
|
// Wenn kein Datum angegeben wurde, wird die Main-Seite geladen und abgebrochen
|
|
if(string.IsNullOrEmpty(formCollection[FormCollectionConstants.DateKey]))
|
|
{
|
|
return View("Main", Model);
|
|
}
|
|
|
|
var distanz = formCollection[FormCollectionConstants.DistanceKey];
|
|
var distanceInMeters = 0;
|
|
|
|
if(!string.IsNullOrEmpty(distanz))
|
|
{
|
|
if(int.TryParse(distanz, out var parsedDistance))
|
|
{
|
|
distanceInMeters = parsedDistance;
|
|
}
|
|
}
|
|
|
|
var selectedCostbearer2SupportConceptRelOid = Model.CostBearer2SupportConceptOid < 1 ? null : Model.CostBearer2SupportConceptOid;
|
|
var datum = Convert.ToDateTime(formCollection[FormCollectionConstants.DateKey]);
|
|
|
|
var enddatum = datum;
|
|
|
|
var endDateString = formCollection[FormCollectionConstants.EndDateKey];
|
|
if(endDateString != null)
|
|
{
|
|
enddatum = Convert.ToDateTime(endDateString);
|
|
}
|
|
|
|
var start = formCollection[FormCollectionConstants.StartKey];
|
|
var ende = formCollection[FormCollectionConstants.EndKey];
|
|
var dauer = 0;
|
|
|
|
if(datum > enddatum)
|
|
{
|
|
enddatum = datum;
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(formCollection[FormCollectionConstants.DurationKey]))
|
|
{
|
|
int.TryParse(formCollection[FormCollectionConstants.DurationKey], out dauer);
|
|
}
|
|
|
|
var doku2 = formCollection[FormCollectionConstants.Dokumentation2Key];
|
|
var doku3 = formCollection[FormCollectionConstants.Dokumentation3Key];
|
|
var doku4 = formCollection[FormCollectionConstants.Dokumentation4Key];
|
|
var doku5 = formCollection[FormCollectionConstants.Dokumentation5Key];
|
|
|
|
var zeitenFeld = new DateTime[2];
|
|
|
|
if(start == string.Empty && ende == string.Empty)
|
|
{
|
|
zeitenFeld[0] = new DateTime(datum.Year, datum.Month, datum.Day, 0, 0, 1);
|
|
|
|
if(enddatum == datum)
|
|
{
|
|
zeitenFeld[1] = new DateTime(datum.Year, datum.Month, datum.Day, 0, 0, 1).AddMinutes(dauer);
|
|
}
|
|
else
|
|
{
|
|
zeitenFeld[1] = new DateTime(enddatum.Year, enddatum.Month, enddatum.Day, 0, 0, 1).AddMinutes(dauer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
zeitenFeld = enddatum == datum ? ConvertRecordTimes(start, ende, datum, dauer) : ConvertRecordTimesWithEndDate(start, ende, datum, enddatum, dauer);
|
|
}
|
|
|
|
if(dauer == 0 || zeitenFeld[1] != zeitenFeld[0])
|
|
{
|
|
dauer = (int)(zeitenFeld[1] - zeitenFeld[0]).TotalMinutes;
|
|
}
|
|
|
|
if(Model.NewServiceRecord is null)
|
|
{
|
|
return RedirectToActionPermanent("Main");
|
|
}
|
|
|
|
Model.NewServiceRecord.IP = Request.UserHostAddress;
|
|
|
|
Model.NewServiceRecord.Goals = Model.SelectedGoals;
|
|
Model.NewServiceRecord.Start = zeitenFeld[0];
|
|
Model.NewServiceRecord.End = zeitenFeld[1];
|
|
|
|
Model.NewServiceRecord.DistanceInMeter = distanceInMeters;
|
|
|
|
if(Model.Employee.EmployeeOid != null)
|
|
{
|
|
|
|
if(Model.SelectedEmployee != null)
|
|
{
|
|
Model.NewServiceRecord.Employee = Model.SelectedEmployee;
|
|
}
|
|
|
|
var sc = Model.SupportConcepts.FirstOrDefault(fod => fod.CostBearerRelations.Any(a => a.CostBearer2SupportConceptOid.HasValue && a.CostBearer2SupportConceptOid.Value.Equals(selectedCostbearer2SupportConceptRelOid)));
|
|
|
|
if(sc != null)
|
|
{
|
|
if(sc.SupportConceptOid != null)
|
|
{
|
|
Model.NewServiceRecord.SupportConcept = CustomerService.LoadCompactSupportConceptDC(sc.SupportConceptOid.Value, Model.Employee.EmployeeOid);
|
|
}
|
|
|
|
Model.NewServiceRecord.Customer = sc.Customer;
|
|
|
|
var cb2ScRel = sc.CostBearerRelations.First(f => f.CostBearer2SupportConceptOid.HasValue && f.CostBearer2SupportConceptOid.Equals(selectedCostbearer2SupportConceptRelOid));
|
|
Model.NewServiceRecord.CostBearer = cb2ScRel.CostBearer;
|
|
|
|
var intervall = Model.NewServiceRecord.CostBearer.ActualMinuteIntervall;
|
|
|
|
if(intervall > 0)
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer % intervall != 0 ? dauer + (intervall - dauer % intervall) : dauer;
|
|
}
|
|
else
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
|
|
Model.NewServiceRecord.CostBearer2SupportConceptOid = selectedCostbearer2SupportConceptRelOid;
|
|
}
|
|
else
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
}
|
|
|
|
Model.NewServiceRecord.DurationInStunden = ZeiterfassungsDauer.Minuten;
|
|
|
|
Model.NewServiceRecord.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
|
|
|
|
Model.NewServiceRecord.Notice = string.IsNullOrEmpty(doku1) ? null : doku1;
|
|
|
|
Model.NewServiceRecord.Notice2 = string.IsNullOrEmpty(doku2) ? null : doku2;
|
|
Model.NewServiceRecord.Notice3 = string.IsNullOrEmpty(doku3) ? null : doku3;
|
|
Model.NewServiceRecord.Notice4 = string.IsNullOrEmpty(doku4) ? null : doku4;
|
|
Model.NewServiceRecord.Notice5 = string.IsNullOrEmpty(doku5) ? null : doku5;
|
|
|
|
var serviceDescOid = 0L;
|
|
|
|
if(!string.IsNullOrEmpty(formCollection[FormCollectionConstants.ServiceDescriptionKey]))
|
|
{
|
|
serviceDescOid = Convert.ToInt64(formCollection[FormCollectionConstants.ServiceDescriptionKey]);
|
|
}
|
|
else if(Model.SelectedServiceDescriptionOid.HasValue)
|
|
{
|
|
serviceDescOid = Model.SelectedServiceDescriptionOid.Value;
|
|
}
|
|
|
|
if(serviceDescOid > 0)
|
|
{
|
|
Model.NewServiceRecord.ServiceDescription = OperationsService.GetServiceDescription(serviceDescOid);
|
|
}
|
|
|
|
if(Model.NewServiceRecord.RoundedDuration == 0)
|
|
{
|
|
Model.NewServiceRecord.RoundedDuration = dauer;
|
|
}
|
|
|
|
Model.NewServiceRecord.InsertedOn = DateTime.Now;
|
|
Model.NewServiceRecord.InsUser = $"{MobileSessionFacade.LoggedInEmployee.FirstName} {MobileSessionFacade.LoggedInEmployee.LastName}";
|
|
Model.NewServiceRecord.IsCreatedInMobileClient = true;
|
|
|
|
|
|
if(Model.IsInEditingMode)
|
|
{
|
|
if(Model.SelectedSupportConcepts.Count > 1)
|
|
{
|
|
return UpdateGroupBooking();
|
|
}
|
|
|
|
OperationsService.UpdateServiceRecords(new List<ServiceRecordDC> { Model.NewServiceRecord });
|
|
}
|
|
else
|
|
{
|
|
if(Model.SelectedSupportConcepts.Count > 1)
|
|
{
|
|
return SaveGroupBooking();
|
|
}
|
|
|
|
OperationsService.InsertNewServiceRecords(new List<ServiceRecordDC> { Model.NewServiceRecord });
|
|
}
|
|
|
|
Model.NewServiceRecord = new ServiceRecordDC();
|
|
|
|
if(selectedCostbearer2SupportConceptRelOid.HasValue)
|
|
{
|
|
Model.ServiceRecords = OperationsService.FindServiceRecordsForLastDays(selectedCostbearer2SupportConceptRelOid, Model.Zeitraum, Model.Employee.EmployeeOid).ToList();
|
|
}
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
Log.Error(exception.Message, exception);
|
|
}
|
|
|
|
return ResetEditingMode();
|
|
}
|
|
}
|
|
}
|