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 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 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 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 void CustomValidate(CFAPContext ctx)
{
List <DbEntityValidationResult> validationResults = new List <DbEntityValidationResult>();
var rateResult = ctx.Entry(this).GetValidationResult();
if (!rateResult.IsValid)
{
validationResults.Add(rateResult);
}
if (this.DateRate == default(DateTime))
{
DbValidationError validationError = new DbValidationError(typeof(DateTime).ToString(), "Значениие не определено");
DbEntityValidationResult dbEntityValidationResult = new DbEntityValidationResult(ctx.Entry(this), new DbValidationError[] { validationError });
validationResults.Add(dbEntityValidationResult);
}
if (validationResults.Count > 0)
{
throw new DbEntityValidationException(
"Ошибка при проверке данных. Данные могут остутствовать или указаны не верно. Проверте внесенные данные и повторите попытку"
, validationResults);
}
}
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 void LoadRelationships(CFAPContext ctx)
{
LoadUserGroupsFromDatabase(ctx);
if (this.IsAccountable == true || this.AccountableId != null)
{
ctx.Configuration.ProxyCreationEnabled = false;
this.Accountable = (from a in ctx.Accountables where a.Id == this.AccountableId select a).Single();
}
}
private User AuthenticateUser(User user, bool hasEncriptedPassword = true)
{
if (
user == null ||
user.UserName == null ||
user.Password == null ||
user.UserName.Length == 0 ||
user.Password.Length == 0
)
{
throw new FaultException <ArgumentNullException>(new ArgumentNullException("Не введен логин или пароль."));
}
User result = null;
if (!hasEncriptedPassword)
{
user.EncriptPassword();
}
using (CFAPContext ctx = new CFAPContext())
{
//Отключение создания прокси-классов наследников для сущностей. Позволяет использовать DataContractAttribute для класса сущности.
ctx.Configuration.ProxyCreationEnabled = false;
var query = from u in ctx.Users
where u.Password == user.Password && u.UserName == user.UserName
select new { User = u, UserGroup = u.UserGroups };
try
{
var resultQuery = query.Single();
result = resultQuery.User;
result.LoadRelationships(ctx);
//var groups = ctx.UserGroups.Include("Users").ToList(); //В этом случае ProxyCreationEnabled = true
var groups = resultQuery.UserGroup;
result.UserGroups = groups.ToList();
}
catch (InvalidOperationException) //На случай если query.Single(); ничего не вернет или врнет больше одного результата
{
throw new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
if (result == null)
{
FaultException <AuthenticateFaultException> fault = new FaultException <AuthenticateFaultException>(new AuthenticateFaultException(user));
throw fault;
}
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 void LoadUserGroupsFromDatabase(CFAPContext ctx)
{
///<summary>
///Прикреплает к экземпляру пользователя существующие в базе данных привязанные группы
/// </summary>
//Для корректной загрузки данных нужен экземпляр контекста вызывающей строны
ctx.Configuration.ProxyCreationEnabled = false;
var groups = (from g in ctx.UserGroups
from u in g.Users
where u.Id == this.Id
select g).ToList();
this.UserGroups = groups;
}
public void SetRelationships(CFAPContext ctx)
{
LoadUserGroupsFromObject(ctx);
if (this.IsAccountable == false || this.Accountable == null)
{
this.AccountableId = null;
this.Accountable = null;
}
else
{
ctx.Accountables.Attach(this.Accountable);
this.AccountableId = this.Accountable.Id;
}
}
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 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 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);
}
private double GetEuroToDollarRate()
{
double result = 0;
using (CFAPContext ctx = new CFAPContext())
{
double?query = (from rate in ctx.Rates
where rate.DateRate.Month == this.SummaryDate.Month && rate.DateRate.Year == this.SummaryDate.Year
select rate.EuroToDollarRate).FirstOrDefault();
if (query != null)
{
result = (double)query;
}
}
return(result);
}
public IEnumerable <ICrudOperations> Select(Filter filter, User user)
{
List <Period> result = new List <Period>();
try
{
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
result = (from p in ctx.Periods select p).Distinct().ToList();
}
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
return(result);
}
public static void LoadRelationships(CFAPContext ctx)
{
var oldCofigurationProxy = ctx.Configuration.ProxyCreationEnabled;
ctx.Configuration.ProxyCreationEnabled = false;
ctx.Accountables.Load();
var accountables = ctx.Accountables.ToList();
ctx.BudgetItems.Load();
var budgetItems = ctx.BudgetItems.ToList();
ctx.Projects.Load();
var projects = ctx.Projects.ToList();
ctx.Users.Load();
var users = ctx.Users.ToList();
Parallel.ForEach <Summary>(ctx.Summaries.Local, (s) =>
{
//Все связанные сущности существуют в одном экземпляре
//В случае отсутствия данных метод Find вернет null
s.Accountable = accountables.Find(a => a.Id == s.Accountable_Id);
s.Project = projects.Find(p => p.Id == s.Project_Id);
s.BudgetItem = budgetItems.Find(b => b.Id == s.BudgetItem_Id);
s.UserLastChanged = users.Find(u => u.Id == s.UserLastChangedId);
}
);
//foreach (var s in ctx.Summaries.Local)
//{
// //Все связанные сущности существуют в одном экземпляре
// //В случае отсутствия данных метод Find вернет null
// s.Accountable = ctx.Accountables.Find(s.Accountable_Id);
// s.Project = ctx.Projects.Find(s.Project_Id);
// s.BudgetItem = ctx.BudgetItems.Find(s.BudgetItem_Id);
// s.UserLastChanged = ctx.Users.Find(s.UserLastChangedId);
// //ctx.Entry(s).Collection("UserGroups").Load(); //Не сработает, если коллекция уже содержит элементы
//}
ctx.Configuration.ProxyCreationEnabled = oldCofigurationProxy;
}
public List <User> GetUsers(User owner)
{
AuthenticateUser(owner);
this.CheckCanChangeUsersData(owner, typeof(User));
List <User> users = new List <User>();
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
if (owner.IsAdmin)
{
users = (from u in ctx.Users
select u).Distinct().ToList(); //Админы могут видеть все пользователей
}
else
{
owner.LoadUserGroupsFromDatabase(ctx);
var ownerUserGroupsId = (from g in owner.UserGroups select g.Id).ToList();
users = (from g in ctx.UserGroups
from u in g.Users
where ownerUserGroupsId.Contains(g.Id)
select u).Distinct().ToList(); //Должны быть толкьо пользователи с групп владельца
}
foreach (var u in users)
{
//u.LoadUserGroupsFromDatabase(ctx); //Пенесено в LoadRelationships()
u.LoadRelationships(ctx);
}
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(users);
}
public void ChangeUserGroups(CFAPContext ctx)
{
var newGoupsId = this.GetUserGroupsIdFromObject();
var objectStateManager = ((IObjectContextAdapter)ctx).ObjectContext.ObjectStateManager;
ctx.Users.Attach(this); //Повторное приединении сущностей или их связей выдаст исключение
//Прикрепить к контексту все существующие группы пользователя
var oldGroups = (from g in ctx.UserGroups
from u in g.Users
where u.Id == this.Id
select g
).ToList();
//Прикрепить к контексту новые группы пользователя
var newGroups = (from g in ctx.UserGroups
where newGoupsId.Contains(g.Id)
select g).ToList();
//Определить группы, с которых был исключен пользователь
var groupsToRemove = (from g in oldGroups where newGoupsId.Contains(g.Id) == false select g).ToList();
//Исключить связи с группами, с которых был исключен пользователь
foreach (var g in groupsToRemove)
{
objectStateManager.ChangeRelationshipState(this, g, u => u.UserGroups, EntityState.Deleted);
}
//Из старого списка групп удалить все группы, с которых был исключен пользователь
oldGroups.RemoveAll(g => groupsToRemove.Contains(g));
//Из списка новых групп исключить группы, к которым пользователь остался прикрепленным. Оставить только группы с которыми нужно создать новые связи.
newGroups.RemoveAll(g => oldGroups.Contains(g));
//Создать связи с группами, в которые пользователь был добален
foreach (var g in newGroups)
{
objectStateManager.ChangeRelationshipState(this, g, u => u.UserGroups, EntityState.Added);
}
}
public List <string> GetLogins()
{
List <string> result = new List <string>();
using (CFAPContext ctx = new CFAPContext())
{
try
{
result = (from u in ctx.Users select u.UserName).Distinct().ToList();
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
//throw new Exception(); //Для тестирование непредвиденных исключений. ЗАКОМЕНТИРОВАТЬ!!!!
return(result);
}
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 List <Project> GetProjects(User user)
{
AuthenticateUser(user);
List <Project> result = null;
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
result = (from a in ctx.Projects select a).Distinct().ToList();
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(result);
}
public void CustomValidate(CFAPContext ctx)
{
List <DbEntityValidationResult> validationResults = new List <DbEntityValidationResult>();
var summaryResult = ctx.Entry(this).GetValidationResult();
if (!summaryResult.IsValid)
{
validationResults.Add(summaryResult);
}
CustomProperiesValidate <Accountable>(this.Accountable, ctx, validationResults);
CustomProperiesValidate <BudgetItem>(this.BudgetItem, ctx, validationResults);
CustomProperiesValidate <Project>(this.Project, ctx, validationResults);
if (validationResults.Count > 0)
{
throw new DbEntityValidationException(
"Ошибка при проверке данных. Данные могут остутствовать или указаны не верно. Проверте внесенные данные и повторите попытку"
, validationResults);
}
}
private void CustomProperiesValidate <TProperty>(TProperty property, CFAPContext ctx, List <DbEntityValidationResult> validationResults) where TProperty : class
{
if (validationResults == null)
{
throw new ArgumentNullException("List<DbEntityValidationResult> validationResults педреан с неопределенным значением.");
}
if (property == null)
{
DbValidationError validationError = new DbValidationError(typeof(TProperty).ToString(), "Значениие не определено");
DbEntityValidationResult dbEntityValidationResult = new DbEntityValidationResult(ctx.Entry(this), new DbValidationError[] { validationError });
validationResults.Add(dbEntityValidationResult);
return;
}
var propertyValidationResult = ctx.Entry(property).GetValidationResult();
if (!propertyValidationResult.IsValid)
{
validationResults.Add(propertyValidationResult);
}
}
//public ICollection<int> GetUserGroupsId()
//{
// if (this.UserGroups == null || this.UserGroups.Count == 0)
// {
// throw new NullReferenceException("Группы пользователя не определены.");
// }
// var groupsId = (from g in this.UserGroups
// select g.Id).ToList();
// return groupsId;
//}
//private void LoadUserGroups(CFAPContext ctx)
//{
// //Для корректной загрузки данных нужен экземпляр контекста вызывающей строны
// ctx.Configuration.ProxyCreationEnabled = false;
// ICollection<int> goupsId = null;
// try
// {
// goupsId = this.GetUserGroupsId();
// }
// catch(NullReferenceException)
// {
// DbValidationError validationError = new DbValidationError("Группы пользователя", "Значениие не определено");
// DbEntityValidationResult dbEntityValidationResult = new DbEntityValidationResult(ctx.Entry(this), new DbValidationError[] { validationError });
// throw new DbEntityValidationException("Ошибка при проверке данных групп пользователей. Группы не добавлены", new DbEntityValidationResult[] { dbEntityValidationResult });
// }
// //LINQ to Entities не умеет вызывать методы
// var groups = (from g in ctx.UserGroups
// where goupsId.Contains(g.Id)
// select g).ToList();
// this.UserGroups = groups;
// var groupsCanUseAllData = (from g in ctx.UserGroups
// where g.CanReadAllData == true
// select g).ToList();
// foreach (var currentGroup in this.UserGroups)
// {
// for (int groupIndex = 0; groupIndex < groupsCanUseAllData.Count; groupIndex++)
// {
// if (groupsCanUseAllData[groupIndex].Id == currentGroup.Id)
// {
// groupsCanUseAllData.RemoveAt(groupIndex);
// }
// }
// }
// if (groupsCanUseAllData.Count > 0)
// {
// foreach (var group in groupsCanUseAllData)
// {
// this.UserGroups.Add(group);
// }
// }
//}
public void SetRelationships(CFAPContext ctx)
{
ctx.Configuration.ProxyCreationEnabled = false;
if (this.Project != null && this.Project.Id != default(int))
{
// В случае наличия связей с другимим сущностями, это наиболле простой способ добавления сущностей в контекст, иначе, видимо, придется прикрепить каждую связанную сущность и ее связи
//this.Project = (from p in ctx.Projects where p.Id == this.Project.Id select p).First();
ctx.Projects.Attach(this.Project);
this.Project_Id = this.Project.Id;
}
if (this.Accountable != null && this.Accountable.Id != default(int))
{
// В случае наличия связей с другимим сущностями, это наиболле простой способ добавления сущностей в контекст, иначе, видимо, придется прикрепить каждую связанную сущность и ее связи
//this.Accountable = (from a in ctx.Accountables where a.Id == this.Accountable.Id select a).First();
ctx.Accountables.Attach(this.Accountable);
this.Accountable_Id = this.Accountable.Id;
}
if (this.BudgetItem != null && this.BudgetItem.Id != default(int))
{
// В случае наличия связей с другимим сущностями, это наиболле простой способ добавления сущностей в контекст, иначе, видимо, придется прикрепить каждую связанную сущность и ее связи
//this.BudgetItem = (from i in ctx.BudgetItems where i.Id == this.BudgetItem.Id select i).First();
ctx.BudgetItems.Attach(this.BudgetItem);
this.BudgetItem_Id = this.BudgetItem.Id;
}
//В данном случае Attach не сработает по причине наличия связи с группами пользователей
//Если добавлять через Attach надо загрузить все группы пользователя и до каждой грппы догрузить всех пользователей
this.UserLastChanged = (from u in ctx.Users where u.Id == this.UserLastChanged.Id select u).First();
this.UserLastChangedId = UserLastChanged.Id;
//this.LoadUserGroups(ctx);
}
public bool CheckPeriodIsUnlocked()
{
int month = SummaryDate.Month;
int year = SummaryDate.Year;
Period period;
using (CFAPContext ctx = new CFAPContext())
{
period = (from p in ctx.Periods where p.Month == month && p.Year == year select p).FirstOrDefault();
}
if (period == null)
{
return(true);
}
if (period.IsLocked)
{
return(false);
}
return(true);
}
public void LoadUserGroupsFromObject(CFAPContext ctx)
{
///<summary>
///Загружает с базы данных группы пользователя исходя из установленных в экземпляре групп
/// </summary>
///
//Для корректной загрузки данных нужен экземпляр контекста вызывающей строны
ctx.Configuration.ProxyCreationEnabled = false;
//Поучение данных о связанных сущностя необходимо для корректного добавления сущности User
//В случае обычного ctx.Users.Add(newUser); без выборки связанных существующих данных
//получим исключение "Не удаеться добавить сущности в коллекцию UserGroup.Users по причине невозможности удаления из Array фиксированной длинны типа"
//Суть ошибки состоит в том, что при вызове метода ctx.Users.Add(newUser); все поля экземпляра помеаються как Added
//Возникает конфликт первычных ключей в БД
var goupsId = this.GetUserGroupsIdFromObject();
//LINQ to Entities не умеет вызывать методы
var groups = (from g in ctx.UserGroups
where goupsId.Contains(g.Id)
select g).ToList();
this.UserGroups = groups;
}
public List <UserGroup> GetUserGroups(User owner)
{
AuthenticateUser(owner);
this.ChechIsAdmin(owner, typeof(UserGroup));
List <UserGroup> userGroups = new List <UserGroup>();
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
try
{
userGroups = (from g in ctx.UserGroups
select g).Distinct().ToList();
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(userGroups);
}
private Summary LoadRelationshipsDbSummary(Summary dbSummary)
{
Summary result = null;
using (CFAPContext ctx = new CFAPContext())
{
ctx.Configuration.ProxyCreationEnabled = false;
ctx.Summaries.Attach(dbSummary);
try
{
Summary.LoadRelationships(ctx);
result = dbSummary;
}
catch (Exception ex)
{
throw new FaultException <DbException>(new DbException(ex));
}
}
return(result);
}
