private void onTimeEntryDeleted(long id)
{
var viewModel = TimeEntries.Select(c => c.SingleOrDefault(vm => vm.Id == id)).SingleOrDefault(vm => vm != null);
if (viewModel == null)
{
return;
}
var collection = TimeEntries.SingleOrDefault(c => c.Date == viewModel.Start.Date);
if (collection == null)
{
return;
}
collection.Remove(viewModel);
var indexToInsert = TimeEntries.IndexOf(collection);
TimeEntries.Remove(collection);
if (collection.Count > 0)
{
var newCollection = new TimeEntryViewModelCollection(collection.Date.DateTime, collection);
TimeEntries.Insert(indexToInsert, newCollection);
}
RaisePropertyChanged(nameof(IsEmpty));
}
void btn_ok_Click(object sender, EventArgs e)
{
ComboBox cb_project = (ComboBox)panel_context.Controls["cb_project"];
DateTimePicker dtp_time = (DateTimePicker)panel_context.Controls["dtp_time"];
ComboBox cb_activity = (ComboBox)panel_context.Controls["cb_activity"];
MaskedTextBox mtb_time = (MaskedTextBox)panel_context.Controls["mtb_time"];
TextBox tb_context = (TextBox)panel_context.Controls["tb_context"];
TimeEntries timet_entries = new TimeEntries();
timet_entries.project_id = cb_project.SelectedValue.ToString();
timet_entries.spent_on = dtp_time.Text;
timet_entries.activity_id = cb_activity.SelectedValue.ToString();
timet_entries.hours = mtb_time.Text;
if (".".Equals(timet_entries.hours))
{
MessageBox.Show("请填写工时！");
return;
}
else if (timet_entries.hours.EndsWith("."))
{
timet_entries.hours = timet_entries.hours.Substring(0, timet_entries.hours.Length - 1);
}
timet_entries.comments = tb_context.Text;
try
{
service.timet_entries(timet_entries);
MessageBox.Show("打卡成功！");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void onTimeEntryUpdated(EntityUpdate <IThreadSafeTimeEntry> update)
{
var timeEntry = update.Entity;
var shouldBeAdded = timeEntry != null && !timeEntry.IsRunning() && !timeEntry.IsDeleted;
var oldCollectionIndex = TimeEntries.IndexOf(c => c.Any(vm => vm.Id == update.Id));
var collectionIndex = TimeEntries.IndexOf(vm => vm.Date == timeEntry.Start.LocalDateTime.Date);
var wasMovedIntoDifferentCollection = oldCollectionIndex >= 0 && oldCollectionIndex != collectionIndex;
var shouldBeRemoved = shouldBeAdded == false || wasMovedIntoDifferentCollection;
if (shouldBeRemoved)
{
safeRemoveTimeEntry(update.Id);
}
if (shouldBeAdded)
{
var timeEntryIndex = collectionIndex < 0 ? -1 : TimeEntries[collectionIndex].IndexOf(vm => vm.Id == update.Id);
var timeEntryExistsInTheCollection = timeEntryIndex >= 0;
if (timeEntryExistsInTheCollection)
{
var timeEntryViewModel = new TimeEntryViewModel(timeEntry, durationFormat);
TimeEntries.ReplaceInChildCollection(collectionIndex, timeEntryIndex, timeEntryViewModel);
return;
}
safeInsertTimeEntry(timeEntry);
}
}
public ActionResult LogOff()
{
// TODO: Clock out...
TimeEntries.ClockOut(User.Identity.GetUserId());
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return(RedirectToAction("Index", "Timesheet"));
}
/// <summary>
/// Updates all of the time entries provided
/// </summary>
/// <param name="val">the time entries you want to update</param>
public void UpdateTimeEntries(TimeEntries val)
{
foreach (TimeEntry entry in val.data)
{
UpdateTimeEntry(entry);
}
}
private void onTimeEntryUpdated(EntityUpdate <IThreadSafeTimeEntry> update)
{
var timeEntry = update.Entity;
if (timeEntry == null)
{
return;
}
if (timeEntry.IsDeleted || timeEntry.IsRunning())
{
onTimeEntryRemoved(timeEntry.Id);
}
else
{
var timeEntryViewModel = new TimeEntryViewModel(timeEntry, durationFormat);
if (timeEntry.Id == timeEntryToDelete?.Id)
{
// Ignore this update because the entity is hidden and might be deleted unless the user
// undoes the action. In that case bring the time entry but with the updated data.
timeEntryToDelete = timeEntryViewModel;
}
else
{
TimeEntries.UpdateItem(update.Id, timeEntryViewModel);
}
}
}
public List <string> MonthEmployers(DateTime Month)
{
return(TimeEntries.Where(entry => entry.Start.Month == Month.Month && entry.Start.Year == Month.Year)
.Select(entry => entry.Employer)
.Distinct()
.ToList());
}
private void addTimeEntries(TimeEntryViewModelCollection collection)
{
IsWelcome = false;
TimeEntries.Add(collection);
RaisePropertyChanged(nameof(IsEmpty));
}
private void onTimeEntryRemoved(long id)
{
var index = TimeEntries.IndexOf(id);
if (index.HasValue)
{
TimeEntries.RemoveItemAt(index.Value.Section, index.Value.Row);
}
}
protected virtual void ClearNavigationProperties()
{
Project = null;
Tag = null;
User = null;
TimeEntries.Clear();
Tasks1.Clear();
Tasks.Clear();
}
private void insertNewTimeEntryGroup(IThreadSafeTimeEntry timeEntry, DateTime indexDate)
{
var timeEntryToAdd = new TimeEntryViewModel(timeEntry, durationFormat);
var newCollection = new TimeEntryViewModelCollection(indexDate, new[] { timeEntryToAdd }, durationFormat);
var foundIndex = TimeEntries.IndexOf(TimeEntries.FirstOrDefault(x => x.Date < indexDate));
var indexToInsert = foundIndex == -1 ? TimeEntries.Count : foundIndex;
TimeEntries.Insert(indexToInsert, newCollection);
}
protected virtual void ClearNavigationProperties()
{
InvoiceFiles.Clear();
InvoiceLines.Clear();
TimeEntries.Clear();
User = null;
CustomerInvoiceGroup = null;
CreditNote.Clear();
InvoiceComments.Clear();
}
private void cancelDeleteTimeEntry()
{
if (!TimeEntries.IndexOf(timeEntryToDelete.Id).HasValue)
{
TimeEntries.InsertItem(timeEntryToDelete);
}
timeEntryToDelete = null;
delayedDeletionDisposable.Dispose();
showUndoSubject.OnNext(false);
}
public long DurationInSeconds()
{
long seconds = TimeEntries.Sum(timeEntry => timeEntry.DurationInSeconds());
long duration = seconds + TimeDifference;
if (duration > 0)
{
return(duration);
}
return(0);
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
//
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
if (returnUrl == null)
{
returnUrl = "~/Timesheet";
}
string userId = SignInManager.AuthenticationManager.AuthenticationResponseGrant.Identity.GetUserId();
//checking here for soft deletes
var teacherService = new TeacherService(new HomeworkHotlineEntities());
var teacher = teacherService.GetById(userId);
if (teacher == null) //teacher is deleted
{
ModelState.AddModelError("", "Invalid login attempt.");
LogOff();
return(View(model));
}
TimeEntry openTimeEntry = TimeEntries.GetOpenTimeEntriesByUser(userId);
if (openTimeEntry != null && openTimeEntry.EntryDate.Value.Date == DateTime.Today) //user is still logged in for today, redirect to timesheets without logging in a second time.
{
return(RedirectToLocal(returnUrl));
}
if (openTimeEntry != null && openTimeEntry.EntryDate.Value.Date < DateTime.Today) //user is still logged in for yesterday, log out, back in and redirect to timesheets
{
TimeEntries.ClockOutAtEndOfDay(userId, openTimeEntry);
}
TimeEntries.ClockIn(userId);
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
private async Task fetchSectionedTimeEntries()
{
var groupedEntries = await interactorFactory.GetAllTimeEntriesVisibleToTheUser().Execute()
.Select(entries => entries
.Where(isNotRunning)
.Where(timeEntry => timeEntry.Id != timeEntryToDelete?.Id)
.Select(te => new TimeEntryViewModel(te, durationFormat))
);
TimeEntries.ReplaceWith(groupedEntries);
}
private IObservable <Unit> cancelDeleteTimeEntry()
{
if (!TimeEntries.IndexOf(timeEntryToDelete.Id).HasValue)
{
TimeEntries.InsertItem(timeEntryToDelete);
}
timeEntryToDelete = null;
delayedDeletionDisposable.Dispose();
showUndoSubject.OnNext(false);
return(Observable.Return(Unit.Default));
}
private static void Output(TimeEntries entries)
{
foreach (TimeEntry entry in entries.data)
{
string output = string.Format("Desc: {0} Start: {1} Stop: {2} ID: {3} Duration: {4}",
entry.description,
entry.start,
entry.stop,
entry.id,
entry.duration);
Console.WriteLine(output);
}
}
private void ExcludeTimeEntry(TimeEntryListItemViewModel timeEntry)
{
if (timeEntry.TimeEntry.IsStopped)
{
return;
}
_dataService.ExcludeTimeEntry(timeEntry.TimeEntry);
TimeEntries.Remove(timeEntry);
InternalCommands.GenerateInvoiceLines.Execute(null);
//_invoiceService.RecalculateInvoice(SelectedInvoice.Invoice);
}
protected virtual void ClearNavigationProperties()
{
Customers.Clear();
Invoices.Clear();
Projects.Clear();
Tasks.Clear();
TimeEntries.Clear();
TimeEntries1.Clear();
UsersCustomers.Clear();
Projects1.Clear();
Customers_1.Clear();
InvoiceComments.Clear();
}
public TimeEntriesViewModel(
ITogglDataSource dataSource,
IInteractorFactory interactorFactory,
IAnalyticsService analyticsService,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory,
ITimeService timeService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.interactorFactory = interactorFactory;
this.analyticsService = analyticsService;
this.schedulerProvider = schedulerProvider;
DelayDeleteTimeEntries = rxActionFactory.FromAction <long[]>(delayDeleteTimeEntries);
ToggleGroupExpansion = rxActionFactory.FromAction <GroupId>(toggleGroupExpansion);
CancelDeleteTimeEntry = rxActionFactory.FromAction(cancelDeleteTimeEntry);
groupsFlatteningStrategy = new TimeEntriesGroupsFlattening(timeService);
var deletingOrPressingUndo = timeEntriesPendingDeletionSubject.SelectUnit();
var collapsingOrExpanding = ToggleGroupExpansion.Elements;
var visibleTimeEntries = interactorFactory.ObserveAllTimeEntriesVisibleToTheUser().Execute()
.Select(timeEntries => timeEntries.Where(isNotRunning))
.ReemitWhen(deletingOrPressingUndo)
.Select(timeEntries => timeEntries.Where(isNotDeleted))
.Select(group)
.ReemitWhen(collapsingOrExpanding);
TimeEntries = Observable.CombineLatest(
visibleTimeEntries,
dataSource.Preferences.Current,
groupsFlatteningStrategy.Flatten)
.AsDriver(schedulerProvider);
Empty = TimeEntries
.Select(groups => groups.None())
.AsDriver(schedulerProvider);
Count = TimeEntries
.Select(log => log.Sum(day => day.Items.Count))
.AsDriver(schedulerProvider);
TimeEntriesPendingDeletion = timeEntriesPendingDeletionSubject.AsObservable().AsDriver(schedulerProvider);
}
private async Task reset()
{
TimeEntries.Clear();
var timeEntries = await dataSource.TimeEntries.GetAll();
timeEntries
.Where(isNotRunning)
.OrderByDescending(te => te.Start)
.Select(te => new TimeEntryViewModel(te))
.GroupBy(te => te.Start.LocalDateTime.Date)
.Select(grouping => new TimeEntryViewModelCollection(grouping.Key, grouping))
.ForEach(addTimeEntries);
}
private void safeRemoveTimeEntry(long id)
{
var collectionIndex = TimeEntries.IndexOf(c => c.Any(vm => vm.Id == id));
if (collectionIndex < 0)
{
return;
}
var item = TimeEntries[collectionIndex].First(vm => vm.Id == id);
TimeEntries.RemoveFromChildCollection(collectionIndex, item);
RaisePropertyChanged(nameof(IsEmpty));
}
public static async void Logout()
{
await RestApi.Logout();
RestApi = new RestApi();
UserData = new UserDataToggl();
UserPresentationData = new UserPresentationData();
ActualRunningTaskData = new TaskPresentationLayout();
Workspaces = new List <WorkspaceToggl>();
Projects = new List <ProjectToggl>();
TimeEntries = new List <TimeEntries>();
RunningTask = new TimeEntries();
History = new List <HistoryRowPresentationData>();
}
public long DurationInSeconds(DateTime date)
{
long seconds =
TimeEntries
.Where(timeEntry => timeEntry.Start.Date.Equals(date.Date) || timeEntry.Stop.Date.Equals(date.Date))
.Sum(timeEntry => timeEntry.DurationInSeconds());
long duration = seconds + TimeDifference;
if (duration > 0)
{
return(duration);
}
return(0);
}
public virtual void RemoveTimeEntry(int timeEntryId)
{
var timeEntry = TimeEntries.Single(te => te.Id == timeEntryId);
if (timeEntry == null)
{
throw new EntityDeleteException("Timeentry not found in task: " + timeEntryId);
}
if (timeEntry.Invoice != null)
{
throw new EntityDeleteException("Timeentry cannot be deleted when billed: Id:" + timeEntry.Id);
}
TimeEntries.Remove(timeEntry);
}
private void safeInsertTimeEntry(IThreadSafeTimeEntry timeEntry)
{
var indexDate = timeEntry.Start.LocalDateTime.Date;
var collectionIndex = TimeEntries.IndexOf(x => x.Date.LocalDateTime == indexDate);
var groupExists = collectionIndex >= 0;
if (groupExists)
{
insertTimeEntryInGroup(timeEntry, collectionIndex);
}
else
{
insertNewTimeEntryGroup(timeEntry, indexDate);
}
RaisePropertyChanged(nameof(IsEmpty));
}
public TimeSpan GetWorkedTime()
{
long totalTicksWorked = 0;
var orderedTimes = TimeEntries.OrderBy(time => time.DateHourPointed).ToList();
if (orderedTimes.Count > 0)
{
int lastIndex = orderedTimes.Count % 2 == 0 ? orderedTimes.Count : orderedTimes.Count - 1;
for (int index = 0; index < lastIndex; index += 2)
{
totalTicksWorked += orderedTimes[index + 1].DateHourPointed.Ticks - orderedTimes[index].DateHourPointed.Ticks;
}
}
return(TimeSpan.FromTicks(totalTicksWorked));
}
private void ExecuteGetInvoicesFromMany(ObservableCollection <CustomersInvoiceView> t)
{
try
{
var tmp = new ObservableCollection <int>();
foreach (var customerInvoiceView in t)
{
tmp.Add(customerInvoiceView.CustomerID);
}
_dataService.GetInvoicesByCustomerId(tmp).Subscribe(i =>
{
if (i != null)
{
Invoices = SeeAll == true ? TakeAll(i) : TakeOnlyNoneClosed(i);
if (_lastInvoiceSelectedId != null &&
Invoices.Select(id => id.Id).Contains(_lastInvoiceSelectedId))
{
SelectedInvoice = Invoices.First(x => x.Id == _lastInvoiceSelectedId);
}
if (SelectedInvoice != null && _lastInvoiceSelectedId != null)
{
LoadInvoiceLines(SelectedInvoice);
LoadTimeEntries(SelectedInvoice);
}
else
{
TimeEntries.Clear();
InvoiceLines.Clear();
}
}
else
{
MessageBox.Show("Something went wrong in a call on the server", "Error", MessageBoxButton.OK);
}
});
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
throw;
}
}
private async Task fetchSectionedTimeEntries()
{
var timeEntries = await interactorFactory.GetAllNonDeletedTimeEntries().Execute();
if (timeEntries == null)
{
TimeEntries.Clear();
return;
}
var groupedEntries = timeEntries
.Where(isNotRunning)
.OrderByDescending(te => te.Start)
.Select(te => new TimeEntryViewModel(te, durationFormat))
.GroupBy(te => te.StartTime.LocalDateTime.Date)
.Select(grouping => new TimeEntryViewModelCollection(grouping.Key, grouping, durationFormat));
TimeEntries.ReplaceWith(groupedEntries);
}
