public ActionResult _AddGeneralAttribute(Model.AddGeneralAttributeModel pModel)
{
if (ModelState.IsValid || (pModel.id_typeA == "4" && pModel.attributeA != null))
{
AttributeTypeDTO attributesType = categorieProvider.getAttributeType(pModel.id_typeA).Result;
Regex r = new Regex(attributesType.reg_expr);
GeneralAttributeDTO generalAttributeDTO = new GeneralAttributeDTO();
if (attributesType.reg_expr == "" || r.Match(pModel.valueA).Success)
{
generalAttributeDTO.name = pModel.attributeA;
generalAttributeDTO.value = pModel.valueA != null ? pModel.valueA : "";
generalAttributeDTO.type_id = pModel.id_typeA;
generalAttributeDTO.user = Request.Cookies["user_id"].Value;
generalAttributeDTO.createdBy = generalAttributeDTO.user;
generalAttributeDTO.categorie_id = pModel.categorie_idA;
if (categorieProvider.postGeneralAttribute(generalAttributeDTO).Result)
{
return(_GeneralAttrList(pModel.categorie_idA));
//return _CategorieGeneralAtr(pModel.categorie_id);
}
}
else
{
return(new HttpStatusCodeResult(404, "Error, el campo valor es inválido"));
}
}
else
{
return(new HttpStatusCodeResult(404, "Error, debe completar todos los campos"));
}
return(new HttpStatusCodeResult(404, "Error, no se puede agregar el atributo"));
}
public ActionResult _AddTaskChange(Model.TaskChangesModel pModel)
{
if (ModelState.IsValid)
{
CategorieProvider categorieProvider = new CategorieProvider();
TaskChangeDTO taskChange = new TaskChangeDTO();
taskChange.task_id = pModel.task_idA;
AttributeTypeDTO typeDTO;
if (pModel.attribute_idA.Substring(0, 1) == "l")
{
taskChange.attributeList_id = pModel.attribute_idA.Substring(1);
AttributeListDTO attributeListDTO = categorieProvider.getAttributeList(taskChange.attributeList_id).Result;
typeDTO = categorieProvider.getAttributeType(attributeListDTO.type_id).Result;
}
else
{
taskChange.attribute_id = pModel.attribute_idA.Substring(1);
GeneralAttributeDTO generalAttributeDTO = categorieProvider.getGeneralAttribute(taskChange.attribute_id).Result;
typeDTO = categorieProvider.getAttributeType(generalAttributeDTO.type_id).Result;
}
if (!(typeDTO.reg_expr == "" || new Regex(typeDTO.reg_expr).Match(pModel.valueA).Success))
{
return(new HttpStatusCodeResult(404, "Error, el campo valor debe ser de tipo: " + typeDTO.type));
}
taskChange.operation_id = pModel.operation_idA;
taskChange.value = pModel.valueA.ToString();
taskChange.userLog = Request.Cookies["user_id"].Value;
if (taskProvider.postTaskChange(taskChange).Result)
{
return(_TaskDataChangesList(taskChange.task_id));
}
}
return(new HttpStatusCodeResult(404, "Error, no se puede agregar el cambio de dato"));
}
public static bool updateGeneralAttribute(GeneralAttributeDTO pGeneralAttributeDTO)
{
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString))
{
SqlCommand command = new SqlCommand("usp_update_generalAttribute", connection);
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.Add("@id_attribute", SqlDbType.Int);
command.Parameters["@id_attribute"].Value = pGeneralAttributeDTO.id_attribute;
command.Parameters.Add("@name", SqlDbType.NVarChar);
command.Parameters["@name"].Value = pGeneralAttributeDTO.name;
command.Parameters.Add("@type_id", SqlDbType.Int);
command.Parameters["@type_id"].Value = pGeneralAttributeDTO.type_id;
command.Parameters.Add("@value", SqlDbType.NVarChar);
command.Parameters["@value"].Value = pGeneralAttributeDTO.value;
command.Parameters.Add("@isEnabled", SqlDbType.Bit);
command.Parameters["@isEnabled"].Value = pGeneralAttributeDTO.isEnabled;
command.Parameters.Add("@pUser", SqlDbType.Int);
command.Parameters["@pUser"].Value = pGeneralAttributeDTO.user;
command.Connection.Open();
int result = command.ExecuteNonQuery();
if (result != 0)
{
return(true);
}
return(false);
};
}
public static GeneralAttributeDTO getGeneralAttribute(string id_attribute)
{
GeneralAttributeDTO generalAttributeDTO = new GeneralAttributeDTO();
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString))
{
SqlCommand command = new SqlCommand("usp_get_generalAttribute", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add("@id_attribute", SqlDbType.Int);
command.Parameters["@id_attribute"].Value = id_attribute;
command.Connection.Open();
SqlDataReader rdr = command.ExecuteReader();
while (rdr.Read())
{
generalAttributeDTO.id_attribute = rdr["id_attribute"].ToString();
generalAttributeDTO.categorie_id = rdr["categorie_id"].ToString();
generalAttributeDTO.name = rdr["name"].ToString();
generalAttributeDTO.type_id = rdr["type"].ToString();
generalAttributeDTO.value = rdr["value"].ToString();
generalAttributeDTO.isEnabled = rdr["isEnabled"].ToString();
generalAttributeDTO.createdBy = rdr["createdBy"].ToString();
generalAttributeDTO.createdDate = rdr["createdDate"].ToString();
}
};
return(generalAttributeDTO);
}
public IHttpActionResult putGeneralAtrribute(GeneralAttributeDTO pGeneralAttributeDTO)
{
if (!CategoriesData.updateGeneralAttribute(pGeneralAttributeDTO))
{
return(BadRequest());
}
return(Ok());
}
public ActionResult _DeleteGeneralAttribute(string id_attribute)
{
GeneralAttributeDTO generalAttributeDTO = new GeneralAttributeDTO();
generalAttributeDTO.id_attribute = id_attribute;
generalAttributeDTO.user = Request.Cookies["user_id"].Value;;
if (categorieProvider.deleteGeneralAttribute(generalAttributeDTO).Result)
{
return(new HttpStatusCodeResult(200));
}
return(new HttpStatusCodeResult(404, "Error, el atributo no se puede eliminar"));
}
public async Task <bool> deleteGeneralAttribute(GeneralAttributeDTO pGeneralAttributeDTO)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_BaseAddress);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", getToken());
HttpResponseMessage response = client.DeleteAsync("api/categories/generalAttr/?id_attribute=" + pGeneralAttributeDTO.id_attribute + "&user=" + pGeneralAttributeDTO.user).Result;
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
}
public async Task <bool> putGeneralAttribute(GeneralAttributeDTO pGeneralAttributeDTO)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_BaseAddress);
var userJson = new JavaScriptSerializer().Serialize(pGeneralAttributeDTO);
HttpContent contentPost = new StringContent(userJson, Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", getToken());
HttpResponseMessage response = client.PutAsync("api/categories/generalAttr", contentPost).Result;
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
}
public async Task <GeneralAttributeDTO> getGeneralAttribute(string id_attribute)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_BaseAddress);
GeneralAttributeDTO generalAttribute = new GeneralAttributeDTO();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", getToken());
HttpResponseMessage response = client.GetAsync("api/categories/generalAttr/?id_attribute=" + id_attribute).Result;
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
generalAttribute = serializer.Deserialize <GeneralAttributeDTO>(result);
}
return(generalAttribute);
}
}
public ActionResult _EditGeneralAttribute(Model.EditGeneralAttributeModel pModel)
{
if (ModelState.IsValid || (pModel.id_type == "4" && pModel.attribute != null))
{
AttributeTypeDTO attributesType = categorieProvider.getAttributeType(pModel.id_type).Result;
Regex r = new Regex(attributesType.reg_expr);
GeneralAttributeDTO generalAttributeDTO = new GeneralAttributeDTO();
if (attributesType.reg_expr == "" || r.Match(pModel.value).Success)
{
generalAttributeDTO.name = pModel.attribute;
generalAttributeDTO.value = pModel.value;
generalAttributeDTO.type_id = pModel.id_type;
generalAttributeDTO.isEnabled = pModel.isEnabled == "on" ? "true" : "false";
generalAttributeDTO.user = Request.Cookies["user_id"].Value;
generalAttributeDTO.id_attribute = pModel.id_attribute;
if (categorieProvider.putGeneralAttribute(generalAttributeDTO).Result)
{
return(new HttpStatusCodeResult(200));
}
}
else
{
return(new HttpStatusCodeResult(404, "El campo valor es inválido"));
}
}
else
{
foreach (ModelState modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
string sError = error.ErrorMessage;
}
}
return(new HttpStatusCodeResult(404, "Error, debe completar todos los campos"));
}
return(new HttpStatusCodeResult(404, "Error, no se puede agregar el atributo"));
}
public GeneralAttributeDTO getGeneralAttribute(string id_attribute)
{
GeneralAttributeDTO attribute = CategoriesData.getGeneralAttribute(id_attribute);
return(attribute);
}
private void completeTask(string id_task)
{
// update completed task
TaskDTO completedTask = new TaskDTO();
TaskDTO completedTaskTemporal = taskProvider.getTask(id_task).Result;
completedTask.id_task = id_task;
completedTask.taskState_id = "2";
completedTask.completedDate = DateTime.Now.ToString();
completedTask.taskPosition = completedTaskTemporal.taskPosition;
completedTask.stage_id = completedTaskTemporal.stage_id;
completedTask.userLog = Request.Cookies["user_id"].Value;
bool isSuccess = taskProvider.putTask(completedTask).Result;
ProcessDTO actualProcess = new ProcessProvider().getProcess(new ProcessProvider().getStage(completedTask.stage_id).Result.processManagment_id).Result;
//update next task
TaskDTO nextTask = new TaskDTO();
List <TaskDTO> tasks = taskProvider.getTasks(completedTaskTemporal.stage_id).Result;
foreach (var task in tasks)
{
if (Int32.Parse(task.taskPosition) == (Int32.Parse(completedTask.taskPosition)) + 1)
{
nextTask.id_task = task.id_task;
break;
}
}
//update actual stage if is final task
if (nextTask.id_task == null)
{
// completes actual stage
ProcessManagmentProvider processManagmentProvider = new ProcessManagmentProvider();
StageDTO actualStage = new StageDTO();
actualStage.id_stage = completedTask.stage_id;
actualStage.isCompleted = "True";
actualStage.completedDate = DateTime.Now.ToString();
actualStage.userLog = Request.Cookies["user_id"].Value;
actualStage.processManagment_id = processManagmentProvider.getStage(actualStage.id_stage).Result.processManagment_id;
bool isStageUpdated = processManagmentProvider.putStage(actualStage).Result;
bool isFirstTaskSuccess = false;
List <StageDTO> stages = processManagmentProvider.getStages(actualStage.processManagment_id).Result;
foreach (var stage in stages)
{
if (stage.isCompleted == "False")
{
List <TaskDTO> stageTasks = taskProvider.getTasks(stage.id_stage).Result;
if (stageTasks.Count >= 1)
{
// change state of first task on next stage
TaskDTO firstTask = new TaskDTO();
firstTask.taskState_id = "1";
firstTask.id_task = stageTasks[0].id_task;
firstTask.userLog = Request.Cookies["user_id"].Value;
isFirstTaskSuccess = taskProvider.putTask(firstTask).Result;
break;
}
else
{
// completes next stage
StageDTO emtpyStage = new StageDTO();
emtpyStage.id_stage = stage.id_stage;
emtpyStage.isCompleted = "True";
emtpyStage.completedDate = DateTime.Now.ToString();
emtpyStage.userLog = Request.Cookies["user_id"].Value;
bool isEmptyStageUpdated = processManagmentProvider.putStage(actualStage).Result;
}
}
}
// completes process
if (!isFirstTaskSuccess)
{
ProcessProvider processProvider = new ProcessProvider();
ProcessDTO editedProcess = new ProcessDTO();
editedProcess.id_processManagment = actualProcess.id_processManagment;
editedProcess.state_id = "2";
editedProcess.userLog = Request.Cookies["user_id"].Value;
bool isProcessEdited = processProvider.putProcess(editedProcess).Result;
}
}
//update next task if is not final task
else
{
nextTask.userLog = Request.Cookies["user_id"].Value;
List <TaskResponsableDTO> nextResponsables = taskProvider.getTaskResponsables(nextTask.id_task).Result;
if (nextResponsables.Count == 0)
{
completeTask(nextTask.id_task);
}
else
{
nextTask.taskState_id = "1";
bool isNextSuccess = taskProvider.putTask(nextTask).Result;
}
}
//send notifications
List <TaskNotificationDTO> notifications = taskProvider.getTaskNotifications(id_task).Result;
foreach (var notification in notifications)
{
TaskNotificationTypeDTO taskNotificationType = new TaskNotificationTypeDTO();
taskNotificationType.notification_id = notification.id_notification;
taskNotificationType.userLog = Request.Cookies["user_id"].Value;
taskNotificationType.isSended = "True";
List <TaskNotificationUserDTO> notificationUsers = taskProvider.getTaskNotificationUsers(notification.id_notification).Result;
string msgHeader = "Gestión #" + actualProcess.id_processManagment + " " + actualProcess.name + ", Tarea " + completedTaskTemporal.name;
//email
if (notification.isEmail == "True")
{
taskNotificationType.type_id = "1";
foreach (var user in notificationUsers)
{
if (!String.IsNullOrEmpty(user.email))
{
Tools.EmailService.sendEmail(user.email, msgHeader, notification.message);
}
}
}
//Telegram
if (notification.isTelegram == "True")
{
taskNotificationType.type_id = "2";
foreach (var user in notificationUsers)
{
if (!String.IsNullOrEmpty(user.telegram_id))
{
TelegramService.sendMessage(user.telegram_id, msgHeader + "\nMensaje:" + notification.message);
}
}
}
if (notification.isIntern == "True")
{
taskNotificationType.type_id = "0";
}
bool isTypeUpdated = taskProvider.putTaskNotificationType(taskNotificationType).Result;
}
// apply changes
List <TaskChangeDTO> changes = taskProvider.getTaskChanges(id_task).Result;
List <OperationTypeDTO> operations = taskProvider.getOperationTypes().Result;
foreach (var change in changes)
{
string operatorString = "";
foreach (var operation in operations)
{
if (operation.id_operationType == change.operation_id)
{
operatorString = operation.operation;
}
}
if (String.IsNullOrEmpty(change.attributeList_id))
{
GeneralAttributeDTO attribute = new CategorieProvider().getGeneralAttribute(change.attribute_id).Result;
GeneralAttributeDTO editAttribute = new GeneralAttributeDTO();
editAttribute.id_attribute = change.attribute_id;
editAttribute.value = change.value;
DataTable dt = new DataTable();
var v = dt.Compute(attribute.value + operatorString + change.value, "");
//var v = dt.Compute("3 * (2+4)","");
change.operation_id
}
}
}
