public void With_Tzid_Sets_Timezone()
{
// Arrange
var tzid = Rnd.Str;
var calendar = new CalendarModel(
Substitute.For <IImmutableList <EventModel> >(),
Rnd.DateTime
);
// Act
var result = new JsonCalendar(calendar, tzid);
// Assert
Assert.Equal(tzid, result.Timezone);
}
public void Handle(int id)
{
Console.Clear();
User user = new UserModel().GetUserById(id);
List <Calendar> days = new CalendarModel().GetByUserId(id);
Console.WriteLine("Showing Calendar of: {0} {1}", user.Firstname, user.Lastname);
var table = new ConsoleTable("Date");
foreach (var day in days)
{
table.AddRow(day.Day);
}
table.Write(Format.Alternative);
}
public void Sets_LastModified_Using_Calendar_LastModified()
{
// Arrange
var lastModified = Rnd.DateTime;
var calendar = new CalendarModel(
Substitute.For <IImmutableList <EventModel> >(),
lastModified
);
// Act
var result = new JsonCalendar(calendar);
// Assert
Assert.Equal(lastModified, result.LastModified);
}
public IActionResult GetAutoGeneratedTasks()
{
//Variable to store the data we are going to send to the front-end.
CalendarModel tasks = new CalendarModel();
//AutoGenerate For users
_auto.AutoGenerateTest(_userManager.GetUserId(User));
//Get auto generated tasks from database on current user
List <Task> te = _db.Tasks
.Where(w => w.Type == Task.TaskType.AUTO && w.UserId == _userManager.GetUserId(User)).ToList();
//Return OK code with the task payload
return(Ok(te));
}
public List <CalendarModel> GetMaidTotalTimeSheet()
{
IEnumerable <string> values;
if (Request.Headers.TryGetValues("Token", out values))
{
var token = values.First();
var tokenModel = JsonConvert.DeserializeObject <TokenModel>(Encrypt.Base64Decode(token));
var maid = _service.GetActiveMaidById(tokenModel.Id);
if (Equals(maid, null))
{
ExceptionContent(HttpStatusCode.Unauthorized, "err_account_not_found");
}
var startTime = ConvertDatetime.GetBeginMonthUnixTimeStampByTimestamp(maid.created_date);
var endCurrentTime = ConvertDatetime.GetEndMonthUnixTimeStamp();
var result = new List <CalendarModel>();
while (startTime < endCurrentTime)
{
var endTime = ConvertDatetime.GetEndMonthUnixTimeStampByTimestamp(startTime);
var apartmentEmployees =
_service.GetListApartmentEmployeeByEmployeeIdAndTimeStamp(maid.employee_id, startTime, endTime).Select(p => new ApartmentEmployeeModel()
{
Id = p.apartment_employee_id,
CheckInTime = p.check_in_time ?? 0,
CheckOutTime = p.check_out_time ?? 0,
Type = p.type,
Apartment = new ApartmentModel()
{
Id = p.contract.apartment_id.Value,
Code = p.contract.apartment.code,
NoBedRoom = p.contract.no_bedroom
}
}).ToList();
var calendar = new CalendarModel()
{
Time = startTime,
ApartmentEmployeeList = apartmentEmployees
};
result.Add(calendar);
startTime = endTime + 1;
}
return(result);
}
return(new List <CalendarModel>());
}
public ActionResult Index(string search, int?placeID, int?page) //int? PlaceID)
{
int recordSize = 10;
page = page ?? 1;
CalendarModel model = new CalendarModel();
model.PlaceID = placeID;
model.Search = search;
model.Calendars = calendarService.SearchCalendar(search, placeID, page.Value, recordSize);
model.Places = placeService.GetPlaces();
var totalRecords = calendarService.SearchCalendarCount(search, placeID);
model.Pager = new BelBike.ViewModel.Pager(totalRecords, page, recordSize);
return(View(model));
}
public string GetCalendarTasks()
{
CalendarModel calendarModel = new CalendarModel();
using (var dbContext = GetDatabaseContext())
{
string currentUserId = GetCurrentUser().Id;
List <Task> tasks = dbContext.Tasks.Where(task => task.AssignedUserId == currentUserId && task.TaskStateId == 2).ToList();
List <CalendarModel> calendarModels = tasks.Select(task => { return(new CalendarModel {
Title = task.TaskTitle, Start = task.TaskStartedDate.ToString("yyyy-MM-dd")
}); }).ToList();
return(JsonConvert.SerializeObject(calendarModels));
}
}
void Date(string[] args)
{
if (AmbitionApp.Game == null || string.IsNullOrEmpty(AmbitionApp.Game.playerID))
{
error("Please start a game before setting the date");
}
else if (args.Length <= 1 || args[1].Length != 8)
{
error("Usage: date <YYYYMMDD>");
}
else
{
string[] substrings = new string[]
{
args[1].Substring(0, 4),
args[1].Substring(4, 2),
args[1].Substring(6)
};
if (!int.TryParse(substrings[0], out int year) ||
!int.TryParse(substrings[1], out int month) ||
!int.TryParse(substrings[2], out int day))
{
error("Usage: date <YYYYMMDD>");
}
else
{
CharacterModel characters = AmbitionApp.GetModel <CharacterModel>();
CalendarModel calendar = AmbitionApp.Calendar;
int currDay = calendar.Day;
RendezVO[] rendezs;
DateTime date = new DateTime(year <= 0 ? 1789 : year, month, day);
calendar.Day = day = date.Subtract(AmbitionApp.Calendar.StartDate).Days;
foreach (KeyValuePair <string, CharacterVO> kvp in characters.Characters)
{
if (kvp.Value.LiaisonDay >= 0 && kvp.Value.LiaisonDay < day)
{
rendezs = AmbitionApp.Calendar.GetOccasions <RendezVO>(kvp.Value.LiaisonDay);
characters.Characters[kvp.Key].LiaisonDay = -1;
Array.ForEach(rendezs, r => r.RSVP = RSVP.Declined);
}
}
AmbitionApp.Story.Update(true);
AmbitionApp.UFlow.Reset();
AmbitionApp.UFlow.Invoke(FlowConsts.DAY_FLOW_CONTROLLER);
}
}
}
public bool Put(string id, CalendarModel calendar)
{
try
{
var client = new RestClient();
var request = new RestRequest(url + id, Method.PUT);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Content-Type", "application/json");
request.AddJsonBody(calendar);
client.Execute(request);
return(true);
}
catch (Exception e)
{
return(false);
}
}
public IActionResult ShowMonth(int?year, int?month, CalendarModel calendarModel)
{
year ??= DateTime.Now.Year;
if (month == null || month >= 12)
{
month = DateTime.Now.Month;
}
calendarModel.FirstDayOfTheMonth = new DateTime((int)year, (int)month, 1);
calendarModel.StartDate = calendarModel.FirstDayOfTheMonth.AddDays(-(int)calendarModel.FirstDayOfTheMonth.DayOfWeek + 1);
if (calendarModel.FirstDayOfTheMonth.DayOfWeek == 0)
{
calendarModel.StartDate =
calendarModel.FirstDayOfTheMonth.AddDays(-6);
}
calendarModel.Tasks = _context.Tasks;
return(View(calendarModel));
}
public CalendarModel GetById(string id)
{
try
{
var client = new RestClient();
var request = new RestRequest(url + id, Method.GET);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Content-Type", "application/json");
IRestResponse <CalendarModel> response = client.Execute <CalendarModel>(request);
CalendarModel calendar = response.Data;
return(calendar);
}
catch (Exception e)
{
return(null);
}
}
public async Task ProcessUserJoinMeeting(string meetingId, string userId, string userCalendarToken)
{
var meeting = _cardinalDataService.GetMeetings().Where(m => m.Id == meetingId).First();
var userEvents = await GetUserEvents(userId, userCalendarToken);
var events = _cardinalDataService.GetUserEvents().Where(e => e.meetingId == meetingId);
foreach (UserEvent userEvent in events)
{
await _cardinalDataService.UpsertUserEventAsync(userEvent);
}
var calendar = new CalendarModel
{
startDate = meeting.StartFence,
endDate = meeting.EndFence,
dayStart = meeting.dayStart,
dayEnd = meeting.dayEnd,
lengthOfMeeting = meeting.Length,
events = events.Select(e => UserEventModel.UserEventModelFromUserEvent(e)).ToList()
};
calendar.consolidateEvents();
var Gaps = calendar.gaps;
DateTime startTime;
foreach (TimeSlotModel gap in Gaps)
{
int numMeetings = Convert.ToInt32(Math.Floor(gap.length.TotalMinutes / meeting.Length.TotalMinutes));
while (numMeetings > 0)
{
startTime = Gaps[numMeetings - 1].start;
await _cardinalDataService.UpsertMeetingTimeAsync(new MeetingTime
{
Id = Guid.NewGuid().ToString(),
MeetingId = meetingId,
StartTime = startTime,
});
numMeetings--;
startTime.Add(meeting.Length);
}
}
_eventManager.OnMeetingTimesUpdated(meetingId);
}
public void Returns_Json()
{
// Arrange
var e0 = new EventModel(Rnd.DateTime, Rnd.DateTime, false, Rnd.Str, Rnd.Str, Rnd.Str, false);
var e1 = new EventModel(Rnd.DateTime, Rnd.DateTime, false, Rnd.Str, Rnd.Str, Rnd.Str, true);
var events = ImmutableList.Create(e0, e1);
var lastModified = Rnd.DateTime;
var calendar = new CalendarModel(events, lastModified);
var tzid = Rnd.Str;
var jsonCalendar = new JsonCalendar(calendar, tzid);
var expected =
"{" +
"\"calendar\":{" +
"\"events\":{" +
$"\"{lastModified:yyyyMMdd\\THHmmss}-000000\":{{" +
$"\"start\":\"{e0.Start:s}\"," +
$"\"end\":\"{e0.End:s}\"," +
$"\"isAllDay\":{JsonF.Bool(e0.IsAllDay)}," +
$"\"summary\":\"{e0.Summary}\"," +
$"\"description\":\"{e0.Description}\"," +
$"\"location\":\"{e0.Location}\"," +
$"\"free\":{JsonF.Bool(e0.Free)}" +
"}," +
$"\"{lastModified:yyyyMMdd\\THHmmss}-000001\":{{" +
$"\"start\":\"{e1.Start:s}\"," +
$"\"end\":\"{e1.End:s}\"," +
$"\"isAllDay\":{JsonF.Bool(e1.IsAllDay)}," +
$"\"summary\":\"{e1.Summary}\"," +
$"\"description\":\"{e1.Description}\"," +
$"\"location\":\"{e1.Location}\"," +
$"\"free\":{JsonF.Bool(e1.Free)}" +
"}" +
"}," +
$"\"lastModified\":\"{lastModified:s}\"," +
$"\"timezone\":\"{tzid}\"" +
"}" +
"}";
// Act
var result = jsonCalendar.ToString();
// Assert
Assert.Equal(expected, result);
}
public IActionResult Index(string year, string month)
{
var result = validationService.Validate(year, month, out var date);
if (!string.IsNullOrEmpty(result))
{
return(View("Error", result));
}
var model = new CalendarModel
{
Title = date.ToString("yyyy MMMM").ToUpper(),
StartDayOfWeak = (int)date.DayOfWeek,
EndDay = date.AddMonths(1).AddSeconds(-1).Day
};
return(View(model));
}
private List <CalendarModel> GetPrivateRoomCourseEventCalendar(string roomName)
{
var privateRoom = GetPrivateRoom(roomName);
var fullCourse = DbContextHelper.GetCourseInfo(privateRoom.Courses);
List <CalendarModel> listCalendarEvent = new List <CalendarModel>();
foreach (var course in fullCourse)
{
var courseTitle = $"{course.CourseAcronym} ({course.GroupNumber})";
var courseEvent = new CalendarModel(course.CourseInfo, courseTitle, course.CourseName);
courseEvent.EventId = course.CourseId;
var labEvent = new CalendarModel(course.CourseInfo1, courseTitle, course.CourseName);
labEvent.EventId = course.CourseId;
listCalendarEvent.Add(courseEvent);
listCalendarEvent.Add(labEvent);
}
return(listCalendarEvent);
}
public DisplayCalendarViewModel()
{
if (File.Exists("calendar.dat"))
{
Stream fileStream = new FileStream("calendar.dat", FileMode.Open);
BinaryFormatter deserializer = new BinaryFormatter();
_calendar = (CalendarModel)deserializer.Deserialize(fileStream);
}
else
{
_calendar = new CalendarModel();
}
CurrentYear = DateTime.Today.Year;
CurrentMonth = DateTime.Today.Month;
CurrentDay = DateTime.Today.Day;
_displayMode = DISPLAY_WEEK;
}
public ActionResult Calendar(int page)
{
ViewData["Page"] = page;
var app = new FacebookWebClient();
var fbContext = FacebookWebContext.Current;
TennisUserModel existingUser = ModelUtils.GetTennisUsers(this.DB).Where(tu => tu.FacebookId == fbContext.UserId).FirstOrDefault();
var calendarModel = new CalendarModel(DateTime.Now.AddDays(7 * page), existingUser, this.DB);
return(Json
(
new
{
Calendar = RenderPartialViewToString("Calendar", calendarModel)
}
));
}
/// <summary>
/// Renders the modified backup set to visualise which backups will be pruned or not.
/// Hint: Open Calendar.html at in this project.
/// </summary>
/// <param name="backupSet">The backup set.</param>
private void RenderPrunedData(IList <BakModel> backupSet)
{
var calendarModel = new CalendarModel
{
Values = backupSet.Select(x => new DateModel
{
Date = x.Created,
Count = x.Prunable.HasValue && x.Prunable.Value ? 1 : 0,
}),
StartYear = backupSet.Min(x => x.Created).Year,
EndYear = backupSet.Max(x => x.Created).Year,
MinValue = 0,
MaxValue = 3
};
var json = JsonConvert.SerializeObject(calendarModel, Formatting.Indented);
File.WriteAllText(@"..\..\prune-test-data.json", json);
}
/// <summary>
/// カレンダーインフォを作成する
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <param name="model"></param>
/// <param name="cdate"></param>
/// <param name="calendarType"></param>
/// <param name="calendarInfoDic"></param>
internal void CreateCalendarInfo(int id, string name, CalendarModel model, DateTime cdate, CalendarType calendarType, Dictionary <int, object[]> calendarInfoDic)
{
try
{
OnExecute = (SQLiteConnection con, SQLiteTransaction tran) => {
try
{
string sql = "INSERT OR REPLACE INTO CALENDAR_INFO (ID, CALENDARNAME, CALENDARVALUE, CDATE, CALENDARTYPE) VALUES(@ID,@CALENDARNAME, @CALENDARVALUE, @CDATE, @CALENDARTYPE)";
using (SQLiteCommand command = new SQLiteCommand(sql, con))
{
command.Parameters.Add(new SQLiteParameter("@ID", id));
command.Parameters.Add(new SQLiteParameter("@CALENDARNAME", name));
command.Parameters.Add(new SQLiteParameter("@CALENDARVALUE", JsonConvert.SerializeObject(model)));
command.Parameters.Add(new SQLiteParameter("@CDATE", cdate));
command.Parameters.Add(new SQLiteParameter("@CALENDARTYPE", calendarType));
command.ExecuteNonQuery();
if (calendarInfoDic.ContainsKey(id))
{
calendarInfoDic[id][0] = name;
calendarInfoDic[id][1] = model;
calendarInfoDic[id][2] = cdate;
calendarInfoDic[id][3] = calendarType;
}
else
{
calendarInfoDic.Add(id, new object[] { name, model, cdate, calendarType });
}
}
tran.Commit();
}
catch (Exception ex)
{
tran.Rollback();
throw Program.ThrowException(ex);
}
};
Execute(true);
}
catch (Exception ex)
{
throw Program.ThrowException(ex);
}
}
/// <summary>
/// 初期化処理
/// </summary>
public void Init(int id)
{
try
{
if (id == 0)
{
_calendarModel = CalendarInfos.GetNewCalendarModel();
}
else
{
_calendarModel = (CalendarModel)CalendarInfos.GetInstance().CalendarInfoDic[id][1];
}
LoadCalendarForm();
}
catch (Exception ex)
{
throw Program.ThrowException(ex);
}
}
public ActionResult Index()
{
var calenders = db.Calendars.ToList();
var calenderModel = new List <CalendarModel>();
foreach (var item in calenders)
{
var foo = new CalendarModel()
{
CalendarID = item.CalendarID,
TenTranDau = item.TenTranDau,
VongDau = item.VongDau
};
foo.Membername1 = db.Members.Where(x => x.MemberID == item.NguoiChoi1).FirstOrDefault().Membername;
foo.Membername2 = db.Members.Where(x => x.MemberID == item.NguoiChoi2).FirstOrDefault().Membername;
calenderModel.Add(foo);
}
return(View(calenderModel));
}
public void Adds_Events_With_Incrementing_Uid()
{
// Arrange
var e0 = new EventModel(Rnd.DateTime, Rnd.DateTime, false, Rnd.Str, Rnd.Str, Rnd.Str, false);
var e1 = new EventModel(Rnd.DateTime, Rnd.DateTime, false, Rnd.Str, Rnd.Str, Rnd.Str, false);
var e2 = new EventModel(Rnd.DateTime, Rnd.DateTime, false, Rnd.Str, Rnd.Str, Rnd.Str, false);
var events = ImmutableList.Create(e0, e1, e2);
var calendar = new CalendarModel(events, Rnd.DateTime);
// Act
var result = new JsonCalendar(calendar);
// Assert
Assert.Collection(result.Events,
x =>
{
Assert.Equal('0', x.Key[^ 1]);
Assert.Equal(e0, x.Value);
},
/// <summary>
/// カレンダーをコンボボックスへ読み込む
/// </summary>
/// <param name="calendarComboBox"></param>
public static void LoadCalendarToComboBox(BaseComboBox calendarComboBox)
{
try
{
DbUtil util = DbUtil.GetInstance();
CalendarModel model = new CalendarModel();
model.CalendarId = 0;
model.Description = "--未設定--";
calendarComboBox.Items.Add(model);
foreach (KeyValuePair <int, object[]> pair in CalendarInfos.GetInstance().CalendarInfoDic)
{
calendarComboBox.Items.Add((CalendarModel)pair.Value[1]);
}
}
catch (Exception ex)
{
throw Program.ThrowException(ex);
}
}
//Information du cours selon le groupe du cours choisit
public string GetCourseInfo(string id)
{
if (id == "")
{
return("");
}
var list = DbContextHelper.GetCourseFromId(Int32.Parse(id));
var courseTitle = $"{list.CourseAcronym} ({list.GroupNumber})";
var courseModel = new CalendarModel(list.CourseInfo, courseTitle, list.CourseName);
var labModel = new CalendarModel(list.CourseInfo1, courseTitle, list.CourseName);
JavaScriptSerializer serialize = new JavaScriptSerializer();
var listCalendarModel = new List <CalendarModel>();
listCalendarModel.Add(courseModel);
listCalendarModel.Add(labModel);
var listSerialized = serialize.Serialize(listCalendarModel);
return(listSerialized);
}
public IHttpActionResult UpdateCalendar(CalendarModel calendarModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var calendarDto = Mapper.Map <CalendarDto>(calendarModel);
_calendarAppService.Update(calendarDto, AuthHelper.GetCurrentUserId());
return(Ok("Calendar Update"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public DisplayCalendarViewModel()
{
if (File.Exists(calendarFileName))
{
Stream fileStream = new FileStream(calendarFileName, FileMode.Open);
BinaryFormatter deserializer = new BinaryFormatter();
calendar = (CalendarModel)deserializer.Deserialize(fileStream);
fileStream.Close();
}
else
{
calendar = new CalendarModel();
}
CurrentYear = DateTime.Today.Year;
CurrentMonth = DateTime.Today.Month;
CurrentDay = DateTime.Today.Day;
displayMode = displayWeek;
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="settings"></param>
/// <param name="logger"></param>
public CalendarViewModel(ISettings settings, ILogger logger)
{
this._settings = settings;
this._logger = logger;
this._calendar = new CalendarModel(settings, logger).AddTo(this.CompositeDisposable);
// Property
this.Dates = this._calendar.Dates.ToReadOnlyReactiveCollection(x => new CalendarDateViewModel(settings, logger, x)).AddTo(this.CompositeDisposable);
this.TargetMonth = this._calendar.TargetMonth.ToReactivePropertyAsSynchronized(x => x.Value).AddTo(this.CompositeDisposable);
this.ShoppingMode =
this._settings
.States
.IngredientDisplayMode
.ToReactivePropertyAsSynchronized(
x =>
x.Value,
x =>
x == IngredientDisplayMode.Shopping,
x =>
x ?
IngredientDisplayMode.Shopping :
IngredientDisplayMode.Normal
);
this.CalendarType =
this._settings
.States
.CalendarType
.ToReactivePropertyAsSynchronized(x => x.Value)
.AddTo(this.CompositeDisposable);
this.DateToDisplay = this.SelectedDate.Where(x => x != null).ToReadOnlyReactiveProperty().AddTo(this.CompositeDisposable);
this.IsBusy = this._calendar.IsBusy.ToReadOnlyReactiveProperty();
// Command
this.GoToPreviousMonth.Subscribe(this._calendar.GoToPreviousMonth).AddTo(this.CompositeDisposable);
this.GoToNextMonth.Subscribe(this._calendar.GoToNextMonth).AddTo(this.CompositeDisposable);
this.LoadDatesCommand.Subscribe(_ => this._calendar.LoadDates()).AddTo(this.CompositeDisposable);
}
/// <summary>
/// CalendarInfoDicにカレンダー情報を取得する
/// </summary>
/// <param name="calendarInfoDic"></param>
internal Dictionary <int, object[]> GetCalendarInfoDic()
{
try
{
Dictionary <int, object[]> calendarInfoDic = new Dictionary <int, object[]>();
DbUtil util = DbUtil.GetInstance();
util.OnExecute = (SQLiteConnection con, SQLiteTransaction tran) =>
{
string sql = "SELECT ID, CALENDARNAME, CALENDARVALUE, CDATE, CALENDARTYPE FROM CALENDAR_INFO ORDER BY ID";
using (SQLiteCommand command = new SQLiteCommand(sql, con))
{
using (SQLiteDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int id = int.Parse("" + reader.GetValue(0));
string name = "" + reader.GetValue(1);
CalendarModel model = JsonConvert.DeserializeObject <CalendarModel>("" + reader.GetValue(2));
DateTime cdate = DateTime.Parse("" + reader.GetValue(3));
CalendarType calendarType = (CalendarType)reader.GetValue(4);
if (calendarType == CalendarType.外部カレンダー)
{
var dic = AsyncUtil.RunSync(() => WebCalendarEditForm.GetCalendarValueFromWeb(null, model.Url, model.UrlParams, model.GetDelimitter(), model.EncodeType));
if (dic != null)
{
model.Value = dic;
}
}
calendarInfoDic.Add(id, new object[] { name, model, cdate, calendarType });
}
}
}
};
util.Execute(false);
return(calendarInfoDic);
}
catch (Exception ex)
{
throw Program.ThrowException(ex);
}
}
public async Task <IActionResult> Put([FromBody] CalendarModel model)
{
if (model is null)
{
throw new ApiException("Model is null.", StatusCodes.Status400BadRequest);
}
var entity = await _repository.SingleOrDefaultAsync(x => x.Code == model.Code);
if (entity is null)
{
throw new ApiException("Calendar doesn't exist.", StatusCodes.Status404NotFound);
}
_mapper.Map(model, entity);
_repository.Update(entity);
await _unitOfWork.CompleteAsync();
return(Ok(_mapper.Map <Calendar, CalendarModel>(entity)));
}
/// <summary>
/// Insert new Day
/// </summary>
/// <param name="day"></param>
/// <returns></returns>
public IHttpActionResult Post([FromBody] CalendarModel day)
{
try
{
if (!ModelState.IsValid)
{
var message = "Failed inserting new day, " + Environment.NewLine;
message += string.Join(Environment.NewLine, ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
throw new Exception(message);
}
TimeKeeperUnit.Calendar.Insert(TimeKeeperFactory.Create(day, TimeKeeperUnit));
TimeKeeperUnit.Save();
Logger.Log("Inserted new day", "INFO");
return(Ok(day));
}
catch (Exception ex)
{
Logger.Log(ex.Message, "ERROR", ex);
return(BadRequest(ex.Message));
}
}
private void LoadModel ()
{
ModellData = new CalendarModel ();
IntID = 0;
DataSet TermineDataSet = WordUpWCFAccess.GetCommonDataSet ("Select * from Termine order by Von");
foreach (DataRow Entry in TermineDataSet.Tables ["Termine"].Rows)
{
InsertOneAppointment ( Entry);
}
}
private async Task<CalendarModel> InternalGetCalendar(string id, DateTime start, DateTime end)
{
start = start.Date;
end = end.Date;
var credentials = credentialProvider.GetCredentials(id);
if (credentials == null)
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, ""));
var calendarModel = new CalendarModel
{
Owner = id,
};
switch (credentials.Type)
{
case "EWS":
var ewsService = new ExchangeService
{
Credentials = new WebCredentials(credentials.Username, credentials.Password, credentials.Domain),
Url = new Uri(credentials.ServiceUrl)
};
var week = ewsService.FindAppointments(WellKnownFolderName.Calendar,
new CalendarView(start, end.AddDays(1)));
calendarModel.Appointments = week.Select(a => new AppointmentModel
{
Subject = a.Subject,
StartTime = a.Start.ToUniversalTime(),
EndTime = a.End.ToUniversalTime(),
Duration = a.Duration,
IsPrivate =
a.Sensitivity == Sensitivity.Private || a.Sensitivity == Sensitivity.Confidential
});
break;
case "ICS":
var cache = calendarCache.GetCalendar(id);
if (cache != null)
{
var icsServiceResponse = await icsService.GetIcsContent(credentials.ServiceUrl, cache.ETag);
if (icsServiceResponse.NotModified)
{
calendarModel.Appointments = cache.CalendarModel.Appointments;
}
else
{
calendarModel.Appointments = icsServiceResponse.Appointments;
calendarCache.PutCalendar(id,
new CalendarCacheEntry(id) { CalendarModel = calendarModel, ETag = icsServiceResponse.ETag });
}
}
else
{
var icsResponse = await icsService.GetIcsContent(credentials.ServiceUrl, string.Empty);
calendarModel.Appointments = icsResponse.Appointments;
calendarCache.PutCalendar(id,
new CalendarCacheEntry(id) { CalendarModel = calendarModel, ETag = icsResponse.ETag });
}
break;
default:
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ""));
}
// Now only return the appointments in the requested range
return new CalendarModel
{
Owner = calendarModel.Owner,
Appointments = calendarModel.Appointments
.Where(a => a != null &&
a.StartTime.Date >= start && a.StartTime.Date <= end)
.OrderBy(a => a.StartTime)
};
}
public ActionResult Calendar(int page)
{
ViewData["Page"] = page;
var app = new FacebookWebClient();
var fbContext = FacebookWebContext.Current;
TennisUserModel existingUser = ModelUtils.GetTennisUsers(this.DB).Where(tu => tu.FacebookId == fbContext.UserId).FirstOrDefault();
var calendarModel = new CalendarModel(DateTime.Now.AddDays(7 * page), existingUser, this.DB);
return Json
(
new
{
Calendar = RenderPartialViewToString("Calendar", calendarModel)
}
);
}
/// <summary>
/// GetLastPartDate
/// </summary>
/// <param name="part"></param>
/// <param name="date"></param>
/// <returns></returns>
private DateTime GetLastPartDate(TimeZonePart part, DateTime date)
{
DateTime pdate = part.StartDate;
if (part.Appc == null)
{
CalendarModel model = new CalendarModel();
Appointment app = new Appointment();
app.StartTime = part.StartDate.Date;
app.EndTime = app.StartTime;
VEventData evData = new VEventData();
evData.RecurRule = part.RecurRule;
ProcessEventEndEx(model, null, app, evData);
part.Appc = new AppointmentSubsetCollection(model, part.StartDate, date);
}
if (part.Appc.Count > 0)
{
foreach (Appointment app in part.Appc)
{
if (app.StartTime > pdate && app.StartTime <= date)
pdate = app.StartTime;
}
}
return (pdate);
}
private void AddMonthlyByDay(CalendarModel model,
Appointment app, DayOfWeek dayOfWeek, int byDay, VEventData evData)
{
AppointmentRecurrence recur = new AppointmentRecurrence();
recur.RecurrenceType = eRecurrencePatternType.Monthly;
recur.Monthly.RepeatInterval = evData.RecurRule.Interval;
recur.Monthly.RelativeDayOfWeek = dayOfWeek;
recur.Monthly.RepeatOnRelativeDayInMonth = GetRelativeDay(byDay);
if (app.Recurrence != null)
{
app = app.Copy();
app.StartTime = evData.StartTime;
app.EndTime = evData.EndTime;
evData.UidApps.Add(app);
}
model.Appointments.Add(app);
DateTime oldStartTime = app.StartTime;
SetNewByDayAppStartTime(app, dayOfWeek, byDay);
if (app.StartTime < oldStartTime)
recur.SkippedRecurrences.Add(app.StartTime);
ProcessRecurrenceRange(app, recur, evData);
app.Recurrence = recur;
}
private void LoadModel ()
{
ModellData = new CalendarModel ();
IntID = 0;
foreach (Termin Entry in Data.DbServer3.WordUp.Termine.OrderBy(Entry => Entry.Von))
{
InsertOneAppointment ( Entry);
}
}
/// <summary>
/// IcsExporter
/// </summary>
/// <param name="model"></param>
public IcsExporter(CalendarModel model)
{
Model = model;
}
private void AddYearlyByMonthDay(CalendarModel model,
Appointment app, int byMonth, int byMonthDay, VEventData evData)
{
AppointmentRecurrence recur = new AppointmentRecurrence();
recur.RecurrenceType = eRecurrencePatternType.Yearly;
recur.Yearly.RepeatOnMonth = byMonth;
recur.Yearly.RepeatOnRelativeDayInMonth = eRelativeDayInMonth.None;
recur.Yearly.RepeatOnDayOfMonth = byMonthDay;
if (app.Recurrence != null)
{
app = app.Copy();
evData.UidApps.Add(app);
}
model.Appointments.Add(app);
int day = DateTime.DaysInMonth(app.StartTime.Year, byMonth);
if (day < byMonthDay)
byMonthDay = day;
DateTime startTime = new DateTime(app.StartTime.Year,
byMonth, byMonthDay, app.StartTime.Hour, app.StartTime.Minute, 0);
if (startTime < app.StartTime)
recur.SkippedRecurrences.Add(startTime);
if (app.StartTime != startTime)
app.MoveTo(startTime);
ProcessRecurrenceRange(app, recur, evData);
app.Recurrence = recur;
}
/// <summary>
/// ProcessEventEndEx
/// </summary>
/// <param name="model"></param>
/// <param name="entry"></param>
/// <param name="app"></param>
/// <param name="evData"></param>
private void ProcessEventEndEx(CalendarModel model,
CalendarEntry entry, Appointment app, VEventData evData)
{
if (ValidateAppTime(entry, app, evData) == true)
{
if (evData.UidApps == null)
{
evData.UidApps = new List<Appointment>();
evData.UidApps.Add(app);
}
if (evData.RecurRule != null)
{
switch (evData.RecurRule.Freq)
{
case Frequency.Daily:
ProcessDailyRecurrence(model, app, evData);
break;
case Frequency.Weekly:
ProcessWeeklyRecurrence(model, app, evData);
break;
case Frequency.Monthly:
ProcessMonthlyRecurrence(model, app, evData);
break;
case Frequency.Yearly:
ProcessYearlyRecurrence(model, app, evData);
break;
}
ProcessRDateRange(model, app, evData);
}
else
{
model.Appointments.Add(app);
}
ProcessVEventReminder(evData);
}
}
private void LoadModel (DataCollection<CommonSearchClass> StartWithThis)
{
CalendarModelInstance = new CalendarModel();
int IntID = 0;
foreach (CommonSearchClass Entry in StartWithThis)
{
AppointmentCover EntryAppointment = new AppointmentCover
((DateTime) Entry.TimeA, (DateTime) Entry.TimeB, Entry.TypNameID, Entry.ID.ToString ());
EntryAppointment.Tag = Entry;
EntryAppointment.OwnerKey = Entry.ID.ToString ();
EntryAppointment.Id = IntID++;
EntryAppointment.Description = "Von: " + Entry.LastModifiedBy + "\r\n" + Entry.Titel;
EntryAppointment.CategoryColor = DataModell.TypCacheInstance.GetColorForTypID(Entry.TypID);
EntryAppointment.TimeMarkedAs = Appointment.TimerMarkerBusy;
// EntryAppointment.StyleResourceName = new ComponentResourceKey(typeof(CalenderViewControl), "AppView");
CalendarModelInstance.Appointments.Add(EntryAppointment);
}
}
/// <summary>
/// Processes Weekly recurrences
/// </summary>
/// <param name="model"></param>
/// <param name="app"></param>
/// <param name="evData"></param>
private void ProcessWeeklyRecurrence(CalendarModel model, Appointment app, VEventData evData)
{
AppointmentRecurrence recur = new AppointmentRecurrence();
recur.RecurrenceType = eRecurrencePatternType.Weekly;
recur.Weekly.RepeatInterval = evData.RecurRule.Interval;
recur.Weekly.RepeatOnDaysOfWeek = (evData.RecurRule.ByDays == eDayOfWeekRecurrence.None)
? GetRecurrenceDay(app.StartTime)
: evData.RecurRule.ByDays;
ProcessRecurrenceRange(app, recur, evData);
app.Recurrence = recur;
model.Appointments.Add(app);
}
/// <summary>
/// ProcessRDateRange
/// </summary>
/// <param name="model"></param>
/// <param name="app"></param>
/// <param name="evData"></param>
private void ProcessRDateRange(
CalendarModel model, Appointment app, VEventData evData)
{
if (evData.RecurDate != null)
{
if (evData.RecurDate.DtRange != null)
{
foreach (DateRange range in evData.RecurDate.DtRange)
{
Appointment appRange = app.Copy();
appRange.StartTime = range.StartTime;
appRange.EndTime = range.EndTime;
model.Appointments.Add(appRange);
}
}
}
}
/// <summary>
/// Processes Daily recurrences
/// </summary>
/// <param name="model"></param>
/// <param name="app"></param>
/// <param name="evData"></param>
private void ProcessDailyRecurrence(CalendarModel model, Appointment app, VEventData evData)
{
AppointmentRecurrence recur = new AppointmentRecurrence();
recur.RecurrenceType = eRecurrencePatternType.Daily;
recur.Daily.RepeatInterval = evData.RecurRule.Interval;
switch (evData.RecurRule.ByDays)
{
case eDayOfWeekRecurrence.WeekDays:
recur.Daily.RepeatOnDaysOfWeek = eDailyRecurrenceRepeat.WeekDays;
break;
case eDayOfWeekRecurrence.WeekendDays:
recur.Daily.RepeatOnDaysOfWeek = eDailyRecurrenceRepeat.WeekendDays;
break;
}
ProcessRecurrenceRange(app, recur, evData);
app.Recurrence = recur;
model.Appointments.Add(app);
}
/// <summary>
/// Processes Monthly recurrences
/// </summary>
/// <param name="model"></param>
/// <param name="app"></param>
/// <param name="evData"></param>
private void ProcessMonthlyRecurrence(CalendarModel model, Appointment app, VEventData evData)
{
RRule rrule = evData.RecurRule;
if (rrule.ByDays == eDayOfWeekRecurrence.None)
{
if (rrule.ByMonthDay != null)
{
foreach (int day in rrule.ByMonthDay)
AddMonthlyByMonthDay(model, app, day, evData);
}
else
{
AddMonthlyByMonthDay(model, app, app.StartTime.Day, evData);
}
}
else
{
for (int i = 0; i < rrule.ByDay.Length; i++)
{
eDayOfWeekRecurrence eday = ((eDayOfWeekRecurrence)(1 << i));
DayOfWeek dayOfWeek = GetRelativeDayOfWeek(eday);
if ((rrule.ByDays & eday) != 0)
{
foreach (int byDay in rrule.ByDay[i])
AddMonthlyByDay(model, app, dayOfWeek, byDay, evData);
}
}
}
}
