public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.Where(p => p.Tasks.Count() > 0)
.ToArray()
.Select(project => new ExportProjectsModel
{
TasksCount = project.Tasks.Count,
ProjectName = project.Name,
HasEndDate = project.DueDate.HasValue ? "Yes" : "No",
Tasks = project.Tasks.ToArray().Select(task => new ExportTaskModel
{
Name = task.Name,
Label = task.LabelType.ToString(),
})
.OrderBy(task => task.Name)
.ToArray()
})
.OrderByDescending(project => project.TasksCount)
.ThenBy(project => project.ProjectName)
.ToArray();
StringBuilder sb = new StringBuilder();
var namespaces = new XmlSerializerNamespaces();
namespaces.Add(String.Empty, String.Empty);
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ExportProjectsModel[]), new XmlRootAttribute("Projects"));
using (StringWriter writer = new StringWriter(sb))
{
xmlSerializer.Serialize(writer, projects, namespaces);
}
return(sb.ToString().TrimEnd());
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employee = context.Employees
.ToArray()
.Where(x => x.EmployeesTasks.Any(y => y.Task.OpenDate >= date))
.Select(x => new
{
x.Username,
Tasks = x.EmployeesTasks
.Where(y => y.Task.OpenDate >= date)
.OrderByDescending(d => d.Task.DueDate)
.ThenBy(n => n.Task.Name)
.Select(t => new
{
TaskName = t.Task.Name,
OpenDate = t.Task.OpenDate
.ToString("d", CultureInfo.InvariantCulture),
DueDate = t.Task.DueDate
.ToString("d", CultureInfo.InvariantCulture),
LabelType = t.Task.LabelType,
ExecutionType = t.Task.ExecutionType
})
.ToArray()
})
.OrderByDescending(x => x.Tasks.Count())
.ThenBy(x => x.Username)
.Take(10)
.ToArray();
return(JsonConvert.SerializeObject(employee, Formatting.Indented));
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employees = context.Employees
.ToArray()
.Where(e => e.EmployeesTasks.Any(et => et.Task.OpenDate >= date))
.Select(e => new
{
Username = e.Username,
Tasks = e.EmployeesTasks
.Where(t => t.Task.OpenDate >= date)
.OrderByDescending(t => t.Task.DueDate)
.ThenBy(t => t.Task.Name)
.Select(t => new
{
TaskName = t.Task.Name,
OpenDate = t.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = t.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = t.Task.LabelType.ToString(),
ExecutionType = t.Task.ExecutionType.ToString()
})
.ToArray()
})
.OrderByDescending(e => e.Tasks.Length)
.ThenBy(e => e.Username)
.Take(10)
.ToArray();
string jsonResult = JsonConvert.SerializeObject(employees, Formatting.Indented);
return(jsonResult);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var rootName = "Projects";
var dtos = context.Projects
.Include(p => p.Tasks)
.ToList()
.Where(p => p.Tasks.Any())
.Select(p => new ExportProjectsWithTasksDTO
{
TasksCount = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate == null ? "No" : "Yes",
Tasks = p.Tasks.Select(t => new ExportTaskPartialDTO
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToList()
})
.OrderByDescending(p => p.TasksCount)
.ThenBy(p => p.ProjectName)
.ToList();
return(XMLCustomSerializer.Serialize(dtos, rootName));
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
XmlSerializer sertializer = new XmlSerializer(typeof(ProjectsExport[]), new XmlRootAttribute("Projects"));
var projects = context.Projects.ToArray().Where(p => p.Tasks.Any())
.Select(p => new ProjectsExport
{
ProjectName = p.Name,
TasksCount = p.Tasks.Count,
HasEndDate = p.DueDate.HasValue ? "Yes" : "No",
Tasks = p.Tasks.Select(x => new TasksXmlExport
{
LabelName = x.LabelType.ToString(),
Name = x.Name
}).OrderBy(x => x.Name).ToArray()
}).OrderByDescending(x => x.TasksCount).ThenBy(x => x.ProjectName).ToArray();
var xml = XmlConverter.Serialize(projects, "Projects");
return(xml);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.ToArray() //for judge
.Where(x => x.Tasks.Count() > 0)
.Select(x => new ProjectsWithTheirTasksDTO
{
ProjectName = x.Name,
TasksCount = x.Tasks.Count(),
HasEndDate = x.DueDate == null ? "No" : "Yes", //.HasValue
Tasks = x.Tasks.Select(y => new TaskDTO
{
Name = y.Name,
Label = y.LabelType.ToString()
//or Label = Enum.GetName(typeof(LabelType), y.LabelType)
}).OrderBy(y => y.Name)
.ToArray()
}).OrderByDescending(x => x.TasksCount)
.ThenBy(x => x.ProjectName)
.ToArray();
var result = XmlConverter.Serialize(projects, "Projects");
return(result);
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var emplyees = context.Employees
.Where(e => e.EmployeesTasks.Any(t => t.Task.OpenDate >= date))
.OrderByDescending(e => e.EmployeesTasks.Count(t => t.Task.OpenDate >= date))
.ThenBy(e => e.Username)
.Select(e => new ExportEmployeeDto
{
Username = e.Username,
Tasks = e.EmployeesTasks
.Where(t => t.Task.OpenDate >= date)
.Select(t => new ExportTaskDto
{
TaskName = t.Task.Name,
LabelType = t.Task.LabelType.ToString(),
ExecutionType = t.Task.ExecutionType.ToString(),
DueDate = t.Task.DueDate.ToString(@"d", CultureInfo.InvariantCulture),
OpenDate = t.Task.OpenDate.ToString(@"d", CultureInfo.InvariantCulture)
})
.OrderByDescending(t => DateTime.ParseExact(t.DueDate, @"d", CultureInfo.InvariantCulture))
.ThenBy(t => t.TaskName)
.ToList()
})
.Take(10)
.ToList();
var json = JsonConvert.SerializeObject(emplyees, Formatting.Indented);
return(json);
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var result = context.Employees
.ToList()
.Where(x => x.EmployeesTasks.Count > 0)
.Select(x => new
{
Username = x.Username,
Tasks = x.EmployeesTasks
.Where(t => t.Task.OpenDate >= date)
.OrderByDescending(t => t.Task.DueDate)
.ThenBy(t => t.Task.Name)
.Select(t => new
{
TaskName = t.Task.Name,
OpenDate = t.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = t.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = t.Task.LabelType.ToString(),
ExecutionType = t.Task.ExecutionType.ToString()
})
.ToList()
})
.OrderByDescending(x => x.Tasks.Count)
.ThenBy(x => x.Username)
.Take(10)
.ToList();
string json = JsonConvert.SerializeObject(result, Formatting.Indented);
return(json);
}
//Export all projects that have at least one task.For each project, export its name, tasks count, and if it has end(due) date
// which is represented like "Yes" and "No". For each task, export its name and label type.Order the tasks by name (ascending).
// Order the projects by tasks count (descending), then by name (ascending).
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var sb = new StringBuilder();
var projects = context.Projects.Where(p => p.Tasks.Any()).ToArray()
.Select(x => new ExportProjectsTasks
{
TasksCount = x.Tasks.Count,
ProjectName = x.Name,
HasEndDate = x.DueDate.HasValue ? "Yes" : "No",
Tasks = x.Tasks.Select(t => new ExportTaskDto
{
Name = t.Name,
Label = t.LabelType.ToString()
}).ToArray().OrderBy(y => y.Name).ToArray()
}).OrderByDescending(t => t.Tasks.Count()).ThenBy(t => t.ProjectName).ToList();
var xmlSerializer = new XmlSerializer(typeof(List <ExportProjectsTasks>)
, new XmlRootAttribute("Projects"));
var namespaces = new XmlSerializerNamespaces();
namespaces.Add("", "");
using (var writer = new StringWriter(sb))
{
xmlSerializer.Serialize(writer, projects, namespaces);
}
return(sb.ToString().Trim());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
var projectsDto = XmlConvert.Deserialize <XmlProjectImportModel>(xmlString, "Projects");
foreach (var projectDto in projectsDto)
{
if (IsValid(projectDto) == false ||
DateTime.TryParseExact(projectDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectOpenDate) == false)
{
sb.AppendLine(ErrorMessage);
continue;
}
bool hasDueDate = DateTime.TryParseExact(projectDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectDueDate);
var project = new Project
{
Name = projectDto.Name,
DueDate = hasDueDate ? (DateTime?)projectDueDate : null,
OpenDate = projectOpenDate,
};
foreach (var taskDto in projectDto.Tasks)
{
if (IsValid(taskDto) == false ||
DateTime.TryParseExact(taskDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskOpenDate) == false ||
DateTime.TryParseExact(taskDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskDueDate) == false ||
taskOpenDate.Date < projectOpenDate.Date)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (hasDueDate)
{
if (taskDueDate.Date > projectDueDate.Date)
{
sb.AppendLine(ErrorMessage);
continue;
}
}
project.Tasks.Add(new Task
{
Name = taskDto.Name,
DueDate = taskDueDate,
LabelType = (LabelType)taskDto.LabelType,
OpenDate = taskOpenDate,
ExecutionType = (ExecutionType)taskDto.ExecutionType,
});
}
context.Projects.Add(project);
sb.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
}
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var result = context.Projects
.ToArray()
.Where(x => x.Tasks.Count > 0)
.Select(x => new ProjectViewModel
{
TasksCount = x.Tasks.Count,
ProjectName = x.Name,
HasEndDate = x.DueDate.HasValue ? "Yes" : "No",
Tasks = x.Tasks.Select(t => new TaskViewModel
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(x => x.Name)
.ToArray()
})
.OrderByDescending(x => x.TasksCount)
.ThenBy(x => x.ProjectName)
.ToArray();
var xml = XmlConverter.Serialize(result, "Projects");
return(xml);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
XmlRootAttribute xmlRoot = new XmlRootAttribute("Projects");
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ExportProjectDto[]), xmlRoot);
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
namespaces.Add(string.Empty, string.Empty);
ExportProjectDto[] projectsWithTasks = context
.Projects
.Where(p => p.Tasks.Count > 0)
.Select(p => new ExportProjectDto
{
ProjectName = p.Name,
TasksCount = p.Tasks.Count.ToString(),
HasEndDate = p.DueDate.HasValue ? "Yes" : "No",
Tasks = p.Tasks.Select(t => new ExportTaskDto
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToArray()
})
.OrderByDescending(p => p.TasksCount)
.ThenBy(p => p.ProjectName)
.ToArray();
StringBuilder sb = new StringBuilder();
StringWriter stringWriter = new StringWriter(sb);;
xmlSerializer.Serialize(stringWriter, projectsWithTasks, namespaces);
return(sb.ToString().TrimEnd());
}
private static string AddTasks(TeisterMaskContext context, Project project, TaskImportDTO[] tasks)
{
StringBuilder result = new StringBuilder();
foreach (var taskDto in tasks)
{
if (IsValid(taskDto) &&
IsValidOpenDate(taskDto.OpenDate, project.OpenDate) &&
IsValidDueDate(taskDto.DueDate, project.DueDate))
{
Task task = new Task
{
Name = taskDto.Name,
OpenDate = DateTime.ParseExact(taskDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture),
DueDate = DateTime.ParseExact(taskDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture),
ExecutionType = (ExecutionType)taskDto.ExcecutionType,
LabelType = (LabelType)taskDto.LabelType,
Project = project
};
context.Add(task);
}
else
{
result.AppendLine(ErrorMessage);
}
}
context.SaveChanges();
return(result.ToString().TrimEnd());
}
private static string AddEmployeeTasks(TeisterMaskContext context, Employee employee, int[] tasks)
{
StringBuilder result = new StringBuilder();
foreach (var task in tasks)
{
if (IsTaskValid(context, task))
{
EmployeeTask employeeTask = new EmployeeTask
{
Employee = employee,
TaskId = task
};
context.EmployeesTasks.Add(employeeTask);
}
else
{
result.AppendLine(ErrorMessage);
}
}
context.SaveChanges();
return(result.ToString().TrimEnd());
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var output = context
.Projects
.Where(p => p.Tasks.Any())
.OrderByDescending(p => p.Tasks.Count())
.ThenBy(p => p.Name)
.Select(p => new ProjectWithTheirTasksDto
{
TasksCount = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate == null ? "No" : "Yes",
Tasks = p.Tasks
.OrderBy(t => t.Name)
.Select(t => new TaskExportDto
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.ToArray()
})
.ToArray();
StringBuilder sb = new StringBuilder();
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
XmlSerializer serializer = new XmlSerializer(typeof(ProjectWithTheirTasksDto[]), new XmlRootAttribute("Projects"));
serializer.Serialize(new StringWriter(sb), output, namespaces);
return(sb.ToString().TrimEnd());
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employees = context.Employees
.Where(e => e.EmployeesTasks.Any(t => t.Task.OpenDate >= date))
.OrderByDescending(e => e.EmployeesTasks.Count)
.ThenBy(e => e.Username)
.Take(10)
.Select(e => new EmployeeExportDto()
{
Username = e.Username,
Tasks = e.EmployeesTasks
.Where(t => t.Task.OpenDate >= date)
.OrderByDescending(et => et.Task.DueDate)
.ThenBy(et => et.Task.Name)
.Select(et => new TaskExportDto()
{
TaskName = et.Task.Name,
OpenDate = et.Task.OpenDate.ToString("MM/dd/yyyy"),
DueDate = et.Task.DueDate.ToString("MM/dd/yyyy"),
LabelType = et.Task.LabelType.ToString(),
ExecutionType = et.Task.ExecutionType.ToString()
})
.ToList()
});
var serializer = new JsonSerializer();
var result = JsonConvert.SerializeObject(employees, Formatting.Indented);
return(result);
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var output = context
.Employees
.Where(e => e.EmployeesTasks.Any(t => t.Task.Name.Count() > 0) &&
e.EmployeesTasks.Any(t => t.Task.OpenDate >= date))
.Select(e => new
{
Username = e.Username,
Tasks = e.EmployeesTasks
.Where(em => em.Task.OpenDate >= date)
.OrderByDescending(em => em.Task.DueDate)
.ThenBy(em => em.Task.Name)
.Select(em => new
{
TaskName = em.Task.Name,
OpenDate = em.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = em.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = em.Task.LabelType.ToString(),
ExecutionType = em.Task.ExecutionType.ToString()
})
})
.OrderByDescending(e => e.Tasks.Count())
.ThenBy(e => e.Username)
.Take(10)
.ToArray();
var jsonString = JsonConvert.SerializeObject(output, Formatting.Indented);
return(jsonString);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.Where(p => p.Tasks.Any())
.Select(p => new ProjectExportDto
{
Count = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate != null ? "Yes" : "No",
Tasks = p.Tasks.Select(t => new ProjectTasksExportDto
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToArray()
})
.OrderByDescending(t => t.Count)
.ThenBy(t => t.ProjectName)
.ToArray();
var xmlSerializer = new XmlSerializer(projects.GetType(), new XmlRootAttribute("Projects"));
var result = new StringBuilder();
var namespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
xmlSerializer.Serialize(new StringWriter(result), projects, namespaces);
return(result.ToString().Trim());
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employees = context.Employees
.ToArray() //for judge
.Where(x => x.EmployeesTasks.Any(y => y.Task.OpenDate >= date))
.Select(x => new
{
Username = x.Username,
Tasks = x.EmployeesTasks
.Where(e => e.Task.OpenDate >= date)
.OrderByDescending(y => y.Task.DueDate)
.ThenBy(y => y.Task.Name)
.Select(y => new
{
TaskName = y.Task.Name,
OpenDate = y.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = y.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
//LabelType = Enum.GetName(typeof(LabelType), y.Task.LabelType),
LabelType = y.Task.LabelType.ToString(),
ExecutionType = y.Task.ExecutionType.ToString(),
})
.ToArray()
}).OrderByDescending(x => x.Tasks.Length)
.ThenBy(x => x.Username)
.ToArray().Take(10);
var result = JsonConvert.SerializeObject(employees, Formatting.Indented);
return(result);
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var top10Employees = context.Employees
.Where(e => e.EmployeesTasks.Any(t => t.Task.OpenDate >= date))
.OrderByDescending(e => e.EmployeesTasks.Count(t => t.Task.OpenDate >= date))
.ThenBy(e => e.Username)
.Select(e => new EmployeeExportDto
{
Username = e.Username,
Tasks = e.EmployeesTasks.Where(t => t.Task.OpenDate >= date)
.Select(t => new EmployeeTasksExportDto
{
TaskName = t.Task.Name,
OpenDate = t.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = t.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = t.Task.LabelType.ToString(),
ExecutionType = t.Task.ExecutionType.ToString(),
})
.OrderByDescending(t => DateTime.ParseExact(t.DueDate, "d", CultureInfo.InvariantCulture))
.ThenBy(t => t.TaskName)
.ToArray()
})
.Take(10)
.ToList();
var result = JsonConvert.SerializeObject(top10Employees, Newtonsoft.Json.Formatting.Indented);
return(result);
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employees = context.Employees
.ToArray()
.Where(e => e.EmployeesTasks.Any(et => et.Task.OpenDate >= date))
.OrderByDescending(e => e.EmployeesTasks.Count(et => et.Task.OpenDate >= date))
.Take(10)
.Select(e => new ExportMostBusiestEmployeesDTO
{
Username = e.Username,
Tasks = e.EmployeesTasks
.Where(et => et.Task.OpenDate >= date)
.OrderByDescending(et => et.Task.DueDate)
.ThenBy(et => et.Task.Name)
.Select(et => new ExportTasksDTO
{
TaskName = et.Task.Name,
OpenDate = et.Task.OpenDate.ToString("MM/dd/yyyy"),
DueDate = et.Task.DueDate.ToString("MM/dd/yyyy"),
LabelType = et.Task.LabelType.ToString(),
ExecutionType = et.Task.ExecutionType.ToString()
})
.ToArray()
})
.ToArray()
.OrderByDescending(e => e.Tasks.Length)
.ThenBy(e => e.Username);
var jsonEmployees = JsonConvert.SerializeObject(employees, Formatting.Indented);
return(jsonEmployees);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.Where(x => x.Tasks.Any())
.ToArray()
.OrderByDescending(x => x.Tasks.Count)
.ThenBy(x => x.Name)
.Select(x => new ProjectsExportModel
{
TasksCount = x.Tasks.Count,
ProjectName = x.Name,
HasEndDate = x.DueDate == null ? "No" : "Yes",
Tasks = x.Tasks.Select(x => new TaskExportModel
{
Name = x.Name,
Label = x.LabelType.ToString()
})
.OrderBy(x => x.Name)
.ToArray()
})
.ToArray();
var xml = XmlConverter.Serialize(projects, "Projects");
return(xml);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.Where(x => x.Tasks.Any())
.ToArray()
.Select(x => new ExportProjectDto
{
ProjectName = x.Name,
TasksCount = x.Tasks.Count,
HasEndDate = x.DueDate.HasValue ? "Yes" : "No",
Tasks = x.Tasks
.ToArray()
.Select(t => new ExportTaskDto
{
Name = t.Name,
Label = t.LabelType.ToString(),
})
.OrderBy(t => t.Name)
.ToArray()
})
.OrderByDescending(x => x.Tasks.Length)
.ThenBy(x => x.ProjectName)
.ToArray();
var serializer = new XmlSerializer(typeof(ExportProjectDto[]), new XmlRootAttribute("Projects"));
var sb = new StringBuilder();
var namespaces = new XmlSerializerNamespaces();
namespaces.Add(String.Empty, String.Empty);
serializer.Serialize(new StringWriter(sb), projects, namespaces);
return(sb.ToString().TrimEnd());
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
const int EmployeesToBeTaken = 10;
var employees = context
.Employees
.Where(x => x.EmployeesTasks.Any(y => y.Task.OpenDate >= date))
.Select(x => new EmployeesJsonModel()
{
Username = x.Username,
Tasks = x.EmployeesTasks
.Where(y => y.Task.OpenDate >= date)
.OrderByDescending(y => y.Task.DueDate)
.ThenBy(y => y.Task.Name)
.Select(t => new EmployeesTasksJson()
{
TaskName = t.Task.Name,
OpenDate = t.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = t.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = t.Task.LabelType.ToString(),
ExecutionType = t.Task.ExecutionType.ToString(),
})
.ToList()
})
.OrderByDescending(p => p.Tasks.Count())
.ThenBy(p => p.Username)
.Take(EmployeesToBeTaken)
.ToList();
var jsonResult = JsonConvert.SerializeObject(employees, Formatting.Indented);
return(jsonResult);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var sortedProjects = context
.Projects
.ToArray()
.Where(p => p.Tasks.Any())
.OrderByDescending(p => p.Tasks.Count) // should it be here
.ThenBy(p => p.Name)
.Select(p => new ProjectWithTheirTasksExportModel()
{
ProjectName = p.Name,
TasksCount = p.Tasks.Count().ToString(),
HasEndDate = p.DueDate.HasValue ? "Yes" : "No", // check for bugs
Tasks = p.Tasks.Select(t => new TaskXmlExportModel()
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToArray()
})
.ToArray();
var xmlResult = XmlConverter.Serialize(sortedProjects, "Projects");
return(xmlResult);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.Where(p => p.Tasks.Count > 0)
.ToArray()
.Select(p => new ExportProjectDto
{
TasksCount = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate.HasValue ? "Yes" : "No",
Tasks = p.Tasks.Select(t => new ExportTaskDto
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToArray()
})
.OrderByDescending(p => p.Tasks.Count())
.ThenBy(p => p.ProjectName)
.ToArray();
XmlSerializer serializer = new XmlSerializer(typeof(ExportProjectDto[]), new XmlRootAttribute("Projects"));
StringWriter writer = new StringWriter();
XmlSerializerNamespaces emptyNamespace = new XmlSerializerNamespaces();
emptyNamespace.Add("", "");
serializer.Serialize(writer, projects, emptyNamespace);
return(writer.ToString());
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projectDtos = context
.Projects
.Where(p => p.Tasks.Any())
.OrderByDescending(p => p.Tasks.Count)
.ThenBy(p => p.Name)
.Select(p => new ExportProjectDto
{
TasksCount = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate.HasValue ? "Yes" : "No",
Tasks = p.Tasks
.OrderBy(t => t.Name)
.Select(t => new ExportTaskXmlDto
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.ToArray()
})
.ToArray();
var xmlSerializer = new XmlSerializer(typeof(ExportProjectDto[]),
new XmlRootAttribute("Projects"));
var stringBuilder = new StringBuilder();
var namespaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
xmlSerializer.Serialize(new StringWriter(stringBuilder), projectDtos, namespaces);
return(stringBuilder.ToString().TrimEnd());
}
public static string ExportMostBusiestEmployees(TeisterMaskContext context, DateTime date)
{
var employees = context.Employees
.Where(s => s.EmployeesTasks.Select(a => a.Task).All(g => g.OpenDate >= date))
.Select(e => new
{
Username = e.Username,
Tasks = e.EmployeesTasks.Select(w => new
{
TaskName = w.Task.Name,
OpenDate = w.Task.OpenDate.ToString("d", CultureInfo.InvariantCulture),
DueDate = w.Task.DueDate.ToString("d", CultureInfo.InvariantCulture),
LabelType = w.Task.LabelType.ToString(),
ExecutionType = w.Task.ExecutionType.ToString()
})
.OrderByDescending(d => d.DueDate)
.ThenBy(n => n.TaskName)
.ToArray()
})
.OrderByDescending(k => k.Tasks.Length)
.ThenBy(u => u.Username)
.Take(10)
.ToArray();
var json = JsonConvert.SerializeObject(employees);
return(json);
}
private static void ResetDatabase(TeisterMaskContext context, bool shouldDropDatabase = false)
{
if (shouldDropDatabase)
{
context.Database.EnsureDeleted();
}
if (context.Database.EnsureCreated())
{
return;
}
var disableIntegrityChecksQuery = "EXEC sp_MSforeachtable @command1='ALTER TABLE ? NOCHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(disableIntegrityChecksQuery);
var deleteRowsQuery = "EXEC sp_MSforeachtable @command1='SET QUOTED_IDENTIFIER ON;DELETE FROM ?'";
context.Database.ExecuteSqlCommand(deleteRowsQuery);
var enableIntegrityChecksQuery =
"EXEC sp_MSforeachtable @command1='ALTER TABLE ? WITH CHECK CHECK CONSTRAINT ALL'";
context.Database.ExecuteSqlCommand(enableIntegrityChecksQuery);
var reseedQuery =
"EXEC sp_MSforeachtable @command1='IF OBJECT_ID(''?'') IN (SELECT OBJECT_ID FROM SYS.IDENTITY_COLUMNS) DBCC CHECKIDENT(''?'', RESEED, 0)'";
context.Database.ExecuteSqlCommand(reseedQuery);
}
public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var projects = context.Projects
.ToArray()
.Where(p => p.Tasks.Count > 0)
.OrderByDescending(p => p.Tasks.Count)
.ThenBy(p => p.Name)
.Select(p => new ProjectXmlExportModel
{
TasksCount = p.Tasks.Count.ToString(),
Name = p.Name,
HasEndDate = p.DueDate.HasValue ? "Yes" : "No",
Tasks = p.Tasks.Select(t => new TaskXmlExportModel
{
Name = t.Name,
Label = t.LabelType.ToString()
})
.OrderBy(t => t.Name)
.ToArray()
})
.ToArray();
var xml = XmlConverter.Serialize(projects, "Projects");
return(xml);
}
