public ProfileDeviceEventsArg(DrawType updateType, ModuleDataModel dataModel, bool preview, DrawingContext drawingContext)
{
UpdateType = updateType.ToString().ToLower();
DataModel = dataModel;
Preview = preview;
DrawingContext = drawingContext;
}
/// <summary>
/// Opens a new LayerEditorView for the given layer
/// </summary>
/// <param name="layer">The layer to open the view for</param>
/// <param name="dataModel">The datamodel to bind the editor to</param>
public void EditLayer(LayerModel layer, ModuleDataModel dataModel)
{
IParameter[] args =
{
new ConstructorArgument("dataModel", dataModel),
new ConstructorArgument("layer", layer)
};
_windowService.ShowDialog <LayerEditorViewModel>("Artemis | Edit layer", null, args);
// If the layer was a folder, but isn't anymore, assign it's children to it's parent.
if (layer.LayerType is FolderType || !layer.Children.Any())
{
return;
}
while (layer.Children.Any())
{
var child = layer.Children[0];
layer.Children.Remove(child);
if (layer.Parent != null)
{
layer.Parent.Children.Add(child);
layer.Parent.FixOrder();
}
else
{
layer.Profile.Layers.Add(child);
layer.Profile.FixOrder();
}
}
}
public bool ConditionsMet(LayerModel layerModel, ModuleDataModel dataModel)
{
lock (layerModel.Properties.Conditions)
{
var conditionsMet = false;
switch (layerModel.Properties.ConditionType)
{
case ConditionType.AnyMet:
conditionsMet = layerModel.Properties.Conditions.Any(cm => cm.ConditionMet(dataModel));
break;
case ConditionType.AllMet:
conditionsMet = layerModel.Properties.Conditions.All(cm => cm.ConditionMet(dataModel));
break;
case ConditionType.NoneMet:
conditionsMet = !layerModel.Properties.Conditions.Any(cm => cm.ConditionMet(dataModel));
break;
}
layerModel.EventProperties.Update(layerModel, conditionsMet);
if (conditionsMet && layerModel.EventProperties.CanTrigger)
{
layerModel.EventProperties.TriggerEvent(layerModel);
}
return(layerModel.EventProperties.MustDraw);
}
}
public async Task <IActionResult> ModuleData_Search([Bind("IdModul,NamaModule,Action,Controller,Img,Status")] ModuleData data)
{
var model = new ModuleDataModel();
var r = new ErrorViewModel();
if (ModelState.IsValid)
{
try
{
model.ListData = await f.ModuleData_GetSearch(data);
return(await Task.Run(() => Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "ModuleData_Table", model) })));
}
catch (Exception ex)
{
r.MessageContent = ex.ToString();
r.MessageTitle = "Error ";
r.RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
model.Error = r;
model.ListData = await f.ModuleData_Get();
return(await Task.Run(() => Json(new { isValid = false, message = r.MessageContent, title = r.MessageTitle, html = Helper.RenderRazorViewToString(this, "ModuleData_Table", model) })));
}
}
else
{
r.MessageContent = "State Model tidak valid";
r.MessageTitle = "Error ";
r.RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
model.Error = r;
model.ListData = await f.ModuleData_Get();
return(await Task.Run(() => Json(new { isValid = false, message = r.MessageContent, title = r.MessageTitle, html = Helper.RenderRazorViewToString(this, "ModuleData_Table", model) })));
}
}
// TODO: Make this and ProfileModel's GetRenderLayers the same through inheritance
/// <summary>
/// Generates a flat list containing all layers that must be rendered on the keyboard,
/// the first mouse layer to be rendered and the first headset layer to be rendered
/// </summary>
/// <param name="dataModel">Instance of said game data model</param>
/// <param name="keyboardOnly">Whether or not to ignore anything but keyboards</param>
/// <param name="ignoreConditions"></param>
/// <returns>A flat list containing all layers that must be rendered</returns>
public List <LayerModel> GetRenderLayers(ModuleDataModel dataModel, bool keyboardOnly, bool ignoreConditions = false)
{
var layers = new List <LayerModel>();
foreach (var layerModel in Children.OrderByDescending(l => l.Order))
{
if (!layerModel.Enabled || keyboardOnly && layerModel.LayerType.DrawType != DrawType.Keyboard)
{
continue;
}
if (!ignoreConditions)
{
if (!layerModel.AreConditionsMet(dataModel) || !layerModel.RenderAllowed)
{
continue;
}
}
layers.Add(layerModel);
layers.AddRange(layerModel.GetRenderLayers(dataModel, keyboardOnly, ignoreConditions));
}
return(layers);
}
public override int?Save(string action)
{
var data = new ModuleDataModel();
data.ModuleId = SystemKeyId;
data.Name = Name;
data.Description = Description;
data.SortOrder = SortOrder;
if (action == "Insert")
{
var dtModule = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.DoesExist(data, SessionVariables.RequestProfile);
if (dtModule.Rows.Count == 0)
{
TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Create(data, SessionVariables.RequestProfile);
}
else
{
throw new Exception("Record with given ID already exists.");
}
}
else
{
TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Update(data, SessionVariables.RequestProfile);
}
return(data.ModuleId);
}
public void Update(LayerModel layerModel, ModuleDataModel dataModel, bool isPreview = false)
{
var properties = layerModel?.Properties as AmbientLightPropertiesModel;
if (properties == null)
{
return;
}
var width = (int)Math.Round(properties.Width);
var height = (int)Math.Round(properties.Height);
var data = ScreenCaptureManager.GetLastScreenCapture();
var newData = GetAmbienceCreator(properties)
.GetAmbience(data, ScreenCaptureManager.LastCaptureWidth, ScreenCaptureManager.LastCaptureHeight, width,
height, properties);
_lastData = _lastData?.Blend(newData, properties.SmoothMode) ?? newData;
var stride = (width * ScreenCaptureManager.LastCapturePixelFormat.BitsPerPixel + 7) / 8;
properties.AmbientLightBrush = new DrawingBrush(new ImageDrawing
(BitmapSource.Create(width, height, 96, 96, ScreenCaptureManager.LastCapturePixelFormat, null, _lastData,
stride), new Rect(0, 0, width, height)));
layerModel.ApplyProperties(true);
}
public void LoadData(int moduleId, bool showId)
{
Clear();
var data = new ModuleDataModel();
data.ModuleId = moduleId;
var items = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.GetEntityDetails(data, SessionVariables.RequestProfile);
if (items.Count != 1)
{
return;
}
var item = items[0];
SetData(item);
if (!showId)
{
SystemKeyId = item.ModuleId;
oHistoryList.Setup(PrimaryEntity, moduleId, PrimaryEntityKey);
}
else
{
CoreSystemKey.Text = String.Empty;
}
}
public void Update(LayerModel layerModel, ModuleDataModel dataModel, bool isPreview = false)
{
// Key press is always as large as the entire keyboard it is drawn for
layerModel.Properties.Width = _deviceManager.ActiveKeyboard.Width;
layerModel.Properties.Height = _deviceManager.ActiveKeyboard.Height;
layerModel.Properties.X = 0;
layerModel.Properties.Y = 0;
layerModel.Properties.Contain = true;
layerModel.ApplyProperties(true);
_layerModel = layerModel;
if (isPreview)
{
return;
}
lock (_keyPressLayers)
{
// Remove expired key presses
var updateLayers = _keyPressLayers.Where(k => !k.LayerAnimation.MustExpire(k)).ToList();
// Update the ones that are still active
foreach (var updateLayer in updateLayers)
{
updateLayer.Update(null, false, true);
}
_keyPressLayers = updateLayers;
}
}
public static string Save(ModuleDataModel data, string action, RequestProfile requestProfile)
{
var sql = "EXEC ";
switch (action)
{
case "Create":
sql += "dbo.ModuleInsert " +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId) +
", " + ToSQLParameter(BaseDataModel.BaseDataColumns.ApplicationId, requestProfile.ApplicationId);
break;
case "Update":
sql += "dbo.ModuleUpdate " +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId);
break;
default:
break;
}
sql = sql + ", " + ToSQLParameter(data, ModuleDataModel.DataColumns.ModuleId) +
", " + ToSQLParameter(data, StandardDataModel.StandardDataColumns.Name) +
", " + ToSQLParameter(data, StandardDataModel.StandardDataColumns.Description) +
", " + ToSQLParameter(data, StandardDataModel.StandardDataColumns.SortOrder);
return(sql);
}
/// <summary>
/// Draw all the given layers on the given rect
/// </summary>
/// <param name="deviceVisualModel"></param>
/// <param name="renderLayers">The layers to render</param>
/// <param name="dataModel">The data model to base the layer's properties on</param>
/// <param name="preview">Indicates wheter the layer is drawn as a preview, ignoring dynamic properties</param>
internal void DrawLayers(DeviceVisualModel deviceVisualModel, List <LayerModel> renderLayers,
ModuleDataModel dataModel, bool preview)
{
renderLayers = renderLayers.Where(rl => rl.LayerType.DrawType == deviceVisualModel.DrawType).ToList();
if (!renderLayers.Any())
{
return;
}
// Setup the DrawingVisual's size
var c = deviceVisualModel.GetDrawingContext();
c.PushClip(new RectangleGeometry(deviceVisualModel.Rect));
c.DrawRectangle(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)), null, deviceVisualModel.Rect);
// Update the layers
foreach (var layerModel in renderLayers)
{
layerModel.Update(dataModel, preview, true);
}
RaiseDeviceUpdatedEvent(new ProfileDeviceEventsArg(deviceVisualModel.DrawType, dataModel, preview, null));
// Draw the layers
foreach (var layerModel in renderLayers)
{
layerModel.Draw(dataModel, c, preview, true);
}
RaiseDeviceDrawnEvent(new ProfileDeviceEventsArg(deviceVisualModel.DrawType, dataModel, preview, c));
// Remove the clip
c.Pop();
}
protected override DataTable GetEntityData(int? entityKey)
{
var moduledata = new ModuleDataModel();
moduledata.ModuleId = entityKey;
var results = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Search(moduledata, SessionVariables.RequestProfile);
return results;
}
public static int Create(ModuleDataModel data, RequestProfile requestProfile)
{
var sql = Save(data, "Create", requestProfile);
var newId = DBDML.RunScalarSQL("Module.Insert", sql, DataStoreKey);
return(Convert.ToInt32(newId));
}
public LayerEditorViewModel(LayerModel layer, ModuleDataModel dataModel, IEnumerable <ILayerType> types,
IEnumerable <ILayerAnimation> layerAnimations)
{
Layer = layer;
ProposedLayer = GeneralHelpers.Clone(layer);
ProposedLayer.Children.Clear();
DataModel = DataModel;
LayerTypes = new BindableCollection <ILayerType>(types.OrderBy(t => t.Name));
LayerAnimations = layerAnimations.OrderBy(l => l.Name).ToList();
DataModelProps = new BindableCollection <GeneralHelpers.PropertyCollection>(GeneralHelpers.GenerateTypeMap(dataModel));
if (Layer.Properties == null)
{
Layer.SetupProperties();
}
// Setup existing conditions
var conditions = ProposedLayer.Properties.Conditions.Select(c => new LayerConditionViewModel(this, c));
var keyBinds = ProposedLayer.Properties.LayerKeybindModels.Select(c => new LayerKeybindViewModel(this, c));
LayerConditionVms = new BindableCollection <LayerConditionViewModel>(conditions);
LayerKeybindVms = new BindableCollection <LayerKeybindViewModel>(keyBinds);
PropertyChanged += PropertiesViewModelHandler;
// Setup existiing properties
PreSelect();
}
protected override void ShowData(int moduleId)
{
oDetailButtonPanel.SetId = SetId;
var data = new ModuleDataModel();
data.ModuleId = moduleId;
var items = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.GetEntityDetails(data, SessionVariables.RequestProfile);
if (items.Count == 1)
{
var item = items[0];
lblModuleId.Text = Convert.ToString(item.ModuleId);
lblName.Text = Convert.ToString(item.Name);
lblDescription.Text = Convert.ToString(item.Description);
lblSortOrder.Text = Convert.ToString(item.SortOrder);
oUpdateInfo.LoadText(item.UpdatedDate, item.UpdatedBy, item.LastAction);
oHistoryList.Setup(PrimaryEntity, moduleId, "Module");
}
else
{
Clear();
}
}
public bool ConditionMet(ModuleDataModel subject)
{
lock (subject)
{
if (string.IsNullOrEmpty(Field) || string.IsNullOrEmpty(Type))
{
return(false);
}
var inspect = GeneralHelpers.GetPropertyValue(subject, Field);
if (inspect == null)
{
_lastValue = null;
return(false);
}
bool returnValue;
if (Operator == "changed" || Operator == "decreased" || Operator == "increased")
{
returnValue = EvaluateEventOperator(subject, inspect);
}
else
{
returnValue = EvaluateOperator(subject);
}
_lastValue = inspect;
return(returnValue);
}
}
private Boolean ExecutePSShellGetModulesInfoByNameXXXXX(string moduleName)
{
Collection <PSObject> psObjects = null;
string script = LoadScript(@"C:\Excalibur\Utilities\PsScripts\ExcListDlls.ps1");
using (var powershell = PowerShell.Create())
{
powershell.Runspace = psRunspace;
powershell.AddScript(script, false);
powershell.Invoke();
powershell.Commands.Clear();
powershell.AddCommand("Get-Dll").AddParameter("ProcessId", testedProcessId); //.AddParameter("Process", null).AddParameter("ProcessName", "").AddParameter("ProcessId", 0).AddParameter("ModuleName", "frontdesk.dll");
Collection <PSObject> output = powershell.Invoke();
// process each object in the output and append to stringbuilder
StringBuilder results = new StringBuilder();
foreach (PSObject psObject in output)
{
//results.AppendLine(obj.ToString());
_moduleDataReport = new ModuleDataModel();
//_moduleDataReport.Name = psObject.Properties["Name"].Value.ToString();
//_moduleDataReport.Name = psObject.Properties["Path"].Value.ToString();
}
}
return(true);
}
public LuaDeviceDrawingEventArgs(string deviceType, ModuleDataModel dataModel, bool preview,
LuaDrawWrapper luaDrawWrapper)
{
DeviceType = deviceType;
DataModel = dataModel;
Preview = preview;
Drawing = luaDrawWrapper;
}
protected override void Clear()
{
base.Clear();
var data = new ModuleDataModel();
SetData(data);
}
public static DataSet GetChildren(ModuleDataModel data, RequestProfile requestProfile)
{
var sql = "EXEC dbo.ModuleChildrenGet" +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId) +
", " + ToSQLParameter(data, ModuleDataModel.DataColumns.ModuleId);
var oDT = new Framework.Components.DataAccess.DBDataSet("Get Children", sql, DataStoreKey);
return(oDT.DBDataset);
}
/// <summary>
/// Draw the layer using the provided context
/// </summary>
/// <param name="dataModel"></param>
/// <param name="c"></param>
/// <param name="preview"></param>
/// <param name="updateAnimations"></param>
public void Draw(ModuleDataModel dataModel, DrawingContext c, bool preview, bool updateAnimations)
{
if (Brush == null)
{
return;
}
LayerType.Draw(this, c);
}
private System.Data.DataTable GetData()
{
// TODO: on all export pages
var data = new ModuleDataModel();
var dt = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Search(data, SessionVariables.RequestProfile);
return(dt);
}
protected override void Update(Dictionary <string, string> values)
{
var data = new ModuleDataModel();
// copies properties from values dictionary object to data object
PropertyMapper.CopyProperties(data, values);
TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Update(data, SessionVariables.RequestProfile);
base.Update(values);
}
private DataTable GetData(string name)
{
var data = new ModuleDataModel();
data.Name = name;
var dt = TaskTimeTracker.Components.Module.ApplicationDevelopment.ModuleDataManager.Search(data, SessionVariables.RequestProfile);
return(dt);
}
public static bool DoesExist(ModuleDataModel data, RequestProfile requestProfile)
{
var doesExistRequest = new ModuleDataModel();
doesExistRequest.ApplicationId = data.ApplicationId;
doesExistRequest.Name = data.Name;
var list = GetEntityDetails(doesExistRequest, requestProfile, 0);
return(list.Count > 0);
}
/// <summary>
/// Draw the layer using the provided context
/// </summary>
/// <param name="dataModel"></param>
/// <param name="c"></param>
/// <param name="preview"></param>
/// <param name="updateAnimations"></param>
public void Draw(ModuleDataModel dataModel, DrawingContext c, bool preview, bool updateAnimations)
{
if (Brush == null || !preview && !RenderAllowed)
{
return;
}
ApplyHierarchyOpacity(c);
LayerType.Draw(this, c);
PopHierarchyOpacity(c);
}
internal void ApplyProperty(ModuleDataModel dataModel, LayerModel layerModel)
{
if (LayerPropertyType == LayerPropertyType.PercentageOf)
{
ApplyPercentageOf(dataModel, layerModel, PercentageSource);
}
if (LayerPropertyType == LayerPropertyType.PercentageOfProperty)
{
ApplyPercentageOfProperty(dataModel, layerModel);
}
}
private bool dllInfoListFilter(object item)
{
ModuleDataModel dllItem = item as ModuleDataModel;
if (dllItem.Name.Contains(_filterString))
{
return(true);
}
else
{
return(false);
}
}
public void Update(LayerModel layerModel, ModuleDataModel dataModel, bool isPreview = false)
{
layerModel.ApplyProperties(true);
if (isPreview || dataModel == null)
{
return;
}
// If not previewing, apply dynamic properties according to datamodel
foreach (var dynamicProperty in layerModel.Properties.DynamicProperties)
{
dynamicProperty.ApplyProperty(dataModel, layerModel);
}
}
public static void Delete(ModuleDataModel data, RequestProfile requestProfile)
{
const string sql = @"dbo.ModuleDelete ";
var parameters =
new
{
AuditId = requestProfile.AuditId
, ModuleId = data.ModuleId
};
using (var dataAccess = new DataAccessBase(DataStoreKey))
{
dataAccess.Connection.Execute(sql, parameters, commandType: CommandType.StoredProcedure);
}
}
