public async Task <IActionResult> CreateIssue([FromBody] CreateIssueModel model)
{
var customer = await _context.Customers.FindAsync(model.CustomerId);
var serviceworker = await _context.ServiceWorkers.FindAsync(model.ServiceWorkerId);
try
{
var issue = new Issue()
{
IssueDescription = model.Description,
CustomerId = model.CustomerId,
ServiceWorkerId = model.ServiceWorkerId,
IssueStatus = model.IssueStatus,
IssueDate = DateTime.Now
};
issue.Customer = customer;
issue.ServiceWorker = serviceworker;
_context.Issues.Add(issue);
await _context.SaveChangesAsync();
}
catch
{
return(new BadRequestResult());
}
return(new OkResult());
}
public async Task <bool> CreateIssueAsync(CreateIssueModel createIssueModel)
{
if (!_context.Issues.Any(issue => issue.Customer == createIssueModel.CustomerName))
{
try
{
var issue = new Issue()
{
IssueUserId = createIssueModel.IssueUserId,
IssueUserFirstName = createIssueModel.IssueUserFirstName,
Customer = createIssueModel.CustomerName,
ActivityStatus = createIssueModel.ActiveStatus,
FinishedStatus = createIssueModel.FinishedStatus,
CurrentStatus = createIssueModel.CurrentStatusDecider(createIssueModel.ActiveStatus, createIssueModel.FinishedStatus),
CreatedDate = createIssueModel.CreatedDateTime(),
EditedDate = createIssueModel.EditedDateTime()
};
_context.Issues.Add(issue);
await _context.SaveChangesAsync();
return(true);
}
catch
{
}
}
return(false);
}
public async Task <IActionResult> CreateIssueAsync([FromBody] CreateIssueModel issueModel)
{
if (await _identity.CreateIssueAsync(issueModel))
{
return(new OkResult());
}
return(new BadRequestResult());
}
public async Task <IActionResult> IssueCreateAsync([FromBody] CreateIssueModel createIssueModel)
{
if (_identity.ValidateAccessRights(IdentityRequest()))
{
if (await _identity.CreateIssueAsync(createIssueModel))
{
return(new OkResult());
}
return(new BadRequestResult());
}
return(new UnauthorizedResult());
}
public async Task <CreateIssueResponseModel> EditIssueRazorAsync(CreateIssueModel request, int id)
{
var response = await client.PostAsync <CreateIssueResponseModel>($"{_baseUrl}/api/issues/edit/{id}", request);
if (response.IsSucceded)
{
return new CreateIssueResponseModel {
Succeeded = true, Message = "The issue is updated"
}
}
;
return(new CreateIssueResponseModel {
Succeeded = false, Message = "The issue is NOT updated"
});
}
public async Task <CreateIssueResponseModel> CreateIssueRazorAsync(CreateIssueModel request)
{
var response = await client.PostAsync <CreateIssueResponseModel>($"{_baseUrl}/api/issues/create", request);
if (response.IsSucceded)
{
return new CreateIssueResponseModel {
Succeeded = true, Message = "The issue is created", CustomerId = request.CustomerId
}
}
;
return(new CreateIssueResponseModel {
Succeeded = false, Message = "The issue is NOT created"
});
}
public JsonResult Create(CreateIssueModel model)
{
bool createdSuccessfully = false;
int issueId = -1;
bool isModelValid = false;
if (ModelState.IsValid)
{
model.ReportedBy = WebHelper.GetLoggedInUserId().ToString();
_issueService.CreateNewIssue(model, out issueId);
createdSuccessfully = true;
isModelValid = true;
}
return(Json(new { createdSuccessfully, issueId, isModelValid }, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult <Issues> > PostIssues(CreateIssueModel model)
{
var issue = new Issues()
{
Description = model.Description,
Category = model.Category,
CustomerEmail = model.CustomerEmail,
CustomerFirstName = model.CustomerFirstName,
CustomerLastName = model.CustomerLastName,
Status = model.Status,
AppUserId = int.Parse(model.AppUserId),
CreateDate = DateTime.Now
};
_context.Errands.Add(issue);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetIssues", new { id = issue.Id }, issue));
}
protected override async Task Save()
{
try
{
if (string.IsNullOrEmpty(Title))
{
throw new Exception("Issue must have a title!");
}
var createIssueModel = new CreateIssueModel
{
Title = Title,
Content = Content ?? string.Empty,
Responsible = AssignedTo != null ? AssignedTo.Username : string.Empty,
Milestone = Milestone ?? string.Empty,
Component = Component ?? string.Empty,
Version = Version ?? string.Empty,
Kind = Kind.ToLower(),
Status = Status.ToLower(),
Priority = Priority.ToLower(),
};
IsSaving = true;
var data = await Task.Run(() => this.GetApplication().Client.Users[Username].Repositories[Repository].Issues[Issue.LocalId].Update(createIssueModel));
Messenger.Publish(new IssueEditMessage(this)
{
Issue = data
});
ChangePresentation(new MvxClosePresentationHint(this));
}
catch (Exception e)
{
DisplayAlert("Unable to save the issue: " + e.Message);
}
finally
{
IsSaving = false;
}
}
public async Task <bool> CreateIssueAsync(CreateIssueModel issueModel)
{
if (!_context.Issues.Any(issue => issue.Title == issueModel.Title))
{
try
{
var issue = new Issue()
{
Title = issueModel.Title,
Description = issueModel.Description,
Status = issueModel.Status,
UserId = 3,
CustomerId = issueModel.CustomerId,
Created = DateTime.Now
};
_context.Issues.Add(issue);
await _context.SaveChangesAsync();
return(true);
}
catch { }
}
return(false);
}
/// <summary>
/// Create a new issue for this repository
/// </summary>
/// <param name="issue">The issue model to create</param>
/// <returns></returns>
public IssueModel Create(CreateIssueModel issue)
{
return(Client.Post <IssueModel>(Uri, issue.Serialize()));
}
/// <summary>
/// Updates an issue
/// </summary>
/// <param name="issue">The issue model</param>
/// <returns></returns>
public IssueModel Update(CreateIssueModel issue)
{
return(Update(ObjectToDictionaryConverter.Convert(issue)));
}
