// Constructor
public ReportsController(IWorktaskRepository worktaskRepository, IAccountRepository accountRepository, ICategoryRepository catRepository, IDepartmentRepository depRepository) : base()
{
this.repository = worktaskRepository;
this.catRepository = catRepository;
this.accRepository = accountRepository;
this.depRepository = depRepository;
}
// Constructor
public DashboardsController(IWorktaskRepository worktaskRepository, ICategoryRepository catRepository, IAccountRepository accRepository, IWorkflowRepository wfRepository) : base()
{
this.repository = worktaskRepository;
this.catRepository = catRepository;
this.accRepository = accRepository;
this.wfRepository = wfRepository;
}
// Constructor
public WorktaskController(IWorktaskRepository worktaskRepository, ICategoryRepository catRepository, IAccountRepository accRepository, IBoardRepository boardRepository) : base()
{
this.repository = worktaskRepository;
this.catRepository = catRepository;
this.accRepository = accRepository;
this.boardRepository = boardRepository;
}
// Constructor
public KanbanController(IBoardRepository boardRepository, IWorktaskRepository worktaskRepository, ICategoryRepository catRepository, IAccountRepository accRepository, IWorkflowRepository wfRepository) : base()
{
this.wRepository = worktaskRepository;
this.catRepository = catRepository;
this.accRepository = accRepository;
this.boardRepository = boardRepository;
this.wfRepository = wfRepository;
}
public WorktaskService(IWorktaskRepository worktaskRepository, ICategoryRepository catRepository)
{
this.worktaskRepository = worktaskRepository;
this.catRepository = catRepository;
if (_instance == null)
{
_instance = this;
}
}
public AdminController(IAccountRepository accRepository, IDepartmentRepository dptRepository, IWorktaskRepository worktaskRepo, ICategoryRepository catRepository) : base()
{
this.dptRepository = dptRepository;
this.catRepository = catRepository;
this.accRepository = accRepository;
this.wRepository = worktaskRepo;
}
public void loadMetaInfo(IWorktaskRepository repository, IAccountRepository accRepository)
{
Type t = this.GetType();
List <PropertyInfo> props = t.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(ComparableAttribute))).ToList();
DisplayTypeE displayType;
MetaValueTypeE metaInfo;
foreach (var p in props)
{
displayType = p.GetCustomAttribute <ComparableAttribute>().DisplayType;
metaInfo = p.GetCustomAttribute <ComparableAttribute>().MetaInfo;
if (metaInfo != MetaValueTypeE.None)
{
string key = p.Name;
WorkTaskMetas meta = this.TaskMetas.Where(m => m.MetaKey == key).FirstOrDefault();
if (meta != null)
{
PropertyInfo fp;
switch (displayType)
{
case DisplayTypeE.Date:
DateTime d;
if (DateTime.TryParseExact(meta.MetaValue, "yyyy-MM-dd", CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out d))
{
p.SetValue(this, d);
}
break;
case DisplayTypeE.RelatedTask:
List <WorkTaskMetas> rlist = this.TaskMetas.Where(m => m.MetaKey == key).ToList();
foreach (var item in rlist)
{
if (this.RelatedTask == null)
{
this.RelatedTask = new List <Worktask>();
}
Worktask task = repository.Detail(item.MetaValue);
if (task != null)
{
this.RelatedTask.Add(task);
}
}
break;
case DisplayTypeE.CategoryCompany:
int v;
if (int.TryParse(meta.MetaValue, out v))
{
p.SetValue(this, v);
}
break;
case DisplayTypeE.UserId:
int uid;
Account acc;
if (int.TryParse(meta.MetaValue, out uid))
{
p.SetValue(this, uid);
fp = t.GetProperty(p.Name + "Acc");
if (fp != null)
{
acc = accRepository.Accounts.Where(a => a.UID == uid).FirstOrDefault();
fp.SetValue(this, acc);
}
}
break;
default:
p.SetValue(this, meta.MetaValue);
break;
}
}
}
}
}
public static void Initialize()
{
ICategoryRepository catRepository = (ICategoryRepository)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(ICategoryRepository));
IAccountRepository accRepository = (IAccountRepository)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(IAccountRepository));
IBoardRepository boardRepository = (IBoardRepository)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(IBoardRepository));
IWorkflowRepository workflowRepository = (IWorkflowRepository)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(IWorkflowRepository));
IWorktaskRepository worktaskRepository = (IWorktaskRepository)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(IWorktaskRepository));
CategoryService catService;
UserPermissionService userService;
KanbanService kanbanService;
WorkflowService workflowService;
BoardService boardService;
WorktaskService worktaskService;
if (CategoryService.GetInstance() == null)
{
catService = new CategoryService(catRepository);
}
else
{
catService = CategoryService.GetInstance();
}
if (UserPermissionService.GetInstance() == null)
{
userService = new UserPermissionService(accRepository);
}
else
{
userService = UserPermissionService.GetInstance();
}
if (KanbanService.GetInstance() == null)
{
kanbanService = new KanbanService(boardRepository, accRepository);
}
else
{
kanbanService = KanbanService.GetInstance();
}
if (WorkflowService.GetInstance() == null)
{
workflowService = new WorkflowService(workflowRepository);
}
else
{
workflowService = WorkflowService.GetInstance();
}
if (BoardService.GetInstance() == null)
{
boardService = new BoardService(boardRepository);
}
else
{
boardService = BoardService.GetInstance();
}
if (WorktaskService.GetInstance() == null)
{
worktaskService = new WorktaskService(worktaskRepository, catRepository);
}
else
{
worktaskService = WorktaskService.GetInstance();
}
}
// Constructor
public WorktaskApiController(IWorktaskRepository worktaskRepository, ICategoryRepository catRepository)
{
this.repository = worktaskRepository;
this.catRepository = catRepository;
}
