private ScheduleRow[] GetScheduleRows()
{
ScheduleRow[] schedule = new ScheduleRow[_durationInMonths];
for (int i = 0; i < _durationInMonths; i++)
{
int monthNo = i + 1;
double previousBalance = monthNo == 1 ? _amount : schedule[i - 1].Balance;
double interest = GetInterestForGivenBalance(previousBalance);
string dateString = GetPayoffDateForGivenMonthNo(monthNo);
schedule[i] = new ScheduleRow {
MonthNo = monthNo,
Payment = _monthlyPayment,
Interest = interest,
Principal = _monthlyPayment - interest,
Balance = previousBalance - _monthlyPayment + interest,
Date = dateString
};
}
foreach (var row in schedule)
{
row.Payment = Math.Round(row.Payment, 2);
row.Interest = Math.Round(row.Interest, 2);
row.Principal = Math.Round(row.Principal, 2);
row.Balance = Math.Round(row.Balance, 2);
}
return(schedule);
}
public void Post([FromBody] ScheduleRow value)
{
DateTime date;
int ScheduleRowID;
date = value.Date;
using (var sql = new SqlScriptExecutor(GetConectionString))
{
sql.BeginTransaction();
List <KeyValuePair <string, object> > values = new List <KeyValuePair <string, object> >()
{
new KeyValuePair <string, object>("Movie", value.Movie),
new KeyValuePair <string, object>("MovieTheater", value.MovieTheater),
new KeyValuePair <string, object>("Date", date)
};
ScheduleRowID = sql.InsertValues("Schedule", values);
values.Clear();
values.Add(new KeyValuePair <string, object>("ScheduleRow", ScheduleRowID));
values.Add(new KeyValuePair <string, object>());
foreach (var scheduleTime in value.StartTimeList)
{
values[1] = new KeyValuePair <string, object>("Time", scheduleTime.Time);
sql.InsertValues("ScheduleTime", values);
}
sql.CommitTransaction();
}
}
public ScheduleRow AddScheduleRow(uint Interval, string Days, string Time, TaskRow parentTaskRowByTask_Schedule)
{
ScheduleRow rowScheduleRow = ((ScheduleRow)(this.NewRow()));
rowScheduleRow.ItemArray = new object[] {
Interval,
Days,
Time,
parentTaskRowByTask_Schedule[6]
};
this.Rows.Add(rowScheduleRow);
return(rowScheduleRow);
}
public ScheduleRow AddScheduleRow(System.Guid PrimaryID, System.Guid SecondaryID, string Title, System.DateTime Start, System.DateTime Finish, int Category)
{
ScheduleRow rowScheduleRow = ((ScheduleRow)(this.NewRow()));
object[] columnValuesArray = new object[] {
PrimaryID,
SecondaryID,
Title,
Start,
Finish,
Category
};
rowScheduleRow.ItemArray = columnValuesArray;
this.Rows.Add(rowScheduleRow);
return(rowScheduleRow);
}
static ScheduleDto mapToSchedule(ScheduleRow pScheduleRow)
{
if (pScheduleRow == null)
{
return(null);
}
ScheduleDto _schedule = new ScheduleDto();
_schedule.ScheduleId = pScheduleRow.Schedule_id;
_schedule.ScheduleType = pScheduleRow.ScheduleType;
_schedule.DayOfWeek = pScheduleRow.DayOfWeek;
_schedule.DayOfTheMonth1 = pScheduleRow.Day_of_the_month_1;
_schedule.DayOfTheMonth2 = pScheduleRow.Day_of_the_month_2;
return(_schedule);
}
static ScheduleRow mapToScheduleRow(ScheduleDto pSchedule)
{
if (pSchedule == null)
{
return(null);
}
ScheduleRow _scheduleRow = new ScheduleRow();
_scheduleRow.Schedule_id = pSchedule.ScheduleId;
_scheduleRow.ScheduleType = pSchedule.ScheduleType;
_scheduleRow.DayOfWeek = pSchedule.DayOfWeek;
_scheduleRow.Day_of_the_month_1 = pSchedule.DayOfTheMonth1;
_scheduleRow.Day_of_the_month_2 = pSchedule.DayOfTheMonth2;
return(_scheduleRow);
}
internal static void Save(Rbr_Db pDb, ScheduleDto pSchedule)
{
ScheduleRow _scheduleRow = mapToScheduleRow(pSchedule);
if (_scheduleRow != null)
{
if (_scheduleRow.Schedule_id == 0)
{
pDb.ScheduleCollection.Insert(_scheduleRow);
pSchedule.ScheduleId = _scheduleRow.Schedule_id;
}
else
{
pDb.ScheduleCollection.Update(_scheduleRow);
}
}
}
/// <summary>
/// Reads data from the provided data reader and returns
/// an array of mapped objects.
/// </summary>
/// <param name="reader">The <see cref="System.Data.IDataReader"/> object to read data from the table.</param>
/// <param name="startIndex">The index of the first record to map.</param>
/// <param name="length">The number of records to map.</param>
/// <param name="totalRecordCount">A reference parameter that returns the total number
/// of records in the reader object if 0 was passed into the method; otherwise it returns -1.</param>
/// <returns>An array of <see cref="ScheduleRow"/> objects.</returns>
protected virtual ScheduleRow[] MapRecords(IDataReader reader,
int startIndex, int length, ref int totalRecordCount)
{
if (0 > startIndex)
{
throw new ArgumentOutOfRangeException("startIndex", startIndex, "StartIndex cannot be less than zero.");
}
if (0 > length)
{
throw new ArgumentOutOfRangeException("length", length, "Length cannot be less than zero.");
}
int schedule_idColumnIndex = reader.GetOrdinal("schedule_id");
int typeColumnIndex = reader.GetOrdinal("type");
int day_of_weekColumnIndex = reader.GetOrdinal("day_of_week");
int day_of_the_month_1ColumnIndex = reader.GetOrdinal("day_of_the_month_1");
int day_of_the_month_2ColumnIndex = reader.GetOrdinal("day_of_the_month_2");
System.Collections.ArrayList recordList = new System.Collections.ArrayList();
int ri = -startIndex;
while (reader.Read())
{
ri++;
if (ri > 0 && ri <= length)
{
ScheduleRow record = new ScheduleRow();
recordList.Add(record);
record.Schedule_id = Convert.ToInt32(reader.GetValue(schedule_idColumnIndex));
record.Type = Convert.ToByte(reader.GetValue(typeColumnIndex));
record.Day_of_week = Convert.ToInt16(reader.GetValue(day_of_weekColumnIndex));
record.Day_of_the_month_1 = Convert.ToInt32(reader.GetValue(day_of_the_month_1ColumnIndex));
record.Day_of_the_month_2 = Convert.ToInt32(reader.GetValue(day_of_the_month_2ColumnIndex));
if (ri == length && 0 != totalRecordCount)
{
break;
}
}
}
totalRecordCount = 0 == totalRecordCount ? ri + startIndex : -1;
return((ScheduleRow[])(recordList.ToArray(typeof(ScheduleRow))));
}
/// <summary>
/// Updates a record in the <c>Schedule</c> table.
/// </summary>
/// <param name="value">The <see cref="ScheduleRow"/>
/// object used to update the table record.</param>
/// <returns>true if the record was updated; otherwise, false.</returns>
public virtual bool Update(ScheduleRow value)
{
string sqlStr = "UPDATE [dbo].[Schedule] SET " +
"[type]=" + _db.CreateSqlParameterName("Type") + ", " +
"[day_of_week]=" + _db.CreateSqlParameterName("Day_of_week") + ", " +
"[day_of_the_month_1]=" + _db.CreateSqlParameterName("Day_of_the_month_1") + ", " +
"[day_of_the_month_2]=" + _db.CreateSqlParameterName("Day_of_the_month_2") +
" WHERE " +
"[schedule_id]=" + _db.CreateSqlParameterName("Schedule_id");
IDbCommand cmd = _db.CreateCommand(sqlStr);
AddParameter(cmd, "Type", value.Type);
AddParameter(cmd, "Day_of_week", value.Day_of_week);
AddParameter(cmd, "Day_of_the_month_1", value.Day_of_the_month_1);
AddParameter(cmd, "Day_of_the_month_2", value.Day_of_the_month_2);
AddParameter(cmd, "Schedule_id", value.Schedule_id);
return(0 != cmd.ExecuteNonQuery());
}
private void SetData(List <ScheduleItem> scheduleItems)
{
if (scheduleItems != null && scheduleRowPrefab != null)
{
foreach (ScheduleItem scheduleItem in scheduleItems)
{
GameObject scheduleRowObject = Instantiate(scheduleRowPrefab);
scheduleRowObject.transform.SetParent(scheduleGrid.transform, false);
ScheduleRow scheduleRow = scheduleRowObject.GetComponent <ScheduleRow>();
if (scheduleRow != null)
{
scheduleRow.ScrollContainer = this.ScrollContainer;
scheduleRow.ScrollSnapContainer = this.ScrollSnapContainer;
scheduleRow.SetData(scheduleItem);
}
}
}
}
/// <summary>
/// Converts <see cref="System.Data.DataRow"/> to <see cref="ScheduleRow"/>.
/// </summary>
/// <param name="row">The <see cref="System.Data.DataRow"/> object to be mapped.</param>
/// <returns>A reference to the <see cref="ScheduleRow"/> object.</returns>
protected virtual ScheduleRow MapRow(DataRow row)
{
ScheduleRow mappedObject = new ScheduleRow();
DataTable dataTable = row.Table;
DataColumn dataColumn;
// Column "Schedule_id"
dataColumn = dataTable.Columns["Schedule_id"];
if (!row.IsNull(dataColumn))
{
mappedObject.Schedule_id = (int)row[dataColumn];
}
// Column "Type"
dataColumn = dataTable.Columns["Type"];
if (!row.IsNull(dataColumn))
{
mappedObject.Type = (byte)row[dataColumn];
}
// Column "Day_of_week"
dataColumn = dataTable.Columns["Day_of_week"];
if (!row.IsNull(dataColumn))
{
mappedObject.Day_of_week = (short)row[dataColumn];
}
// Column "Day_of_the_month_1"
dataColumn = dataTable.Columns["Day_of_the_month_1"];
if (!row.IsNull(dataColumn))
{
mappedObject.Day_of_the_month_1 = (int)row[dataColumn];
}
// Column "Day_of_the_month_2"
dataColumn = dataTable.Columns["Day_of_the_month_2"];
if (!row.IsNull(dataColumn))
{
mappedObject.Day_of_the_month_2 = (int)row[dataColumn];
}
return(mappedObject);
}
/// <summary>
/// Adds a new record into the <c>Schedule</c> table.
/// </summary>
/// <param name="value">The <see cref="ScheduleRow"/> object to be inserted.</param>
public virtual void Insert(ScheduleRow value)
{
string sqlStr = "INSERT INTO [dbo].[Schedule] (" +
"[schedule_id], " +
"[type], " +
"[day_of_week], " +
"[day_of_the_month_1], " +
"[day_of_the_month_2]" +
") VALUES (" +
_db.CreateSqlParameterName("Schedule_id") + ", " +
_db.CreateSqlParameterName("Type") + ", " +
_db.CreateSqlParameterName("Day_of_week") + ", " +
_db.CreateSqlParameterName("Day_of_the_month_1") + ", " +
_db.CreateSqlParameterName("Day_of_the_month_2") + ")";
IDbCommand cmd = _db.CreateCommand(sqlStr);
AddParameter(cmd, "Schedule_id", value.Schedule_id);
AddParameter(cmd, "Type", value.Type);
AddParameter(cmd, "Day_of_week", value.Day_of_week);
AddParameter(cmd, "Day_of_the_month_1", value.Day_of_the_month_1);
AddParameter(cmd, "Day_of_the_month_2", value.Day_of_the_month_2);
cmd.ExecuteNonQuery();
}
public PlannedMaterial(ScheduleRow s, Material m){
ScheduleRow = s;
Material = m;
}
internal static ScheduleDto Get(Rbr_Db pDb, int pScheduleId)
{
ScheduleRow _scheduleRow = pDb.ScheduleCollection.GetByPrimaryKey(pScheduleId);
return(mapToSchedule(_scheduleRow));
}
/// <summary>
/// Deletes the specified object from the <c>Schedule</c> table.
/// </summary>
/// <param name="value">The <see cref="ScheduleRow"/> object to delete.</param>
/// <returns>true if the record was deleted; otherwise, false.</returns>
public bool Delete(ScheduleRow value)
{
return(DeleteByPrimaryKey(value.Schedule_id));
}
public void Put(int id, [FromBody] ScheduleRow value)
{
DateTime date;
int ScheduleRowID = id;
date = value.Date;
using (var sql = new SqlScriptExecutor(GetConectionString))
{
sql.BeginTransaction();
//Сохраним саму запись
List <KeyValuePair <string, object> > values = new List <KeyValuePair <string, object> >()
{
new KeyValuePair <string, object>("Movie", value.Movie),
new KeyValuePair <string, object>("MovieTheater", value.MovieTheater),
new KeyValuePair <string, object>("Date", date)
};
sql.UpdateValues("Schedule", id, values);
values.Clear();
values.Add(new KeyValuePair <string, object>("ScheduleRow", ScheduleRowID));
values.Add(new KeyValuePair <string, object>());
LinkedList <int> timesToDelete = new LinkedList <int>(); //Список элементов на удаление
LinkedList <ScheduleTime> timesToUpdate = new LinkedList <ScheduleTime>(); //Список элементов на обновление
ScheduleTime[] timesToInsert = value.StartTimeList.Where(it => it.ID == 0).ToArray(); //Список элементов на добавление
//Просмотрим существующие записи о времени. Вслучае, если передаваемые записи на изменение были удалены,
//Запретим менять запись, выкинув Exception.
const string cmdText = "SELECT [ID] FROM [ScheduleTime] WHERE [ScheduleRow] = @id ORDER BY [ID]";
using (SqlCommand cmd = new SqlCommand(cmdText))
{
cmd.Parameters.Add(new SqlParameter("@id", id));
//Упорядочим идентификаторы существующих записей для сравнения с записями в БД
ScheduleTime[] orderedTime = value.StartTimeList.Where(it => it.ID != 0).OrderBy(it => it.ID).ToArray();
int i = 0;
int valueFromReader = -1;
ScheduleTime currentTime = null;
//Сравним две упорядоченные цепочки идентификаторов
using (var reader = sql.ExecuteReader(cmd))
{
bool readerEnd = !reader.Read();
bool localValuesEnd = i == orderedTime.Length;
while (!readerEnd && !localValuesEnd)
{
valueFromReader = reader.GetInt32(0);
currentTime = orderedTime[i];
if (currentTime.ID == valueFromReader)//Оба значения есть и там и там, всё впорядке, обновим запись. Двигаем обе цепочки
{
timesToUpdate.AddLast(currentTime);
readerEnd = !reader.Read();
localValuesEnd = ++i == orderedTime.Length;
}
else if (currentTime.ID < valueFromReader) //Записи в БД нет, то есть она была удалена за время редактирования. Продолжение невозможно. Выкидываем Exception
{
throw new Exception("Информация устарела, обновите редактор");
}
else //(currentTime.ID > valueFromReader) //Есть запись в БД, которой нет локально - Двигаем reader
{
timesToDelete.AddLast(valueFromReader);
readerEnd = !reader.Read();
}
}
if (!readerEnd) //Если остались записи в БД, которых нет локально
{
do
{
timesToDelete.AddLast(reader.GetInt32(0));
}while (reader.Read());
}
else if (!localValuesEnd) //Остались записи, которых нет в БД
{
throw new Exception("Информация устарела, обновите редактор");
}
}
}
foreach (var currentID in timesToDelete)
{
sql.DeleteValues("ScheduleTime", currentID);
}
foreach (var currentTime in timesToUpdate)
{
values[1] = new KeyValuePair <string, object>("Time", currentTime.Time);
sql.UpdateValues("ScheduleTime", currentTime.ID, values);
}
foreach (var currentTime in timesToInsert)
{
values[1] = new KeyValuePair <string, object>("Time", currentTime.Time);
sql.InsertValues("ScheduleTime", values);
}
sql.CommitTransaction();
}
}
public ScheduleRowChangeEvent(ScheduleRow row, global::System.Data.DataRowAction action)
{
this.eventRow = row;
this.eventAction = action;
}
public void RemoveScheduleRow(ScheduleRow row)
{
this.Rows.Remove(row);
}
public ApiResponse <object> CreateSchedule(DataModels.User dataUser, Schedule schedule)
{
if (schedule.Title == null)
{
return(new ApiResponse <object>("Schedule's title can't be null"));
}
schedule.Title = schedule.Title.Trim();
if (schedule.Title == string.Empty)
{
return(new ApiResponse <object>("Schedule's title can't be empty"));
}
if (schedule.Title.Length > 50)
{
return(new ApiResponse <object>("Schedule's title can't be greater then 50 symbols"));
}
if (schedule.ScheduleRows == null || schedule.ScheduleRows.Count() == 0)
{
return(new ApiResponse <object>("Schedule rows can't be null or empty"));
}
IEnumerable <int> orderList = schedule.ScheduleRows.Select(x => x.Order);
List <int> sortOrderList = orderList.OrderBy(x => x).ToList();
int sortOrderCount = sortOrderList.Last() - sortOrderList.First() + 1;
if (sortOrderCount > sortOrderList.Count)
{
return(new ApiResponse <object>("Order list has gaps"));
}
if (sortOrderCount < sortOrderList.Count)
{
return(new ApiResponse <object>("Order list has duplicates"));
}
IEnumerable <IGrouping <int, ScheduleRow> > scheduleRowsGroupIndex = schedule.ScheduleRows.GroupBy(x => x.UserId);
//foreach (var sr in scheduleRowsGroupIndex)
//{
// if (sr.GroupBy(x => x.CreateRandomOrder).Count() > 1)
// return new ApiResponse<object>($"User {sr.Key} have more then one order");
//}
DataModels.Schedule dataSchedule = new DataModels.Schedule()
{
BlockSize = sortOrderList.Count,
DateCreated = DateTime.UtcNow,
Title = schedule.Title,
UserId = dataUser.Id,
};
_dbContext.Schedules.Add(dataSchedule);
_dbContext.SaveChanges();
int addedScheduleId = dataSchedule.Id;
var dataScheduleRowList = new List <DataModels.ScheduleRow>();
foreach (var sr in scheduleRowsGroupIndex)
{
ScheduleRow firstScheduleRow = sr.First();
//if(firstScheduleRow.CreateRandomOrder)
//{
// CreateRandomOrderForUser(firstScheduleRow.UserId, addedScheduleId);
//}
for (int i = 0; i < sr.Count(); i++)
{
dataScheduleRowList.Add(new DataModels.ScheduleRow()
{
GroupIndex = i + 1,
Order = sr.ElementAt(i).Order,
ScheduleId = addedScheduleId,
UserId = firstScheduleRow.UserId,
});
}
}
_dbContext.ScheduleRows.AddRange(dataScheduleRowList);
_dbContext.SaveChanges();
return(new ApiResponse <object>()
{
Ok = true,
Data = dataSchedule,
});
}
public void AddScheduleRow(ScheduleRow row)
{
this.Rows.Add(row);
}
public ActionResult ShowSchedule(int?courseId)
{
if (courseId == null)
{
ApplicationUser currentUser = db.Users
.Where(u => u.UserName == User.Identity.Name)
.FirstOrDefault();
courseId = currentUser.CourseId;
}
ScheduleVM schedule = new ScheduleVM();
//var courseId = currentUser.CourseId;
var course = db.Courses.Find(courseId);
//Activities List for one module
List <Activity> activities = new List <Activity>();
//Activities List for all modules
List <Activity> completeActivitiesList = new List <Activity>();
//Activities List for all modules sorted on start date
List <Activity> sortedActivities = new List <Activity>();
//Read modules from database for this course
var modules = db.Modules.Where(c => c.CourseId == courseId)
.OrderByDescending(s => s.StartDate).ToList();
schedule.CourseName = course.Name;
schedule.ModuleExists = true;
//Read all activities for all modules from the database if modules were found for the course
if (modules.Count > 0)
{
foreach (var item in modules)
{
//Read activities for one module
var moduleId = item.Id;
activities = db.Activities.Where(m => m.ModuleId == moduleId)
.ToList();
foreach (var activityItem in activities)
{
completeActivitiesList.Add(activityItem);
}
}
//Sort all activities according to start date
sortedActivities = completeActivitiesList.OrderByDescending(s => s.StartDate).ToList();
string activityType = " ";
//Calculate number of schedule rows based course start date and end date
TimeSpan courseSpan;
courseSpan = course.EndDate - course.StartDate;
int numberOfDays = int.Parse((courseSpan.Days + 1).ToString());
List <ScheduleRow> rowList = new List <ScheduleRow>();
//Populate viewmodel properties by iterating over each row in the schedule
for (int i = 0; i < numberOfDays; i++)
{
//Instantiate a new scheduleRow in the viewmodel
ScheduleRow scheduleRow = new ScheduleRow();
//Assign values to the ScheduleRowDate and ScheduleRowWeekDay properties in the viewmodel
var dateInSchedule = course.StartDate.AddDays(i);
scheduleRow.ScheduleRowDate = dateInSchedule.ToShortDateString();
scheduleRow.ScheduleRowWeekDay = dateInSchedule.DayOfWeek.ToString();
//Reset all hours, minutes and seconds to 0 in module DateTime properties. This will
//enable a correct comparison when checking for a module for this date.
foreach (var item in modules)
{
item.StartDate = item.StartDate.Date;
item.EndDate = item.EndDate.Date;
}
//Check if there is a module for this date
var module = modules.Where(s => s.StartDate <= dateInSchedule)
.Where(e => e.EndDate >= course.StartDate.AddDays(i - 1))
.FirstOrDefault();
//If there is a module for this date, assign it to the viewmodel,
//else assign an empty string to the module name in the viewmodel.
if (module != null)
{
//Assign the module name to the viewmodel if it is weekday
if (dateInSchedule.DayOfWeek.ToString() != "Saturday" && dateInSchedule.DayOfWeek.ToString() != "Sunday")
{
scheduleRow.ModuleName = module.Name;
//Check if there are any activities for this date
var activitiesForThisDate = sortedActivities.Where(s => s.StartDate.Date == course.StartDate.Date.AddDays(i))
.OrderBy(t => t.StartDate.TimeOfDay)
.ToList();
//Read activity type names into a list
if (activitiesForThisDate.Count > 0)
{
List <AmObject> amActivities = new List <AmObject>();
List <PmObject> pmActivities = new List <PmObject>();
foreach (var item in activitiesForThisDate)
{
//The following is only needed if activities are allowed to span more than one day. Not yet implemented.
//Check if the start date of the activity is less than the current date. If it is the set start time = 8:30.
//Check if the end date of the activity is greater than the current date. If it is the set end time = 17:00.
//Read activity type names into a List of strings
activityType = db.ActivityTypes.Find(item.ActivityTypeId).TypeName;
var amObject = new AmObject();
var pmObject = new PmObject();
//Check if the activity is in the morning
if (item.StartDate.Hour < 12 && item.EndDate.Hour <= 12)
{
if (!item.External)
{
amObject.AmActivityTitle = item.StartDate.ToShortTimeString() + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name;
amObject.AmActivityDescription = item.Description;
amActivities.Add(amObject);
}
else
{
amObject.AmActivityTitle = item.StartDate.ToShortTimeString() + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name + " (EXT)";
amObject.AmActivityDescription = item.Description;
amActivities.Add(amObject);
}
}
//Check if the activity is in the afternoon
else if (item.StartDate.Hour >= 12)
{
if (!item.External)
{
pmObject.PmActivityTitle = item.StartDate.ToShortTimeString() + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name;
pmObject.PmActivityDescription = item.Description;
pmActivities.Add(pmObject);
}
else
{
pmObject.PmActivityTitle = item.StartDate.ToShortTimeString() + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name + "(EXT)";
pmObject.PmActivityDescription = item.Description;
pmActivities.Add(pmObject);
}
}
//The activity starts before lunch and finishes after lunch. Split it in one morning activity and one
//afternoon activity.
else
{
if (!item.External)
{
amObject.AmActivityTitle = item.StartDate.ToShortTimeString() + " - " + "12:00"
+ ": " + activityType + ", " + item.Name;
amObject.AmActivityDescription = item.Description;
pmObject.PmActivityTitle = "13:00" + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name;
pmObject.PmActivityDescription = item.Description;
amActivities.Add(amObject);
pmActivities.Add(pmObject);
}
else
{
amObject.AmActivityTitle = item.StartDate.ToShortTimeString() + " - " + "12:00"
+ ": " + activityType + ", " + item.Name + " (EXT)";
amObject.AmActivityDescription = item.Description;
pmObject.PmActivityTitle = "13:00" + " - " + item.EndDate.ToShortTimeString()
+ ": " + activityType + ", " + item.Name + " (EXT)";
pmObject.PmActivityDescription = item.Description;
amActivities.Add(amObject);
pmActivities.Add(pmObject);
}
}
}
scheduleRow.AmActivity = amActivities;
scheduleRow.PmActivity = pmActivities;
}
}
else
{
scheduleRow.ModuleName = "";
}
}
else
{
scheduleRow.ModuleName = "";
}
rowList.Add(scheduleRow);
}
schedule.ScheduleRowList = rowList;
}
else
{
schedule.ModuleExists = false;
}
schedule.UpdatedDate = course.DateChanged;
return(View("Schedule", schedule));
}
