public static string ExportProjectWithTheirTasks(TeisterMaskContext context)
{
var targetProjects = context.Projects
.ToList()
.Where(p => p.Tasks.Any())
.Select(p => new ExportProjectWithTasksDto
{
TasksCount = p.Tasks.Count,
ProjectName = p.Name,
HasEndDate = p.DueDate == null || p.DueDate.Value.Year == 1 ? "No" : "Yes",
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)
.ToList();
var resultXml = XmlConverter.Serialize(targetProjects, "Projects");
return(resultXml);
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
var projectsToImport = new List <Project>();
var projects = XmlConverter.Deserializer <ProjectXmlInputModel>(xmlString, "Projects");
foreach (var currentProject in projects)
{
var isValidCurrentProjectOpenDate = DateTime.TryParseExact(
currentProject.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime currentProjectOpenDate);
if (!IsValid(currentProject) ||
!isValidCurrentProjectOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var isValidDueDate = DateTime.TryParseExact(
currentProject.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime currentDueDate);
var projectToAdd = new Project
{
Name = currentProject.Name,
OpenDate = currentProjectOpenDate,
DueDate = isValidDueDate ? (DateTime?)currentDueDate : null,
};
foreach (var currentTask in currentProject.Tasks)
{
var isValidTaskOpenDate = DateTime.TryParseExact(
currentTask.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime currentTaskOpenDate);
var isValidTaskDueDate = DateTime.TryParseExact(
currentTask.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime currentTaskDueDate);
if (!IsValid(currentTask) ||
!isValidTaskOpenDate ||
!isValidTaskDueDate ||
currentTaskOpenDate < currentProjectOpenDate ||
currentTaskDueDate > projectToAdd.DueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var taskToAdd = new Task
{
Name = currentTask.Name,
OpenDate = currentTaskOpenDate,
DueDate = currentTaskDueDate,
ExecutionType = Enum.Parse <ExecutionType>(currentTask.ExecutionType),
LabelType = Enum.Parse <LabelType>(currentTask.LabelType)
};
projectToAdd.Tasks.Add(taskToAdd);
}
projectsToImport.Add(projectToAdd);
sb.AppendLine(string.Format(SuccessfullyImportedProject, projectToAdd.Name, projectToAdd.Tasks.Count));
}
context.Projects.AddRange(projectsToImport);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var data = XmlConverter.Deserializer <ImportProjectDTO>(xmlString, "Projects");
StringBuilder sb = new StringBuilder();
foreach (var item in data)
{
if (!IsValid(item))
{
sb.AppendLine(ErrorMessage);
continue;
}
var validOpenDateProject = DateTime.TryParseExact(item.OpenDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectOpenDate);
if (!validOpenDateProject)
{
sb.AppendLine(ErrorMessage);
continue;
}
var project = new Project
{
Name = item.Name,
OpenDate = projectOpenDate
};
var validProjectDueDate = DateTime.TryParseExact(item.DueDate?.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectDueDate);
if (string.IsNullOrEmpty(item.DueDate))
{
project.DueDate = null;
}
else
{
if (!validProjectDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
project.DueDate = projectDueDate;
}
foreach (var taskDTO in item.Tasks)
{
if (!IsValid(taskDTO))
{
sb.AppendLine(ErrorMessage);
continue;
}
var validOpenDate = DateTime.TryParseExact(taskDTO.OpenDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime openDate);
var validDueDate = DateTime.TryParseExact(taskDTO.DueDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dueDate);
if (!validOpenDate || !validDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
//task open date is before project open date - invalid
if (openDate < dueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
//maybe due date null
if (projectDueDate == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
//task due date is after project due date - invalid
if (dueDate > projectDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var validExecutionType = Enum.TryParse <ExecutionType>(taskDTO.ExecutionType.ToString(), out ExecutionType et);
var validLabelType = Enum.TryParse <LabelType>(taskDTO.LabelType.ToString(), out LabelType lt);
if (!validExecutionType || !validLabelType)
{
sb.AppendLine(ErrorMessage);
continue;
}
var task = new Task
{
Name = taskDTO.Name,
OpenDate = openDate,
DueDate = dueDate,
ExecutionType = et,
LabelType = lt,
};
project.Tasks.Add(task);
}
if (project.Tasks.Count == 0)
{
continue;
}
context.Projects.Add(project);
sb.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
}
context.SaveChanges();
return(sb.ToString());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var projectsDto = XmlConverter.Deserializer <ProjectImportModel>(xmlString, "Projects");
var projects = new List <Project>();
StringBuilder sb = new StringBuilder();
foreach (var currentProject in projectsDto)
{
var isValidProjectOpenDate = DateTime.TryParseExact(currentProject.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectOpenDate);
var isValidProjectDueDate = DateTime.TryParseExact(currentProject.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectDueDate);
if (!IsValid(currentProject) || !isValidProjectOpenDate)
{
sb.AppendLine("Invalid data!");
continue;
}
var tasks = new List <Task>();
foreach (var currentTask in currentProject.Tasks)
{
var isValidTaskOpenDate = DateTime.TryParseExact(currentTask.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskOpenDate);
var isValidTaskDueDate = DateTime.TryParseExact(currentTask.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskDueDate);
int compareOpenDates = DateTime.Compare(taskOpenDate, projectOpenDate);
int compareDueDates = DateTime.Compare(taskDueDate, projectDueDate);
if (!IsValid(currentTask) || !isValidTaskOpenDate || !isValidTaskDueDate || compareOpenDates < 0 || (isValidProjectDueDate && compareDueDates > 0))
{
sb.AppendLine("Invalid data!");
continue;
}
var task = new Task
{
Name = currentTask.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)(currentTask.ExecutionType),
LabelType = (LabelType)(currentTask.LabelType),
};
tasks.Add(task);
}
var project = new Project
{
Name = currentProject.Name,
OpenDate = projectOpenDate,
DueDate = isValidProjectDueDate ? projectDueDate : (DateTime?)null,
Tasks = tasks
};
projects.Add(project);
sb.AppendLine($"Successfully imported project - {project.Name} with {project.Tasks.Count} tasks.");
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
ImportProjectDto[] xmlProjects = XmlConverter.Deserializer <ImportProjectDto>(xmlString, "Projects");
foreach (var xmlProject in xmlProjects)
{
if (!IsValid(xmlProject))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime projectOpenDate;
bool isValidOpenDate = DateTime.TryParseExact(xmlProject.OpenDate,
"dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None,
out projectOpenDate);
if (!isValidOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime projectDueDate;
bool isValidDueDate = DateTime.TryParseExact(xmlProject.DueDate,
"dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None,
out projectDueDate);
DateTime?finalProjectDueDate = isValidDueDate
? (DateTime?)projectDueDate
: null;
List <Task> validTasks = new List <Task>();
foreach (var taskDto in xmlProject.Tasks)
{
if (!IsValid(taskDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskOpenDate;
bool isValidTaskOpenDate = DateTime.TryParseExact(taskDto.OpenDate,
"dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskOpenDate);
if (!isValidTaskOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (taskOpenDate < projectOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskDueDate;
bool isValidTaskDueDate = DateTime.TryParseExact(taskDto.DueDate,
"dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskDueDate);
if (!isValidTaskDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (finalProjectDueDate != null)
{
if (taskDueDate > finalProjectDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
}
Task task = new Task
{
Name = taskDto.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = Enum.Parse <ExecutionType>(taskDto.ExecutionType),
LabelType = Enum.Parse <LabelType>(taskDto.LabelType),
};
validTasks.Add(task);
}
Project project = new Project
{
Name = xmlProject.Name,
OpenDate = projectOpenDate,
DueDate = isValidDueDate ? (DateTime?)projectDueDate : null,
Tasks = validTasks
};
context.Projects.Add(project);
context.SaveChanges();
sb.AppendLine(string.Format(SuccessfullyImportedProject,
project.Name,
project.Tasks.Count));
}
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var projectDtos = XmlConverter.Deserializer <ProjectDTO>(xmlString, "Projects");
var projects = new List <Project>();
var sb = new StringBuilder();
foreach (ProjectDTO projectDto in projectDtos)
{
// Project
if (!IsValid(projectDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
//valid open date
DateTime projectOpenDate;
bool isProjectOpenDateValid = DateTime.TryParseExact(projectDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out projectOpenDate);
if (!isProjectOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
//valid due date
DateTime?projectDueDate;
if (!string.IsNullOrEmpty(projectDto.DueDate))
{
//if we receive date
DateTime projectDueDateValue;
bool isProjectDueDateValid = DateTime.TryParseExact(projectDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out projectDueDateValue);
if (!isProjectDueDateValid)
{
sb.AppendLine(ErrorMessage);
}
projectDueDate = projectDueDateValue;
}
else
{
//if we dont receive date
projectDueDate = null;
}
var pr = new Project
{
Name = projectDto.Name,
OpenDate = projectOpenDate,
DueDate = projectDueDate
};
//validate task
foreach (var taskDto in projectDto.Tasks)
{
if (!IsValid(taskDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var checkExecutionType = Enum.IsDefined(typeof(ExecutionType), taskDto.ExecutionType);
var checkLabelType = Enum.IsDefined(typeof(LabelType), taskDto.LabelType);
//is task open date valid
DateTime taskOpenDate;
bool istaskOpenDateValid = DateTime.TryParseExact(taskDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out taskOpenDate);
if (!istaskOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
//is task duedate valid
DateTime taskDueDate;
bool isTaskDueDateDateValid = DateTime.TryParseExact(taskDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out taskDueDate);
if (!isTaskDueDateDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
//check for open date
if (taskOpenDate < projectOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
//check for due date
if (projectDueDate.HasValue)
{
if (taskDueDate > projectDueDate.Value)
{
sb.AppendLine(ErrorMessage);
continue;
}
}
var task = new Task
{
Name = taskDto.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)taskDto.ExecutionType,
LabelType = (LabelType)taskDto.LabelType,
};
pr.Tasks.Add(task);
}
projects.Add(pr);
sb.AppendLine(string.Format(SuccessfullyImportedProject, pr.Name, pr.Tasks.Count()));
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
ImportProjectModel[] projectDtos = XmlConverter.Deserializer <ImportProjectModel>(xmlString, "Projects");
foreach (var p in projectDtos)
{
if (!IsValid(p))
{
sb.AppendLine(ErrorMessage);
continue;
}
bool isOpenDateValid = DateTime.TryParseExact(p.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out var openDate);
bool isDueDateValid = DateTime.TryParseExact(p.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dueDate);
if (!isOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var project = new Project
{
Name = p.Name,
DueDate = dueDate
};
if (isOpenDateValid)
{
project.OpenDate = openDate;
}
foreach (var t in p.Tasks)
{
if (!IsValid(t))
{
sb.AppendLine(ErrorMessage);
continue;
}
bool isTaskOpenDateValid = DateTime.TryParseExact(t.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out var taskOpenDate);
bool isTaskDueDateValid = DateTime.TryParseExact(t.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out var taskDueDate);
if (taskOpenDate < openDate || (isDueDateValid && taskDueDate > dueDate))
{
sb.AppendLine(ErrorMessage);
continue;
}
var task = new Task
{
Name = t.Name,
ExecutionType = (ExecutionType)t.ExecutionType,
LabelType = (LabelType)t.LabelType
};
if (isTaskOpenDateValid)
{
task.OpenDate = taskOpenDate;
}
if (isTaskDueDateValid)
{
task.DueDate = taskDueDate;
}
project.Tasks.Add(task);
}
context.Projects.Add(project);
context.SaveChanges();
sb.AppendLine(String.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
}
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var projectDTOs = XmlConverter.Deserializer <ProjectTasksImportModel>(xmlString,
"Projects");
var result = new StringBuilder();
foreach (var projectDTO in projectDTOs)
{
if (!IsValid(projectDTO))
{
result.AppendLine(ErrorMessage);
continue;
}
DateTime dueDate;
bool isDueDateValid = DateTime.TryParseExact(projectDTO.DueDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out dueDate);
DateTime openDate;
bool isOpenDateValid = DateTime.TryParseExact(projectDTO.OpenDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out openDate);
if (!isOpenDateValid)
{
result.AppendLine(ErrorMessage);
continue;
}
var project = new Project()
{
Name = projectDTO.Name,
OpenDate = openDate
};
if (!isDueDateValid)
{
project.DueDate = null;
}
else
{
project.DueDate = dueDate;
}
foreach (var taskDTO in projectDTO.Tasks)
{
if (!IsValid(taskDTO))
{
result.AppendLine(ErrorMessage);
continue;
}
DateTime taskDueDate;
bool isTaskDueDateValid = DateTime.TryParseExact(taskDTO.DueDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out taskDueDate);
DateTime taskOpenDate;
bool isTaskOpenDateValid = DateTime.TryParseExact(taskDTO.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out taskOpenDate);
if (!isTaskDueDateValid || !isTaskOpenDateValid)
{
result.AppendLine(ErrorMessage);
continue;
}
if (taskOpenDate < project.OpenDate ||
taskDueDate > project.DueDate) // TODO: might have some bugs
{
result.AppendLine(ErrorMessage);
continue;
}
var task = new Task()
{
Name = taskDTO.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
LabelType = Enum.Parse <LabelType>(taskDTO.LabelType), // should be int
ExecutionType = Enum.Parse <ExecutionType>(taskDTO.ExecutionType)
};
project.Tasks.Add(task);
}
context.Projects.Add(project);
context.SaveChanges();
result.AppendLine(String.Format(SuccessfullyImportedProject, project.Name,
project.Tasks.Count));
}
return(result.ToString().Trim());
//TODO: Check DateTime? DueDate on project
//I dont have to parse the project OpenDate as well as the dates on Task
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var outputResult = new StringBuilder();
var validProjectsToAdd = new List <Project>();
var datetimeDefaulValue = default(DateTime);
var projectsDtos = XmlConverter.Deserializer <ImportProjectDto>(xmlString, "Projects");
foreach (var projectDto in projectsDtos)
{
if (!IsValid(projectDto))
{
outputResult.AppendLine(ErrorMessage);
continue;
}
var projectOpenDate = DateTime.ParseExact(projectDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture);
DateTime dueDateToAdd;
var projectDueDate = DateTime.TryParseExact
(
projectDto.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out dueDateToAdd
);
if (projectDto.DueDate != null && projectDto.DueDate != "" && projectOpenDate > dueDateToAdd)
{
outputResult.AppendLine(ErrorMessage);
continue;
}
var newProject = new Project
{
Name = projectDto.Name,
OpenDate = projectOpenDate,
DueDate = dueDateToAdd
};
foreach (var taskDto in projectDto.Tasks)
{
if (!IsValid(taskDto) ||
!Enum.IsDefined(typeof(ExecutionType), taskDto.ExecutionType) ||
!Enum.IsDefined(typeof(LabelType), taskDto.LabelType))
{
outputResult.AppendLine(ErrorMessage);
continue;
}
var taskOpenDate = DateTime.ParseExact(taskDto.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture);
var taskDueDate = DateTime.ParseExact(taskDto.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture);
if (taskOpenDate < newProject.OpenDate)
{
outputResult.AppendLine(ErrorMessage);
continue;
}
if (newProject.DueDate != datetimeDefaulValue && taskDueDate > newProject.DueDate)
{
outputResult.AppendLine(ErrorMessage);
continue;
}
var newTask = new Task
{
Name = taskDto.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)taskDto.ExecutionType,
LabelType = (LabelType)taskDto.LabelType
};
newProject.Tasks.Add(newTask);
}
validProjectsToAdd.Add(newProject);
outputResult.AppendLine(string.Format(SuccessfullyImportedProject, newProject.Name, newProject.Tasks.Count));
}
context.Projects.AddRange(validProjectsToAdd);
context.SaveChanges();
return(outputResult.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
string root = "Projects";
StringBuilder sb = new StringBuilder();
ProjectInputXmlModel[] projects = XmlConverter.Deserialize <ProjectInputXmlModel>(xmlString, root);
foreach (var currProject in projects)
{
if (!IsValid(currProject))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime openDate;
bool parseOpenDate = DateTime.TryParseExact(currProject.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out openDate);
if (!parseOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime?dueDate;
if (!String.IsNullOrEmpty(currProject.DueDate))
{
DateTime projDueDate;
bool parseDueDate = DateTime
.TryParseExact(currProject.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out projDueDate);
if (!parseDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
dueDate = projDueDate;
}
else
{
dueDate = null;
}
Project project = new Project()
{
Name = currProject.Name,
OpenDate = openDate,
DueDate = dueDate
};
foreach (var currTask in currProject.Tasks)
{
if (!IsValid(currTask))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskOpenDate;
bool parseTaskOpenDate = DateTime.TryParseExact(currTask.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskOpenDate);
if (!parseTaskOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (taskOpenDate < project.OpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskDueDate;
bool parseTaskDueDate = DateTime.TryParseExact(currTask.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskDueDate);
if (!parseTaskDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (project.DueDate.HasValue)
{
if (taskDueDate > project.DueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
}
Task task = new Task()
{
Name = currTask.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)currTask.ExecutionType,
LabelType = (LabelType)currTask.LabelType,
};
project.Tasks.Add(task);
}
context.Projects.Add(project);
context.SaveChanges();
sb.AppendLine($"Successfully imported project - {project.Name} with {project.Tasks.Count()} tasks.");
//sb.AppendLine(String.Format(SuccessfullyImportedBook, book.Name, book.Price));
}
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
var projectDtos = XmlConverter.Deserializer <ProjectDto>(xmlString, "Projects");
List <Project> projects = new List <Project>();
foreach (var projectDto in projectDtos)
{
if (!IsValid(projectDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var IsOpenDateValid = DateTime.TryParseExact(projectDto.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime openDate);
if (!IsOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime?dueDate = null;
if (!string.IsNullOrWhiteSpace(projectDto.DueDate))
{
var isDueDateValid =
DateTime.TryParseExact(projectDto.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime dueDateTp);
if (!isDueDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
dueDate = dueDateTp;
}
Project project = new Project()
{
Name = projectDto.Name,
OpenDate = openDate,
DueDate = dueDate
};
foreach (var task in projectDto.Tasks)
{
if (!IsValid(task))
{
sb.AppendLine(ErrorMessage);
continue;
}
var IsTaskOpenDateValid = DateTime.TryParseExact(task.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime taskOpenDate);
if (!IsTaskOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var IsTaskDueDateValid = DateTime.TryParseExact(task.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime taskDueDate);
if (!IsTaskDueDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (taskOpenDate < openDate || (dueDate.HasValue && taskDueDate > dueDate.Value))
{
sb.AppendLine(ErrorMessage);
continue;
}
Task newTask = new Task()
{
Name = task.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = Enum.Parse <ExecutionType>(task.ExecutionType),
LabelType = Enum.Parse <LabelType>(task.LabelType)
};
project.Tasks.Add(newTask);
}
sb.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
projects.Add(project);
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
var projects = new List <Project>();
var validProjects = XmlConverter
.Deserializer <XmlImportProjectDto>(xmlString, "Projects");
foreach (var currentProject in validProjects)
{
if (!IsValid(currentProject))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime projectOpenDate;
var validProjectOpenDate = DateTime.TryParseExact(
currentProject.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out projectOpenDate);
if (!validProjectOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime?projectDueDate;
if (!string.IsNullOrWhiteSpace(currentProject.DueDate))
{
DateTime nonNullableDate;
var isDueDateProjectValid = DateTime.TryParseExact(
currentProject.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out nonNullableDate);
if (!isDueDateProjectValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
projectDueDate = nonNullableDate;
}
else
{
projectDueDate = null;
}
var project = new Project
{
Name = currentProject.Name,
OpenDate = projectOpenDate,
DueDate = projectDueDate
};
//We need to validate the tasks as well
foreach (var taskDto in currentProject.Tasks)
{
if (!IsValid(taskDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskOpenDate;
var validTaskOpenDate = DateTime.TryParseExact(
taskDto.OpenDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskOpenDate);
if (!validTaskOpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskDueDate;
var validTaskDueDate = DateTime.TryParseExact(
taskDto.DueDate,
"dd/MM/yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out taskDueDate);
if (!validTaskDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (taskOpenDate < projectOpenDate || taskDueDate > projectDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var task = new Task
{
Name = taskDto.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)taskDto.ExecutionType,
LabelType = (LabelType)taskDto.LabelType
};
project.Tasks.Add(task);
}
projects.Add(project);
sb
.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count()));
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
const string root = "Projects";
var projectsDto = XmlConverter.Deserializer <ProjectInputModel>(xmlString, root);
List <Project> projects = new List <Project>();
foreach (var project in projectsDto)
{
if (!IsValid(project))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime outDate;
bool isValidDate = DateTime
.TryParseExact(project.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out outDate);
DateTime?dueDate = null;
bool isValidDateDueDate = false;
if (!string.IsNullOrEmpty(project.DueDate))
{
DateTime dueDateValue;
isValidDateDueDate = DateTime.TryParseExact(project.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out dueDateValue);
if (!isValidDateDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
dueDate = dueDateValue;
}
if (!isValidDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var projectt = new Project
{
Name = project.Name,
OpenDate = outDate,
DueDate = dueDate,
};
foreach (var task in project.Tasks)
{
if (!IsValid(task))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskOutDate;
bool isValidTaksDate = DateTime
.TryParseExact(task.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out taskOutDate);
DateTime taskDueDate;
bool isValidTaskDueDate = DateTime
.TryParseExact(task.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out taskDueDate);
if (!isValidTaksDate || !isValidTaskDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (taskOutDate < projectt.OpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (dueDate != null && taskDueDate > projectt.DueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var taskk = new Task
{
Name = task.Name,
OpenDate = taskOutDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)task.ExecutionType,
LabelType = (LabelType)task.LabelType,
};
projectt.Tasks.Add(taskk);
}
projects.Add(projectt);
sb.AppendLine(string.Format(SuccessfullyImportedProject, projectt.Name, projectt.Tasks.Count));
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
var projectsDto = XmlConverter.Deserializer <ProjectImportModel>(xmlString, "Projects");
var projects = new List <Project>();
foreach (var projectDto in projectsDto)
{
if (!IsValid(projectDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var isProjectOpenDateValid = DateTime.TryParseExact(projectDto.OpenDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectOpenDate);
if (!isProjectOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var isProjectDueDateValid = DateTime.TryParseExact(projectDto.DueDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime projectDueDate);
var project = new Project
{
Name = projectDto.Name,
OpenDate = projectOpenDate,
DueDate = isProjectDueDateValid ? (DateTime?)projectDueDate : null
};
foreach (var task in projectDto.Tasks)
{
var isTaskOpenDateValid = DateTime.TryParseExact(task.OpenDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskOpenDate);
var isTaskDueDateValid = DateTime.TryParseExact(task.DueDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime taskDueDate);
if (!IsValid(task) || !isTaskOpenDateValid || !isTaskDueDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (isProjectOpenDateValid && taskOpenDate < projectOpenDate || isProjectDueDateValid && taskDueDate > projectDueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
else
{
project.Tasks.Add(new Task
{
Name = task.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)task.ExecutionType,
LabelType = (LabelType)task.LabelType
});
}
}
projects.Add(project);
sb.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
var projectsFromXml = XmlConverter
.Deserializer <ProjectInputXml>(xmlString, "Projects");
var projects = new List <Project>();
foreach (var projectDto in projectsFromXml)
{
if (IsValid(projectDto) == false)
{
sb.AppendLine(ErrorMessage);
continue;
}
var validDueDate = DateTime.TryParseExact(projectDto.DueDate, "dd/MM/yyyy",
CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dueDate);
var openProjectDate = DateTime.ParseExact(projectDto.OpenDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
var project = new Project
{
Name = projectDto.Name,
OpenDate = openProjectDate,
DueDate = validDueDate ? (DateTime?)dueDate : null
};
foreach (var taskDto in projectDto.Tasks)
{
if (IsValid(taskDto) == false)
{
sb.AppendLine(ErrorMessage);
continue;
}
var openTaskDate = DateTime.ParseExact(taskDto.OpenDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
var dueTaskDate = DateTime.ParseExact(taskDto.DueDate.ToString(), "dd/MM/yyyy", CultureInfo.InvariantCulture);
if (openTaskDate < openProjectDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (validDueDate && dueTaskDate > dueDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
var task = new Task
{
Name = taskDto.Name,
OpenDate = openTaskDate,
DueDate = dueTaskDate,
ExecutionType = Enum.Parse <ExecutionType>(taskDto.ExecutionType),
LabelType = Enum.Parse <LabelType>(taskDto.LabelType)
};
project.Tasks.Add(task);
}
sb.AppendLine($"Successfully imported project - {project.Name} with {project.Tasks.Count} tasks.");
projects.Add(project);
}
context.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
// throw new NotImplementedException();
}
public static string ImportProjects(TeisterMaskContext context, string xmlString)
{
var sb = new StringBuilder();
var projects = new List <Project>();
var projectDtos = XmlConverter
.Deserializer <ProjectInputModel>(xmlString, "Projects");
foreach (var projectInfo in projectDtos)
{
if (!IsValid(projectInfo))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime openDate;
var isOpenDateValid = DateTime.TryParseExact(projectInfo.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out openDate);
if (!isOpenDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime?dueDate = null;
if (!string.IsNullOrEmpty(projectInfo.DueDate))
{
DateTime dueDateValue;
var isDueDateValid = DateTime.TryParseExact(projectInfo.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out dueDateValue);
if (!isDueDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
dueDate = dueDateValue;
}
var project = new Project
{
Name = projectInfo.Name,
OpenDate = openDate,
DueDate = dueDate
};
foreach (var taskInfo in projectInfo.Tasks)
{
if (!IsValid(taskInfo))
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskOpenDate;
var isTaskOpenDateValid = DateTime.TryParseExact(taskInfo.OpenDate, "dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None, out taskOpenDate);
if (taskOpenDate < project.OpenDate)
{
sb.AppendLine(ErrorMessage);
continue;
}
DateTime taskDueDate;
var isTaskDueDateValid = DateTime.TryParseExact(taskInfo.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture,
DateTimeStyles.None, out taskDueDate);
if (!isTaskDueDateValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
if (dueDate.HasValue && (taskDueDate > project.DueDate))
{
sb.AppendLine(ErrorMessage);
continue;
}
var task = new Task
{
Name = taskInfo.Name,
OpenDate = taskOpenDate,
DueDate = taskDueDate,
ExecutionType = (ExecutionType)taskInfo.ExecutionType,
LabelType = (LabelType)taskInfo.LabelType
};
project.Tasks.Add(task);
}
projects.Add(project);
sb.AppendLine(string.Format(SuccessfullyImportedProject, project.Name, project.Tasks.Count));
}
context.Projects.AddRange(projects);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
