private void UpdateFilter(string filterName,
dynamic newValue, ScheduleDefinition scheduleDefinition)
{
ScheduleFilter filter = null;
int index = 0;
for (int i = 0; i < scheduleDefinition.GetFilterCount(); ++i)
{
ScheduleFilter curFilter = scheduleDefinition.GetFilter(i);
ScheduleField field = scheduleDefinition.GetField(curFilter.FieldId);
if (field.GetName().Equals(filterName))
{
index = i;
filter = curFilter;
break;
}
}
if (newValue != null && filter != null && scheduleDefinition != null)
{
filter.SetValue(newValue);
scheduleDefinition.SetFilter(index, filter);
}
}
internal ScheduleFilter AppendFilter(ViewSchedule _viewSchedule, ScheduleField field, ScheduleFilterType filterType, object value)
{
ScheduleFilter _filter;
if (value is int _valueInt)
{
_filter = new ScheduleFilter(field.FieldId, filterType, _valueInt);
}
else if (value is double _valueDouble)
{
_filter = new ScheduleFilter(field.FieldId, filterType, _valueDouble);
}
else if (value is string _valueString)
{
_filter = new ScheduleFilter(field.FieldId, filterType, _valueString);
}
else if (value is ElementId _valueId)
{
_filter = new ScheduleFilter(field.FieldId, filterType, _valueId);
}
else if (value == null)
{
_filter = new ScheduleFilter(field.FieldId, filterType);
}
else
{
return(null);
}
_viewSchedule.Definition.AddFilter(_filter);
return(_filter);
}
/// <summary>
/// The business logic to process the API export
/// </summary>
/// <returns>An instance of ActivityApiResponse</returns>
public override async Task <ActivityApiResponse> Export()
{
var response = new ActivityApiResponse();
var cnxFilter = await Task.FromResult(_mapperService.GetQueryParams <CNX1Filter>());
if (!(cnxFilter.AgentIds.Any() && cnxFilter.StartDate <= cnxFilter.EndDate && cnxFilter.StartDate != DateTime.MinValue & cnxFilter.EndDate != DateTime.MinValue))
{
response.Message = Messages.InvalidQueryParamsCNX1;
return(response);
}
ScheduleFilter filter = new ScheduleFilter()
{
AgentIds = cnxFilter.AgentIds.Select(x => { return(x.Trim()); }).ToList(),
StartDate = cnxFilter.StartDate,
EndDate = cnxFilter.EndDate
};
var agents = await _agentRepository.GetAgents(filter.AgentIds);
List <AgentActivitySchedule> agentActivitySchedulesList = filter.AgentIds.Where(ag => !agents.Select(x => x.Ssn).Contains(ag))
.Select(x => new AgentActivitySchedule()
{
AgentId = x,
Message = Messages.AgentNotFound
})
.ToList();
filter.AgentIds.RemoveAll(x => agentActivitySchedulesList.Select(y => y.AgentId).Contains(x));
if (filter.AgentIds.Any())
{
List <CalendarChart> calenderCharts = await _scheduleService.GetCalendarChartsUsingIds(filter);
var schedules = _scheduleService.GenerateActivityAgentSchedules(calenderCharts);
var missingSchedules = filter.AgentIds
.Where(x => !schedules.Select(y => y.AgentId).Contains(x))
.Select(z => new AgentActivitySchedule
{
AgentId = z,
Message = string.Format(Messages.NoSchedulesPresent, filter.StartDate.ToString("yyyy-MM-dd"), filter.EndDate.ToString("yyyy-MM-dd"))
})
.ToList();
agentActivitySchedulesList.AddRange(schedules);
agentActivitySchedulesList.AddRange(missingSchedules);
}
response.Data = agentActivitySchedulesList.OrderBy(x => x.AgentId).ToList();
return(response);
}
public async Task <List <ScheduleViewModel> > GetSchedule([FromUri] ScheduleFilter param)
{
IList <string> list = new List <string> {
"id", "userId", "start", "end"
};
var para = APIProvider.APIDefaultParameter(list, 0, param.UserId, param.Start, param.End);
var source = await _scheduleRepo.Query(para);
var dest = Mapper.Map <List <ScheduleViewModel> >(source);
return(dest);
}
internal FieldFilter(ViewSchedule vs, string paramName)
{
ParameterName = paramName;
m_scheduleDef = vs.Definition;
for (int i = 0; i < m_scheduleDef.GetFilterCount(); ++i)
{
ScheduleFilter sFilter =
m_scheduleDef.GetFilter(i);
if (m_scheduleDef.GetField(sFilter.FieldId).GetName() == ParameterName)
{
Index = i;
Filter = sFilter;
}
}
}
/// <summary>
/// Get schedules filtered by the criteria specified in the passed in filter.
/// </summary>
/// <param name="filter">Limit the items returned. If null, then all items returned.</param>
/// <returns>ICollection of items as specified in the filter.</returns>
public ICollection <Schedule> Schedules(ScheduleFilter filter)
{
return(Get <Schedule>(filter ?? new ScheduleFilter()));
}
/// <summary>
/// Create a schedule for a given property set.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element being created.</param>
/// <param name="parameterGroupMap">The parameters of the element. Cached for performance.</param>
/// <param name="parametersCreated">The created parameters.</param>
protected void CreateScheduleForPropertySet(Document doc, Element element, IFCParameterSetByGroup parameterGroupMap, ISet <string> parametersCreated)
{
// Don't bother creating schedules if we are maximizing performance.
if (IFCImportFile.TheFile.Options.UseStreamlinedOptions)
{
return;
}
if (parametersCreated.Count == 0)
{
return;
}
Category category = element.Category;
if (category == null)
{
return;
}
ElementId categoryId = category.Id;
bool elementIsType = (element is ElementType);
Tuple <ElementId, bool, string> scheduleKey = new Tuple <ElementId, bool, string>(categoryId, elementIsType, Name);
ISet <string> viewScheduleNames = Importer.TheCache.ViewScheduleNames;
IDictionary <Tuple <ElementId, bool, string>, ElementId> viewSchedules = Importer.TheCache.ViewSchedules;
ElementId viewScheduleId;
if (!viewSchedules.TryGetValue(scheduleKey, out viewScheduleId))
{
string scheduleName = scheduleKey.Item3;
string scheduleTypeName = elementIsType ? " " + Resources.IFCTypeSchedule : string.Empty;
int index = 1;
while (viewScheduleNames.Contains(scheduleName))
{
string indexString = (index > 1) ? " " + index.ToString() : string.Empty;
scheduleName += " (" + category.Name + scheduleTypeName + indexString + ")";
index++;
if (index > 1000)
{
Importer.TheLog.LogWarning(Id, "Too many property sets with the name " + scheduleKey.Item3 +
", no longer creating schedules with that name.", true);
return;
}
}
// Not all categories allow creating schedules. Skip these.
ViewSchedule viewSchedule = null;
try
{
viewSchedule = ViewSchedule.CreateSchedule(doc, scheduleKey.Item1);
}
catch
{
// Only try to create the schedule once per key.
viewSchedules[scheduleKey] = ElementId.InvalidElementId;
return;
}
if (viewSchedule != null)
{
viewSchedule.Name = scheduleName;
viewSchedules[scheduleKey] = viewSchedule.Id;
viewScheduleNames.Add(scheduleName);
ElementId ifcGUIDId = new ElementId(elementIsType ? BuiltInParameter.IFC_TYPE_GUID : BuiltInParameter.IFC_GUID);
string propertySetListName = elementIsType ? Resources.IFCTypeSchedule + " IfcPropertySetList" : "IfcPropertySetList";
IList <SchedulableField> schedulableFields = viewSchedule.Definition.GetSchedulableFields();
bool filtered = false;
foreach (SchedulableField sf in schedulableFields)
{
string fieldName = sf.GetName(doc);
if (parametersCreated.Contains(fieldName) || sf.ParameterId == ifcGUIDId)
{
viewSchedule.Definition.AddField(sf);
}
else if (!filtered && fieldName == propertySetListName)
{
// We want to filter the schedule for specifically those elements that have this property set assigned.
ScheduleField scheduleField = viewSchedule.Definition.AddField(sf);
scheduleField.IsHidden = true;
ScheduleFilter filter = new ScheduleFilter(scheduleField.FieldId, ScheduleFilterType.Contains, "\"" + Name + "\"");
viewSchedule.Definition.AddFilter(filter);
filtered = true;
}
}
}
}
return;
}
/// <summary>
/// Create a schedule for a given property set.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element being created.</param>
/// <param name="parameterGroupMap">The parameters of the element. Cached for performance.</param>
/// <param name="parametersCreated">The created parameters.</param>
protected void CreateScheduleForPropertySet(Document doc, Element element, IFCParameterSetByGroup parameterGroupMap, ISet<string> parametersCreated)
{
if (parametersCreated.Count == 0)
return;
Category category = element.Category;
if (category == null)
return;
ElementId categoryId = category.Id;
KeyValuePair<ElementId, string> scheduleKey = new KeyValuePair<ElementId, string>(categoryId, Name);
ISet<string> viewScheduleNames = Importer.TheCache.ViewScheduleNames;
IDictionary<KeyValuePair<ElementId, string>, ElementId> viewSchedules = Importer.TheCache.ViewSchedules;
ElementId viewScheduleId;
if (!viewSchedules.TryGetValue(scheduleKey, out viewScheduleId))
{
// Not all categories allow creating schedules. Skip these.
ViewSchedule viewSchedule = null;
try
{
viewSchedule = ViewSchedule.CreateSchedule(doc, scheduleKey.Key);
}
catch
{
}
if (viewSchedule != null)
{
string scheduleName = scheduleKey.Value;
if (viewScheduleNames.Contains(scheduleName))
scheduleName += " (" + category.Name + ")";
viewSchedule.Name = scheduleName;
viewSchedules[scheduleKey] = viewSchedule.Id;
viewScheduleNames.Add(scheduleName);
bool elementIsType = (element is ElementType);
ElementId ifcGUIDId = new ElementId(elementIsType ? BuiltInParameter.IFC_TYPE_GUID : BuiltInParameter.IFC_GUID);
string propertySetListName = elementIsType ? "Type IfcPropertySetList" : "IfcPropertySetList";
IList<SchedulableField> schedulableFields = viewSchedule.Definition.GetSchedulableFields();
bool filtered = false;
foreach (SchedulableField sf in schedulableFields)
{
string fieldName = sf.GetName(doc);
if (parametersCreated.Contains(fieldName) || sf.ParameterId == ifcGUIDId)
{
viewSchedule.Definition.AddField(sf);
}
else if (!filtered && fieldName == propertySetListName)
{
// We want to filter the schedule for specifically those elements that have this property set assigned.
ScheduleField scheduleField = viewSchedule.Definition.AddField(sf);
scheduleField.IsHidden = true;
ScheduleFilter filter = new ScheduleFilter(scheduleField.FieldId, ScheduleFilterType.Contains, "\"" + Name + "\"");
viewSchedule.Definition.AddFilter(filter);
filtered = true;
}
}
}
}
return;
}
/// <summary>
/// Create a view schedule of wall category and add schedule field, filter and sorting/grouping field to it.
/// </summary>
/// <param name="uiDocument">UIdocument of revit file.</param>
/// <returns>ICollection of created view schedule(s).</returns>
private ICollection <ViewSchedule> CreateSchedules(UIDocument uiDocument)
{
Document document = uiDocument.Document;
Transaction t = new Transaction(document, "Create Schedules");
t.Start();
List <ViewSchedule> schedules = new List <ViewSchedule>();
//Create an empty view schedule of wall category.
ViewSchedule schedule = ViewSchedule.CreateSchedule(document, new ElementId(BuiltInCategory.OST_Walls), ElementId.InvalidElementId);
schedule.Name = "Wall Schedule 1";
schedules.Add(schedule);
//Iterate all the schedulable field gotten from the walls view schedule.
foreach (SchedulableField schedulableField in schedule.Definition.GetSchedulableFields())
{
//Judge if the FieldType is ScheduleFieldType.Instance.
if (schedulableField.FieldType == ScheduleFieldType.Instance)
{
//Get ParameterId of SchedulableField.
ElementId parameterId = schedulableField.ParameterId;
//If the ParameterId is id of BuiltInParameter.ALL_MODEL_MARK then ignore next operation.
if (ShouldSkip(parameterId))
{
continue;
}
//Add a new schedule field to the view schedule by using the SchedulableField as argument of AddField method of Autodesk.Revit.DB.ScheduleDefinition class.
ScheduleField field = schedule.Definition.AddField(schedulableField);
//Judge if the parameterId is a BuiltInParameter.
if (Enum.IsDefined(typeof(BuiltInParameter), parameterId.IntegerValue))
{
BuiltInParameter bip = (BuiltInParameter)parameterId.IntegerValue;
//Get the StorageType of BuiltInParameter.
StorageType st = document.get_TypeOfStorage(bip);
//if StorageType is String or ElementId, set GridColumnWidth of schedule field to three times of current GridColumnWidth.
//And set HorizontalAlignment property to left.
if (st == StorageType.String || st == StorageType.ElementId)
{
field.GridColumnWidth = 3 * field.GridColumnWidth;
field.HorizontalAlignment = ScheduleHorizontalAlignment.Left;
}
//For other StorageTypes, set HorizontalAlignment property to center.
else
{
field.HorizontalAlignment = ScheduleHorizontalAlignment.Center;
}
}
//Filter the view schedule by volume
if (field.ParameterId == new ElementId(BuiltInParameter.HOST_VOLUME_COMPUTED))
{
double volumeFilterInCubicFt = 0.8 * Math.Pow(3.2808399, 3.0);
ScheduleFilter filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.GreaterThan, volumeFilterInCubicFt);
schedule.Definition.AddFilter(filter);
}
//Group and sort the view schedule by type
if (field.ParameterId == new ElementId(BuiltInParameter.ELEM_TYPE_PARAM))
{
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
sortGroupField.ShowHeader = true;
schedule.Definition.AddSortGroupField(sortGroupField);
}
}
}
t.Commit();
uiDocument.ActiveView = schedule;
return(schedules);
}
private static void AddFilterToSchedule(ViewSchedule schedule, IEnumerable<Parameter> parameters, string filterValue, string paramName)
{
var definition = schedule.Definition;
var seriesField = FindField(schedule, parameters.FirstOrDefault(p => p.Definition.Name == paramName));
if (null == seriesField)
{
seriesField = definition.AddField(ScheduleFieldType.Instance, new ElementId(BuiltInParameter.ROOM_LEVEL_ID));
}
seriesField.IsHidden = true;
var filter = new ScheduleFilter(seriesField.FieldId, ScheduleFilterType.Equal, filterValue);
definition.AddFilter(filter);
}
//private UIDocument _uiDoc;
public Result CreateAllItemsSchedule(UIDocument uiDoc)
{
try
{
Document doc = uiDoc.Document;
FilteredElementCollector sharedParameters = new FilteredElementCollector(doc);
sharedParameters.OfClass(typeof(SharedParameterElement));
#region Debug
////Debug
//StringBuilder sbDev = new StringBuilder();
//var list = new ParameterDefinition().ElementParametersAll;
//int i = 0;
//foreach (SharedParameterElement sp in sharedParameters)
//{
// sbDev.Append(sp.GuidValue + "\n");
// sbDev.Append(list[i].Guid.ToString() + "\n");
// i++;
// if (i == list.Count) break;
//}
////sbDev.Append( + "\n");
//// Clear the output file
//File.WriteAllBytes(InputVars.OutputDirectoryFilePath + "\\Dev.pcf", new byte[0]);
//// Write to output file
//using (StreamWriter w = File.AppendText(InputVars.OutputDirectoryFilePath + "\\Dev.pcf"))
//{
// w.Write(sbDev);
// w.Close();
//}
#endregion
Transaction t = new Transaction(doc, "Create items schedules");
t.Start();
#region Schedule ALL elements
ViewSchedule schedAll = ViewSchedule.CreateSchedule(doc, ElementId.InvalidElementId,
ElementId.InvalidElementId);
schedAll.Name = "PCF - ALL Elements";
schedAll.Definition.IsItemized = false;
IList <SchedulableField> schFields = schedAll.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedAll.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedAll.Definition.AddSortGroupField(sortGroupField);
}
string curUsage = "U";
string curDomain = "ELEM";
var query = from p in new plst().LPAll where p.Usage == curUsage && p.Domain == curDomain select p;
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
ScheduleField field = schedAll.Definition.AddField(queryField);
if (pDef.Name != "PCF_ELEM_TYPE")
{
continue;
}
ScheduleFilter filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.HasParameter);
schedAll.Definition.AddFilter(filter);
}
#endregion
#region Schedule FILTERED elements
ViewSchedule schedFilter = ViewSchedule.CreateSchedule(doc, ElementId.InvalidElementId,
ElementId.InvalidElementId);
schedFilter.Name = "PCF - Filtered Elements";
schedFilter.Definition.IsItemized = false;
schFields = schedFilter.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedFilter.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedFilter.Definition.AddSortGroupField(sortGroupField);
}
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
ScheduleField field = schedFilter.Definition.AddField(queryField);
if (pDef.Name != "PCF_ELEM_TYPE")
{
continue;
}
ScheduleFilter filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.HasParameter);
schedFilter.Definition.AddFilter(filter);
filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.NotEqual, "");
schedFilter.Definition.AddFilter(filter);
}
#endregion
#region Schedule Pipelines
ViewSchedule schedPipeline = ViewSchedule.CreateSchedule(doc, new ElementId(BuiltInCategory.OST_PipingSystem), ElementId.InvalidElementId);
schedPipeline.Name = "PCF - Pipelines";
schedPipeline.Definition.IsItemized = false;
schFields = schedPipeline.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedPipeline.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedPipeline.Definition.AddSortGroupField(sortGroupField);
}
curDomain = "PIPL";
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
schedPipeline.Definition.AddField(queryField);
}
#endregion
t.Commit();
sharedParameters.Dispose();
return(Result.Succeeded);
}
catch (Exception e)
{
BuildingCoderUtilities.InfoMsg(e.Message);
return(Result.Failed);
}
}
/// <summary>
/// Create a schedule for a given property set.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element being created.</param>
/// <param name="parameterGroupMap">The parameters of the element. Cached for performance.</param>
/// <param name="parametersCreated">The created parameters.</param>
protected void CreateScheduleForPropertySet(Document doc, Element element, IFCParameterSetByGroup parameterGroupMap, ISet <string> parametersCreated)
{
if (parametersCreated.Count == 0)
{
return;
}
Category category = element.Category;
if (category == null)
{
return;
}
ElementId categoryId = category.Id;
KeyValuePair <ElementId, string> scheduleKey = new KeyValuePair <ElementId, string>(categoryId, Name);
ISet <string> viewScheduleNames = Importer.TheCache.ViewScheduleNames;
IDictionary <KeyValuePair <ElementId, string>, ElementId> viewSchedules = Importer.TheCache.ViewSchedules;
ElementId viewScheduleId;
if (!viewSchedules.TryGetValue(scheduleKey, out viewScheduleId))
{
// Not all categories allow creating schedules. Skip these.
ViewSchedule viewSchedule = null;
try
{
viewSchedule = ViewSchedule.CreateSchedule(doc, scheduleKey.Key);
}
catch
{
}
if (viewSchedule != null)
{
string scheduleName = scheduleKey.Value;
if (viewScheduleNames.Contains(scheduleName))
{
scheduleName += " (" + category.Name + ")";
}
viewSchedule.Name = scheduleName;
viewSchedules[scheduleKey] = viewSchedule.Id;
viewScheduleNames.Add(scheduleName);
bool elementIsType = (element is ElementType);
ElementId ifcGUIDId = new ElementId(elementIsType ? BuiltInParameter.IFC_TYPE_GUID : BuiltInParameter.IFC_GUID);
string propertySetListName = elementIsType ? "Type IfcPropertySetList" : "IfcPropertySetList";
IList <SchedulableField> schedulableFields = viewSchedule.Definition.GetSchedulableFields();
bool filtered = false;
foreach (SchedulableField sf in schedulableFields)
{
string fieldName = sf.GetName(doc);
if (parametersCreated.Contains(fieldName) || sf.ParameterId == ifcGUIDId)
{
viewSchedule.Definition.AddField(sf);
}
else if (!filtered && fieldName == propertySetListName)
{
// We want to filter the schedule for specifically those elements that have this property set assigned.
ScheduleField scheduleField = viewSchedule.Definition.AddField(sf);
scheduleField.IsHidden = true;
ScheduleFilter filter = new ScheduleFilter(scheduleField.FieldId, ScheduleFilterType.Contains, "\"" + Name + "\"");
viewSchedule.Definition.AddFilter(filter);
filtered = true;
}
}
}
}
return;
}
// Create a new schedule
public ViewSchedule CreateSchedule(string filePath, UIDocument uidoc)
{
ViewSchedule sched = null;
_doc = uidoc.Document;
if (uidoc.Document.IsWorkshared)
{
docPath = ModelPathUtils.ConvertModelPathToUserVisiblePath(uidoc.Document.GetWorksharingCentralModelPath());
}
else
{
docPath = uidoc.Document.PathName;
}
excelFilePath = filePath;
if (File.Exists(excelFilePath))
{
// read the Excel file and create the schedule
Excel.Application excelApp = new Excel.Application();
Excel.Workbook workbook = excelApp.Workbooks.Open(excelFilePath, ReadOnly: true);
Excel.Sheets worksheets = workbook.Worksheets;
List <WorksheetObject> worksheetObjs = new List <WorksheetObject>();
foreach (Excel.Worksheet ws in worksheets)
{
WorksheetObject wo = new WorksheetObject();
string name = ws.Name;
wo.Name = name;
Excel.Range range = ws.UsedRange;
try
{
range.CopyPicture(Excel.XlPictureAppearance.xlPrinter, Excel.XlCopyPictureFormat.xlBitmap);
if (Clipboard.GetDataObject() != null)
{
IDataObject data = Clipboard.GetDataObject();
if (data.GetDataPresent(DataFormats.Bitmap))
{
System.Drawing.Image img = (System.Drawing.Image)data.GetData(DataFormats.Bitmap, true);
wo.Image = img;
}
}
}
catch { }
worksheetObjs.Add(wo);
}
// Pop up the worksheet form
WorksheetSelectForm wsForm = new WorksheetSelectForm(worksheetObjs, this, _doc);
// Revit version
int version = Convert.ToInt32(uidoc.Application.Application.VersionNumber);
// Get the Revit window handle
IntPtr handle = IntPtr.Zero;
if (version < 2019)
{
handle = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
}
else
{
handle = uidoc.Application.GetType().GetProperty("MainWindowHandle") != null
? (IntPtr)uidoc.Application.GetType().GetProperty("MainWindowHandle").GetValue(uidoc.Application)
: IntPtr.Zero;
}
System.Windows.Interop.WindowInteropHelper wih = new System.Windows.Interop.WindowInteropHelper(wsForm)
{
Owner = handle
};
//Show the Worksheet Select form
wsForm.ShowDialog();
if (wsForm.DialogResult.HasValue && wsForm.DialogResult.Value)
{
foreach (Excel.Worksheet ws in worksheets)
{
if (ws.Name == selectedWorksheet.Name)
{
worksheet = ws;
break;
}
}
}
else
{
worksheet = null;
}
if (worksheet != null)
{
workSheetName = worksheet.Name;
Transaction trans = new Transaction(_doc, "Create Schedule");
trans.Start();
// Create the schedule
sched = ViewSchedule.CreateSchedule(_doc, new ElementId(-1));
sched.Name = worksheet.Name;
// Add a single parameter for data, Assembly Code
ElementId assemblyCodeId = new ElementId(BuiltInParameter.UNIFORMAT_DESCRIPTION);
ScheduleFieldId fieldId = null;
foreach (SchedulableField sField in sched.Definition.GetSchedulableFields())
{
ElementId paramId = sField.ParameterId;
if (paramId == assemblyCodeId)
{
ScheduleField field = sched.Definition.AddField(sField);
fieldId = field.FieldId;
break;
}
}
if (fieldId != null && sched.Definition.GetFieldCount() > 0)
{
ScheduleDefinition schedDef = sched.Definition;
// Add filters to hide all elements in the schedule, ie make sure nothing shows up in the body.
ScheduleFilter filter0 = new ScheduleFilter(fieldId, ScheduleFilterType.Equal, "NO VALUES FOUND");
ScheduleFilter filter1 = new ScheduleFilter(fieldId, ScheduleFilterType.Equal, "ALL VALUES FOUND");
schedDef.AddFilter(filter0);
schedDef.AddFilter(filter1);
// Turn off the headers
schedDef.ShowHeaders = false;
// Fill out the schedule from Excel data
AddScheduleData(filePath, sched, _doc, PathType.Absolute, false);
}
if (linkFile)
{
AssignSchemaData(sched.Id, workSheetName, _doc);
}
trans.Commit();
}
//workbook.Close();
workbook.Close(false);
Marshal.ReleaseComObject(worksheets);
if (worksheet != null)
{
Marshal.ReleaseComObject(worksheet);
}
Marshal.ReleaseComObject(workbook);
excelApp.Quit();
Marshal.ReleaseComObject(excelApp);
}
return(sched);
}
public ScheduleAdapter(Activity context, List<CalendarItem> items)
{
_context = context;
_items = items;
Filter = new ScheduleFilter (this);
}
/// <summary>
/// filter fields
/// </summary>
/// <param name="filters">applied filters array</param>
public void filterFields(List<ScheduleFilterDataHolder> filters)
{
if (Schedule != null)
{
int scheduleFieldsCount = Schedule.Definition.GetFieldCount();
for (int i = 0; i < scheduleFieldsCount; i++)
{
ScheduleField schedulableField = Schedule.Definition.GetField(i);
foreach (ScheduleFilterDataHolder filter in filters)
{
if (filter.fieldName.ToUpper() == schedulableField.GetName().ToUpper())
{
ScheduleFilter sFilter = new ScheduleFilter(schedulableField.FieldId, filter.filterType, filter.Value);
Schedule.Definition.AddFilter(sFilter);
break;
}
}
}
}
else
{
System.Windows.Forms.MessageBox.Show("please generate schedule first");
}
}
