public async Task <IActionResult> DeleteComment(int ticketActivityActionId)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
// Check exist data
var account = await WorksContext.CWX_AccountTicketActivityAction.Where(c => c.TicketActivityActionID == ticketActivityActionId).FirstOrDefaultAsync();
if (account == null)
{
//status code 404
return(NotFound());
}
WorksContext.CWX_AccountTicketActivityAction.Remove(account);
await WorksContext.SaveChangesAsync();
//status code 204
return(NoContent());
}
catch (Exception ex)
{
WriteLog(ex, nameof(WorkplanController) + "-" + nameof(DeleteComment), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public AdminController(WorksContext context, ManagerLoginAdmin managerLoginAdmin)
{
db = context;
_managerLoginAdmin = managerLoginAdmin;
db.Images.Load();
}
public async Task <IActionResult> InsertNotes([FromBody] NotesCurrentInsertRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
NotesCurrent notesCurrent = new NotesCurrent();
notesCurrent.EmployeeID = request.EmployeeID;
notesCurrent.DebtorID = request.DebtorID;
notesCurrent.BillID = request.AccountID;
notesCurrent.NoteDateTime = DateTime.Now;
notesCurrent.NoteType = request.NoteType;
notesCurrent.NoteText = request.NoteText;
notesCurrent.NotePriority = request.NotePriority;
WorksContext.NotesCurrent.Add(notesCurrent);
await WorksContext.SaveChangesAsync();
return(new ObjectResult(notesCurrent));
}
catch (Exception ex)
{
WriteLog(ex, nameof(ActivityController) + "-" + nameof(InsertNotes), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public async Task <IActionResult> InsertActionOther([FromBody] AccountActionsOtherInsertRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
AccountActionsOther accountActionsOther = new AccountActionsOther();
accountActionsOther.AccountID = request.AccountID;
accountActionsOther.ActionDate = DateTime.Now;
accountActionsOther.ActionID = request.ActionID;
accountActionsOther.ActionType = request.ActionType;
accountActionsOther.CompletedBy = request.CompletedBy;
WorksContext.AccountActionsOther.Add(accountActionsOther);
await WorksContext.SaveChangesAsync();
return(new ObjectResult(accountActionsOther));
}
catch (Exception ex)
{
WriteLog(ex, nameof(ActivityController) + "-" + nameof(InsertActionOther), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public async Task <IActionResult> InsertAction([FromBody] AccountActionsInsertRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
AccountActions accountActions = new AccountActions();
accountActions.Status = 1;
accountActions.ResponsibleParty = request.EmployeeID;
accountActions.Deadline = DateTime.Now;
accountActions.ActionID = request.ActionID;
accountActions.DateCompleted = DateTime.Now;
accountActions.CompletedBy = request.EmployeeID;
accountActions.AccountID = request.AccountID;
accountActions.AdditionalData = request.AdditionalData;
accountActions.UnitCost = 0;
WorksContext.AccountActions.Add(accountActions);
await WorksContext.SaveChangesAsync();
return(new ObjectResult(accountActions));
}
catch (Exception ex)
{
WriteLog(ex, nameof(ActivityController) + "-" + nameof(InsertAction), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public async Task <IActionResult> UpdateStatus(int accountTicketId, [FromBody] StatusUpdateRequest request)
{
// Validate inputs
string modelError = string.Empty;
if (!ModelState.IsValid)
{
//status code 400
return(BadRequest());
}
if (request == null)
{
request = new StatusUpdateRequest();
}
request.AccountTicketID = accountTicketId;
try
{
// Check exist data
var accountTA = await WorksContext.CWX_AccountTicketActivity.Where(c => c.AccountTicketID == accountTicketId).FirstOrDefaultAsync();
if (accountTA == null)
{
//status code 404
return(NotFound());
}
accountTA.ActivityStatus = request.ActivityStatus;
accountTA.StartDate = request.StartDate;
accountTA.DueDate = request.DueDate;
accountTA.UpdatedBy = request.UpdatedBy;
accountTA.UpdatedDate = request.UpdatedDate;
accountTA.CompletedBy = request.CompletedBy;
accountTA.CompletedDate = request.CompletedDate;
WorksContext.SaveChanges();
return(new ObjectResult(accountTA));
}
catch (Exception ex)
{
WriteLog(ex, nameof(ActivityController) + "-" + nameof(UpdateStatus), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public async Task <IActionResult> Insert([FromBody] AccountPromiseInsertRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var accPromise = await WorksContext.AccountPromise.Where(c => c.PromiseID == request.PromiseID).FirstOrDefaultAsync();
if (accPromise != null)
{
//status code 400
return(BadRequest("PromiseID: " + request.PromiseID + " exists already"));
}
AccountPromise accountPromise = new AccountPromise();
accountPromise.PromiseID = request.PromiseID;
accountPromise.AccountID = request.AccountID;
accountPromise.EmployeeID = request.EmployeeID;
accountPromise.Sequence = request.Sequence;
accountPromise.AmountPromised = request.AmountPromised;
accountPromise.DatePromised = request.DatePromised;
accountPromise.Status = 0;
accountPromise.DatePaid = DateTime.MinValue;
accountPromise.AmountPaid = 0;
accountPromise.Term = request.Term.Substring(0, 1);
accountPromise.Period = request.Period;
accountPromise.PeriodSeq = request.PeriodSeq;
accountPromise.PromiseFrequency = request.PromiseFrequency;
accountPromise.PromiseGiver = request.PromiseGiver;
accountPromise.DateTaken = DateTime.Now;
WorksContext.AccountPromise.Add(accountPromise);
await WorksContext.SaveChangesAsync();
return(new ObjectResult(accountPromise));
}
catch (Exception ex)
{
WriteLog(ex, nameof(PromiseController) + "-" + nameof(Insert), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public HomeController(WorksContext context, IConfiguration configuration)
{
db = context;
db.Images.Load();
if (!db.Works.Any())
{
Work work = new Work()
{
Name = "test", Description = "Description", Address = "Address", Prestige = true
};
List <Image> images = new List <Image>()
{
new Image()
{
url = configuration["Urls:1"], Work = work
},
new Image()
{
url = configuration["Urls:2"], Work = work
},
new Image()
{
url = configuration["Urls:3"], Work = work
},
new Image()
{
url = configuration["Urls:4"], Work = work
}
};
work.Images.AddRange(images);
db.Works.Add(work);
db.Images.AddRange(images);
db.SaveChanges();
}
}
public async Task <IActionResult> InsertComment([FromBody] CWXAccountTicketActivityActionInsertRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
CWX_AccountTicketActivityAction CWXaccount = new CWX_AccountTicketActivityAction();
CWXaccount.AccountTicketID = request.AccountTicketID;
CWXaccount.TicketActivityID = -1;
CWXaccount.AccountTicketActivityID = request.AccountTicketActivityID;
CWXaccount.Level = -1;
CWXaccount.PermissionType = -1;
CWXaccount.Action = "Noted";
CWXaccount.ActionBy = request.EmployeeID;
CWXaccount.ActionDate = DateTime.Now;
CWXaccount.ApproverID = 0;
CWXaccount.Type = "Note";
CWXaccount.Status = "A";
CWXaccount.Comment = request.Comment;
WorksContext.CWX_AccountTicketActivityAction.Add(CWXaccount);
await WorksContext.SaveChangesAsync();
return(new ObjectResult(CWXaccount));
}
catch (Exception ex)
{
WriteLog(ex, nameof(WorkplanController) + "-" + nameof(InsertComment), LogLevel.Error, false);
// status code = 400
return(BadRequest());
throw;
}
}
public CommentController(WorksContext context, ManagerLoginAdmin managerLoginAdmin, MyFileLogger logger)
{
db = context;
_managerLoginAdmin = managerLoginAdmin;
_logger = logger;
}
