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 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 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);
}
/// <summary>
/// Update an item
/// </summary>
/// <param name="id">Item id</param>
/// <param name="model">Item model</param>
/// <returns></returns>
public virtual async Task <IHttpActionResult> Put(long id, T model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != model.Id)
{
return(BadRequest());
}
try
{
_unitOfWork.BeginTransaction();
_service.Insert(model);
await _unitOfWork.SaveChangesAsync();
_unitOfWork.Commit();
}
catch (DbUpdateConcurrencyException)
{
if (!ModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
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();
_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 BeginTransaction(IsolationLevel isolationLevel)
{
if (_uow != null)
{
_uow.BeginTransaction(isolationLevel);
}
}
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);
}
}
/// <summary>
/// Overriding base implementation
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override async Task <IHttpActionResult> Post(Role model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_unitOfWork.BeginTransaction();
var modelToUpdate = await _service.FindAsync(model.Id);
modelToUpdate.CopyFrom(model);
_service.Update(modelToUpdate);
await _unitOfWork.SaveChangesAsync();
_unitOfWork.Commit();
}
catch (System.Exception ex)
{
return(InternalServerError(ex));
}
return(CreatedAtRoute("DefaultApi", new { id = model.Id }, model));
}
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 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 int AddNotification(NotificationDTO obj)
{
try
{
_unitOfWork.BeginTransaction();
Notification notification = new Notification();
Mapper.Map <NotificationDTO, Notification>(obj, notification);
base.Insert(notification);
_unitOfWork.SaveChanges();
_unitOfWork.Commit();
return(notification.Id);
}
catch (Exception)
{
throw;
}
}
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;
}
}
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;
}
}
/// <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 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 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 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);
}
