public UserGroup UpdateUserGroup(UserGroup userGroupForUpdate, User owner)
{
//Аутентификация пользователя-владельца
AuthenticateUser(owner);
//Проверка - иммеет ли право владелец добавлять или изменять данные
this.ChechIsAdmin(owner, typeof(UserGroup));
//Создание экземпляра контекста
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
ctx.Entry(userGroupForUpdate).State = EntityState.Modified;
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(userGroupForUpdate);
}
public Rate AddRate(Rate newRate, User user)
{
AuthenticateUser(user);
this.ChechIsAdmin(user, typeof(Rate));
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
ctx.Rates.Add(newRate);
newRate.CustomValidate(ctx);
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(newRate);
}
public BudgetItem AddBudgetItem(BudgetItem newBudgetItem, User user)
{
AuthenticateUser(user);
this.ChechIsAdmin(user, typeof(BudgetItem));
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
ctx.BudgetItems.Add(newBudgetItem);
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(newBudgetItem);
}
public UserGroup AddNewUserGroup(UserGroup newUserGroup, User owner)
{
AuthenticateUser(owner);
this.ChechIsAdmin(owner, typeof(UserGroup));
using (CFAPContext ctx = new CFAPContext())
{
try
{
ctx.UserGroups.Add(newUserGroup);
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(newUserGroup);
}
public ICrudOperations Update(DbConcurencyUpdateOptions concurencyUpdateOptions, User user)
{
if (user.IsAdmin == false)
{
throw new FaultException <NoRightsToChangeDataException>(new NoRightsToChangeDataException(user, this.GetType().Name));
}
concurencyUpdateOptions = DbConcurencyUpdateOptions.ClientPriority;
Period result = null;
try
{
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
ctx.Periods.Attach(this);
ctx.Entry(this).State = System.Data.Entity.EntityState.Modified;
ctx.SaveChanges(concurencyUpdateOptions);
result = (from p in ctx.Periods where p.Month == this.Month && p.Year == this.Year select p).Single();
}
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
return(result);
}
public ICrudOperations Add(DbConcurencyUpdateOptions concurencyUpdateOptions, User user)
{
concurencyUpdateOptions = DbConcurencyUpdateOptions.ClientPriority;
if (user.IsAdmin == false)
{
throw new FaultException <NoRightsToChangeDataException>(new NoRightsToChangeDataException(user, this.GetType().Name));
}
bool isExists = false;
try
{
using (CFAPContext ctx = new CFAPContext())
{
var existsPeriod = (from p in ctx.Periods where p.Month == this.Month && p.Year == this.Year select p).FirstOrDefault();
if (existsPeriod != null)
{
isExists = true;
}
}
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
if (isExists)
{
return(Update(concurencyUpdateOptions, user));
}
Period result = null;
try
{
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
ctx.Periods.Add(this);
ctx.SaveChanges(concurencyUpdateOptions);
result = (from p in ctx.Periods where p.Month == this.Month && p.Year == this.Year select p).Single();
}
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
return(result);
}
public User UpdateUser(User userForUpdate, User owner)
{
//Аутентификация пользователя-владельца
AuthenticateUser(owner);
//Проверка - иммеет ли право владелец добавлять или изменять данные пользователей (User.CanAddNewUser)
this.CheckCanChangeUsersData(owner, typeof(User));
if (userForUpdate.UserGroups == null || userForUpdate.UserGroups.Count == 0)
{
throw new FaultException <UserHasNotGroupsException>(new UserHasNotGroupsException(userForUpdate));
}
if (userForUpdate.IsAccountable && userForUpdate.Accountable == null)
{
throw new FaultException <AccountableUserHasNotAccountableRefferenceException>(new AccountableUserHasNotAccountableRefferenceException(userForUpdate));
}
//Создание экземпляра контекста
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
var oldPassword = (from u in ctx.Users where u.Id == userForUpdate.Id select u.Password).Single();
if (oldPassword != userForUpdate.Password)
{
userForUpdate.EncriptPassword();
}
try
{
//Загрузка в контекст данных о группах пользователя
//userForUpdate.LoadUserGroupsFromObject(ctx);
userForUpdate.SetRelationships(ctx);
//Изменение связей с группами если они изменились
userForUpdate.ChangeUserGroups(ctx);
ctx.Entry(userForUpdate).State = EntityState.Modified;
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(userForUpdate);
}
public Rate UpdateRate(Rate rateToUpdate, User user, DbConcurencyUpdateOptions concurencyUpdateOption)
{
AuthenticateUser(user);
this.ChechIsAdmin(user, typeof(Rate));
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
ctx.Rates.Attach(rateToUpdate);
var ratesToUpdateDbVersion = (Rate)ctx.Entry(rateToUpdate).GetDatabaseValues().ToObject();
if (ratesToUpdateDbVersion.ReadOnly)
{
throw new ReadOnlyException();
}
ctx.Entry(rateToUpdate).State = EntityState.Modified;
rateToUpdate.CustomValidate(ctx);
ctx.SaveChanges(concurencyUpdateOption);
}
catch (ReadOnlyException)
{
throw new FaultException <TryChangeReadOnlyFiledException>(new TryChangeReadOnlyFiledException(typeof(Rate), rateToUpdate.Id, null, user));
}
catch (DbUpdateConcurrencyException ex)
{
var currentValue = rateToUpdate;
var dbValue = (Rate)ex.Entries.Single().GetDatabaseValues().ToObject();
ConcurrencyException <Rate> concurrencyException = new ConcurrencyException <Rate>(dbValue, currentValue);
throw new FaultException <ConcurrencyException <Rate> >(concurrencyException);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(rateToUpdate);
}
public BudgetItem UpdateBudgetItem(BudgetItem budgetItemToUpdate, User user, DbConcurencyUpdateOptions concurencyUpdateOption)
{
AuthenticateUser(user);
this.ChechIsAdmin(user, typeof(BudgetItem));
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
ctx.BudgetItems.Attach(budgetItemToUpdate);
var budgetItemToUpdateDbVersion = (BudgetItem)ctx.Entry(budgetItemToUpdate).GetDatabaseValues().ToObject();
if (budgetItemToUpdateDbVersion.ReadOnly)
{
throw new ReadOnlyException();
}
ctx.Entry(budgetItemToUpdate).State = EntityState.Modified;
ctx.SaveChanges(concurencyUpdateOption);
}
catch (ReadOnlyException)
{
throw new FaultException <TryChangeReadOnlyFiledException>(new TryChangeReadOnlyFiledException(typeof(BudgetItem), budgetItemToUpdate.Id, budgetItemToUpdate.ItemName, user));
}
catch (DbUpdateConcurrencyException ex)
{
var currentValue = budgetItemToUpdate;
var dbValue = (BudgetItem)ex.Entries.Single().GetDatabaseValues().ToObject();
ConcurrencyException <BudgetItem> concurrencyException = new ConcurrencyException <BudgetItem>(dbValue, currentValue);
throw new FaultException <ConcurrencyException <BudgetItem> >(concurrencyException);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(budgetItemToUpdate);
}
public User AddNewUser(User newUser, User owner)
{
AuthenticateUser(owner);
this.CheckCanChangeUsersData(owner, typeof(User));
if (newUser.UserGroups == null || newUser.UserGroups.Count == 0)
{
throw new FaultException <UserHasNotGroupsException>(new UserHasNotGroupsException(newUser));
}
if (newUser.Password == null || newUser.Password.Length == 0)
{
Dictionary <string, string> errors = new Dictionary <string, string>();
errors.Add("Password", "Не указан пароль.");
throw new FaultException <DataNotValidException>(new DataNotValidException(errors));
}
if (newUser.IsAccountable && newUser.Accountable == null)
{
throw new FaultException <AccountableUserHasNotAccountableRefferenceException>(new AccountableUserHasNotAccountableRefferenceException(newUser));
}
newUser.EncriptPassword();
using (CFAPContext ctx = new CFAPContext())
{
try
{
//newUser.LoadUserGroupsFromObject(ctx); //Перенесено в SetRelationships()
newUser.SetRelationships(ctx);
ctx.Users.Add(newUser);
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(newUser);
}
public void ChangeSummaryReadOnlyStatus(bool onOff, Filter filter, User user)
{
AuthenticateUser(user);
bool canReadSummary = false;
foreach (var g in user.UserGroups)
{
if (g.CanReadAccountablesSummary)
{
canReadSummary = true;
}
}
if (!canReadSummary)
{
throw new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
}
this.ChechIsAdmin(user, typeof(Summary));
List <Summary> summaries = this.GetSummary(user, filter).ToList();
using (CFAPContext ctx = new CFAPContext())
{
try
{
foreach (var summary in summaries)
{
ctx.Summaries.Attach(summary);
summary.ReadOnly = onOff;
ctx.Entry(summary).State = EntityState.Modified;
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
}
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
}
public Summary RemoveSummary(Summary summary, User user, DbConcurencyUpdateOptions concurencyUpdateOption)
{
AuthenticateUser(user);
bool canReadSummary = false;
foreach (var g in user.UserGroups)
{
if (g.CanReadAccountablesSummary)
{
canReadSummary = true;
}
}
if (!canReadSummary)
{
throw new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
}
if (summary.CheckPeriodIsUnlocked() == false)
{
throw new FaultException <PeriodIsLockedException>(new PeriodIsLockedException(summary.SummaryDate));
}
if (concurencyUpdateOption == DbConcurencyUpdateOptions.DatabasePriority)
{
throw new FaultException <InvalidOperationException>(new InvalidOperationException("Работа опрации в режиме DbConcurencyUpdateOptions.DatabasePriority не имеет смысла."));
}
Summary result = null;
using (CFAPContext ctx = new CFAPContext())
{
if (summary.UserLastChanged == null || summary.UserLastChanged.Id != user.Id)
{
summary.UserLastChanged = user;
}
summary.SetRelationships(ctx);
//Когда сущность проходит через SaveChanges все ассоциации обнуляються. Так как с базы данных после удаления обькт получить невозможно - единственный способ сохранить его состояние через клонирование.
result = (Summary)summary.Clone();
try
{
ctx.Summaries.Attach(summary);
var summaryDbVersion = (Summary)ctx.Entry(summary).GetDatabaseValues().ToObject();
if (summaryDbVersion.ReadOnly)
{
throw new ReadOnlyException();
}
ctx.Entry(summary).State = EntityState.Deleted;
ctx.SaveChanges(concurencyUpdateOption);
//Ссылочные свойства (связи в БД) больше не отслеживаютсья контекстом и подлежать востановлению только вручную, через явное указание Id и поиск в БД сущности связи по идентификатору.
}
catch (ReadOnlyException)
{
throw new FaultException <TryChangeReadOnlyFiledException>(new TryChangeReadOnlyFiledException(typeof(Summary), summary.Id, null, user));
}
catch (DbUpdateConcurrencyException ex)
{
Summary dbSummary = (Summary)ex.Entries.Single().GetDatabaseValues().ToObject();
Summary currentSummary = result;
//Метод Load не загрузит ссылочные свойства без конкретного указания Id.
//Свойство коллекции UserGroups является связью многие-ко-многим. Экземпляр сущности не содержит ключи этих связей в виде элементарных типов данных.
//dbSummary.UserGroups = result.UserGroups;
dbSummary = LoadRelationshipsDbSummary(dbSummary);
ConcurrencyException <Summary> concurrencyException = new ConcurrencyException <Summary>(dbSummary, currentSummary);
throw new FaultException <ConcurrencyException <Summary> >(concurrencyException);
}
catch (NullReferenceException ex)
{
throw new FaultException <FiledDeletedException>(new FiledDeletedException(ex));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(result);
}
public Summary UpdateSummary(Summary summary, User user, DbConcurencyUpdateOptions concurencyUpdateOption)
{
//Изменение значения поля ReadOnly осуществляеться другой операцией службы
AuthenticateUser(user);
bool canReadSummary = false;
foreach (var g in user.UserGroups)
{
if (g.CanReadAccountablesSummary)
{
canReadSummary = true;
}
}
if (!canReadSummary)
{
throw new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
}
if (summary.CheckPeriodIsUnlocked() == false)
{
throw new FaultException <PeriodIsLockedException>(new PeriodIsLockedException(summary.SummaryDate));
}
//Пользователь который изменил данные устанавливается по факту
if (summary.UserLastChanged == null || summary.UserLastChanged.Id != user.Id)
{
summary.UserLastChanged = user;
}
summary.SetAutoValues();
Summary result = null;
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
//Группы пользователей уже существуют в сущности
//Если, по какой то причине их нет - будет исключение валидации
summary.SetRelationships(ctx);
//В данном случае AddOrUpdate не сработает в выдаче исключения оптимистичного паралелизма. Он перезагружет сущности в контекс и формирует уже актуальное поле RowVersion
ctx.Summaries.Attach(summary);
var summaryDbVersion = (Summary)ctx.Entry(summary).GetDatabaseValues().ToObject();
if (summaryDbVersion.ReadOnly)
{
throw new ReadOnlyException();
}
ctx.Entry(summary).State = EntityState.Modified;
//Ручной запуск валидации необходм так как при модификации данных связи с сущностями помечены как EntityState.Unchanged
//В итоге, без ручной валидации, при неверных данных или значениях null будет исключения при внесении данных в бд, а валидация EF ничего не заметит
summary.CustomValidate(ctx);
ctx.SaveChanges(concurencyUpdateOption);
result = (from s in ctx.Summaries where s.Id == summary.Id select s).Single();
}
catch (ReadOnlyException)
{
throw new FaultException <TryChangeReadOnlyFiledException>(new TryChangeReadOnlyFiledException(typeof(Summary), summary.Id, null, user));
}
catch (DbUpdateConcurrencyException ex)
{
Summary dbSummary = (Summary)ex.Entries.Single().GetDatabaseValues().ToObject();
Summary currentSummary = summary;
dbSummary = LoadRelationshipsDbSummary(dbSummary);
ConcurrencyException <Summary> concurrencyException = new ConcurrencyException <Summary>(dbSummary, currentSummary);
throw new FaultException <ConcurrencyException <Summary> >(concurrencyException);
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (NullReferenceException ex)
{
throw new FaultException <FiledDeletedException>(new FiledDeletedException(ex));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(result);
}
public Summary AddSummary(Summary summary, User user)
{
AuthenticateUser(user);
bool canReadSummary = false;
foreach (var g in user.UserGroups)
{
if (g.CanReadAccountablesSummary)
{
canReadSummary = true;
}
}
if (!canReadSummary)
{
throw new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
}
if (summary.CheckPeriodIsUnlocked() == false)
{
throw new FaultException <PeriodIsLockedException>(new PeriodIsLockedException(summary.SummaryDate));
}
//if (summary.UserGroups == null || summary.UserGroups.Count == 0)
//{
// summary.UserGroups = user.UserGroups;
//}
if (summary.UserLastChanged == null || summary.UserLastChanged.Id != user.Id)
{
summary.UserLastChanged = user;
}
summary.SetAutoValues();
Summary result = null;
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
summary.SetRelationships(ctx);
try
{
ctx.Summaries.Add(summary);
ctx.SaveChanges(DbConcurencyUpdateOptions.ClientPriority);
result = summary;
}
catch (DbEntityValidationException ex)
{
throw new FaultException <DataNotValidException>(new DataNotValidException(ex.EntityValidationErrors));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(result);
}
