public static void FilledBy(this ProjectAuthorizationModel model, Project project)
{
model.Id = project.Id;
model.Name = project.Name;
model.Authorizations = new List<AuthorizationModel>();
model.Authorizations.FilledBy(project.Authorizations);
}
private static void Filledby(this AbstractModel model, Project project)
{
model.Name = project.Name;
model.Description = project.Description;
model.Founder = new UserModel();
model.Founder.FilledBy(project.Founder);
}
public void Top_Group()
{
Project root = new Project();
Project project_1 = new Project
{
Parent = root
};
Assert.That(project_1.Root, Is.EqualTo(root));
Project project_2 = new Project
{
Parent = project_1
};
Assert.That(project_2.Root, Is.EqualTo(root));
Project project_3_1 = new Project
{
Parent = project_2
};
Project project_3_2 = new Project
{
Parent = project_2
};
Assert.That(project_3_1.Root, Is.EqualTo(root));
Assert.That(project_3_2.Root, Is.EqualTo(root));
}
internal static void Create()
{
Project project_1 = new Project { Name = "成员检索项目A" };
Project project_2 = new Project { Name = "成员检索项目B" };
Project project_3 = new Project { Name = "成员检索项目C" };
User user_1 = UserFactory.create("成员检索测试员-A");
AuthorizationFactory.SetAuth(user_1, project_1, false, true, true);
AuthorizationFactory.SetAuth(user_1, project_2, false, true, true);
AuthorizationFactory.SetAuth(user_1, project_3, false, true, true);
User user_2 = UserFactory.create("成员检索测试员-B");
AuthorizationFactory.SetAuth(user_2, project_1, true, false, true);
Task task_1 = TaskFactory.CreateTask(project_1,
publisher: user_1,
title: "task_1");
task_1.CurrentStatus = Status.Accept;
Task task_2 = TaskFactory.CreateTask(project_1,
owner: user_1,
title: "task_2"
);
task_2.CurrentStatus = Status.Accept;
Task task_3 = TaskFactory.CreateTask(project_2,
owner: user_1,
title: "task_3"
);
task_3.CurrentStatus = Status.Accept;
Task task_3_1 = TaskFactory.CreateTask(project_2,
owner: user_1,
title: "task_3_1");
task_3_1.CurrentStatus = Status.BeginWork;
Task task_4 = TaskFactory.CreateTask(project_3,
owner: user_1,
title: "task_4");
task_4.CurrentStatus = Status.Pause;
Task task_5 = TaskFactory.CreateTask(project_1,
accepter: user_1,
title: "task_5");
task_5.CurrentStatus = Status.Remove;
Task task_6 = TaskFactory.CreateTask(project_2,
accepter: user_1,
title: "task_6");
task_6.CurrentStatus = Status.Dissent;
Task task_7 = TaskFactory.CreateTask(project_1,
owner: user_2,
title: "task_7");
task_7.CurrentStatus = Status.BeginWork;
Task task_8 = TaskFactory.CreateTask(project_1,
owner: user_2,
title: "task_8");
task_8.CurrentStatus = Status.Accept;
}
protected bool contains(IList<FullItemModel> model, Project project)
{
return model.ToList().Exists(m => (
m.LiteItem.Id == project.Id &&
m.LiteItem.Name == project.Name &&
m.Description == project.Description));
}
internal static void Create()
{
founder_a = UserFactory.create("修改项目测试员-A");
founder_b = UserFactory.create("修改项目测试员-B");
project_a = ProjectFactory.create(founder_b, "修改测试项目-A", string.Empty, null);
project_b = ProjectFactory.create(founder_a, "修改测试项目-B", string.Empty, null);
}
private void project_founder_previlege(User user, Project project)
{
Assert.That(project.Founder == user);
Assert.That(project.Owners.Contains(user));
Assert.That(project.Publisher.Contains(user));
Assert.That(project.Admins.Contains(user));
}
private static void create_project()
{
User user = new User();
not_publish_root = ProjectFactory.create(user, "无发权项目-根", string.Empty, null);
not_publish_branch_1 = ProjectFactory.create(user, "无发权项目-枝-1", string.Empty, not_publish_root);
not_publish_leaf = ProjectFactory.create(user, "无发权项目-叶", string.Empty, not_publish_branch_1);
not_publish_branch_2 = ProjectFactory.create(user, "无发权项目-枝-2", string.Empty, not_publish_root);
}
internal static void addAuth(User user, Project project,
bool isAdmin = true,
bool isPublisher = true,
bool isOwner = true)
{
Authorization auth = new Authorization { User = user, Project = project };
setAuth(auth, isAdmin, isPublisher, isOwner);
user.Authorizations.Add(auth);
}
internal static void createAuth(User user, Project project,
bool isAdmin = true,
bool isPublisher = true,
bool isOwner = true)
{
Authorization auth = new Authorization { User = user, Project = project };
user.Authorizations = new List<Authorization> { auth };
setAuth(auth, isAdmin, isPublisher, isOwner);
}
private static void create_project()
{
renwuguanli = ProjectFactory.create(founder, "任务管理", "测试ProjectJoin页面流程用的项目", null);
meigong = ProjectFactory.create(founder, "美工", "测试ProjectJoin页面流程用的项目", renwuguanli);
ui = ProjectFactory.create(founder, "UI", "测试ProjectJoin页面流程用的项目", renwuguanli);
houtai = ProjectFactory.create(founder, "后台", "测试ProjectJoin页面流程用的项目", renwuguanli);
csharp = ProjectFactory.create(founder, "C#", "测试EdProjectJoinit页面流程用的项目", houtai);
dba = ProjectFactory.create(founder, "DBA", "测试EdProjectJoinit页面流程用的项目", houtai);
}
private Authorization create_authorization(Project project)
{
Authorization auth = new Authorization
{
Project = project
};
Save(auth);
return auth;
}
private void fill_1_level()
{
project_1 = new Project { Parent = root };
project_1.MockId(1);
project_2 = new Project { Parent = root };
project_2.MockId(2);
root.Children = new List<Project> { project_1, project_2 };
}
public virtual void Join(Project project)
{
Authorization auth = new Authorization
{
User = this,
Project = project
};
Add(project, auth);
}
public void Create_RootProject()
{
Project root = new Project();
User executor = new User();
executor.Create(root);
Assert.That(executor.RootProjects.Count, Is.EqualTo(1));
Assert.That(executor.RootProjects.Contains(root));
project_founder_previlege(executor, root);
}
private void fill_2_level()
{
project_2_1 = new Project { Parent = project_2 };
project_2_1.MockId(21);
project_2_2 = new Project { Parent = project_2 };
project_2_2.MockId(22);
project_2_3 = new Project { Parent = project_2 };
project_2_3.MockId(23);
project_2.Children = new List<Project> { project_2_1, project_2_2, project_2_3 };
}
public static FullItemModel FilledBy(this FullItemModel model, Project project)
{
model.LiteItem = new LiteItemModel();
model.LiteItem.FilledBy(project);
model.Description = project.Description;
if (project.Children != null)
{
model.Children = new List<FullItemModel>();
model.Children.FilledBy(project.Children);
}
return model;
}
public static void FilledBy(this JoinModel model, Project project, int userId)
{
model.Item = new FullItemModel();
model.Children = new List<JoinModel>();
model.Item.FilledBy(project);
model.HasJoined = project.Authorizations.Count(x => x.User.Id == userId) > 0;
foreach (Project childProject in project.Children)
{
JoinModel childModel = new JoinModel();
childModel.FilledBy(childProject, userId);
model.Children.Add(childModel);
}
}
protected virtual void Add(Project project, Authorization auth)
{
Authorizations = Authorizations ?? new List<Authorization>();
Authorizations.Add(auth);
project.Authorizations = project.Authorizations ?? new List<Authorization>();
project.Authorizations.Add(auth);
//TODO: not sure
if (project.Parent != null)
{
project.Parent.AddChild(project);
}
}
public virtual void Create(Project project)
{
Authorization auth = new Authorization
{
User = this,
Project = project,
IsFounder = true,
IsPublisher = true,
IsOwner = true,
IsAdmin = true
};
Add(project, auth);
}
private void set_Projects_Hierarchy()
{
root = new Project();
project_1 = new Project { Parent = root };
project_2 = new Project { Parent = root };
project_1_1 = new Project { Parent = project_1 };
project_1_2 = new Project { Parent = project_1 };
root.Children = new List<Project> { project_1, project_2 };
project_1.Children = new List<Project> { project_1_1, project_1_2 };
}
public void Join_Project_In_Parent_Project()
{
User user = new User();
Project project = new Project
{
Parent = new Project()
};
user.Join(project);
//Assert.That(user.Projects.Count, Is.EqualTo(1));
//Assert.That(user.Projects.Contains(project));
Assert.That(project.Authorizations.Count, Is.EqualTo(1));
project_newbie_previlege(project.Authorizations[0]);
}
public static void FilledBy(this SummaryModel model, Project project)
{
if (project.Authorizations != null)
{
model.Authorizations = new List<AuthorizationModel>();
model.Authorizations.FilledBy(project.Authorizations);
}
if (project.Children != null)
{
model.Projects = new List<FullItemModel>();
model.Projects.FilledBy(project.Children);
}
model.Abstract = new AbstractModel();
model.Abstract.Filledby(project);
}
public void Get_Descendant_Ids()
{
Project project_1 = new Project();
project_1.MockId(1);
Project project_1_1 = new Project();
project_1_1.MockId(11);
Project project_1_1_1 = new Project();
project_1_1_1.MockId(111);
Project project_1_1_2 = new Project();
project_1_1_2.MockId(112);
Project project_1_1_3 = new Project();
project_1_1_3.MockId(113);
Project project_1_1_3_1 = new Project();
project_1_1_3_1.MockId(1131);
Project project_1_2 = new Project();
project_1_2.MockId(12);
Project project_1_3 = new Project();
project_1_3.MockId(13);
Project project_1_3_1 = new Project();
project_1_3_1.MockId(131);
project_1.Children = new List<Project> { project_1_1, project_1_2, project_1_3 };
project_1_1.Children = new List<Project> { project_1_1_1, project_1_1_2, project_1_1_3 };
project_1_1_3.Children = new List<Project> { project_1_1_3_1 };
project_1_3.Children = new List<Project> { project_1_3_1 };
IList<int> ids = project_1.GetDescendantIds();
Assert.That(ids.Count, Is.EqualTo(9));
Assert.That(ids.Contains(1));
Assert.That(ids.Contains(11));
Assert.That(ids.Contains(111));
Assert.That(ids.Contains(112));
Assert.That(ids.Contains(113));
Assert.That(ids.Contains(1131));
Assert.That(ids.Contains(12));
Assert.That(ids.Contains(13));
Assert.That(ids.Contains(131));
}
public void Get_By_Name()
{
string project_name_1 = "zyfei";
string project_name_2 = "DBA";
Project project_1 = new Project { Name = project_name_1 };
Project project_2 = new Project { Name = project_name_2 };
Project project_3 = new Project { Name = project_name_1 };
IQueryable<Project> iqueryable = new List<Project>
{
project_1,project_2,project_3
}.AsQueryable();
ProjectQuery query = new ProjectQuery(iqueryable);
IList<Project> projects = query.GetByName(project_name_2).ToList();
Assert.That(projects.Count, Is.EqualTo(1));
Assert.That(projects.Contains(project_2));
}
internal static Task CreateTask(Project project,
User publisher = null,
User accepter = null,
User owner = null,
string title = "")
{
Task task = new Task
{
Title = title,
Project = project,
Publisher = publisher,
Accepter = accepter,
Owner = owner
};
task.Publish();
session.Save(task);
return task;
}
public void Create_Project_In_Parent_Project()
{
Project parent_Project = new Project();
Project new_created_project = new Project
{
Parent = parent_Project,
Name = "",
Description = ""
};
User executor = new User();
executor.Create(new_created_project);
Assert.That(executor.RootProjects.Count, Is.EqualTo(1));
Assert.That(executor.RootProjects.Contains(parent_Project));
Assert.That(parent_Project.Children.Count == 1);
Assert.That(parent_Project.Children.Contains(new_created_project));
project_founder_previlege(executor, new_created_project);
}
public int Create(CreateModel model, int? parentId, int userId)
{
User user = session.Load<User>(userId);
Project project = new Project();
if (parentId == null)
{
project.FilledBy(model, null);
}
else
{
Project parent = session.Load<Project>(parentId);
project.FilledBy(model, parent);
}
user.Create(project);
session.Save(project);
return project.Id;
}
public void Project()
{
Project project_1 = new Project();
Project project_2 = new Project();
Message message_1 = create_message(project_1);
Message message_2 = create_message(project_2);
var result_project_id_not_value = session.Query<Message>().Project(null).ToList();
Assert.That(result_project_id_not_value.Count, Is.EqualTo(2));
Contains(result_project_id_not_value, message_1);
Contains(result_project_id_not_value, message_2);
var result_project_1 = session.Query<Message>().Project(project_1.Id).ToList();
Assert.That(result_project_1.Count, Is.EqualTo(1));
Assert.That(result_project_1.Single().Id, Is.EqualTo(message_1.Id));
var result_project_2 = session.Query<Message>().Project(project_2.Id).ToList();
Assert.That(result_project_2.Count, Is.EqualTo(1));
Assert.That(result_project_2.Single().Id, Is.EqualTo(message_2.Id));
}
internal static void SetAuth(User user, Project project,
bool isAdmin = true,
bool isPublisher = true,
bool isOwner = true)
{
if (user.Authorizations != null)
{
Authorization auth = user.Authorizations
.Where(a => a.Project == project).SingleOrDefault();
if ( auth == null)
{
addAuth(user, project, isAdmin, isPublisher, isOwner);
}
else
{
setAuth(auth, isAdmin, isPublisher, isOwner);
}
}
else
{
createAuth(user,project,isAdmin,isPublisher,isOwner);
}
}