public void RenameView()
{
if (lvViews.SelectedItems.Count == 1)
{
var item = lvViews.SelectedItems[0];
var entity = (Entity)item.Tag;
var rDialog = new ViewPropertiesDialog
{
ViewName = entity.GetAttributeValue <string>("name"),
ViewDescription = entity.GetAttributeValue <string>("description")
};
if (rDialog.ShowDialog(ParentForm) == DialogResult.OK)
{
entity["name"] = rDialog.ViewName;
entity["description"] = rDialog.ViewDescription;
loadingPanel = InformationPanel.GetInformationPanel(this, "Updating properties...", 340, 120);
var bwUpdateView = new BackgroundWorker {
WorkerReportsProgress = true
};
bwUpdateView.DoWork += bwUpdateView_DoWork;
bwUpdateView.ProgressChanged += bwUpdateView_ProgressChanged;
bwUpdateView.RunWorkerCompleted += bwUpdateView_RunWorkerCompleted;
bwUpdateView.RunWorkerAsync(entity);
}
}
}
internal void UpdateFilterFromView(bool isSystem)
{
if (lvViews.SelectedItems.Count == 0)
{
return;
}
var view = GetSelectedSystemView().FirstOrDefault();
if (view == null)
{
MessageBox.Show(this, "Please select a view", "Warning", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
return;
}
var rsDialog = new RuleSelectionDialog(service, view.GetAttributeValue <string>("returnedtypecode"), isSystem);
if (rsDialog.ShowDialog(this) == DialogResult.OK)
{
var rule = rsDialog.SelectedRule;
loadingPanel = InformationPanel.GetInformationPanel(this, "Updating filter...", 340, 120);
var bwUpdateRule = new BackgroundWorker {
WorkerReportsProgress = true
};
bwUpdateRule.DoWork += bwUpdateRule_DoWork;
bwUpdateRule.ProgressChanged += bwUpdateRule_ProgressChanged;
bwUpdateRule.RunWorkerCompleted += bwUpdateRule_RunWorkerCompleted;
bwUpdateRule.RunWorkerAsync(new object[] { rule, view, isSystem });
}
}
/// <summary>
/// start the copy operation
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void executeButton_Click(object sender, EventArgs e)
{
//check if source and target are set - this shouldn't be necessary since the button is disabled if they're not both set, but leaving it in anyway
if (_service != null && _targetService != null)
{
//reset the counter to 0
_counter = 0;
//display the initializing message
_infoPanel = InformationPanel.GetInformationPanel(this, _initializing, 340, 120);
//change the cursor
Cursor = Cursors.WaitCursor;
//set up and call the backgroundworker - all querying and updates are done there
var worker = new BackgroundWorker();
worker.DoWork += WorkerDoWork;
worker.ProgressChanged += WorkerProgressChanged;
worker.RunWorkerCompleted += WorkerRunWorkerCompleted;
worker.WorkerReportsProgress = true;
worker.RunWorkerAsync();
}
else
{
MessageBox.Show(_unselectedError);
}
}
private void PopulateEntities(bool working)
{
if (!working)
{
ClearAllListViews();
ManageWorkingState(true);
informationPanel = InformationPanel.GetInformationPanel(this, "Loading entities...", 340, 150);
using (var bwFill = new BackgroundWorker())
{
bwFill.DoWork += (sender, e) =>
{
var serviceParameters = new ServiceParameters(OrganizationService, MetadataService, NotificationService, ExceptionService);
var controller = new EntityController();
e.Result = controller.RetrieveSourceEntitiesList(cbShowSystemAttributes.Checked, cachedMetadata, entityAttributes, serviceParameters);
};
bwFill.RunWorkerCompleted += (sender, e) =>
{
informationPanel.Dispose();
var controller = new EntityController();
controller.PopulateEntitiesListView(e.Result as List <ListViewItem>, e.Error, this, lvEntities, NotificationService);
ManageWorkingState(false);
};
bwFill.RunWorkerAsync();
}
}
}
private void buttonCDSComboRetrieve_Click(object sender, EventArgs e)
{
//
var infoPanel = InformationPanel.GetInformationPanel(this, "CDS Combo Box Retrieve Example", 340, 150);
infoPanel.BringToFront();
Refresh();
textBoxCDSComboProgress.Text = "";
cdsDataComboRetrieve.RetrieveMultiple(xmlViewerFetchCDSCombo.Text,
(string message) => {
textBoxCDSComboProgress.Text += $"{message}{Environment.NewLine}";
InformationPanel.ChangeInformationPanelMessage(infoPanel, message);
Refresh();
},
(int itemCount, Entity FirstItem) =>
{
// Thread.Sleep(2000);
textBoxCDSComboProgress.Text += $"Count: {itemCount}{Environment.NewLine}";
InformationPanel.ChangeInformationPanelMessage(infoPanel, $"Count: {itemCount}, Entity: {FirstItem?.Attributes.First().ToString()}");
Refresh();
// Thread.Sleep(2000);
if (Controls.Contains(infoPanel))
{
infoPanel.Dispose();
Controls.Remove(infoPanel);
}
});
}
internal void ReplaceUserFilters()
{
if (MessageBox.Show(ParentForm,
"Are you sure you want to apply the selected user synchronization filters to other users?",
"Question", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
List <Entity> users = null;
var usDialog = new UserSelectionDialog(service);
if (usDialog.ShowDialog(this) == DialogResult.OK)
{
users = usDialog.SelectedUsers;
}
else
{
return;
}
loadingPanel = InformationPanel.GetInformationPanel(this, "Initiating...", 340, 120);
var bwReplaceFilters = new BackgroundWorker {
WorkerReportsProgress = true
};
bwReplaceFilters.DoWork += bwReplaceFilters_DoWork;
bwReplaceFilters.ProgressChanged += bwReplaceFilters_ProgressChanged;
bwReplaceFilters.RunWorkerCompleted += bwReplaceFilters_RunWorkerCompleted;
bwReplaceFilters.RunWorkerAsync(new object[] { GetSelectedUsers()[0], users });
}
private void tsbExport_Click(object sender, EventArgs e)
{
var sfd = new SaveFileDialog {
Title = "Select where to save the file", Filter = "Csv file|*.csv"
};
if (sfd.ShowDialog(ParentForm) != DialogResult.OK)
{
return;
}
infoPanel = InformationPanel.GetInformationPanel(this, "Exporting many to many relationship records...", 340, 150);
listLog.Items.Clear();
var settings = new ImportFileSettings
{
FirstEntity = ((EntityInfo)cbbFirstEntity.SelectedItem).Metadata.LogicalName,
FirstAttributeIsGuid = rdbFirstGuid.Checked,
FirstAttributeName = ((AttributeInfo)cbbFirstEntityAttribute.SelectedItem).Metadata.LogicalName,
Relationship = ((RelationshipInfo)cbbRelationship.SelectedItem).Metadata.IntersectEntityName,
SecondEntity = ((EntityInfo)cbbSecondEntity.SelectedItem).Metadata.LogicalName,
SecondAttributeIsGuid = rdbSecondGuid.Checked,
SecondAttributeName = ((AttributeInfo)cbbSecondEntityAttribute.SelectedItem).Metadata.LogicalName,
};
var exportWorker = new BackgroundWorker();
exportWorker.DoWork += exportWorker_DoWork;
exportWorker.RunWorkerCompleted += exportWorker_RunWorkerCompleted;
exportWorker.RunWorkerAsync(new object[] { settings, sfd.FileName });
}
public void LoadSystemViews(List <Entity> users = null, string returnedTypeExpected = null)
{
if (!DisplaySystemView && !DisplayRulesTemplate && !DisplaySystemRules && !lvViews.Columns.ContainsKey("User"))
{
lvViews.Columns.Add(new ColumnHeader
{
Text = "User",
Name = "User",
Width = 150
});
lvViews.Columns.Add(new ColumnHeader
{
Text = "State",
Name = "State",
Width = 75
});
}
if (DisplayRulesTemplate && !lvViews.Columns.ContainsKey("IsDefault"))
{
lvViews.Columns.Add(new ColumnHeader
{
Text = "Is Default",
Name = "IsDefault",
Width = 75
});
}
if (DisplaySystemView || DisplayRulesTemplate)
{
lvViews.ShowGroups = true;
}
List <Entity> solutions = new List <Entity>();
if (returnedTypeExpected == null)
{
var sp = new SolutionPicker(service);
if (sp.ShowDialog(this) != DialogResult.OK)
{
return;
}
solutions = sp.SelectedSolutions;
}
lvViews.Items.Clear();
loadingPanel = InformationPanel.GetInformationPanel(this, "Retrieving items...", 340, 120);
var bw = new BackgroundWorker {
WorkerReportsProgress = true
};
bw.DoWork += bw_DoWork;
bw.ProgressChanged += bw_ProgressChanged;
bw.RunWorkerCompleted += bw_RunWorkerCompleted;
bw.RunWorkerAsync(new object[] { users, returnedTypeExpected, solutions });
}
public AttributeEditor()
{
InitializeComponent();
// Setup ViewModel
_vm = new AttributeEditorViewModel(new TestableMetadataHelper());
_vm.OnRequestConnection += (sender, args) =>
{
var arg = new RequestConnectionEventArgs {
ActionName = "Load", Control = this
};
RaiseRequestConnectionEvent(arg);
};
_vm.OnEntitiesListChanged += (sender, args) =>
{
cmbEntities.Items.Clear();
cmbEntities.DisplayMember = "DisplayName";
cmbEntities.ValueMember = "SchemaName";
cmbEntities.Items.AddRange(_vm.Entities.ToArray());
};
_vm.OnWorkingStateChanged += (sender, args) =>
{
ManageWorkingState(_vm.WorkingState);
};
_vm.OnGetInformationPanel += (sender, args) =>
{
args.Panel = InformationPanel.GetInformationPanel(this, args.Message, args.Width, args.Height);
};
_vm.OnShowMessageBox += (sender, args) =>
{
MessageBox.Show(this, args.Message, args.Caption, args.Buttons, args.Icon);
};
}
private void TsbTransfertSolutionClick(object sender, EventArgs e)
{
if (lstSourceSolutions.SelectedItems.Count == 1 && targetService != null)
{
importId = Guid.NewGuid();
var item = lstSourceSolutions.SelectedItems[0];
infoPanel = InformationPanel.GetInformationPanel(this, "Initializing...", 340, 120);
var requests = new List <OrganizationRequest>();
requests.Add(new ExportSolutionRequest
{
Managed = chkExportAsManaged.Checked,
SolutionName = item.Text,
ExportAutoNumberingSettings = chkAutoNumering.Checked,
ExportCalendarSettings = chkCalendar.Checked,
ExportCustomizationSettings = chkCustomization.Checked,
ExportEmailTrackingSettings = chkEmailTracking.Checked,
ExportGeneralSettings = chkGeneral.Checked,
ExportIsvConfig = chkIsvConfig.Checked,
ExportMarketingSettings = chkMarketing.Checked,
ExportOutlookSynchronizationSettings = chkOutlookSynchronization.Checked,
ExportRelationshipRoles = chkRelationshipRoles.Checked
});
requests.Add(new ImportSolutionRequest
{
ConvertToManaged = chkConvertToManaged.Checked,
OverwriteUnmanagedCustomizations = chkOverwriteUnmanagedCustomizations.Checked,
PublishWorkflows = chkActivate.Checked,
ImportJobId = importId
});
if (!chkExportAsManaged.Checked && chkPublish.Checked)
{
requests.Add(new PublishAllXmlRequest());
}
btnDownloadLog.Enabled = false;
tsbLoadSolutions.Enabled = false;
tsbTransfertSolution.Enabled = false;
btnSelectTarget.Enabled = false;
Cursor = Cursors.WaitCursor;
var worker = new BackgroundWorker();
worker.DoWork += WorkerDoWorkExport;
worker.ProgressChanged += WorkerProgressChanged;
worker.RunWorkerCompleted += WorkerRunWorkerCompleted;
worker.WorkerReportsProgress = true;
worker.RunWorkerAsync(requests);
}
else
{
MessageBox.Show("You have to select a source solution and a target organization to continue.", "Warning",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void PopulateEntities()
{
if (!workingstate)
{
// Reinit other controls
cmbEntities.Items.Clear();
ManageWorkingState(true);
informationPanel = InformationPanel.GetInformationPanel(this, "Loading entities...", 340, 150);
// Launch treatment
var bwFill = new BackgroundWorker();
bwFill.DoWork += (sender, e) =>
{
// Retrieve
List <EntityMetadata> sourceList = MetadataHelper.RetrieveEntities(service);
// Prepare list of items
var sourceEntitiesList = new List <EntityItem>();
foreach (EntityMetadata entity in sourceList)
{
sourceEntitiesList.Add(new EntityItem(entity));
}
e.Result = sourceEntitiesList.OrderBy(i => i.DisplayName).ToArray();
};
bwFill.RunWorkerCompleted += (sender, e) =>
{
informationPanel.Dispose();
if (e.Error != null)
{
MessageBox.Show(this, "An error occured: " + e.Error.Message, "Error", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else
{
var items = (EntityItem[])e.Result;
if (items.Length == 0)
{
MessageBox.Show(this, "The system does not contain any entities", "Warning", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
}
else
{
cmbEntities.DisplayMember = "DisplayName";
cmbEntities.ValueMember = "SchemaName";
cmbEntities.Items.AddRange(items);
}
}
ManageWorkingState(false);
};
bwFill.RunWorkerAsync();
}
}
public void LoadEntities()
{
infoPanel = InformationPanel.GetInformationPanel(ParentForm, "Loading entities...", 340, 150);
var worker = new BackgroundWorker();
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
worker.RunWorkerAsync();
}
public void DeleteSelectedRules()
{
loadingPanel = InformationPanel.GetInformationPanel(this, "Deleting selected records...", 340, 120);
var bwDelete = new BackgroundWorker();
bwDelete.DoWork += bwDelete_DoWork;
bwDelete.RunWorkerCompleted += bwDelete_RunWorkerCompleted;
bwDelete.RunWorkerAsync(lvViews.SelectedItems);
}
private void LoadMetadata()
{
infoPanel = InformationPanel.GetInformationPanel(this, "Loading metadata...", 340, 150);
var worker = new BackgroundWorker();
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
worker.RunWorkerAsync();
}
private void buttonSaveAs_Click(object sender, EventArgs e)
{
Entity newformXml = formXml;
string newFormXmlName = ITLec.CRMFormXml.AppCode.Common.ShowDialog("New FormXml Name:", "FormXml Name", txtName.Text + " - COPY");
if (!string.IsNullOrEmpty(newFormXmlName))
{
newformXml["name"] = newFormXmlName;
newformXml["description"] = txtDescription.Text;
// newformXml["datadescription"] = tecDataDescription.Text;
newformXml["formxml"] = tecVisualizationDescription.Text;
newformXml.Attributes.Remove(newformXml.LogicalName + "id");
/* newformXml.Id = Guid.NewGuid();
*
* if (newformXml.Attributes.Contains("savedqueryvisualizationid"))
* {
* newformXml["savedqueryvisualizationid"] = newformXml.Id;
* }
* else
* {
* newformXml["userqueryvisualizationid"] = newformXml.Id;
* }*/
infoPanel = InformationPanel.GetInformationPanel(this, "Save As formXml...", 350, 150);
var worker = new BackgroundWorker {
WorkerReportsProgress = true
};
worker.DoWork += (w, evt) =>
{
service.Create((Entity)evt.Argument);
};
worker.ProgressChanged += (w, evt) =>
{
InformationPanel.ChangeInformationPanelMessage(infoPanel, evt.UserState.ToString());
};
worker.RunWorkerCompleted += (w, evt) =>
{
if (evt.Error != null)
{
MessageBox.Show(this, evt.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
HasUpdatedContent = true;
}
Controls.Remove(infoPanel);
infoPanel.Dispose();
this.Close();
};
worker.RunWorkerAsync(newformXml);
}
}
private void ProcessWhoAmI()
{
infoPanel = InformationPanel.GetInformationPanel(this, "Retrieving your user id...", 340, 100);
var worker = new BackgroundWorker();
worker.DoWork += WorkerDoWork;
worker.ProgressChanged += WorkerProgressChanged;
worker.RunWorkerCompleted += WorkerRunWorkerCompleted;
worker.WorkerReportsProgress = true;
worker.RunWorkerAsync();
}
private void BtnCreateWebResourcesClick(object sender, EventArgs e)
{
if (lvFiles.Items.Count > 0)
{
infoPanel = InformationPanel.GetInformationPanel(this, "Creating web resource(s)...", 340, 150);
var bWorker = new BackgroundWorker();
bWorker.RunWorkerCompleted += BWorkerRunWorkerCompleted;
bWorker.DoWork += BWorkerDoWork;
bWorker.RunWorkerAsync();
}
}
private void LoadUsers()
{
btnSearch.Enabled = false;
lvUsers.Items.Clear();
loadingPanel = InformationPanel.GetInformationPanel(this, "Retrieving users...", 340, 120);
var bw = new BackgroundWorker();
bw.DoWork += bw_DoWork;
bw.RunWorkerCompleted += bw_RunWorkerCompleted;
bw.RunWorkerAsync(txtSearch.Text);
}
private void Publish(bool all)
{
if (lvEntities.SelectedItems.Count == 0)
{
return;
}
ManageWorkingState(true);
var message = all ? "Publishing all customizations" : "Publishing entity...";
informationPanel = InformationPanel.GetInformationPanel(this, message, 340, 120);
var bwPublish = new BackgroundWorker();
bwPublish.DoWork += (sender, e) =>
{
if (string.IsNullOrEmpty(e.Argument.ToString()))
{
var pubRequest = new PublishAllXmlRequest();
targetService.Execute(pubRequest);
}
else
{
var pubRequest = new PublishXmlRequest();
pubRequest.ParameterXml = string.Format(@"<importexportxml>
<entities>
<entity>{0}</entity>
</entities>
<nodes/><securityroles/><settings/><workflows/>
</importexportxml>",
e.Argument.ToString());
targetService.Execute(pubRequest);
}
};
bwPublish.RunWorkerCompleted += (sender, e) =>
{
ManageWorkingState(false);
Controls.Remove(informationPanel);
informationPanel.Dispose();
if (e.Error != null)
{
MessageBox.Show(this, e.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
};
bwPublish.RunWorkerAsync(all ? "" : ((EntityMetadata)lvEntities.SelectedItems[0].Tag).LogicalName);
}
private void btnCloneRecord_Click(object sender, EventArgs e)
{
var recordToProcess = lstRecordsToProcess.Items;
infoPanel = InformationPanel.GetInformationPanel(this, "Initializing...", 540, 220);
ToggleWaitMode(true);
using (var worker = new BackgroundWorker())
{
worker.DoWork += WorkerDoWorkCloneRecords;
worker.ProgressChanged += WorkerProgressChanged;
worker.RunWorkerCompleted += WorkerRunWorkerCompleted;
worker.WorkerReportsProgress = true;
worker.RunWorkerAsync(recordToProcess);
}
}
private void tsbPublishAll_Click(object sender, EventArgs e)
{
tsbPublishEntity.Enabled = false;
tsbPublishAll.Enabled = false;
tsbLoadEntities.Enabled = false;
Cursor = Cursors.WaitCursor;
informationPanel = InformationPanel.GetInformationPanel(this, "Publishing all customizations...", 340, 120);
var bwPublishAll = new BackgroundWorker();
bwPublishAll.DoWork += BwPublishAllDoWork;
bwPublishAll.RunWorkerCompleted += BwPublishAllRunWorkerCompleted;
bwPublishAll.RunWorkerAsync();
}
private void btnUpdate_Click(object sender, EventArgs e)
{
chart["name"] = txtName.Text;
chart["description"] = txtDescription.Text;
chart["datadescription"] = tecDataDescription.Text;
chart["presentationdescription"] = tecVisualizationDescription.Text;
infoPanel = InformationPanel.GetInformationPanel(this, "Updating chart...", 350, 150);
var worker = new BackgroundWorker {
WorkerReportsProgress = true
};
worker.DoWork += (w, evt) =>
{
service.Update((Entity)evt.Argument);
((BackgroundWorker)w).ReportProgress(0, "Publishing entity...");
service.Execute(new PublishXmlRequest
{
ParameterXml = $@"<importexportxml><entities><entity>{chart.GetAttributeValue<string>("primaryentitytypecode")
}</entity></entities><nodes/><securityroles/><settings/><workflows/></importexportxml>"
});
};
worker.ProgressChanged += (w, evt) =>
{
InformationPanel.ChangeInformationPanelMessage(infoPanel, evt.UserState.ToString());
};
worker.RunWorkerCompleted += (w, evt) =>
{
if (evt.Error != null)
{
MessageBox.Show(this, evt.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
HasUpdatedContent = true;
}
Controls.Remove(infoPanel);
infoPanel.Dispose();
};
worker.RunWorkerAsync(chart);
}
private void LoadEntities()
{
ManageWorkingState(false);
lvEntities.Items.Clear();
lvSourceViews.Items.Clear();
lvSourceViewLayoutPreview.Columns.Clear();
informationPanel = InformationPanel.GetInformationPanel(this, "Loading entities...", 340, 120);
var bwFillEntities = new BackgroundWorker();
bwFillEntities.DoWork += (sender, e) =>
{
_savedQueryMetadata = MetadataHelper.RetrieveEntity("savedquery", service);
entitiesCache = MetadataHelper.RetrieveEntities(service);
var list = new List <ListViewItem>();
foreach (EntityMetadata emd in entitiesCache)
{
var item = new ListViewItem {
Text = emd.DisplayName.UserLocalizedLabel.Label, Tag = emd
};
item.SubItems.Add(emd.LogicalName);
list.Add(item);
}
e.Result = list;
};
bwFillEntities.RunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
MessageBox.Show(ParentForm, e.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
lvEntities.Items.AddRange(((List <ListViewItem>)e.Result).ToArray());
}
Controls.Remove(informationPanel);
ManageWorkingState(false);
};
bwFillEntities.RunWorkerAsync();
}
private void tsbPublishEntity_Click(object sender, EventArgs e)
{
if (lvEntities.SelectedItems.Count > 0)
{
tsbPublishEntity.Enabled = false;
tsbPublishAll.Enabled = false;
tsbLoadEntities.Enabled = false;
CommonDelegates.SetCursor(this, Cursors.WaitCursor);
informationPanel = InformationPanel.GetInformationPanel(this, "Publishing entity...", 340, 120);
var bwPublish = new BackgroundWorker();
bwPublish.DoWork += BwPublishDoWork;
bwPublish.RunWorkerCompleted += BwPublishRunWorkerCompleted;
bwPublish.RunWorkerAsync(lvEntities.SelectedItems[0].Text);
}
}
private void cbbEntities_SelectedIndexChanged(object sender, EventArgs e)
{
var entityInfo = cbbEntities.SelectedItem;
if (entityInfo != null)
{
lvAttributes.Items.Clear();
infoPanel = InformationPanel.GetInformationPanel(ParentForm, "Loading attributes...", 340, 150);
var attrWorker = new BackgroundWorker();
attrWorker.DoWork += attrWorker_DoWork;
attrWorker.RunWorkerCompleted += attrWorker_RunWorkerCompleted;
attrWorker.RunWorkerAsync(entityInfo);
lvAttributes.Focus();
}
}
internal void ApplySelectedFiltersToUsers(bool applyToActiveUsers = false)
{
if (lvViews.SelectedItems.Count == 0)
{
return;
}
var templates = new EntityReferenceCollection();
foreach (ListViewItem item in lvViews.SelectedItems)
{
templates.Add(new EntityReference(entityName, ((Entity)item.Tag).Id));
}
List <Entity> users = null;
if (!applyToActiveUsers)
{
var usDialog = new UserSelectionDialog(service);
if (usDialog.ShowDialog(this) == DialogResult.OK)
{
users = usDialog.SelectedUsers;
}
else
{
return;
}
}
if (users == null || users.Count > 0)
{
loadingPanel = InformationPanel.GetInformationPanel(this, "Processing...", 340, 120);
var bwApplyFiltersToUsers = new BackgroundWorker {
WorkerReportsProgress = true
};
bwApplyFiltersToUsers.DoWork += bwApplyFiltersToUsers_DoWork;
bwApplyFiltersToUsers.ProgressChanged += bwApplyFiltersToUsers_ProgressChanged;
bwApplyFiltersToUsers.RunWorkerCompleted += bwApplyFiltersToUsers_RunWorkerCompleted;
bwApplyFiltersToUsers.RunWorkerAsync(new object[] { templates, users });
}
}
private void LoadEntities()
{
lvEntities.Items.Clear();
gbEntities.Enabled = false;
tsbPublishEntity.Enabled = false;
tsbPublishAll.Enabled = false;
lvSourceViews.Items.Clear();
lvSourceViewLayoutPreview.Columns.Clear();
CommonDelegates.SetCursor(this, Cursors.WaitCursor);
informationPanel = InformationPanel.GetInformationPanel(this, "Loading entities...", 340, 120);
var bwFillEntities = new BackgroundWorker();
bwFillEntities.DoWork += BwFillEntitiesDoWork;
bwFillEntities.RunWorkerCompleted += BwFillEntitiesRunWorkerCompleted;
bwFillEntities.RunWorkerAsync();
}
private void buttonDeleteEmailTemplate_Click(object sender, EventArgs e)
{
var confirmResult = MessageBox.Show("Are you sure to delete this emailTemplate ??",
"Confirm Delete!!",
MessageBoxButtons.YesNo);
if (confirmResult == DialogResult.Yes)
{
infoPanel = InformationPanel.GetInformationPanel(this, "Deleting emailTemplate...", 350, 150);
var worker = new BackgroundWorker {
WorkerReportsProgress = true
};
worker.DoWork += (w, evt) =>
{
service.Delete(((Entity)evt.Argument).LogicalName, ((Entity)evt.Argument).Id);
};
worker.ProgressChanged += (w, evt) =>
{
InformationPanel.ChangeInformationPanelMessage(infoPanel, evt.UserState.ToString());
};
worker.RunWorkerCompleted += (w, evt) =>
{
if (evt.Error != null)
{
MessageBox.Show(this, evt.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
HasUpdatedContent = true;
}
Controls.Remove(infoPanel);
infoPanel.Dispose();
this.Close();
};
worker.RunWorkerAsync(emailTemplate);
}
}
internal void DefineAsDefault()
{
var currentItem = GetSelectedSystemView().FirstOrDefault();
if (currentItem != null)
{
var associatedItems = (from ListViewItem lvi in lvViews.Items select(Entity) lvi.Tag).ToList().Where(e => e.GetAttributeValue <string>("returnedtypecode") == currentItem.GetAttributeValue <string>("returnedtypecode"));
if (!currentItem.GetAttributeValue <bool>("isdefault"))
{
loadingPanel = InformationPanel.GetInformationPanel(this, "Removing default status to previous default record", 340, 120);
var bwApplyDefault = new BackgroundWorker {
WorkerReportsProgress = true
};
bwApplyDefault.DoWork += bwApplyDefault_DoWork;
bwApplyDefault.ProgressChanged += bwApplyDefault_ProgressChanged;
bwApplyDefault.RunWorkerCompleted += bwApplyDefault_RunWorkerCompleted;
bwApplyDefault.RunWorkerAsync(new object[] { currentItem, associatedItems });
}
}
}
public void ApplyChanges()
{
settings.Actions = actions;
if (settings.Actions.Count == 0)
{
MessageBox.Show(this, "Please select at least one privilege", "Warning", MessageBoxButtons.OK,
MessageBoxIcon.Warning);
return;
}
infoPanel = InformationPanel.GetInformationPanel(this, "Updating roles...", 500, 120);
var worker = new BackgroundWorker();
worker.DoWork += WorkerDoWork;
worker.ProgressChanged += WorkerProgressChanged;
worker.RunWorkerCompleted += WorkerRunWorkerCompleted;
worker.WorkerReportsProgress = true;
worker.RunWorkerAsync();
}