public async Task <WebApiResult> GetData(ReportModel model)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
// gets all time of day
var start = model.Start.Date;
var end = (model.End?.Date ?? start).AddDays(1).AddMilliseconds(-1);
var projectDtos = _service.GetData(start, end, model.IncludeNew, model.IncludeZero, model.ProjectIds, GetUserDto());
var sumActualWork = new TimeSpan(projectDtos
.Select(e => e.SumActualWork.Ticks)
.DefaultIfEmpty(0)
.Sum());
return WebApiResult.Succeed(
new {
ReportProjects = projectDtos,
SumActualWork = sumActualWork
});
}));
} catch (Exception e) {
Logger.e("GetSingle", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> Attach()
{
#if DEBUG
await Task.Delay(300);
#endif
try {
if (!Request.Content.IsMimeMultipartContent())
{
return(WebApiResult.Failed("Bad Request"));
}
MultipartMemoryStreamProvider provider = await Request.Content.ReadAsMultipartAsync();
var entityId = new Guid(HttpHeadersHelper.GetHeader(Request.Headers, "EntityId"));
var existsFiles = _service.GetFileNames(entityId);
var existsModels = _service.GetModels(entityId);
// adds new files
foreach (HttpContent file in provider.Contents)
{
var fileName = file.Headers.ContentDisposition.Name.Trim('\"');
byte[] data = await file.ReadAsByteArrayAsync();
// a existing file
if (data.Length != 0)
{
var fileDto = await _service.SaveFile(entityId, fileName, data);
_service.SaveModel(fileDto, base.GetUserDto());
}
// removes file
existsFiles.Remove(fileName);
// removes model
if (existsModels.Any(e => e.FileName == fileName))
{
existsModels.Remove(existsModels.First(e => e.FileName == fileName));
}
}
// removes unspecified files
foreach (string fileName in existsFiles)
{
_service.RemoveFile(entityId, fileName);
}
// removes unspecified models
foreach (FileDto model in existsModels)
{
_service.RemoveModel(model);
}
return(WebApiResult.Succeed());
} catch (IOException e) {
var entityId = new Guid(HttpHeadersHelper.GetHeader(Request.Headers, "EntityId"));
_service.RemoveModels(entityId);
_service.RemoveFiles(entityId);
return(WebApiResult.Succeed());
} catch (Exception e) {
Logger.e("SaveFile", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> GetData()
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
List <ProjectDto> projects = _service.GetData(GetUserDto());
return WebApiResult.Succeed(new { Projects = projects });
}));
} catch (Exception e) {
Logger.e("GetData", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> SaveTask(Task1Dto task)
{
try {
#if DEBUG
await Task.Delay(300);
#endif
return(await Task.Factory.StartNew(() => {
this._service.SaveTask(task, GetUserDto());
return WebApiResult.Succeed(new { EntityId = task.EntityId });
}));
} catch (Exception e) {
Logger.e("SaveTask", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> InvertCommentShow(Guid commentId)
{
try {
#if DEBUG
await Task.Delay(300);
#endif
return(await Task.Factory.StartNew(() => {
var result = this._service.InvertCommentShow(commentId, GetUserDto());
return WebApiResult.Succeed(new { Show = result });
}));
} catch (Exception e) {
Logger.e("InvertSubTaskFavorite", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> DownSubTask(Guid id)
{
try {
#if DEBUG
await Task.Delay(300);
#endif
return(await Task.Factory.StartNew(() => {
var subTasks = this._service.DownSubTask(id, GetUserDto());
return WebApiResult.Succeed(new { SubTasks = subTasks });
}));
} catch (Exception e) {
Logger.e("DownSubTask", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> GetNearAlarms(DateTime date)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
List <AlarmDto> alarms = _service.GetNearAlarms(date, GetUserDto());
return WebApiResult.Succeed(new { Alarms = alarms });
}));
} catch (Exception e) {
Logger.e("GetData", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> Save(ProjectDto project)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
this._service.Save(project, GetUserDto());
return WebApiResult.Succeed();
}));
} catch (Exception e) {
Logger.e("Save", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> Delete(Guid id)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
this._service.Delete(id, GetUserDto());
return WebApiResult.Succeed();
}));
} catch (Exception e) {
Logger.e("Delete", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> FindUser(UserDto userDto)
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
Guid userId = IdentityExtensions1.GetUserId(this.User.Identity);
userDto = _service.FindUser(userId, userDto);
return WebApiResult.Succeed(new { User = userDto });
}));
} catch (Exception e) {
Logger.e("FindUser", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> AcceptCompany()
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
Guid userId = IdentityExtensions1.GetUserId(this.User.Identity);
_service.AcceptCompany(userId);
return WebApiResult.Succeed();
}));
} catch (Exception e) {
Logger.e("AcceptCompany", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> InvertFavoriteFilter()
{
try {
#if DEBUG
await Task.Delay(100);
#endif
return(await Task.Factory.StartNew(() => {
Guid userId = IdentityExtensions1.GetUserId(this.User.Identity);
TaskManagerUser user = base.UserManager.FindById(userId);
user.FavoriteFilter = !user.FavoriteFilter;
base.UserManager.Update(user);
return WebApiResult.Succeed(new { FavoriteFilter = user.FavoriteFilter });
}));
} catch (Exception e) {
Logger.e("SaveSorting", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> Login([FromBody] LoginViewModel model)
{
try {
if (!ModelState.IsValid)
{
return(WebApiResult.Failed(base.GetErrors()));
}
Logger.i($"ReturnUrl: {model.ReturnUrl}");
// gets user by email
TaskManagerUser user = await UserManager.FindByEmailAsync(model.Login);
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(
user != null?user.UserName : model.Login, model.Password, true, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(WebApiResult.Succeed(new { ReturnUrl = model.ReturnUrl ?? "/Home" }));
case SignInStatus.LockedOut:
throw new NotImplementedException();
//return View("Lockout");
case SignInStatus.RequiresVerification:
throw new NotImplementedException();
//return RedirectToAction("SendCode", new { ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(WebApiResult.Failed(base.GetErrors()));
}
} catch (Exception e) {
Logger.e("Login", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> GetData(DateTime?historyFilter = null, bool reportFilter = false, bool showFilter = false, bool allSubtasksFilter = false)
{
try {
#if DEBUG
await Task.Delay(300);
#endif
return(await Task.Factory.StartNew(() => {
List <UserDto> users;
List <ProjectDto> projects;
List <Task1Dto> tasks;
List <DateTime> historyFilters;
List <Guid> lastResponsibleIds;
bool lastFavorite;
byte lastPriority;
var user = GetUserDto();
users = Mapper.Map <List <UserDto> >(
this.UserManager.Users.Where(e => e.CompanyId == user.CompanyId));
this._service.GetData(user, historyFilter, reportFilter, showFilter, allSubtasksFilter, out projects, out tasks, out historyFilters,
out lastResponsibleIds, out lastFavorite, out lastPriority);
return WebApiResult.Succeed(new {
Projects = projects,
Users = users,
Tasks = tasks,
HistoryFilters = historyFilters,
SortBy = user.SortBy,
FavoriteFilter = user.FavoriteFilter,
LastResponsibleIds = lastResponsibleIds,
LastFavorite = lastFavorite,
LastPriority = lastPriority
});
}));
} catch (Exception e) {
Logger.e("GetData", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> GetData()
{
try {
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
Guid userId = IdentityExtensions1.GetUserId(this.User.Identity);
CompanyDto company, invitationCompany;
List <UserDto> users, invitedUsers;
_service.GetData(userId, out company, out invitationCompany, out users, out invitedUsers);
return WebApiResult.Succeed(new {
Company = company,
InvitationCompany = invitationCompany,
Users = users,
InvitedUsers = invitedUsers
});
}));
} catch (Exception e) {
Logger.e("GetData", e);
return(WebApiResult.Failed(e.Message));
}
}
public async Task <WebApiResult> ChangePassword(ChangePasswordModel model)
{
#if DEBUG
await Task.Delay(500);
#endif
return(await Task.Factory.StartNew(() => {
if (!ModelState.IsValid)
{
return WebApiResult.Failed("Invalid model state");
}
Guid userId = IdentityExtensions1.GetUserId(this.User.Identity);
TaskManagerUser user = base.UserManager.FindById(userId);
var result = UserManager.ChangePassword(user.Id, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
SignInManager.SignIn(user, true, true);
return WebApiResult.Succeed();
}
else
{
return WebApiResult.Failed(String.Join(Environment.NewLine, result.Errors));
}
}));
}
public async Task <WebApiResult> Register(RegisterViewModel model)
{
try {
// to Trim and to Lower strings
model.CompanyName = model.CompanyName?.Trim();
model.Email = model.Email?.Trim().ToLower();
model.UserName = model.UserName?.Trim();
if (!ModelState.IsValid)
{
return(WebApiResult.Failed(base.GetErrors()));
}
if (UserManager.Users.Any(e => e.UserName == model.UserName))
{
return(WebApiResult.Failed($"User with this name '{model.UserName}' already exists"));
}
var companyService = ServicesHost.GetService <ICompanyService>();
var projectsService = ServicesHost.GetService <IProjectsService>();
if (model.CompanyName != null && companyService.GetCompanyByName(model.CompanyName) != null)
{
return(WebApiResult.Failed($"Company with this name '{model.CompanyName}' already exists"));
}
// Creates user
TaskManagerUser user = new TaskManagerUser {
UserName = model.UserName,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
CompanyDto companyDto = null;
var userDto = Mapper.Map <UserDto>(user);
if (model.CompanyName != null)
{
// Creates company
companyDto = new CompanyDto();
companyDto.Name = model.CompanyName;
companyService.CreateCompany(companyDto, userDto);
// Modifies user
user.CompanyId = userDto.CompanyId = companyDto.EntityId;
await UserManager.UpdateAsync(user);
// Create Example project
var project = new ProjectDto();
project.Title = "My Project";
projectsService.Save(project, userDto);
}
// Sign in
await SignInManager.SignInAsync(user, isPersistent : true, rememberBrowser : false);
return(WebApiResult.Succeed(new { ReturnUrl = "/Home", User = userDto, Company = companyDto }));
}
AddErrors(result);
// If we got this far, something failed, redisplay form
return(WebApiResult.Failed(base.GetErrors()));
} catch (Exception e) {
Logger.e("Register", e);
return(WebApiResult.Failed(e.Message));
}
}