public void Create(AspNetUserModel model, out string id)
{
try
{
_unitOfWork.BeginTransaction();
id = "";
var passwordHash = new PasswordHasher();
var password = passwordHash.HashPassword(model.Password);
var entity = Mapper.Map <AspNetUserModel, AspNetUser>(model);
entity.PasswordHash = password;
entity.SecurityStamp = Guid.NewGuid().ToString();
entity.Id = Guid.NewGuid().ToString();
_repository.Insert(entity);
/*var repository = _repository.GetRepository<IdentityUserRole>();
* var reposRole = _repository.GetRepository<AspNetRole>();
* repository.Insert(new IdentityUserRole()
* {
* UserId = entity.Id,
* RoleId = reposRole.Find(c=> c.Name == model.RoleName).Id
* });*/
id = entity.Id;
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw new Exception(ex.Message);
}
}
public void Create(ComplaintModel model, string username)
{
try
{
_unitOfWork.BeginTransaction();
var complaint = new Complaint
{
Id = Guid.NewGuid().ToString(),
Category = (int)model.Category,
Description = model.Description,
Summary = model.Summary,
DateCreated = DateTime.UtcNow,
Status = (int)ComplaintStatus.Created,
Type = (int)model.Type,
ComplainBy = model.ComplainBy
};
_repository.Insert(complaint);
_unitOfWork.Commit();
}
catch (Exception e)
{
_unitOfWork.Rollback();
throw e;
}
}
public void Create(UserProfileModel model)
{
try
{
_unitOfWork.BeginTransaction();
if (!String.IsNullOrEmpty(model.EmailAddress))
{
if (_repository.EmailExists(model))
{
throw new DuplicateNameException("A user with that e-mail address already exists!");
}
}
var entity = Mapper.Map <UserProfileModel, UserProfile>(model);
entity.DateCreated = DateTime.Now;
_repository.Insert(entity);
model.Id = entity.Id;
_unitOfWork.Commit();
}
catch (DuplicateNameException ec)
{
throw new Exception("An error has occured " + ec.Message);
}
catch (Exception ec)
{
_unitOfWork.Rollback();
throw new Exception("An error has occured " + ec.Message);
}
}
public void Delete(int id)
{
try
{
//TODO:Throw clear exception once delete object has childs
_unitOfWorkAsync.BeginTransaction();
_repository.Delete(id);
_unitOfWorkAsync.SaveChanges();
_unitOfWorkAsync.Commit();
}
catch { _unitOfWorkAsync.Rollback(); throw; }
}
public int Delete(int id)
{
try
{
_unitOfWork.BeginTransaction();
List <int> refItemIds = _repository.Query().Include(c => c.ReferenceItems).SelectQueryable().Where(c => c.Id == id).FirstOrDefault().ReferenceItems.Select(c => c.Id).ToList();
List <int> NotIds = _notificationBLL.Query().Include(c => c.Decision).SelectQueryable().Where(c => c.DecisionId == id).Select(c => c.Id).ToList();
refItemIds.ForEach(c => _referenceItemRepository.Delete(c));
_unitOfWork.SaveChanges();
NotIds.ForEach(c => _notificationBLL.Delete(c));
_repository.Delete(id);
_unitOfWork.SaveChanges();
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
if (ex is DbUpdateException)
{
if (!(ex as DbUpdateException).InnerException.InnerException.Message.Contains("The DELETE statement conflicted with the REFERENCE constraint"))
{
ex = new Exception("Reference Item");
}
}
throw ex;
}
return(0);
}
public string ReserveTicket(string eventId, int tktQty)
{
_unitOfWorkAsync.BeginTransaction();
EventModel Event = _eventService.FindBy(eventId);
if (!Event.CanReserveTicket(tktQty))
{
_unitOfWorkAsync.Rollback();
return(String.Format("There are {0} ticket(s) available.", Event.AvailableAllocation()));
}
Event.ReserveTicket(tktQty);
_eventService.Save(Event);
_unitOfWorkAsync.Commit();
return(String.Format("{0} ticket(s) has been reserved for you for the event with Id {1}.", tktQty, Event.Id));;
}
public int Delete(int id)
{
try
{
_unitOfWork.BeginTransaction();
_repository.Delete(id);
_unitOfWork.SaveChanges();
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw ex;
}
return(0);
}
public void Create(CourseModel model, int currentUserId)
{
try
{
_unitOfWork.BeginTransaction();
var entity = Mapper.Map <CourseModel, Course>(model);
entity.CreatedAt = DateTime.Now;
_levelRepository.Insert(entity);
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw new Exception(ex.Message);
}
}
public void Rollback()
{
if (_uow != null)
{
_uow.Rollback();
}
}
public void Create(UserModel model)
{
try
{
_unitOfWork.BeginTransaction();
var entity = Mapper.Map <UserModel, User>(model);
entity.CreatedAt = DateTime.Now;
_repository.Insert(entity);
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw new Exception(ex.Message);
}
}
public void Create(SectionModel model, int currentUserId)
{
try
{
_unitOfWork.BeginTransaction();
if (model.IsActive)
{
UpdateActiveSession();
}
var entity = Mapper.Map <SectionModel, Section>(model);
entity.CreatedAt = DateTime.Now;
_sectionRepository.Insert(entity);
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw new Exception(ex.Message);
}
}
public void Update(SubCategoryDTO dtoObject)
{
try
{
_unitOfWorkAsync.BeginTransaction();
SubCategory subCategory = new SubCategory();
Mapper.Map <SubCategoryDTO, SubCategory>(dtoObject, subCategory);
Update(subCategory);
_unitOfWorkAsync.SaveChanges();
_unitOfWorkAsync.Commit();
}
catch (Exception ex)
{
_unitOfWorkAsync.Rollback();
throw ex;
}
}
public void Save(EventModel Event)
{
try
{
_unitOfWorkAsync.BeginTransaction();
var eventEntity = _eventRepository.Find(Event.Id);
RemovePurchasedAndReservedTicketsFrom(eventEntity);
_eventRepository.Insert(Mapper.Map <EventModel, Event>(Event));
InsertPurchasedTicketsFrom(Event);
InsertReservedTicketsFrom(Event);
_eventRepository.SaveChanges();
}
catch (Exception)
{
_unitOfWorkAsync.Rollback();
throw;
}
}
/// <summary>
/// Inserts the specified entity dto.
/// </summary>
/// <param name="entityDto">The entity dto.</param>
/// <exception cref="System.NullReferenceException">errore nel cast da DTO a TEntity in Service --> Insert</exception>
public virtual void Insert(TDto entityDto)
{
try
{
var entity = CreateDataFromDTO(entityDto);
if (entity == null)
{
throw new NullReferenceException("errore nel cast da DTO a TEntity in Service --> Insert");
}
_uow.BeginTransaction();
_repository.Add(entity);
_uow.SaveChanges();
_uow.Commit();
}
catch (Exception ex)
{
_uow.Rollback();
_logger.LogException(ex);
throw;
}
}
public void Create(MeetingModel model, string username)
{
try
{
_unitOfWork.BeginTransaction();
GroupMeeting meeting = new GroupMeeting
{
Description = model.Description,
GroupMeetingDate = model.GroupMeetingDate,
GroupMeetingLeadName = model.GroupMeetingLeadName,
ProjectName = model.ProjectName,
TeamLeadName = model.TeamLeadName
};
_repository.Insert(meeting);
_unitOfWork.Commit();
}
catch (System.Exception e)
{
_unitOfWork.Rollback();
throw e;
}
}
public int InsertMeeting(MeetingDTO objDTO, string userId)
{
Meeting meetingObject = new Meeting();
objDTO.MeetingIndexNumber = _repository.Query().SelectQueryable().Max(c => c.MeetingIndexNumber) + 1;
objDTO.MeetingNumber = _repository.Query().SelectQueryable().Where(c => c.MeetingDate.Year == objDTO.MeetingDate.Year).Any() ? _repository.Query().SelectQueryable().Where(c => c.MeetingDate.Year == objDTO.MeetingDate.Year).Max(c => c.MeetingNumber) + 1 : 1;
try
{
_unitOfWork.BeginTransaction();
objDTO.RoundId = _roundRepository.Query().SelectQueryable().Where(c => c.CouncilTypeId == objDTO.CouncilTypeId && c.IsCurrent).FirstOrDefault().Id;
Mapper.Map <MeetingDTO, Meeting>(objDTO, meetingObject);
//operationObject.RefernceNo = GenerateRefernceNo(operationObject);
objDTO.MeetingAttendances.ToList().ForEach(c =>
{
MeetingAttendance externalattendence = new MeetingAttendance();
Mapper.Map <MeetingAttendanceDTO, MeetingAttendance>(c, externalattendence);
externalattendence.MemberType = (int)EnumMemberType.External;
meetingObject.MeetingAttendances.Add(externalattendence);
});
//meetingObject.MeetingAttendances.ToList().ForEach(c => c.MemberType = (int)EnumMemberType.External);
objDTO.SelectedCouncilMembers.ToList().ForEach(c =>
{
var councilMember = _councilMemberBLL.GetById(c);
meetingObject.MeetingAttendances.Add(new MeetingAttendance()
{
CouncilMemberId = councilMember.Id,
Name = councilMember.Name,
MemberType = (int)EnumMemberType.CouncilMember,
Email = councilMember.Email,
});
});
objDTO.SelectedEmployees.ToList().ForEach(c =>
{
var emp = _employeeService.GetById(c.Id);
meetingObject.MeetingAttendances.Add(new MeetingAttendance()
{
Name = c.Name,
EmployeId = c.Id.ToString(),
DepartmentId = c.DepartmentId,
DepartmentName = c.DepartmentName,
MemberType = (int)EnumMemberType.Employee,
Email = emp.Email,
});
});
base.Insert(meetingObject);
if (_unitOfWork.SaveChanges() > 0)
{
objDTO.AgendaItems.Where(c => c.AttachementName != "").ToList().ForEach(c =>
{
meetingObject
.AgendaItems
.Where(d => d.AgendaNumber == c.AgendaNumber).FirstOrDefault()
.AttachementName = CopyAttachment(
userId,
c.AttachementName,
meetingObject.Id,
meetingObject.AgendaItems.Where(d => d.AgendaNumber == c.AgendaNumber).FirstOrDefault().Id
, null);
var adendaItemId = meetingObject.AgendaItems.Where(item => item.AgendaNumber == c.AgendaNumber).FirstOrDefault().Id;
c.AgendaDetails.ToList().ForEach(d =>
{
meetingObject.AgendaItems.Where(f => f.Id == adendaItemId).SelectMany(y => y.AgendaDetails).Where(det => det.TreeNumber == d.TreeNumber).FirstOrDefault()
.AttachementName = CopyAttachment(
userId,
d.AttachementName,
meetingObject.Id,
adendaItemId,
meetingObject.AgendaItems.Where(f => f.Id == adendaItemId).SelectMany(y => y.AgendaDetails).Where(det => det.TreeNumber == d.TreeNumber).FirstOrDefault().Id);
});
_unitOfWork.SaveChanges();
});
}
_unitOfWork.Commit();
return(meetingObject.Id);
}
catch (Exception ex)
{
_unitOfWork.Rollback();
throw ex;
}
}
public bool Insert(Usuario item, Session session = null)
{
//LoggerFactory.CreateLog().Start();
var committed = 0;
bool result = false;
UserPasswords oUserPass = new UserPasswords();
Password oPass = new Password();
try
{
//if (session != null)
// _repositoryUsuario.UnitOfWork.SetConnectionDb(session.ConnectionString);
if (item == null)
{
throw new ArgumentNullException("item");
}
var validator = EntityValidatorFactory.CreateValidator();
if (validator.IsValid(item))
{
var _repoPass = _repositoryUsuario.GetRepository <Password>();
var _repoUserPass = _repositoryUsuario.GetRepository <UserPasswords>();
_unitOfWorkAsync.BeginTransaction();
oUserPass = item.UserPasswords.FirstOrDefault();
oPass = oUserPass.Password;
//oUserPass = item.UserPasswords.FirstOrDefault();
//Password
string _srtEncrypt = desHelper.EncryptString(oPass.Password1);
//string _strDecrypt = desHelper.DecryptString("39S4D8vXqfk=");
//oPass.Password1 = item..Password;
oPass.PasswordHash = _srtEncrypt;
oPass.TrackingState = TrackingState.Added;
////////_repoPass.Insert(oPass);
//committed = _unitOfWorkAsync.SaveChanges();
//var oPassTemp = _repoPass.Queryable().Where(x => x.PasswordHash == _srtEncrypt).FirstOrDefault();
item.TrackingState = TrackingState.Added;
_repositoryUsuario.Insert(item, false);
//var oUser = _repositoryUsuario.Queryable().Where(x => x.AccountName == item.AccountName).FirstOrDefault();
//committed = _unitOfWorkAsync.SaveChanges();
oUserPass.IdUsuario = item.Id;
oUserPass.IdPassword = oPass.Id;
oUserPass.TrackingState = TrackingState.Added;
//_repoUserPass.Insert(oUserPass);
committed = _unitOfWorkAsync.SaveChanges();
result = _unitOfWorkAsync.Commit();
// Domain Services?
//_repositoryUsuario.Insert(Mapper.Map<Dominio.Entidades.Usuario>(item));
//_repositoryUsuario.Insert(item);
}
else
{
throw new ApplicationValidationErrorsException(validator.GetInvalidMessages(item));
}
}
catch (Exception ex)
{
_unitOfWorkAsync.Rollback();
//LoggerFactory.CreateLog().Error(ex);
}
//LoggerFactory.CreateLog().Stop();
//return committed > 0;
return(result);
}
public ResultDTO SaveCluster(RuleClusterDTO ruleCluster)
{
ResultDTO sonuc = new ResultDTO();
var resistivity = EditVisibleName(ruleCluster.ResistivityList);
var soil = EditVisibleName(ruleCluster.SoilList);
#region Database Operations
try
{
_unitOfWork.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted);
#region Rule
Kural rule = new Kural
{
KuralAdi = ruleCluster.RuleName,
AktifMi = true,
EklenmeTarihi = DateTime.Now
};
_ruleService.BulkInsert(rule);
#endregion
#region RuleListText
List <KuralListText> rules = new List <KuralListText>();
foreach (var ruleListItem2 in ruleCluster.RuleList)
{
string ruleText = GenerateRule(ruleListItem2);
rules.Add(new KuralListText {
KuralID = rule.KuralID, KuralText = ruleText
});
}
_ruleListTextService.BulkInsertRange(rules);
#endregion
#region Input Variable
Degisken resistivityVariable = new Degisken
{
KuralID = rule.KuralID,
DegiskenTipID = (byte)Enums.VariableType.Input,
DegiskenAdi = "Özdirenç",
DegiskenGorunenAdi = "Ozdirenc"
};
_variableService.BulkInsert(resistivityVariable);
var ozdirencItem = (from a in resistivity
select new DegiskenItem()
{
DegiskenID = resistivityVariable.DegiskenID,
DegiskenItemAdi = a.Name,
DegiskenItemGorunenAdi = a.VisibleName,
MinDeger = a.MinValue,
MaxDeger = a.MaxValue
});
_variableItemService.BulkInsertRange(ozdirencItem);
#endregion
#region Output Variable
Degisken soilVariable = new Degisken
{
KuralID = rule.KuralID,
DegiskenTipID = (byte)Enums.VariableType.Output,
DegiskenAdi = "Toprak",
DegiskenGorunenAdi = "Toprak"
};
_variableService.BulkInsert(soilVariable);
var soilItem = (from a in soil
select new DegiskenItem()
{
DegiskenID = soilVariable.DegiskenID,
DegiskenItemAdi = a.Name,
DegiskenItemGorunenAdi = a.VisibleName,
MinDeger = a.MinValue,
MaxDeger = a.MaxValue
});
_variableItemService.BulkInsertRange(soilItem);
#endregion
#region RuleList
List <KuralListItem> ruleListItem = new List <KuralListItem>();
for (int i = 0; i < ruleCluster.RuleList.Count; i++)
{
var ruleList = (new KuralList {
KuralID = rule.KuralID, SiraNo = (byte)(i + 1)
});
_ruleListService.BulkInsert(ruleList);
foreach (var item in ruleCluster.RuleList)
{
var InputVariableId = _variableItemService.Queryable().FirstOrDefault(d => d.Degisken.DegiskenTipID == (byte)Enums.VariableType.Input && d.DegiskenItemAdi == item.Rule.Resistivity).DegiskenItemID;
ruleListItem.Add(new KuralListItem {
KuralListID = ruleList.KuralListID, DegiskenItemID = InputVariableId
});
var OutputVariableId = _variableItemService.Queryable().FirstOrDefault(d => d.Degisken.DegiskenTipID == (byte)Enums.VariableType.Output && d.DegiskenItemAdi == item.Rule.Soil).DegiskenItemID;
ruleListItem.Add(new KuralListItem {
KuralListID = ruleList.KuralListID, DegiskenItemID = InputVariableId
});
}
}
_ruleListItemService.BulkInsertRange(ruleListItem);
#endregion
_unitOfWork.Commit();
sonuc.Result = true;
sonuc.Message = "Save Successful For Rule Cluster.";
sonuc.Object = null;
return(sonuc);
}
catch (Exception ex)
{
_unitOfWork.Rollback();
sonuc.Result = false;
sonuc.Message = "An Error Occured While Saving Rule Cluster. Error: " + ex.Message;
sonuc.Object = null;
return(sonuc);
}
#endregion
}
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
}
