public ActionResult Settings(ProfileSettingsViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
string userId = User.Identity.GetUserId();
GenericServiceResult result = profileService.UpdateUserProfile(model, userId);
if (result == GenericServiceResult.Error)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
ModelState.AddModelError("Error", "Unknown error");
return(View(model));
}
var identity = new ClaimsIdentity(User.Identity);
identity.RemoveClaim(identity.FindFirst("Theme"));
identity.AddClaim(new Claim("Theme", model.Theme));
AuthenticationManager.AuthenticationResponseGrant =
new AuthenticationResponseGrant(
new ClaimsPrincipal(identity),
new AuthenticationProperties {
}
);
return(View(model));
}
public ActionResult CreateTask(CreateTaskViewModel model)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
string userId = User.Identity.GetUserId();
GenericServiceResult result = taskService.CreateTask(model, userId);
if (result == GenericServiceResult.Error)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
ModelState.AddModelError("Error", "Unknown error");
return(PartialView(model));
}
if (result == GenericServiceResult.AccessDenied)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(RedirectToAction("Default", "Error"));
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public IServiceResult <IProduct> GetProduct(string productName)
{
HttpCaller caller = new HttpCaller();
Task <HttpResponseMessage> mess = caller.GetResponse(_configurationRepository.GetUrl("ProductEndpoint"));
HttpResponseMessage message = mess.Result;
IProduct product = JsonConvert.DeserializeObject <Product>(message.Content.ReadAsStringAsync().Result);
IServiceResult <IProduct> result = new GenericServiceResult <IProduct>(product, message.IsSuccessStatusCode, message.StatusCode.ToString());
return(result);
}
protected virtual GenericServiceResult <TResult> GetSuccessResult <TResult>(TResult result)
{
var instance = new GenericServiceResult <TResult>
{
Result = result,
CodeResult = CodeResult.Success
};
return(instance);
}
public IServiceResult <IProduct> GetProduct(string name)
{
var response = _productRepository.GetProduct(name);
if (response.Success && response.Entity == null)
{
response = new GenericServiceResult <IProduct>(null, false, "There is no such a product.");
}
return(response);
}
public IServiceResult <ICustomerEntity> GetCustomer(string customerName)
{
HttpCaller caller = new HttpCaller();
Task <HttpResponseMessage> mess = caller.GetResponse(_configurationRepository.GetUrl("CustomerEndpoint") + customerName);
mess.Start();
HttpResponseMessage message = mess.Result;
Customer customer = JsonConvert.DeserializeObject <Customer>(message.Content.ReadAsStringAsync().Result);
IServiceResult <ICustomerEntity> result = new GenericServiceResult <ICustomerEntity>(customer, message.IsSuccessStatusCode, message.StatusCode.ToString());
return(result);
}
public GenericServiceResult <Order> BuildOrder(string orderList)
{
string[] orderLines = _lineSeparator.Separate(orderList);
Order order = new Order();
foreach (var orderLine in orderLines)
{
GenericServiceResult <OrderLine> result = _orderLineBuilder.BuildOrderLine(orderLine);
if (result.Success == true)
{
OrderLine line = _orderLineBuilder.BuildOrderLine(orderLine).Entity;
order.Lines.Add(line);
}
}
return(new GenericServiceResult <Order>(order, true, "All good."));
}
public ActionResult MoveTaskToColumn(int taskId, int columnId, int boardId)
{
string userId = User.Identity.GetUserId();
GenericServiceResult result = taskService.MoveTask(userId, boardId, taskId, columnId);
if (result == GenericServiceResult.AccessDenied)
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(RedirectToAction("Forbidden", "Error"));
}
if (result == GenericServiceResult.Error)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(RedirectToAction("Default", "Error"));
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public async Task <GenericServiceResult <User> > AuthenticateAsync(AuthenticateUserRequest request)
{
try
{
var entity = await _unitofWork.UserRepository.SingleOrDefaultAsync(q => q.Username.Equals(request.Username) && q.Password.Equals(request.Password));
if (entity == null)
{
return(GenericServiceResult <User> .Error("Invalid username or password."));
}
return(GenericServiceResult <User> .Success(entity));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(GenericServiceResult <User> .Error("An error occurred while authenticate user."));
}
}
public ActionResult CreateProject(CreateProjectViewModel model)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
string userId = User.Identity.GetUserId();
GenericServiceResult result = projectService.CreateNewProject(userId, model);
if (result == GenericServiceResult.Error)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
ModelState.AddModelError("Error", "Unknown error");
return(PartialView(model));
}
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public GenericServiceResult CreateTask(CreateTaskViewModel model, string userId)
{
try
{
bool isUserCanCreateTask = CanUserCreateTask(userId, model.BoardId);
if (!isUserCanCreateTask)
{
return(GenericServiceResult.AccessDenied);
}
Task task = new Task
{
ColumnId = model.ColumnId,
Title = model.Title,
Content = model.Content,
Priority = (int)model.Priority,
Severity = (int)model.Severity,
Type = (int)model.Type,
StartTime = DateTime.Now,
AssigneeId = model.AssigneeId,
CreatorId = userId
};
unitOfWork.Tasks.Create(task);
int taskId = task.Id;
GenericServiceResult result = UploadAttachment(taskId, model.Attachments);
string creatorId = unitOfWork.ProjectUser.GetFirstOrDefaultWhere(p => p.ProjectId == model.ProjectId && p.Role == (int)ProjectRoles.Administrator).UserId;
string projectTitle = unitOfWork.Projects.Get(model.ProjectId).Title;
NotificationMessage message = new NotificationMessage
{
NotificationType = NotificationType.Changed,
Title = $"{projectTitle}",
Message = $"Task {task.Title} was created",
Initiator = userId,
SendTo = creatorId
};
Notifyer.Notify(message);
if (task.AssigneeId != null)
{
message = new NotificationMessage
{
NotificationType = NotificationType.Assigned,
Title = $"{projectTitle}",
Message = $"You were assigned to task {task.Title}",
Initiator = userId,
SendTo = task.AssigneeId
};
Notifyer.Notify(message);
}
return(GenericServiceResult.Success);
}
catch
{
return(GenericServiceResult.Error);
}
}
