internal static OracleDynamicParameters getQPForCreateORUpdateRuleSet(RuleSetDTO ruleSetDTO)
{
var isactive = (ruleSetDTO.IsActive ? 1 : 0);
var isValidateAptTime = (ruleSetDTO.isValidateAptTime ? 1 : 0);
var sendSMSIfAdmitted = (ruleSetDTO.IgnoreSMStoAdmittedPatient ? 1 : 0);
OracleDynamicParameters dynamicParameters = AssocativeArraysConverter
.ConvertCollectionToPLSQLAssociativeArray(ruleSetDTO.ExcludingOrgUnitIDs, "p_excludedReshIDs");
dynamicParameters.Add("p_oldRulesetGuid", GuidConvert.ToRaw(ruleSetDTO.RuleSetGUID), OracleMappingType.Raw, ParameterDirection.Input);
dynamicParameters.Add("p_hospitalID", ruleSetDTO.HospitalID, OracleMappingType.Long, ParameterDirection.Input);
dynamicParameters.Add("p_departmentID", ruleSetDTO.DepartmentID, OracleMappingType.Long, ParameterDirection.Input);
dynamicParameters.Add("p_ruleSetName", ruleSetDTO.Name, OracleMappingType.Varchar2, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_sendBeforeDays", ruleSetDTO.SendSMSBeforeDays, OracleMappingType.Int16, ParameterDirection.Input);
dynamicParameters.Add("p_retryExpireDays", ruleSetDTO.DaysForRetryExpiry, OracleMappingType.Int16, ParameterDirection.Input);
dynamicParameters.Add("p_validateAptTime", isValidateAptTime, OracleMappingType.Int16, ParameterDirection.Input);
dynamicParameters.Add("p_validAptFromTime", ruleSetDTO.AptValidate_From, OracleMappingType.Varchar2, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_validAptToTime", ruleSetDTO.AptValidate_To, OracleMappingType.Varchar2, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_validFrom", ruleSetDTO.ValidFrom, OracleMappingType.TimeStamp, ParameterDirection.InputOutput, 25);
dynamicParameters.Add("p_validTo", ruleSetDTO.ValidTo, OracleMappingType.TimeStamp, ParameterDirection.InputOutput, 25);
dynamicParameters.Add("p_timeWindowFrom", ruleSetDTO.SendingTimeWindowFrom, OracleMappingType.Varchar2, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_timeWindowTo", ruleSetDTO.SendingTimeWindowTo, OracleMappingType.Varchar2, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_sendBefore", ruleSetDTO.SendSMSBeforeInMins, OracleMappingType.Int16, ParameterDirection.Input, 0, true, 9, 0, String.Empty, DataRowVersion.Current);
dynamicParameters.Add("p_isActive", isactive, OracleMappingType.Int16, ParameterDirection.Input);
dynamicParameters.Add("p_ignoreForAdmitted", sendSMSIfAdmitted, OracleMappingType.Int16, ParameterDirection.Input);
dynamicParameters.Add("l_ruleSetGuid", null, OracleMappingType.Raw, ParameterDirection.ReturnValue, 16);
return(dynamicParameters);
}
private RuleSetDTO MapModalToDto(RuleSet ruleSet)
{
try
{
RuleSetDTO dto = new RuleSetDTO();
if (ruleSet.ExcludeOrgUnits != null)
{
var excludeIDs = (from orgUnits in ruleSet.ExcludeOrgUnits
select orgUnits.UnitID).ToList();
dto.ExcludingOrgUnitIDs = excludeIDs;
}
dto.ValidFrom = ruleSet.ScheduleValidityPeriodFrom;
dto.ValidTo = ruleSet.ScheduleValidityPeriodTo;
dto.IsActive = ruleSet.IsActive;
dto.SendSMSBeforeInMins = ruleSet.MinimumTimeFromMinutes;
dto.SendSMSBeforeDays = ruleSet.SendBeforeInDays;
dto.DaysForRetryExpiry = ruleSet.ExpireInDays;
dto.SendingTimeWindowFrom = ruleSet.SendingTimeIntervalFrom;
dto.SendingTimeWindowTo = ruleSet.SendingTimeIntervalTo;
dto.IgnoreSMStoAdmittedPatient = ruleSet.IgnoreSMStoAdmittedPatient;
dto.AptValidate_To = ruleSet.AppointmentTo;
dto.AptValidate_From = ruleSet.AppointmentFrom;
dto.DepartmentID = ruleSet.DepartmentId;
dto.HospitalID = ruleSet.HospitalId;
dto.Name = ruleSet.RulesetName;
dto.RuleSetGUID = ruleSet.RulesetId;
dto.isValidateAptTime = ruleSet.IsAppointmentTimeValidate;
return(dto);
}
catch (Exception ex)
{
s_log.ErrorException("Map Rule Set modal to Dto failed ", ex);
throw;
}
}
private RuleSet MapDTOtoModel(RuleSetDTO ruleSetDto)
{
List <OrgUnit> orgUnitList = new List <OrgUnit>();
RuleSet modle = new RuleSet();
modle.IsActive = ruleSetDto.IsActive;
modle.SendBeforeInDays = ruleSetDto.SendSMSBeforeDays;
modle.ExpireInDays = ruleSetDto.DaysForRetryExpiry;
modle.SendingTimeIntervalFrom = ruleSetDto.SendingTimeWindowFrom;
modle.SendingTimeIntervalTo = ruleSetDto.SendingTimeWindowTo;
modle.IgnoreSMStoAdmittedPatient = ruleSetDto.IgnoreSMStoAdmittedPatient;
modle.AppointmentTo = ruleSetDto.AptValidate_To;
modle.AppointmentFrom = ruleSetDto.AptValidate_From;
modle.DepartmentId = ruleSetDto.DepartmentID;
modle.HospitalId = ruleSetDto.HospitalID;
modle.RulesetName = ruleSetDto.Name;
modle.RulesetId = ruleSetDto.RuleSetGUID.Value;
modle.ScheduleValidityPeriodFrom = ruleSetDto.ValidFrom;
modle.ScheduleValidityPeriodTo = ruleSetDto.ValidTo;
modle.MinimumTimeFromMinutes = ruleSetDto.SendSMSBeforeInMins;
modle.IsAppointmentTimeValidate = ruleSetDto.isValidateAptTime;
foreach (var id in ruleSetDto.ExcludingOrgUnitIDs)
{
OrgUnit orgUnit = new OrgUnit();
orgUnit.UnitID = id;
orgUnitList.Add(orgUnit);
}
modle.ExcludeOrgUnits = orgUnitList;
return(modle);
}
public Guid InsertUpdateRuleSet(RuleSetDTO ruleSetDTO)
{
string spName = "apt_code.SmsAppointmentService.createUpdateRuleSet";
try
{
using (var connection = m_providerFactory.CreateConnection())
{
var oracleParameters = RuleSetQueryParamsHelper.getQPForCreateORUpdateRuleSet(ruleSetDTO);
var newGuid = SaveAndReturnPK(spName, "l_ruleSetGuid", oracleParameters, connection);
return(newGuid);
}
}
catch (Oracle.ManagedDataAccess.Client.OracleException ex)
{
s_log.ErrorException("InsertUpdateRuleSet Fails(Error from Oracle)", ex);
throw new DBOperationException(ex.Message, ex.Number, DBExceptionScenarios.OracleExceptionOccured, ex);
}
catch (DBOperationException e)
{
s_log.WarnException("Error Occured in InsertUpdateRuleSet", e);
throw;
}
catch (Exception ex)
{
s_log.ErrorException("InsertUpdateRuleSet Fails", ex);
throw new DBOperationException(ex.Message, DBExceptionScenarios.ExceptionOccured, ex);
}
}
private RuleSetDTO MapToRuleSetDTOForListItem(IDictionary <string, Object> dictionary)
{
var rulesetGuid = dictionary["RULESETGUID"];
var rulesetName = dictionary["RULESETNAME"];
var isActive = dictionary["ISACTIVE"];
var hospitalID = dictionary["HOSPITALID"];
var departmentID = dictionary["DEPARTMENTID"];
RuleSetDTO dto = new RuleSetDTO();
if (rulesetGuid != null)
{
dto.RuleSetGUID = GuidConvert.FromRaw((byte[])rulesetGuid);
}
dto.Name = rulesetName as string;
dto.IsActive = (Convert.ToInt16(isActive) == 0 ? false : true);
dto.HospitalID = (long)hospitalID;
if (departmentID != null)
{
dto.DepartmentID = (long)departmentID;
}
else
{
dto.DepartmentID = null;
}
return(dto);
}
public RuleSetDTO SelectRuleSetBy(Guid ruleSetGuid)
{
const string spName = "apt_code.SmsAppointmentService.getRuleSetDetails";
try
{
using (var connection = m_providerFactory.CreateConnection())
{
var oracleparameters = RuleSetQueryParamsHelper.GetRuleSetByIdQueryParams(ruleSetGuid);
var resultSet = connection.Query(spName, oracleparameters, commandType: CommandType.StoredProcedure);
if (resultSet == null)
{
s_log.Error("Select RuleSet By Id returned empty or null result.");
throw new DBOperationException("SelectRuleSetBy returned empty or null result.", GlobalOptions.DBExceptionScenarios.DBReturnedEmptyOrNullDataSet);
}
var mappedRuleSetDTOs = resultSet.ToList().Select(r => MapToRuleSetDTO(r)).ToList();
if (mappedRuleSetDTOs.Select(p => p.RuleSetGUID).Distinct().Count() > 1)
{
throw new DBOperationException("Select RuleSet By Id returned more than one ruleset.");
}
RuleSetDTO dtoToReturn = mappedRuleSetDTOs.FirstOrDefault();
if (dtoToReturn == null)
{
throw new DBOperationException("SelectRuleSetBy returned empty or null result.", GlobalOptions.DBExceptionScenarios.DBReturnedEmptyOrNullDataSet);
}
if (dtoToReturn.ExcludingOrgUnitIDs == null)
{
dtoToReturn.ExcludingOrgUnitIDs = new List <string>();
}
return(dtoToReturn);
}
}
catch (OracleException ex)
{
s_log.ErrorException("SelectRuleSetBy(Guid RuleSetID) Fails(Error from Oracle)", ex);
throw new DBOperationException(ex.Message, ex.Number, DBExceptionScenarios.OracleExceptionOccured, ex);
}
catch (DBOperationException e)
{
s_log.WarnException("Error Occured in SelectRuleSetBy Guid DB function.)", e);
throw;
}
catch (Exception ex)
{
s_log.ErrorException("SelectRuleSetByID Fails", ex);
throw new DBOperationException(ex.Message, DBExceptionScenarios.ExceptionOccured, ex);
}
}
private RuleSetListItem MapDTOtoViewModel(RuleSetDTO dto)
{
return(new RuleSetListItem()
{
RulesetId = (Guid)dto.RuleSetGUID,
RulesetName = dto.Name,
IsActive = dto.IsActive,
DepartmentId = dto.DepartmentID,
HospitalId = dto.HospitalID
});
}
public JsonResult SaveSet(RuleSetDTO ruleSet)
{
var result = _fuzzyManager.SaveSet(ruleSet);
var session = (SessionDTO)result.ResultObject;
Session["groundItem"] = session.groundItem;
Session["groundVariable"] = session.groundVariable;
Session["resistivityItem"] = session.resistivityItem;
Session["resistivityVariable"] = session.resistivityVariable;
Session["rule"] = session.rule;
Session["ruleList"] = session.ruleList;
Session["ruleListItem"] = session.ruleListItem;
Session["rules"] = session.rules;
Session["variables"] = session.variables;
Session["variableItems"] = session.variableItems;
return(Json(new { Success = result.Success, ResultObject = result.ResultObject, Message = result.Message, Exception = result.Exception }, JsonRequestBehavior.AllowGet));
}
public Guid SaveRuleSet(RuleSetDTO rulseSet)
{
return(m_rulesetDataStore.InsertUpdateRuleSet(rulseSet));
}
public ResultDTO SaveSet(RuleSetDTO ruleSet)
{
ResultDTO result = new ResultDTO();
// var resistivity = EditVisibleName(ruleSet.ResistivityList);
// var ground = EditVisibleName(ruleSet.GroundList);
var resistivity = ruleSet.ResistivityList;
var ground = ruleSet.GroundList;
#region Database
//try
//{
// _unitOfWork.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted);
// #region Fuzzy Rule
// Rule rule = new Rule
// {
// ruleName = ruleSet.SetName,
// isActive = true,
// addDate = DateTime.Now
// };
// _ruleService.BulkInsert(rule);
// #endregion
// #region RuleListText
// List<RuleListText> rules = new List<RuleListText>();
// foreach (var RuleListItem in ruleSet.RuleList)
// {
// string ruleText = CreateRule(RuleListItem);
// rules.Add(new RuleListText { ruleID = rule.ruleID, ruleText = ruleText });
// }
// _ruleListTextService.BulkInsertRange(rules);
// #endregion
// #region Input Variable
// Variable resistivityVariable = new Variable
// {
// ruleID = rule.ruleID,
// variableTypeID = (byte)Enums.VariableType.Input,
// variableName = "Resistivity",
// visibleVariableName = "Resistivity"
// };
// _variableService.BulkInsert(resistivityVariable);
// var resistivityItem = (from a in resistivity
// select new VariableItem()
// {
// variableID = resistivityVariable.variableID,
// variableItemName = a.Name,
// variableItemVisibleName = a.VisibleName,
// minValue = a.MinValue,
// maxValue = a.MaxValue
// });
// _variableItemService.BulkInsertRange(resistivityItem);
// #endregion
// #region Output Variable
// Variable groundVariable = new Variable
// {
// ruleID = rule.ruleID,
// variableTypeID = (byte)Enums.VariableType.Output,
// variableName = "Ground",
// visibleVariableName = "Ground"
// };
// _variableService.BulkInsert(groundVariable);
// var groundItem = (from a in ground
// select new VariableItem()
// {
// variableID = groundVariable.variableID,
// variableItemName = a.Name,
// variableItemVisibleName = a.VisibleName,
// minValue = a.MinValue,
// maxValue = a.MaxValue
// });
// _variableItemService.BulkInsertRange(groundItem);
// #endregion
// #region RuleList
// List<RuleListItem> ruleListItem = new List<RuleListItem>();
// for (int i = 0; i < ruleSet.RuleList.Count; i++)
// {
// var ruleList = (new RuleList { ruleID = rule.ruleID, orderNumber = (byte)(i + 1) });
// _ruleListService.BulkInsert(ruleList);
// foreach (var item in ruleSet.RuleList)
// {
// var InputVariableID = _variableItemService.Queryable().FirstOrDefault(d => d.variable.variableTypeID == (byte)Enums.VariableType.Input && d.variableItemName == item.Rule.Resistivity).variableItemID;
// ruleListItem.Add(new RuleListItem { ruleListID = ruleList.ruleListID, variableItemID = InputVariableID });
// var OutputVariableID = _variableItemService.Queryable().FirstOrDefault(d => d.variable.variableTypeID == (byte)Enums.VariableType.Output && d.variableItemName == item.Rule.Ground).variableItemID;
// ruleListItem.Add(new RuleListItem { ruleListID = ruleList.ruleListID, variableItemID = InputVariableID });
// }
// }
// _ruleListItemService.BulkInsertRange(ruleListItem);
// #endregion
// _unitOfWork.Commit();
// result.Success = true;
// result.Message = "Rule set successfully added";
// result.ResultObject = null;
// return result;
//}
//catch (Exception ex)
//{
// _unitOfWork.Rollback();
// result.Success = false;
// result.Message = "Error while adding rule set" + ex.Message;
// result.ResultObject = null;
// return result;
//}
#endregion
#region Lite Edition
try
{
//_unitOfWork.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted);
session.variables = new List <Variable>();
#region Fuzzy Rule
Rule rule = new Rule
{
ruleID = 0,
ruleName = ruleSet.SetName,
isActive = true,
addDate = DateTime.Now
};
session.rule = rule;
//_ruleService.BulkInsert(rule);
#endregion
#region RuleListText
List <RuleListText> rules = new List <RuleListText>();
foreach (var RuleListItem in ruleSet.RuleList)
{
string ruleText = CreateRule(RuleListItem);
rules.Add(new RuleListText {
ruleID = rule.ruleID, ruleText = ruleText
});
}
session.rules = rules;
//_ruleListTextService.BulkInsertRange(rules);
#endregion
#region Input Variable
Variable resistivityVariable = new Variable
{
variableID = 0,
ruleID = rule.ruleID,
variableTypeID = (byte)Enums.VariableType.Input,
variableName = "Resistivity",
visibleVariableName = "Resistivity"
};
session.variables.Add(resistivityVariable);
session.resistivityVariable = resistivityVariable;
//_variableService.BulkInsert(resistivityVariable);
var resistivityItem = (from a in resistivity
select new VariableItem()
{
variableID = resistivityVariable.variableID,
variableItemName = a.Name,
variable = resistivityVariable,
variableItemVisibleName = a.Name,
minValue = a.MinValue,
maxValue = a.MaxValue
}).ToList();
session.resistivityItem = resistivityItem;
//_variableItemService.BulkInsertRange(resistivityItem);
#endregion
#region Output Variable
Variable groundVariable = new Variable
{
variableID = 1,
ruleID = rule.ruleID,
variableTypeID = (byte)Enums.VariableType.Output,
variableName = "Ground",
visibleVariableName = "Ground"
};
session.variables.Add(groundVariable);
session.groundVariable = groundVariable;
//_variableService.BulkInsert(groundVariable);
var groundItem = (from a in ground
select new VariableItem()
{
variableID = groundVariable.variableID,
variable = groundVariable,
variableItemName = a.Name,
variableItemVisibleName = a.Name,
minValue = a.MinValue,
maxValue = a.MaxValue
}).ToList();
session.groundItem = groundItem;
//_variableItemService.BulkInsertRange(groundItem);
#endregion
var variableItems = resistivityItem.Union(groundItem).ToList();
for (int i = 0; i < variableItems.Count; i++)
{
variableItems[i].variableItemID = i;
}
session.variableItems = variableItems;
#region RuleList
List <RuleList> _ruleList = new List <RuleList>();
List <RuleListItem> ruleListItem = new List <RuleListItem>();
for (int i = 0; i < ruleSet.RuleList.Count; i++)
{
var ruleList = (new RuleList {
ruleListID = i, ruleID = rule.ruleID, orderNumber = (byte)(i + 1)
});
_ruleList.Add(ruleList);
//_ruleListService.BulkInsert(ruleList);
foreach (var item in ruleSet.RuleList)
{
var InputVariableID = variableItems.FirstOrDefault(d => d.variable.variableTypeID == (byte)Enums.VariableType.Input && d.variableItemName == item.Rule.Resistivity).variableItemID;
ruleListItem.Add(new RuleListItem {
ruleListID = ruleList.ruleListID, variableItemID = InputVariableID
});
var OutputVariableID = variableItems.FirstOrDefault(d => d.variable.variableTypeID == (byte)Enums.VariableType.Output && d.variableItemName == item.Rule.Ground).variableItemID;
ruleListItem.Add(new RuleListItem {
ruleListID = ruleList.ruleListID, variableItemID = InputVariableID
});
}
}
session.ruleList = _ruleList;
session.ruleListItem = ruleListItem;
//_ruleListItemService.BulkInsertRange(ruleListItem);
#endregion
//_unitOfWork.Commit();
result.Success = true;
result.Message = "Rule set successfully added";
result.ResultObject = session;
return(result);
}
catch (Exception ex)
{
_unitOfWork.Rollback();
result.Success = false;
result.Message = "Error while adding rule set" + ex.Message;
result.ResultObject = null;
return(result);
}
#endregion
}
public void CreateRulesFLS(RuleSetDTO ruleSet)
{
throw new System.NotImplementedException();
}
private RuleSetDTO MapToRuleSetDTO(IDictionary <string, Object> dictionary)
{
var rulesetGuid = dictionary["RULESETGUID"];
var hospitalID = dictionary["HOSPITALID"];
var departmentID = dictionary["DEPARTMENTID"];
var rulesetName = dictionary["RULESETNAME"];
var sendBeforeDays = dictionary["SENDBEFOREDAYS"];
var retryDaysCount = dictionary["RETRYEXPIREDAYS"];
var validateApt = dictionary["VALIDATEAPTTIME"];
var validAptToTime = dictionary["VALIDAPTTOTIME"];
var validAptFromTime = dictionary["VALIDAPTFROMTIME"];
var validFrom = dictionary["VALIDFROM"];
var validTo = dictionary["VALIDTO"];
var sendBeforeInMins = dictionary["SENDBEFOREINMINS"];
var timeWindowFrom = dictionary["SCHSENDTIMEWINDOWFROM"];
var timeWindowTo = dictionary["SCHSENDTIMEWINDOWTO"];
var isActive = dictionary["ISACTIVE"];
var IgnoreSMStoAdmittedPatient = dictionary["IGNOREADMITTEDPATIENT"];
var replacedByGuid = dictionary["REPLACEDBYGUID"];
var excludedOrgUnits = dictionary["RESHIDS"];
RuleSetDTO dto = new RuleSetDTO();
if (rulesetGuid != null)
{
dto.RuleSetGUID = new Guid((byte[])rulesetGuid);
}
if (replacedByGuid != null)
{
dto.ReplacedByGUID = new Guid((byte[])replacedByGuid);
}
if (validFrom != null)
{
dto.ValidFrom = (DateTime)validFrom;
}
if (validTo != null)
{
dto.ValidTo = (DateTime)validTo;
}
if (sendBeforeDays != null)
{
dto.SendSMSBeforeDays = (int)sendBeforeDays;
}
dto.HospitalID = (long)hospitalID;
if (departmentID != null)
{
dto.DepartmentID = (long)departmentID;
}
else
{
dto.DepartmentID = null;
}
dto.Name = rulesetName as string;
if (retryDaysCount != null)
{
dto.DaysForRetryExpiry = (int)retryDaysCount;
}
dto.isValidateAptTime = (Convert.ToInt16(isActive) == 0 ? false : true);
dto.IsActive = (Convert.ToInt16(isActive) == 0 ? false : true);
dto.isValidateAptTime = (Convert.ToInt16(validateApt) == 0 ? false : true);
dto.AptValidate_From = validAptFromTime as string;
dto.AptValidate_To = validAptToTime as string;
if (sendBeforeInMins != null)
{
dto.SendSMSBeforeInMins = Convert.ToInt32(sendBeforeInMins);
}
dto.SendingTimeWindowFrom = timeWindowFrom as string;
dto.SendingTimeWindowTo = timeWindowTo as string;
dto.IgnoreSMStoAdmittedPatient = (Convert.ToInt16(IgnoreSMStoAdmittedPatient) == 0 ? false : true);
if (excludedOrgUnits != null)
{
dto.ExcludingOrgUnitIDs = excludedOrgUnits.ToString().Split(',').ToList();
}
return(dto);
}
