protected override IList <Microsoft.VisualStudio.Modeling.ModelElement> BuildElementList(object component)
{
Microsoft.VisualStudio.Modeling.DomainClassInfo domainClassInfo = DomainRoleInfo.RolePlayer;
if (domainClassInfo == null || component == null)
{
return(new System.Collections.Generic.List <Microsoft.VisualStudio.Modeling.ModelElement>());
}
Microsoft.VisualStudio.Modeling.Store store = this.GetStore(component);
ExternModelContext externModelContext = component as ExternModelContext;
System.Collections.Generic.List <Microsoft.VisualStudio.Modeling.ModelElement> list = new System.Collections.Generic.List <Microsoft.VisualStudio.Modeling.ModelElement>();
System.Collections.Generic.IList <Microsoft.VisualStudio.Modeling.ModelElement> ilist = store.ElementDirectory.FindElements(domainClassInfo, true);
foreach (Microsoft.VisualStudio.Modeling.ModelElement modelElement in ilist)
{
BaseModelContext p = modelElement as BaseModelContext;
if (p.MetaModel.IsTopMost)
{
continue;
}
list.Add(p);
}
return(list);
}
public static SelectList GetByRegistration(string modelField, bool useDescriptionAsText = false)
{
BaseModelContext <FieldOptionModelFieldModel> db = new BaseModelContext <FieldOptionModelFieldModel>();
var query = db.Models.Where(c => c.ModelField == modelField);
return(FieldOptionModelContext.MakeList((query.FirstOrDefault() != null ? query.FirstOrDefault().FieldOption : null), useDescriptionAsText));
}
public static bool AddJob(FileHelper fileModel, string entityName, string primaryKey, int printerId, string userId)
{
string printDirectory = FileDirectoryService.GetPathByName("PrintServiceDirectory");
BaseModelContext <PrintModel> printDb = new BaseModelContext <PrintModel>();
PrintModel printModel = new PrintModel()
{
EntityName = entityName,
PrimaryKey = primaryKey,
PrinterId = printerId,
FileLocation = "C:\\Temp",
Status = PrintModel.newStatus
};
printDb.Models.Add(printModel);
printDb.SaveChanges(userId);
if (printModel.Id > 0)
{
string printServicePath = printDirectory + printModel.Id.ToString() + "-" + fileModel.FileName;
if (fileModel.CopyTo(printServicePath))
{
printModel.Status = PrintModel.queuedStatus;
printModel.FileLocation = printServicePath;
printDb.Entry(printModel);
printDb.SaveChanges(userId);
return(true);
}
else
{
printDb.Models.Remove(printModel);
printDb.SaveChanges(userId);
}
}
return(false);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
public ModelContextViewModel(ViewModelStore viewModelStore, BaseModelContext baseModelContext, bool isLocked)
: base(viewModelStore)
{
this.modelContext = baseModelContext;
this.copyCommand = new DelegateCommand(CopyCommand_Executed, CopyCommand_CanExecute);
this.pasteCommand = new DelegateCommand(PasteCommand_Executed, PasteCommand_CanExecute);
this.copyAllTreeCommand = new DelegateCommand(CopyAllTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
this.copyEmbeddingTreeCommand = new DelegateCommand(CopyEmbeddingTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
this.copyReferenceTreeCommand = new DelegateCommand(CopyReferenceTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
//this.cutCommand = new DelegateCommand(CutCommand_Executed, CutCommand_CanExecute);
this.optimizeCommand = new DelegateCommand(OptimizeCommand_Executed);
if (baseModelContext is ModelContext)
{
ModelContext modelContext = baseModelContext as ModelContext;
this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView);
this.modelTreeViewModel.IsLocked = isLocked;
this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView);
this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel);
this.modelContextType = ModelContextViewType.ModelContext;
}
else if( baseModelContext is ExternModelContext)
{
ExternModelContext modelContext = baseModelContext as ExternModelContext;
if (modelContext.ModelContext != null)
{
this.AddModelContext(modelContext.ModelContext);
}
this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId),
true, this.modelContext.Id, new System.Action<ElementAddedEventArgs>(OnModelContextAdded));
this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId),
true, this.modelContext.Id, new System.Action<ElementDeletedEventArgs>(OnModelContextRemoved));
this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ExternModelContextDomainRoleId),
new System.Action<RolePlayerChangedEventArgs>(OnModelContextChanged));
this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ModelContextDomainRoleId),
new System.Action<RolePlayerChangedEventArgs>(OnModelContextChanged));
this.modelContextType = ModelContextViewType.ExternModelContext;
}
else if (baseModelContext is LibraryModelContext)
{
LibraryModelContext modelContext = baseModelContext as LibraryModelContext;
this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView);
this.modelTreeViewModel.IsLocked = isLocked;
this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView);
this.modelContextType = ModelContextViewType.LibraryContext;
this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel);
}
this.selectedItem = this.ModelTreeViewModel;
if( this.ModelContext != null )
this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(
this.Store.DomainDataDirectory.GetDomainProperty(BaseModelContext.NameDomainPropertyId), this.ModelContext.Id, new System.Action<ElementPropertyChangedEventArgs>(NamePropertyChanged));
}
public static SelectList GetBySlug(string slug, bool useDescriptionAsText = false)
{
BaseModelContext <FieldOptionModel> db = new BaseModelContext <FieldOptionModel>();
var query = db.Models.Where(c => c.Slug == slug);
return(FieldOptionModelContext.MakeList(query.FirstOrDefault(), useDescriptionAsText));
}
/// <summary>
/// View Report is a viewer for the user.
/// </summary>
/// <param name="reportModel"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static ReportViewerModel View(ReportModel reportModel, string userId)
{
if (reportModel != null)
{
var reportviewerModel = new ReportViewerModel
{
Report = reportModel,
ReportPath = "/ReportService/" + reportModel.SSRSReportName.Replace(".rdl", ""),
Parameters = null,
ServerUrl = reportServerPathViewer,
UserName = userName,
Password = password
};
BaseModelContext <ReportUserActivityLogModel> reportUserActivityLogDb = new BaseModelContext <ReportUserActivityLogModel>();
ReportUserActivityLogModel reportUserActivityModel = new ReportUserActivityLogModel()
{
ReportId = reportModel.Id,
UserId = userId,
Activity = ReportUserActivityLogModel.ViewActivity
};
reportUserActivityLogDb.Models.Add(reportUserActivityModel);
reportUserActivityLogDb.SaveChanges(userId);
return(reportviewerModel);
}
return(null);
}
public static SelectList GetByName(string name, bool useDescriptionAsText = false)
{
List <SelectListItem> listItems = new List <SelectListItem>();
BaseModelContext <FieldOptionModel> db = new BaseModelContext <FieldOptionModel>();
var query = db.Models.Where(c => c.Name == name);
return(FieldOptionModelContext.MakeList(query.FirstOrDefault(), useDescriptionAsText));
}
public static string GetPathByName(string name)
{
FileDirectoryModel fileDirectory = new BaseModelContext <FileDirectoryModel>().Models.Where(n => n.Name == name).FirstOrDefault();
if (fileDirectory != null)
{
return(fileDirectory.Path);
}
throw new ArgumentNullException($"Could not find {name} in File Directories");
}
/// <summary>
/// Deletes the model context view model that is hosting the given node.
/// </summary>
/// <param name="m">ModelContext.</param>
public void DeleteModelContext(BaseModelContext m)
{
for (int i = this.rootNodeVMs.Count - 1; i >= 0; i--)
{
if (this.rootNodeVMs[i].ModelContext.Id == m.Id)
{
this.rootNodeVMs[i].Dispose();
this.rootNodeVMs.RemoveAt(i);
}
}
UpdateIndices();
}
public ServiceResult EmailResults(string userId, string subject, string fromUserId = null)
{
UserModel user = new BaseModelContext <UserModel>().Models.Find(userId);
if (user != null)
{
return(EmailResults(new List <string>()
{
user.Email
}, subject, fromUserId));
}
return(this);
}
public ActionResult DeleteAvatar()
{
BaseModelContext <UserModel> userDb = new BaseModelContext <UserModel>();
UserModel user = userDb.Models.Find(User.Identity.GetUserId());
if (user != null)
{
user.Avatar = null;
userDb.Entry(user);
userDb.SaveChanges();
FileHelper fileModel = new FileHelper(user.Id + ".jpg", user.Id);
fileModel.Delete();
}
return(Redirect(Url.Action("UpdateProfile", "Manage")));
}
/// <summary>
/// Adds a new model context view model for the given node.
/// </summary>
/// <param name="m">ModelContext.</param>
public void AddModelContext(BaseModelContext m)
{
// verify that node hasnt been added yet
foreach (ModelContextViewModel viewModel in this.rootNodeVMs)
{
if (viewModel.ModelContext.Id == m.Id)
{
return;
}
}
ModelContextViewModel vm = new ModelContextViewModel(this.ViewModelStore, m);
vm.Index = this.rootNodeVMs.Count + 1;
this.rootNodeVMs.Add(vm);
}
public static void GetPrinterTrays(PrinterModel printerModel)
{
if (string.IsNullOrWhiteSpace(printerModel.Name))
{
return;
}
BaseModelContext <PrinterTrayModel> printerTrayDb = new BaseModelContext <PrinterTrayModel>();
PrintDocument printDocument = new PrintDocument();
List <SelectListItem> trayOptions = new List <SelectListItem>();
printDocument.PrinterSettings.PrinterName = printerModel.Name.Trim();
Dictionary <int, string> paperSources = new Dictionary <int, string>();
if (printDocument.PrinterSettings.IsValid)
{
//Get Trays for this printer
List <PrinterTrayModel> printerTrays = printerTrayDb.Models.Where(t => t.PrinterId == printerModel.Id).ToList();
//Add printer trays
int i = 0;
foreach (PaperSource paperSource in printDocument.PrinterSettings.PaperSources)
{
paperSources[i] = paperSource.SourceName;
PrinterTrayModel exists = printerTrays.Where(t => t.Index == i && t.Name == paperSource.SourceName).FirstOrDefault();
if (exists == null)
{
printerTrayDb.Models.Add(new PrinterTrayModel()
{
PrinterId = printerModel.Id,
Index = i,
Name = paperSource.SourceName
});
}
i++;
}
//Remove Printer Trays
foreach (PrinterTrayModel printerTrayModel in printerTrays)
{
if (!(paperSources.ContainsKey(printerTrayModel.Index) && paperSources[printerTrayModel.Index].Equals(printerTrayModel.Name)))
{
printerTrayDb.Entry(printerTrayModel);
printerTrayDb.Models.Remove(printerTrayModel);
}
}
}
printerTrayDb.SaveChanges();
}
public static SelectList GetPrinterTrays(int printerId)
{
List <SelectListItem> listItems = new List <SelectListItem>();
BaseModelContext <PrinterTrayModel> db = new BaseModelContext <PrinterTrayModel>();
List <PrinterTrayModel> printerTrays = db.Models.Where(p => p.PrinterId == printerId).OrderBy(o => o.Index).ToList();
listItems.Add(new SelectListItem {
Text = null, Value = null
});
foreach (PrinterTrayModel item in printerTrays)
{
listItems.Add(new SelectListItem {
Text = item.Name, Value = item.Id.ToString()
});
}
return(new SelectList(listItems, "Value", "Text"));
}
public override IHttpActionResult Put(string id, string method, JObject jsonObject)
{
BaseModelContext <UserModel> userdb = new BaseModelContext <UserModel>();
BaseModelContext <RoleModel> roledb = new BaseModelContext <RoleModel>();
UserModel user = userdb.Models.Find(id);
ServiceResult serviceResult = new ServiceResult();
if (user != null)
{
if (method.Equals("Toggle"))
{
string roleId = (string)jsonObject.GetValue("RoleId");
RoleModel role = roledb.Models.Find(roleId);
UserRoleModel userRole = DB.Models.Find(id, roleId);
if (userRole == null && role != null)
{
userRole = new UserRoleModel();
userRole.RoleId = roleId;
userRole.UserId = id;
userRole.CreatedById = UserId;
DB.Models.Add(userRole);
serviceResult.Success($"{role.Name} enabled.");
}
else if (userRole != null)
{
DB.Models.Remove(userRole);
serviceResult.Success($"{role.Name} disabled.");
}
try
{
DB.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
serviceResult.Error($"An error occurred while. Please refresh and try again.");
}
}
}
return(Ok(serviceResult));
}
//GET: /Account/Manage/Avatar/324908234-234823-0284234
public ActionResult Image(string id)
{
FileHelper fileModel = new FileHelper(id + ".jpg", id);
if (!fileModel.Exists())
{
BaseModelContext <UserModel> userDb = new BaseModelContext <UserModel>();
UserModel user = userDb.Models.Find(id);
if (user != null && !string.IsNullOrWhiteSpace(user.Avatar))
{
fileModel.Write(Convert.FromBase64String(user.Avatar));
}
else
{
fileModel.FilePathAndName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Images") + "/silhouette_md.png";
}
}
return(File(fileModel.GetContent(), "image/jpeg"));
}
public ServiceResult EmailResults(List <string> emails, string subject, string fromUserId = null)
{
if (emails != null)
{
EmailService emailService = new EmailService();
emailService.Subject = subject;
if (!string.IsNullOrWhiteSpace(fromUserId))
{
UserModel fromUser = new BaseModelContext <UserModel>().Models.Find(fromUserId);
if (fromUser != null)
{
emailService.ReplyTo = fromUser.Email;
}
}
if (Messages.Count() > 1)
{
emailService.Message = "<p>Below are the results of your request: </p>";
foreach (var message in Messages.GroupBy(g => g.Type, (key, items) => new
{
Key = key,
Items = items
}))
{
emailService.Message += "<ul>";
foreach (MessageModel m in message.Items)
{
emailService.Message += "<li style=\"color: " + (m.Type == MessageModel.Types.Error ? "#B50000" : "") + "\">" + m.Message + "</li>";
}
emailService.Message += "</ul>";
}
}
else
{
emailService.Message = (Messages.First() != null ? Messages.First().Message : "");
}
emailService.Send(string.Join(";", emails), true);
}
return(this);
}
public static SelectList GetPrinters(bool isActiveOnly = true)
{
List <SelectListItem> listItems = new List <SelectListItem>();
BaseModelContext <PrinterModel> db = new BaseModelContext <PrinterModel>();
List <PrinterModel> printers = db.Models.OrderBy(o => o.Name).ThenBy(o => o.PrinterTray.Index).ToList();
if (isActiveOnly)
{
printers = printers.Where(p => p.IsActive == true).ToList();
}
listItems.Add(new SelectListItem {
Text = null, Value = null
});
foreach (PrinterModel item in printers)
{
listItems.Add(new SelectListItem {
Text = item.Description + (item.PrinterTray != null && !string.IsNullOrWhiteSpace(item.PrinterTray.Name) ? " - " + item.PrinterTray.Name : ""), Value = item.Id.ToString()
});
}
return(new SelectList(listItems, "Value", "Text"));
}
public ActionResult Requeue(Int64 id)
{
BaseModelContext <PrintModel> printDb = new BaseModelContext <PrintModel>();
PrintLogModel printLogModel = DB.Models.Find(id);
if (printLogModel != null)
{
PrintModel printModel = new PrintModel()
{
EntityName = printLogModel.EntityName,
PrimaryKey = printLogModel.PrimaryKey,
FileLocation = printLogModel.FileLocation,
PrinterId = printLogModel.PrinterId,
Status = PrintModel.queuedStatus,
RetryCount = 0,
DeleteFile = false,
};
printDb.Models.Add(printModel);
printDb.SaveChanges();
TempData["Success"] = "Successfully re-queued job id: " + printLogModel.PrintId.ToString() + ".";
}
return(Redirect(Url.Action("Index", "Print")));
}
public ServiceResult PrintDocument(string userId, int Id)
{
ServiceResult serviceResult = new ServiceResult();
using (BaseModelContext <PrintModel> printModeldb = new BaseModelContext <PrintModel>())
{
//find the record
var unPrintedDocument = printModeldb.Models.Find(Id);
PrintModel printModel = new PrintModel();
printModel.EntityName = unPrintedDocument.EntityName;
printModel.PrimaryKey = unPrintedDocument.PrimaryKey;
printModel.FileLocation = unPrintedDocument.FileLocation;
printModel.PrinterId = unPrintedDocument.PrinterId;
//printModel.PrintedDateTime = "";
printModel.Status = "Queued";
printModel.DeleteFile = unPrintedDocument.DeleteFile;
printModel.CreatedById = userId;
printModel.Created = DateTime.Now.Date;
printModeldb.Models.Add(printModel);
printModeldb.SaveChanges();
serviceResult.Success(unPrintedDocument.EntityName + " document has been added to print queue.");
}
return(serviceResult);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
public ModelContextViewModel(ViewModelStore viewModelStore, BaseModelContext baseModelContext)
: this(viewModelStore, baseModelContext, false)
{
}
public ServiceResult ProcessFileAction(string userId, string url, Int64?Id)
{
ServiceResult serviceResult = new ServiceResult();
using (BaseModelContext <TFOF.Areas.File.Models.FileModel> fileModeldb = new BaseModelContext <TFOF.Areas.File.Models.FileModel>())
{
var fileinfo = fileModeldb.Models.Find(Id);
if (fileinfo != null)
{
if (fileinfo.Action.ToUpper() == "EXPORT")
{
if (System.IO.Directory.Exists(fileinfo.FileLocation))
{
string argument = "/select, \"" + fileinfo.FileLocation + @"\" + fileinfo.FileName + "\"";
Process.Start("explorer.exe", argument);
}
else
{
serviceResult.Error("File not found!");
}
}
else if (fileinfo.Action.ToUpper() == "IMPORT")
{
if (System.IO.Directory.Exists(fileinfo.FileLocation))
{
//Download the file
System.IO.FileInfo file = new System.IO.FileInfo(fileinfo.FileLocation + @"\" + fileinfo.FileName);
// prepare the response to the client. resp is the client Response
var Response = HttpContext.Current.Response;
Response.Clear();
Response.AddHeader("Content-Disposition", "attachment; filename=" + file.Name);
Response.AddHeader("Content-Length", file.Length.ToString());
Response.WriteFile(file.FullName);
Response.End();
serviceResult.Success("File downloaded successfully!");
}
else
{
serviceResult.Error("File path not found!");
}
}
else if (fileinfo.Action.ToUpper() == "PRINT")
{
//using (BaseModelContext<PrintModel> printModeldb = new BaseModelContext<PrintModel>())
//{
// PrintModel printModel = new PrintModel();
// printModel.EntityName = "RevenueShareMYOBExport";
// printModel.PrimaryKey = "MYOBExport";// need to check with pd
// printModel.FileLocation = fileinfo.FileLocation + @"\" + fileinfo.FileName;
// printModel.Printer = "local";// need to check with pd
// printModel.Status = "Queued";
// printModel.DeleteFile = true;
// printModel.CreatedById = userId;
// printModel.Created = DateTime.Now.Date;
// printModeldb.Models.Add(printModel);
// printModeldb.SaveChanges();
// serviceResult.Success("Document has been added to print queue.");
//}
//return serviceResult;
}
}
else
{
serviceResult.Error("File not found!");
}
}
return(serviceResult);
}
/// <summary>
/// Run reports is used for scheduled reports.
/// </summary>
/// <param name="reportModel"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static FileHelper Run(ReportModel reportModel, string userId)
{
string URL = reportServerPathRunner + reportModel.SSRSReportName.Replace(".rdl", "");
string Command = "Render";
string Query = "";
FileHelper file = new FileHelper((!string.IsNullOrWhiteSpace(reportModel.FileName) ? reportModel.FileName : reportModel.SSRSReportName.Replace(".rdl", "")), userId);
//Replace filename parameters.
foreach (ReportParameterModel reportParameter in reportModel.ReportParameters)
{
//Setup the query
if (!string.IsNullOrWhiteSpace(reportParameter.DefaultValue))
{
Query += $"&{reportParameter.Name}={reportParameter.DefaultValue}";
}
//Replace any parameter in the name.
if (file.FileName.Contains("{" + reportParameter.Name + "}"))
{
string defaultValue = reportParameter.DefaultValue;
//If the parameter is a date make sure we format it so its fiel friendly.
if (!string.IsNullOrWhiteSpace(reportParameter.DataType) && reportParameter.DataType.Equals(ReportParameterModel.dateTimeType))
{
DateTime dateTimeValue;
DateTime.TryParse(reportParameter.DefaultValue, out dateTimeValue);
defaultValue = (dateTimeValue != null ? dateTimeValue.ToString("yyyyMMdd") : "");
}
file.FileName = file.FileName.Replace("{" + reportParameter.Name + "}", defaultValue);
}
}
file.FileName = Regex.Replace(file.FileName, "-{2,}", "-");
file.FileName = file.FileName + "." + ReportModel.Extensions[reportModel.Format];
//Delete existing file
if (file.Delete())
{
URL = URL + "&rs:Command=" + Command + "&rs:Format=" + reportModel.Format + Query;
System.Net.HttpWebRequest Req = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(URL);
NetworkCredential credential = new NetworkCredential(userName, password, domain);
Req.Credentials = credential;
Req.Method = "GET";
//Specify the path for saving.
//Do File Service here and return FileService fileService = new FileService();
//file.FilePathAndName = string.Format("{0}{1}{2}", file.FilePath, file.FileName, @".pdf");
System.Net.WebResponse objResponse = Req.GetResponse();
System.IO.FileStream fs = new System.IO.FileStream(file.FilePathAndName, System.IO.FileMode.Create);
System.IO.Stream stream = objResponse.GetResponseStream();
byte[] buf = new byte[1024];
int len = stream.Read(buf, 0, 1024);
while (len > 0)
{
fs.Write(buf, 0, len);
len = stream.Read(buf, 0, 1024);
}
stream.Close();
fs.Close();
BaseModelContext <ReportUserActivityLogModel> reportUserActivityLogDb = new BaseModelContext <ReportUserActivityLogModel>();
ReportUserActivityLogModel reportUserActivityModel = new ReportUserActivityLogModel()
{
ReportId = reportModel.Id,
UserId = userId,
Activity = ReportUserActivityLogModel.RunActivity,
Parameters = Query
};
reportUserActivityLogDb.Models.Add(reportUserActivityModel);
reportUserActivityLogDb.SaveChanges(userId);
BaseModelContext <ReportModel> reportDb = new BaseModelContext <ReportModel>();
reportModel.LastRun = DateTime.Now;
reportDb.Entry(reportModel);
reportDb.SaveChanges(userId);
}
return(file);
}
/// <summary>
/// Adds a new model context view model for the given node.
/// </summary>
/// <param name="m">ModelContext.</param>
public void AddModelContext(BaseModelContext m)
{
// verify that node hasnt been added yet
foreach (ModelContextViewModel viewModel in this.rootNodeVMs)
if (viewModel.ModelContext.Id == m.Id)
return;
ModelContextViewModel vm = new ModelContextViewModel(this.ViewModelStore, m);
vm.Index = this.rootNodeVMs.Count +1;
this.rootNodeVMs.Add(vm);
}
/// <summary>
/// Deletes the model context view model that is hosting the given node.
/// </summary>
/// <param name="m">ModelContext.</param>
public void DeleteModelContext(BaseModelContext m)
{
for (int i = this.rootNodeVMs.Count - 1; i >= 0; i--)
if (this.rootNodeVMs[i].ModelContext.Id == m.Id)
{
this.rootNodeVMs[i].Dispose();
this.rootNodeVMs.RemoveAt(i);
}
UpdateIndices();
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
public ModelContextViewModel(ViewModelStore viewModelStore, BaseModelContext baseModelContext)
: this(viewModelStore, baseModelContext, false)
{
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
public ModelContextViewModel(ViewModelStore viewModelStore, BaseModelContext baseModelContext, bool isLocked)
: base(viewModelStore)
{
this.modelContext = baseModelContext;
this.copyCommand = new DelegateCommand(CopyCommand_Executed, CopyCommand_CanExecute);
this.pasteCommand = new DelegateCommand(PasteCommand_Executed, PasteCommand_CanExecute);
this.copyAllTreeCommand = new DelegateCommand(CopyAllTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
this.copyEmbeddingTreeCommand = new DelegateCommand(CopyEmbeddingTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
this.copyReferenceTreeCommand = new DelegateCommand(CopyReferenceTreeCommand_Executed, CopyAllTreeCommand_CanExecute);
//this.cutCommand = new DelegateCommand(CutCommand_Executed, CutCommand_CanExecute);
this.optimizeCommand = new DelegateCommand(OptimizeCommand_Executed);
if (baseModelContext is ModelContext)
{
ModelContext modelContext = baseModelContext as ModelContext;
this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView);
this.modelTreeViewModel.IsLocked = isLocked;
this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView);
this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel);
this.modelContextType = ModelContextViewType.ModelContext;
}
else if (baseModelContext is ExternModelContext)
{
ExternModelContext modelContext = baseModelContext as ExternModelContext;
if (modelContext.ModelContext != null)
{
this.AddModelContext(modelContext.ModelContext);
}
this.EventManager.GetEvent <ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId),
true, this.modelContext.Id, new System.Action <ElementAddedEventArgs>(OnModelContextAdded));
this.EventManager.GetEvent <ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId),
true, this.modelContext.Id, new System.Action <ElementDeletedEventArgs>(OnModelContextRemoved));
this.EventManager.GetEvent <ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ExternModelContextDomainRoleId),
new System.Action <RolePlayerChangedEventArgs>(OnModelContextChanged));
this.EventManager.GetEvent <ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ModelContextDomainRoleId),
new System.Action <RolePlayerChangedEventArgs>(OnModelContextChanged));
this.modelContextType = ModelContextViewType.ExternModelContext;
}
else if (baseModelContext is LibraryModelContext)
{
LibraryModelContext modelContext = baseModelContext as LibraryModelContext;
this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView);
this.modelTreeViewModel.IsLocked = isLocked;
this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView);
this.modelContextType = ModelContextViewType.LibraryContext;
this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel);
}
this.selectedItem = this.ModelTreeViewModel;
if (this.ModelContext != null)
{
this.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(
this.Store.DomainDataDirectory.GetDomainProperty(BaseModelContext.NameDomainPropertyId), this.ModelContext.Id, new System.Action <ElementPropertyChangedEventArgs>(NamePropertyChanged));
}
}
public static List <ReportModel> GetReports(ReportModel reportModel, string category, IPrincipal User)
{
BaseModelContext <ReportModel> reportDb = new BaseModelContext <ReportModel>();
List <ReportModel> reports;
//Get list of active reports
if (!User.IsInRole(SiteRole.Administrators))
{
reports = reportDb.Models.Where(r => r.IsActive == true).ToList();
}
else
{
reports = reportDb.Models.ToList();
}
//Reduce to category if category is specified
if (!string.IsNullOrWhiteSpace(category))
{
reports = reports.Where(r => r.Category == category).ToList();
}
//Reduce to a specific report if specified
if (reportModel != null)
{
reports = reports.Where(r => r.Id == reportModel.Id).ToList();
}
//If Admin return all report/s
if (User.IsInRole(SiteRole.Administrators))
{
return(reports);
}
List <ReportModel> userReports = new List <ReportModel>();
//Add report/s for everyone
userReports = userReports.Concat(
reports.Where(r => r.Permit == ReportModel.permitEveryone)
).ToList();
//Gather roleIds of user
string userId = User.Identity.GetUserId();
BaseModelContext <UserModel> userDb = new BaseModelContext <UserModel>();
UserModel userModel = userDb.Models.Find(userId);
//UserRoles are not preloaded. So load them.
userDb.Entry(userModel).Collection("UserRoles").Load();
if (userModel != null)
{
List <string> roleIds = userModel.UserRoles.Select(r => r.RoleId).ToList();
//Add reports matching user roles
userReports = userReports.Concat(
reports.Where(r => r.Permit == ReportModel.permitUserOrRole).SelectMany(r => r.ReportRoles.Where(e => roleIds.Contains(e.RoleId))).Select(r => r.Report)
).ToList();
//Add reprots matching user
userReports = userReports.Concat(
reports.Where(r => r.Permit == ReportModel.permitUserOrRole && r.ReportUsers.Select(u => u.UserId).Contains(userId))
).ToList();
}
//Return Unique Reports.
return(new HashSet <ReportModel>(userReports).ToList());
}
