// GET /Calendar
// Displays a calendar view of the current week for
// the logged-in user
public async Task <IActionResult> Index()
{
await EnsureScopes(_calendarScopes);
try
{
// TZConvert handles either an IANA or Windows identifier
// Graph can return either
var userTimeZone = TZConvert.GetTimeZoneInfo(
User.GetUserGraphTimeZone());
var startOfWeek = CalendarController.GetUtcStartOfWeekInTimeZone(
DateTime.Today, userTimeZone);
var events = await GetUserWeekCalendar(startOfWeek);
var model = new CalendarViewModel(startOfWeek, events);
return(View(model));
}
catch (ServiceException ex)
{
InvokeAuthIfNeeded(ex);
return(View(new CalendarViewModel())
.WithError("Error getting calendar view", ex.Message));
}
}
public ActionResult GetDetail(int id)
{
CalendarViewModel model = new CalendarViewModel();
model = _calService.GetAll().Where(x => x.ID == id).FirstOrDefault();
return(Json(model, JsonRequestBehavior.AllowGet));
}
public void WhenExecutingTheGotToEmailCommand_ThenNavigatesToEmailView()
{
var meeting = new Meeting {
EmailId = Guid.NewGuid()
};
var calendarServiceMock = new Mock <ICalendarService>();
Mock <IRegion> regionMock = new Mock <IRegion>();
regionMock
.Setup(x => x.RequestNavigate(new Uri(@"EmailView?EmailId=" + meeting.EmailId.ToString("N"), UriKind.Relative), It.IsAny <Action <NavigationResult> >()))
.Callback <Uri, Action <NavigationResult> >((s, c) => c(new NavigationResult(null, true)))
.Verifiable();
Mock <IRegionManager> regionManagerMock = new Mock <IRegionManager>();
regionManagerMock.Setup(x => x.Regions.ContainsRegionWithName(RegionNames.MainContentRegion)).Returns(true);
regionManagerMock.Setup(x => x.Regions[RegionNames.MainContentRegion]).Returns(regionMock.Object);
var viewModel = new CalendarViewModel(calendarServiceMock.Object, regionManagerMock.Object);
viewModel.OpenMeetingEmailCommand.Execute(meeting);
regionMock.VerifyAll();
}
// GET /Calendar
// Displays a calendar view of the current week for
// the logged-in user
public async Task <IActionResult> Index()
{
try
{
// TZConvert handles either an IANA or Windows identifier
// Graph can return either
var userTimeZone = TZConvert.GetTimeZoneInfo(
User.GetUserGraphTimeZone());
var startOfWeek = CalendarController.GetUtcStartOfWeekInTimeZone(
DateTime.Today, userTimeZone);
var events = await GetUserWeekCalendar(startOfWeek);
var model = new CalendarViewModel(startOfWeek, events);
return(View(model));
}
catch (ServiceException ex)
{
if (ex.InnerException is MsalUiRequiredException)
{
throw;
}
return(View(new CalendarViewModel())
.WithError("Error getting calendar view", ex.Message));
}
}
public IActionResult Index(int?year, int?month)
{
if (year.HasValue && (year < DateTime.MinValue.Year || year > DateTime.MaxValue.Year))
{
ModelState.AddModelError("All", "The requested year is invalid");
}
if (month.HasValue && (month < 1 || month > 12))
{
ModelState.AddModelError("All", "The requested month is invalid");
}
if (ModelState.IsValid)
{
var displayMonth = new DateTime(year ?? DateTime.Today.Year, month ?? DateTime.Today.Month, 1);
var model = new CalendarViewModel()
{
CurrentMonth = displayMonth
};
model.Appointments =
_mapper.Map <IEnumerable <AppointmentViewModel> >(_appointmentService.List(model.DisplayStartDate,
model.DisplayEndDate));
return(View(model));
}
return(View());
}
public MySmallCalendarMonthView(ViewGroup parent, MyCalendarView calendarView, CalendarViewModel viewModel, DayOfWeek firstDayOfWeek) : base(parent, calendarView, firstDayOfWeek)
{
_viewModel = viewModel;
// Now that we've set the view model, call the actual Initialize, which will then call CreateDay (which depends on the view model being set)
base.Initialize();
}
public ActionResult Index()
{
var date = Utility.GetDBDate();
var calendar = new Calendar();
var entries = calendar.GetCalendarFromDatabase().Where(x => (x.month >= date.Month && x.year >= date.Year) || x.year > date.Year);
var serializer = new JavaScriptSerializer();
var time = entries.Select(x => new Pair <int, int>(x.month, x.year)).Distinct().ToArray();
var years = time.Select(x => x.Second).Distinct();
var timeList = new Dictionary <int, IEnumerable <string> >();
foreach (var year in years)
{
int year1 = year;
timeList[year] = time.Where(x => x.Second == year1).Select(x => Calendar.months[x.First - 1]);
}
var viewmodel = new CalendarViewModel(baseviewmodel)
{
calendar = serializer.Serialize(entries),
months = time,
time = timeList
};
return(View(viewmodel));
}
public void Initialize(CalendarViewModel viewModel)
{
try
{
_viewModel = viewModel;
// Not bothering to bind this property for now
smallCalendar.FirstDayOfWeek = viewModel.FirstDayOfWeek;
// Don't set selected date, since this doesn't use a selected date
smallCalendar.SetBinding(TCalendarView.DisplayMonthProperty, new Binding()
{
Path = new PropertyPath(nameof(viewModel.DisplayMonth)),
Source = viewModel,
Mode = BindingMode.TwoWay
});
smallCalendar.ViewModel = viewModel.SemesterItemsViewGroup;
smallCalendar.SelectionChanged += SmallCalendar_SelectionChanged;
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public async Task <object> GetEvents([FromBody] CalendarViewModel model)
{
try
{
model.listEvents = new List <CalendarEventModel>();
model.listEvents = _calendarRepository.GetEvents(model.UserId);
return(new SingleResponse <CalendarViewModel>
{
Message = string.Empty,
DidError = false,
ErrorMessage = string.Empty,
Token = string.Empty,
Model = model
});
}
catch (Exception ex)
{
return(new SingleResponse <CalendarViewModel>
{
Message = string.Empty,
DidError = true,
ErrorMessage = ex.Message,
Token = string.Empty,
Model = null
});
}
}
public ActionResult Update(CalendarViewModel model)
{
model.LoggedUserID = Convert.ToInt32(User.Identity.GetUserId());
string msg = _calService.Update(model);
return(Json(new { Message = msg }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Home()
{
var currentUser = await _userManager.GetUserAsync(User);
if (currentUser == null)
{
return(Challenge());
}
var currentDateTime = DateTime.Now;
var calendar = new CalendarViewModel(currentDateTime.Month, currentDateTime.Year);
var recentlyAddedTodos = await _todoItemService.GetRecentlyAddedItemsAsync(currentUser);
var dueTo2daysTodos = await _todoItemService.GetDueTo2DaysItems(currentUser);
var monthlyItems = await _todoItemService.GetMonthlyItems(currentUser, currentDateTime.Month);
var public_todos = await _todoItemService.GetIncompletePublicItemsAsync();
var homeViewModel = new HomeViewModel()
{
RecentlyAddedTodos = recentlyAddedTodos,
CloseDueToTodos = dueTo2daysTodos,
MonthlyToTodos = monthlyItems,
CalendarViewModel = calendar,
PublicTodos = public_todos
};
return(View(homeViewModel));
}
public async Task <IActionResult> Index()
{
try
{
var userTimeZone = TimeZoneInfo.FindSystemTimeZoneById(
User.GetUserGraphTimeZone());
var startOfWeek = CalendarController.GetUtcStartOfWeekInTimeZone(
DateTime.Today, userTimeZone);
var events = await GetUserWeekCalendar(startOfWeek);
var model = new CalendarViewModel(startOfWeek, events);
return(View(model));
}
catch (ServiceException ex)
{
if (ex.InnerException is MsalUiRequiredException)
{
throw ex;
}
return(View(new CalendarViewModel())
.WithError("Error getting calendar view", ex.Message));
}
}
public CalendarPage()
{
InitializeComponent();
BindingContext = _calendarVM = new CalendarViewModel();
Calendar.Characters = _calendarVM.SeasonCharacters;
// calendar frame tapped
Calendar.FrameTapped += (sender, controlTapped) =>
{
// go to character page
var frameClicked = (Frame)controlTapped;
var day = int.Parse(((Label)frameClicked.Content).Text);
var frameCharas = Calendar.Characters.Where(c => c.Birthday.EndsWith(" " + day));
if (frameCharas.Any())
{
var charaVM = new CharacterViewModel(frameCharas.First());
Navigation.PushAsync(new CharacterPage(charaVM));
}
};
MessagingCenter.Subscribe <GameSelectionPage>(this, "GameSelected", SourceCallback);
}
private void AddButtonClicked()
{
try
{
var parent = VisualTreeExtensions.FindParent <MainCalendarView>(this);
if (parent == null)
{
throw new NullReferenceException("Couldn't find parent.");
}
CalendarViewModel viewModel = parent.ViewModel;
if (viewModel == null)
{
throw new NullReferenceException("Parent's view model was null");
}
App.ShowFlyoutAddHomeworkOrExam(
elToCenterFrom: _addButton,
addHomeworkAction: delegate { viewModel.AddHomework(base.Date); },
addExamAction: delegate { viewModel.AddExam(base.Date); },
addHolidayAction: delegate { viewModel.AddHoliday(base.Date); });
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public ActionResult CalendarDisplaySimple(CalendarViewModel model)
{
CalendarSimpleSettings settings = new CalendarSimpleSettings();
if (this.WidgetPayload is CalendarSimpleSettings)
{
settings = (CalendarSimpleSettings)this.WidgetPayload;
settings.LoadData();
model.SiteID = settings.SiteID;
model.AlternateViewFile = settings.AlternateViewFile;
}
ModelState.Clear();
model.LoadData(model.SiteID, true);
if (String.IsNullOrEmpty(model.AlternateViewFile))
{
return(PartialView(model));
}
else
{
return(PartialView(model.AlternateViewFile, model));
}
}
public async Task <IActionResult> GetCalendar(int year, int month, int page)
{
year = year == 0 ? DateTime.Now.Year : year;
month = month == 0 ? DateTime.Now.Month : month;
page = page == 0 ? 1 : page;
int resultsPerPage = 3;
int employeeCount = await _employeeRepository.CountAsync();
int maxPages = (int)Math.Ceiling(((double)employeeCount) / resultsPerPage);
IEnumerable <CalendarDayViewModel> calendarDays = _mapper.Map <IEnumerable <CalendarDayViewModel> >(await _calendarRepository.FindAsync(year, month));
List <CalendarEmployeeViewModel> employees = _mapper.Map <IEnumerable <CalendarEmployeeViewModel> >(await _employeeRepository.FindAsync(page, resultsPerPage)).ToList();
int userId = 0;
if (User.Identity.IsAuthenticated)
{
userId = Int32.Parse(User.Claims.Single(x => x.Type == ApplicationClaimTypes.UserId).Value);
}
bool isAdmin = User.IsInRole(Roles.Admin);
CalendarViewModel retVal = new CalendarViewModel(employees, calendarDays, userId, isAdmin, maxPages);
return(Json(retVal));
}
public void EditCalendar_UserNotOwner_ThrowsForbiddenExceptions()
{
var calendarVM = new CalendarViewModel
{
Id = 3,
UserId = 2,
Name = "123"
};
var calendar = new Calendar
{
Id = 3,
UserId = 2,
Name = "123"
};
var mockCalendarRepo = new Mock <ICalendarRepository>();
mockCalendarRepo
.Setup(cr => cr.GetCalendar(It.IsAny <int>()))
.Returns(() => calendar);
var calendarDomain = new CalendarDomain(mockCalendarRepo.Object, _mapper, null, null);
Assert.Throws <ForbiddenException>(() => calendarDomain.EditCalendar(calendarVM, 5));
mockCalendarRepo.Verify(cr => cr.GetCalendar(It.IsAny <int>()), Times.Once());
}
public async Task <IActionResult> Index(CalendarViewModel model)
{
model.discordMembers = new List <DiscordMember>();
if (model.guildId > 0)
{
var guild = await HttpClientHelper.ClientBot().GetGuildAsync(model.guildId) as RestGuild;
var users = await guild.GetUsersAsync().FirstOrDefault();
if (users != null)
{
foreach (var item in users)
{
var avatar = item.GetAvatarUrl(Discord.ImageFormat.Auto, 64);
if (string.IsNullOrEmpty(avatar))
{
avatar = item.GetDefaultAvatarUrl();
}
var member = new DiscordMember
{
Id = item.Id,
Name = item.Username,
Avatar = avatar
};
model.discordMembers.Add(member);
}
}
return(View(model));
}
return(View(new CalendarViewModel()));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var m = new CalendarViewModel();
var currentyear = Lib.persianDateTime.GetTodayYear();
var currentmonth = Lib.persianDateTime.GetTodayMonth();
var currentday = Lib.persianDateTime.GetTodayDay();
var year = Request.Query["year"].ToString();
var month = Request.Query["month"].ToString();
if (year == "" && month == "")
{
m.Year = currentyear;
m.Month = currentmonth;
m.Day = currentday;
}
else if (year != "" && month != "")
{
m.Year = int.Parse(year);
m.Month = int.Parse(month);
if (year == currentyear.ToString() && month == currentmonth.ToString())
{
m.Day = currentday;
}
}
else
{
throw new Exception("تاریخ اشتباه");
}
return(View("Default", m));
}
public void Initialize(CalendarViewModel viewModel)
{
try
{
_viewModel = viewModel;
smallCalendar.SelectedDate = viewModel.SelectedDate;
// Set after, since display month can be different than selected date
smallCalendar.SetBinding(TCalendarView.DisplayMonthProperty, new Binding()
{
Path = new PropertyPath(nameof(viewModel.DisplayMonth)),
Source = viewModel,
Mode = BindingMode.TwoWay
});
smallCalendar.ViewModel = viewModel.SemesterItemsViewGroup;
smallCalendar.SelectionChanged += SmallCalendar_SelectionChanged;
listHeader.Classes = viewModel.SemesterItemsViewGroup.Classes;
UpdateDay();
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public async Task <IActionResult> Index()
{
try
{
var userTimeZone = TZConvert.GetTimeZoneInfo(
User.GetUserGraphTimeZone());
var startOfWeek = CalendarController.GetUtcStartOfWeekInTimeZone(
DateTime.Today, userTimeZone);
var events = await GetUserWeekCalendar(startOfWeek);
var model = new CalendarViewModel(startOfWeek, events);
return(View(model));
}
catch (ServiceException ex)
{
if (ex.InnerException is MicrosoftIdentityWebChallengeUserException)
{
throw ex;
}
return(View(new CalendarViewModel())
.WithError("Error getting calendar view", ex.Message));
}
}
// GET: Calendar
public async Task <IActionResult> Index(int?month, int?year)
{
month = month ?? DateTime.Now.Month;
year = year ?? DateTime.Now.Year;
DateTime dateTime = new DateTime(year ?? DateTime.Now.Year, month ?? DateTime.Now.Month, 1);
var applicationDbContext = await _context.Events.Include(p => p.Instructor).Where(p => p.Date.Month == (month ?? DateTime.Now.Month) && p.Date.Year == (year ?? DateTime.Now.Year)).ToListAsync();
foreach (var item in applicationDbContext)
{
item.Amount = item.Amount - _context.EventUser.Where(p => p.Event.Id == item.Id).Count();
}
CalendarViewModel calendarViewModel = new CalendarViewModel()
{
Events = applicationDbContext,
Month = month ?? DateTime.Now.Month,
Year = year ?? DateTime.Now.Year,
PrevMonth = dateTime.AddMonths(-1).Month,
PrevYear = dateTime.AddMonths(-1).Year,
NextMonth = dateTime.AddMonths(1).Month,
NextYear = dateTime.AddMonths(1).Year
};
return(View(calendarViewModel));
}
public CalendarView()
{
InitializeComponent();
_viewModel = new CalendarViewModel(this);
this.BindingContext = _viewModel;
carouselView.PositionSelected += CarouselView_PositionSelected;
}
static public CalendarViewModel GetFilteredDate(string startDate, string endDate)
{
var targetDate = new CalendarViewModel();
if (IsDefaultValue(endDate))
{
endDate = DateTime.Now.AddDays(1).ToString("yyyy-MM-dd");
var viewEndDate = DateTime.Now.ToString("yyyy-MM-dd");
targetDate.EndDate = viewEndDate;
}
else
{
targetDate.EndDate = endDate;
}
if (IsDefaultValue(startDate) || IsDefaultStartDate(startDate))
{
targetDate.StartDate = LocalConstants.DefaultDate;
}
else
{
targetDate.StartDate = startDate;
}
return(targetDate);
}
public async Task <HomeViewModel> ListTodoItemAsync(ITodoItemService todoItemService, SignInManager <IdentityUser> signInManager, UserManager <IdentityUser> userManager /*, IFileStorageService fileStorageService*/)
{
var currentUser = await userManager.GetUserAsync(signInManager.Context.User);
if (currentUser == null)
{
return(null);
}
var currentDateTime = DateTime.Now;
var calendar = new CalendarViewModel(currentDateTime.Month, currentDateTime.Year);
var recentlyAddedTodos = await todoItemService.GetRecentlyAddedItemsAsync(currentUser);
var dueTo2daysTodos = await todoItemService.GetDueTo2DaysItems(currentUser);
var monthlyItems = await todoItemService.GetMonthlyItems(currentUser, currentDateTime.Month);
var homeViewModel = new HomeViewModel()
{
RecentlyAddedTodos = recentlyAddedTodos,
CloseDueToTodos = dueTo2daysTodos,
MonthlyToTodos = monthlyItems,
CalendarViewModel = calendar
};
return(homeViewModel);
}
async Task LoadCalendarEventsAsync()
{
var calendars = await _calendarService.GetCalendarsAsync();
if (!calendars.IsNullOrEmpty() && calendars.All(calendar => calendar != Empty))
{
var view = ApplicationView.GetForCurrentView();
var take = view.Orientation == ApplicationViewOrientation.Portrait ? 7 : 5;
var events =
calendars.SelectMany(calendar => calendar?.Events)
.Where(e =>
e.StartDateTime > DateTime.Now &&
!string.IsNullOrWhiteSpace(e.Summary) &&
e.Summary.IndexOf("cancel", StringComparison.OrdinalIgnoreCase) == -1)
.OrderBy(e => e.StartDateTime)
.Take(take)
.ToArray();
if (!events.IsNullOrEmpty())
{
DataContext = new CalendarViewModel(this, events);
_fadeIn.Begin();
}
else
{
Visibility = Visibility.Collapsed;
}
}
}
// GET: Dashboard
public ActionResult Index()
{
var DbUsers = db.UserDetailsModel.ToList();
DashboardViewModels dashboardVM = new DashboardViewModels();
UserDetailsRepository UDR = new UserDetailsRepository();
dashboardVM.UserList = UDR.GetUsers();
TeamRepository TR = new TeamRepository();
dashboardVM.TeamList = TR.GetTeams();
List <IdentityRole> roles = db.Roles.ToList();
dashboardVM.RoleList = roles;
VacationRepository vac = new VacationRepository();
BankHolidayRepository bank = new BankHolidayRepository();
CalendarViewModel calendar = new CalendarViewModel();
calendar.BankHolidayList = bank.GetBankHolidays();
calendar.VacationList = vac.GetVacations();
dashboardVM.Calendar = calendar;
return(View(dashboardVM));
}
public ActionResult Create(CalendarViewModel model)
{
if (ModelState.IsValid)
{
if (model.StartDate < SessionHelper.Calendar.EndDate)
{
ModelState.AddModelError("Error", "Start date is overlaping with previous period!");
}
else if (model.StartDate > model.EndDate)
{
ModelState.AddModelError("Error", "Invalid Dates!");
}
else
{
////Not sure about the validity of this code,
////To be checked later.
//////////////////////////////////////////////////
////Calendar duplicateRecord = service.getCalendarByPeriod(AuthenticationHelper.User.CompanyId, model.SOBId, model.StartDate, model.EndDate);
//////////////////////////////////////////////////
////if (duplicateRecord == null)
////{
model.ClosingStatus = "Open";
string result = service.Insert(mapModel(model)); ////TODO: mapper should be in service
return(RedirectToAction("Index"));
////}
////else
////{
//// ModelState.AddModelError("Error", "Period Already Exists!");
////}
}
}
return(View(model));
}
public IActionResult GetTestTimeEditTasks()
{
//Variable to store the data we are going to send to the front-end.
CalendarViewModel tasks = new CalendarViewModel();
//List to store the course codes in
List <string> courses = new List <string>();
//Get course codes from the user
List <Course> courseObjects = _db.Courses.Where(w => w.UserId == _userManager.GetUserAsync(User).Result.Id).ToList();
//Loop through and add all the course codes.
foreach (var obj in courseObjects)
{
courses.Add(obj.Code);
}
//Add TimeEdit reservation to tasks in the calendar
//Get all reservation from the te controller
foreach (var res in _te.GetAllTest(courses).Result)
{
//Take out every task out from the list
foreach (var te in res.Reservations)
{
//Add the task to the te
tasks.AddTask(te);
}
}
//Return OK code with the task payload
return(Ok(tasks.GetTasks()));
}
public async Task <IActionResult> Index()
{
try
{
var userTimeZone = TZConvert.GetTimeZoneInfo(
User.GetUserGraphTimeZone());
var startOfWeekUtc = CalendarController.GetUtcStartOfWeekInTimeZone(
DateTime.Today, userTimeZone);
var events = await GetUserWeekCalendar(startOfWeekUtc);
// Convert UTC start of week to user's time zone for
// proper display
var startOfWeekInTz = TimeZoneInfo.ConvertTimeFromUtc(startOfWeekUtc, userTimeZone);
var model = new CalendarViewModel(startOfWeekInTz, events);
return(View(model));
}
catch (ServiceException ex)
{
if (ex.InnerException is MicrosoftIdentityWebChallengeUserException)
{
throw;
}
return(View(new CalendarViewModel())
.WithError("Error getting calendar view", ex.Message));
}
}
public CalendarController(SettingsViewModel settingsViewModel, CalendarViewModel calendarViewModel)
{
SettingsViewModel = settingsViewModel;
CalendarViewModel = calendarViewModel;
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="ListecalVM"> Le CalendarListConfigViewModel</param>
public CalendarGoogleViewModel(CalendarsListConfigViewModel ListecalVM)
{
this.parent = ListecalVM;
this.cal = new CalendarViewModel(new CalendarListEntry());
}
public UpdateCalendarGoogleViewModel(CalendarViewModel cal, CalendarsListConfigViewModel ListecalVM)
{
this.parent = ListecalVM;
this.cal = cal;
}
