public static List <TaskAttachment> ToTaskAttachment(DbDataReader readers)
{
if (readers == null)
{
return(null);
}
var models = new List <TaskAttachment>();
while (readers.Read())
{
var model = new TaskAttachment
{
Id = Convert.ToString(readers["Id"]),
TaskId = Convert.IsDBNull(readers["TaskId"]) ? string.Empty : Convert.ToString(readers["TaskId"]),
FileName = Convert.IsDBNull(readers["FileName"]) ? string.Empty : Convert.ToString(readers["FileName"]),
BlobName = Convert.IsDBNull(readers["BlobName"]) ? string.Empty : Convert.ToString(readers["BlobName"]),
UpdatedAt = Convert.IsDBNull(readers["UpdatedAt"]) ? (DateTime?)null : Convert.ToDateTime(readers["UpdatedAt"]),
UpdatedById = Convert.IsDBNull(readers["UpdatedById"]) ? string.Empty : Convert.ToString(readers["UpdatedById"])
};
models.Add(model);
}
return(models);
}
public int Save(TaskAttachment entity)
{
int newID = (int)_session.Save(entity);
_session.Flush();
return(newID);
}
public ResponseModel SaveTaskAttachment(TaskAttachment model)
{
var errMessage = string.Empty;
var queryParamList = new QueryParamList
{
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@Id", ParamValue = Guid.NewGuid().ToString()
},
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@TaskId", ParamValue = model.TaskId
},
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@FileName", ParamValue = model.FileName
},
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@BlobName", ParamValue = model.BlobName
},
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@UpdatedAt", ParamValue = DateTime.UtcNow, DBType = DbType.DateTime
},
new QueryParamObj {
ParamDirection = ParameterDirection.Input, ParamName = "@UpdatedById", ParamValue = model.UpdatedById
},
};
const string sql = @"INSERT INTO ResourceTracker_TaskAttachments(Id,TaskId,FileName,BlobName,UpdatedAt,UpdatedById)
VALUES (@Id,@TaskId,@FileName,@BlobName,@UpdatedAt,@UpdatedById)";
DBExecCommandEx(sql, queryParamList, ref errMessage);
return(new ResponseModel {
Success = string.IsNullOrEmpty(errMessage)
});
}
public ActionResult AddTask(TaskAttachment taskAttachment)
{
try
{
TaskTable task = taskAttachment.Task;
db.AddTask.Add(task);
List <int> attachmentIDs = new List <int>();
bool result = db.SaveChanges() > 0 ? true : false;
if (result)
{
foreach (var item in taskAttachment.Attachment)
{
db.Attachments.Add(new AttachmentModel
{
FK_TypeID = item.FK_TypeID,
FK_ItemID = task.ID,
Title = item.Title,
Content = item.Content,
CreationDate = item.CreationDate,
FK_CreatedBy = item.FK_TypeID,
});
bool result2 = db.SaveChanges() > 0 ? true : false;
}
}
return(Ok(new { id = task.ID /*, AttachmentIDs = taskAttachment.Attachment*/ }));
}
catch
{
return(BadRequest());
}
}
// GET: /TaskAttachment/Delete/<id>
public ActionResult Delete(
Int32?TaskID
, Int32?TaskAttachmentID
)
{
if (
TaskID == null ||
TaskAttachmentID == null
)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
dtTask = TaskAttachment_TaskData.SelectAll();
TaskAttachment TaskAttachment = new TaskAttachment();
TaskAttachment.TaskID = System.Convert.ToInt32(TaskID);
TaskAttachment.TaskAttachmentID = System.Convert.ToInt32(TaskAttachmentID);
TaskAttachment = TaskAttachmentData.Select_Record(TaskAttachment);
TaskAttachment.Task = new Task()
{
TaskID = (Int32)TaskAttachment.TaskID
};
if (TaskAttachment == null)
{
return(HttpNotFound());
}
return(View(TaskAttachment));
}
public ActionResult Edit(TaskAttachment TaskAttachment)
{
TaskAttachment oTaskAttachment = new TaskAttachment();
oTaskAttachment.TaskID = System.Convert.ToInt32(TaskAttachment.TaskID);
oTaskAttachment.TaskAttachmentID = System.Convert.ToInt32(TaskAttachment.TaskAttachmentID);
oTaskAttachment = TaskAttachmentData.Select_Record(TaskAttachment);
if (ModelState.IsValid)
{
bool bSucess = false;
bSucess = TaskAttachmentData.Update(oTaskAttachment, TaskAttachment);
if (bSucess == true)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Can Not Update");
}
}
// ComboBox
ViewData["TaskID"] = new SelectList(TaskAttachment_TaskData.List(), "TaskID", "TaskID", TaskAttachment.TaskID);
return(View(TaskAttachment));
}
// GET: /TaskAttachment/Edit/<id>
public ActionResult Edit(
Int32?TaskID
, Int32?TaskAttachmentID
)
{
if (
TaskID == null ||
TaskAttachmentID == null
)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TaskAttachment TaskAttachment = new TaskAttachment();
TaskAttachment.TaskID = System.Convert.ToInt32(TaskID);
TaskAttachment.TaskAttachmentID = System.Convert.ToInt32(TaskAttachmentID);
TaskAttachment = TaskAttachmentData.Select_Record(TaskAttachment);
if (TaskAttachment == null)
{
return(HttpNotFound());
}
// ComboBox
ViewData["TaskID"] = new SelectList(TaskAttachment_TaskData.List(), "TaskID", "TaskID", TaskAttachment.TaskID);
return(View(TaskAttachment));
}
public ActionResult Create([Bind(Include =
"TaskID"
+ "," + "TaskAttachmentID"
+ "," + "AttachmentName"
+ "," + "Decription"
+ "," + "FilePath"
)] TaskAttachment TaskAttachment)
{
if (ModelState.IsValid)
{
bool bSucess = false;
bSucess = TaskAttachmentData.Add(TaskAttachment);
if (bSucess == true)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Can Not Insert");
}
}
// ComboBox
ViewData["TaskID"] = new SelectList(TaskAttachment_TaskData.List(), "TaskID", "TaskID", TaskAttachment.TaskID);
return(View(TaskAttachment));
}
public static bool Update(TaskAttachment oldTaskAttachment,
TaskAttachment newTaskAttachment)
{
SqlConnection connection = PMMSData.GetConnection();
string updateProcedure = "[TaskAttachmentUpdate]";
SqlCommand updateCommand = new SqlCommand(updateProcedure, connection);
updateCommand.CommandType = CommandType.StoredProcedure;
updateCommand.Parameters.AddWithValue("@NewTaskID", newTaskAttachment.TaskID);
updateCommand.Parameters.AddWithValue("@NewTaskAttachmentID", newTaskAttachment.TaskAttachmentID);
updateCommand.Parameters.AddWithValue("@NewAttachmentName", newTaskAttachment.AttachmentName);
if (newTaskAttachment.Decription != null)
{
updateCommand.Parameters.AddWithValue("@NewDecription", newTaskAttachment.Decription);
}
else
{
updateCommand.Parameters.AddWithValue("@NewDecription", DBNull.Value);
}
updateCommand.Parameters.AddWithValue("@NewFilePath", newTaskAttachment.FilePath);
updateCommand.Parameters.AddWithValue("@OldTaskID", oldTaskAttachment.TaskID);
updateCommand.Parameters.AddWithValue("@OldTaskAttachmentID", oldTaskAttachment.TaskAttachmentID);
updateCommand.Parameters.AddWithValue("@OldAttachmentName", oldTaskAttachment.AttachmentName);
if (oldTaskAttachment.Decription != null)
{
updateCommand.Parameters.AddWithValue("@OldDecription", oldTaskAttachment.Decription);
}
else
{
updateCommand.Parameters.AddWithValue("@OldDecription", DBNull.Value);
}
updateCommand.Parameters.AddWithValue("@OldFilePath", oldTaskAttachment.FilePath);
updateCommand.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int);
updateCommand.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
try
{
connection.Open();
updateCommand.ExecuteNonQuery();
int count = System.Convert.ToInt32(updateCommand.Parameters["@ReturnValue"].Value);
if (count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (SqlException)
{
return(false);
}
finally
{
connection.Close();
}
}
public static bool Add(TaskAttachment TaskAttachment)
{
SqlConnection connection = PMMSData.GetConnection();
string insertProcedure = "[TaskAttachmentInsert]";
SqlCommand insertCommand = new SqlCommand(insertProcedure, connection);
insertCommand.CommandType = CommandType.StoredProcedure;
insertCommand.Parameters.AddWithValue("@TaskID", TaskAttachment.TaskID);
insertCommand.Parameters.AddWithValue("@TaskAttachmentID", TaskAttachment.TaskAttachmentID);
insertCommand.Parameters.AddWithValue("@AttachmentName", TaskAttachment.AttachmentName);
if (TaskAttachment.Decription != null)
{
insertCommand.Parameters.AddWithValue("@Decription", TaskAttachment.Decription);
}
else
{
insertCommand.Parameters.AddWithValue("@Decription", DBNull.Value);
}
insertCommand.Parameters.AddWithValue("@FilePath", TaskAttachment.FilePath);
insertCommand.Parameters.Add("@ReturnValue", System.Data.SqlDbType.Int);
insertCommand.Parameters["@ReturnValue"].Direction = ParameterDirection.Output;
try
{
connection.Open();
insertCommand.ExecuteNonQuery();
int count = System.Convert.ToInt32(insertCommand.Parameters["@ReturnValue"].Value);
if (count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (SqlException)
{
return(false);
}
finally
{
connection.Close();
}
}
public FileContentResult Download(int attachmentId)
{
TaskAttachment taskFile = null;
if (attachmentId > 0)
{
// taskFile = <your code to get the file>
// which assumes it's an object with relevant properties as required below
if (taskFile != null)
{
var cd = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
{
FileNameStar = taskFile.Filename
};
Response.Headers.Add(HeaderNames.ContentDisposition, cd.ToString());
}
}
return(new FileContentResult(taskFile?.FileData, taskFile?.FileContentType));
}
public ActionResult UpdateTask(TaskAttachment taskAttachment)
{
try
{
var obj = db.AddTask.Find(taskAttachment.Task.ID);
if (obj == null)
{
return(NotFound());
}
if (obj != null)
{
List <AttachmentModel> attachs = db.Attachments.Where(a => a.FK_ItemID == taskAttachment.Task.ID).ToList();
foreach (var item in attachs)
{
db.Attachments.Remove(item);
}
db.SaveChanges();
foreach (var item in taskAttachment.Attachment)
{
db.Attachments.Add(new AttachmentModel
{
FK_TypeID = item.FK_TypeID,
FK_ItemID = obj.ID,
Title = item.Title,
Content = item.Content,
CreationDate = item.CreationDate,
FK_CreatedBy = item.FK_TypeID,
});
bool result2 = db.SaveChanges() > 0 ? true : false;
}
db.SaveChanges();
}
db.SaveChanges();
return(NoContent());
}
catch
{
return(BadRequest());
}
}
public static TaskAttachment Select_Record(TaskAttachment TaskAttachmentPara)
{
TaskAttachment TaskAttachment = new TaskAttachment();
SqlConnection connection = PMMSData.GetConnection();
string selectProcedure = "[TaskAttachmentSelect]";
SqlCommand selectCommand = new SqlCommand(selectProcedure, connection);
selectCommand.CommandType = CommandType.StoredProcedure;
selectCommand.Parameters.AddWithValue("@TaskID", TaskAttachmentPara.TaskID);
selectCommand.Parameters.AddWithValue("@TaskAttachmentID", TaskAttachmentPara.TaskAttachmentID);
try
{
connection.Open();
SqlDataReader reader
= selectCommand.ExecuteReader(CommandBehavior.SingleRow);
if (reader.Read())
{
TaskAttachment.TaskID = System.Convert.ToInt32(reader["TaskID"]);
TaskAttachment.TaskAttachmentID = System.Convert.ToInt32(reader["TaskAttachmentID"]);
TaskAttachment.AttachmentName = System.Convert.ToString(reader["AttachmentName"]);
TaskAttachment.Decription = reader["Decription"] is DBNull ? null : reader["Decription"].ToString();
TaskAttachment.FilePath = System.Convert.ToString(reader["FilePath"]);
}
else
{
TaskAttachment = null;
}
reader.Close();
}
catch (SqlException)
{
return(TaskAttachment);
}
finally
{
connection.Close();
}
return(TaskAttachment);
}
public ActionResult DeleteConfirmed(
Int32?TaskID
, Int32?TaskAttachmentID
)
{
TaskAttachment TaskAttachment = new TaskAttachment();
TaskAttachment.TaskID = System.Convert.ToInt32(TaskID);
TaskAttachment.TaskAttachmentID = System.Convert.ToInt32(TaskAttachmentID);
TaskAttachment = TaskAttachmentData.Select_Record(TaskAttachment);
bool bSucess = false;
bSucess = TaskAttachmentData.Delete(TaskAttachment);
if (bSucess == true)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Can Not Delete");
}
return(null);
}
private static void TaskSample()
{
#region Create Task
var phase = taskfly.GetTaskPhases().First();
var priority = taskfly.GetTaskPriority().First();
var taskType = taskfly.GetTaskType().First();
var customer = taskfly.GetCustomers().First();
var project = taskfly.GetProjects().First();
var newTask = new Tasks
{
Description = "Task Created",
EstimatedDate = DateTime.Now.AddDays(10),
PhaseId = phase.Id,
PriorityId = priority.Id,
TypeId = taskType.Id,
CustomerId = customer.Id,
ProjectId = project.Id
};
int newID = taskfly.AddTask(newTask);
#endregion
#region Task Timer
taskfly.TaskStartTimer(newID);
taskfly.TaskStopTimer(newID);
#endregion
#region Task Find
var filter = new Dictionary <string, object>
{
{ "Id", newID }
};
var task = taskfly.GetTasks(filter);
#endregion
#region Transfer Task to Another User
var userTransfer = taskfly.GetUsersToTransferTask();
taskfly.TransferTask(newID, userTransfer.First().UserId);
#endregion
#region Task Comments
var taskComments = taskfly.GetTaskComments(newID);
var comment = new TaskComment
{
PhaseId = null,
SendToUserId = null,
Description = "Commented using API"
};
taskfly.SendTaskComments(newID, comment);
#endregion
#region Task Attachments
var fileName = "TaskFlyImage.png";
var fs = new FileStream(fileName, FileMode.Open);
byte[] bytearray = new byte[fs.Length];
fs.Read(bytearray, 0, (int)fs.Length);
var attachment = new TaskAttachment
{
Name = fileName,
ByteArrayFile = bytearray
};
taskfly.SendTaskAttachmment(newID, attachment);
#endregion
}
private static async Task TaskSample()
{
#region Get Task Custom Fields
var customFields = await taskfly.GetTaskCustomFields();
#endregion
#region Create Task
var board = (await taskfly.GetBoards()).First();
var phase = (await taskfly.GetTaskPhases(board.Id)).First();
var priority = (await taskfly.GetTaskPriority()).First();
var taskType = (await taskfly.GetTaskType()).First();
var customer = (await taskfly.GetCustomers()).First();
var project = (await taskfly.GetProjects()).First();
var newTask = new Tasks
{
Title = "Title Task",
Description = "Task Created",
EstimatedDate = DateTime.Now.AddDays(10),
PhaseId = phase.Id,
PriorityId = priority.Id,
TypeId = taskType.Id,
CustomerId = customer.Id,
ProjectId = project.Id,
BoardId = board.Id
};
// You need to check Custom Fields - maybe you have required fields
if (customFields.Count() > 0)
{
foreach (var f in customFields)
{
var newField = new TaskAddCustomFields();
newField.CustomFieldId = f.Id;
switch (f.Type)
{
case "text":
{
newField.Value = "Text Sample Value";
break;
}
case "int":
{
newField.Value = "0";
break;
}
case "decimal":
{
newField.Value = "1.23";
break;
}
case "date":
{
newField.Value = DateTime.Today.ToShortDateString();
break;
}
case "bool":
{
newField.Value = "true";
break;
}
default:
break;
}
newTask.CustomFields.Add(newField);
}
}
int newID = await taskfly.AddTask(newTask);
#endregion
#region Task Timer
await taskfly.TaskStartTimer(newID);
await Task.Delay(2000);
await taskfly.TaskStopTimer(newID);
#endregion
#region Task Find
var filter = new Dictionary <string, object>
{
{ "Id", newID }
};
var task = taskfly.GetTasks(filter);
#endregion
#region Transfer Task to Another User
var userTransfer = await taskfly.GetUsersToTransferTask();
await taskfly.TransferTask(newID, userTransfer.First().UserId);
#endregion
#region Task Comments
var taskComments = taskfly.GetTaskComments(newID);
var comment = new TaskComment
{
PhaseId = null,
SendToUserId = null,
Description = "Commented using API"
};
await taskfly.SendTaskComments(newID, comment);
#endregion
#region Task Attachments
var fileName = "TaskFlyImage.png";
using (var fs = new FileStream(fileName, FileMode.Open))
{
byte[] bytearray = new byte[fs.Length];
fs.Read(bytearray, 0, (int)fs.Length);
var attachment = new TaskAttachment
{
Name = fileName,
ByteArrayFile = bytearray
};
await taskfly.SendTaskAttachmment(newID, attachment);
}
#endregion
#region Tasks by Tag
var userTasks = taskfly.GetTasksByTag("<YOUR_TAG>");
#endregion
}
public async Task SendTaskAttachmment(int ID, TaskAttachment attachment) => await CallService <object>("POST", $"/tasks/{ID}/attachments", attachment);
public IHttpActionResult SaveTaskAttachment(TaskAttachment model)
{
var result = _taskRepository.SaveTaskAttachment(model);
return(Ok(result));
}
public void SendTaskAttachmment(int ID, TaskAttachment attachment) => SendToService("POST", $"/tasks/{ID}/attachments", attachment);
