static void Main(string[] args)
{
try
{
ConnectionHelper connectionHelper = new ConnectionHelper("D365TR_Sandbox");
var organizationService = connectionHelper.GetIOrganizationService();
if (organizationService != null)
{
OptionSetValueCollection multiselect = new OptionSetValueCollection();
multiselect.Add(new OptionSetValue(1));
multiselect.Add(new OptionSetValue(2));
multiselect.Add(new OptionSetValue(3));
Entity entity = new Entity("contact");
entity["d365tr_multiselect"] = multiselect;
}
}
catch (FaultException <OrganizationServiceFault> organizationFaultException)
{
/*
* INFO :
* Dynamics 365 SDK tarafından oluşan hataları FaultException<OrganizationServiceFault>
* yapısını kullanarak yakalabiliriz.
*
*/
}
catch (Exception ex)
{
}
Console.WriteLine(" ");
Console.WriteLine("Kapatmak için bir tuşa basınız");
Console.ReadLine();
}
public void OptionSetAndOtherValuesCanBeSerializedAndDeserialized()
{
Entity entity = new Entity("Test");
entity["optionsetvalue"] = new OptionSetValue(9);
entity["decimal"] = 10m;
entity["number"] = 2384;
#if !XRM_8 && !XRM_7 && !XRM_6 && !XRM_5
OptionSetValueCollection optionSetValue = new OptionSetValueCollection();
optionSetValue.Add(new OptionSetValue(10));
optionSetValue.Add(new OptionSetValue(20));
entity["multioptionset"] = optionSetValue;
#endif
JsonSerializer serializer = new EntitySerializer();
MemoryStream memoryStream = new MemoryStream(new byte[9000], true);
using (StreamWriter writer = new StreamWriter(memoryStream))
{
serializer.Serialize(new JsonTextWriter(writer), entity);
}
Entity deserializedEntity;
memoryStream = new MemoryStream(memoryStream.ToArray());
using (StreamReader reader = new StreamReader(memoryStream))
{
deserializedEntity = (Entity)serializer.Deserialize(new JsonTextReader(reader));
}
Assert.Equal(entity.Attributes.Count, deserializedEntity.Attributes.Count);
}
/// <summary>
/// Set multi-select picklist values
/// </summary>
/// <typeparam name="T">The type of the enum corresponding to the field</typeparam>
/// <param name="entity"></param>
/// <param name="fieldName"></param>
/// <param name="values">List of selected values</param>
public static void SetOptionSetValues <T>(this Entity entity, string fieldName, params T[] values)
{
OptionSetValueCollection optionSetValueCollection = null;
if (values != null)
{
optionSetValueCollection = new OptionSetValueCollection();
foreach (var value in values)
{
var intValue = (int)(object)value;
if (typeof(T).IsEnum)
{
if (value.ToString() != "Null" || intValue != 0)
{
optionSetValueCollection.Add(new OptionSetValue(intValue));
}
}
else
{
optionSetValueCollection.Add(new OptionSetValue(intValue));
}
}
}
entity[fieldName] = optionSetValueCollection;
}
private OptionSetValueCollection MergeOptionSetCollections(OptionSetValueCollection newValues, OptionSetValueCollection existingValues, ITracingService tracingService)
{
tracingService.Trace("Merging new and exiting multi-select optionset values");
if (existingValues == null && newValues == null)
{
return(new OptionSetValueCollection());
}
if (existingValues == null)
{
return(newValues);
}
if (newValues == null)
{
return(existingValues);
}
foreach (OptionSetValue newValue in newValues)
{
if (!existingValues.Contains(newValue))
{
existingValues.Add(newValue);
}
}
tracingService.Trace("New and exiting multi-select optionset values have been merged correctly. Total options: {0} ", existingValues.Count);
return(existingValues);
}
protected override void ExecuteWorkflowLogic()
{
if (string.IsNullOrEmpty(Values))
{
throw new InvalidPluginExecutionException("Values parameter is empty");
}
var intValues = ConvertStringToIntArray(Values);
var currentFieldValue = Record.GetAttributeValue <OptionSetValueCollection>(FieldName)?.ToList();
if (currentFieldValue == null)
{
currentFieldValue = new List <OptionSetValue>();
}
foreach (var intValue in intValues)
{
var existingOption = currentFieldValue.FirstOrDefault(o => o.Value == intValue);
if (existingOption != null)
{
continue;
}
currentFieldValue.Add(new OptionSetValue(intValue));
}
var record = Record;
record[FieldName] = new OptionSetValueCollection(currentFieldValue);
Context.UserService.Update(record);
}
private static bool AreEqual(OptionSetValueCollection a, OptionSetValueCollection b)
{
if (a == null && b == null)
{
return(true);
}
if (a == null || b == null)
{
return(false);
}
if (a.Count != b.Count)
{
return(false);
}
foreach (var aItem in a)
{
if (!b.Any(bItem => bItem.Value == aItem.Value))
{
return(false);
}
}
return(true);
}
public void OptionSetValueCollectionCanBeSerializedAndDeserialized()
{
OptionSetValueCollection optionSetValue = new OptionSetValueCollection();
optionSetValue.Add(new OptionSetValue(1));
optionSetValue.Add(new OptionSetValue(2));
JsonSerializer serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.All;
serializer.Converters.Add(new OptionSetValueCollectionConverter());
serializer.Converters.Add(new OptionSetValueConverter());
MemoryStream memoryStream = new MemoryStream(new byte[9000], true);
using (StreamWriter writer = new StreamWriter(memoryStream))
{
serializer.Serialize(new JsonTextWriter(writer), optionSetValue);
}
object deserializedOptionSetValueCollection;
memoryStream = new MemoryStream(memoryStream.ToArray());
using (StreamReader reader = new StreamReader(memoryStream))
{
deserializedOptionSetValueCollection = serializer.Deserialize(new JsonTextReader(reader), typeof(OptionSetValueCollection));
}
Assert.Equal(optionSetValue.GetType(), deserializedOptionSetValueCollection.GetType());
Assert.Equal(optionSetValue.Count, ((OptionSetValueCollection)deserializedOptionSetValueCollection).Count);
}
public OptionSetValueCollectionWrapper(OptionSetValueCollection optionSetValueCollection)
{
this.Value = new List <OptionSetValueWrapper>();
foreach (var osv in optionSetValueCollection)
{
this._value.Add(new OptionSetValueWrapper(osv));
}
}
/// <summary>
/// Checks if a multi-select picklist field contains specific values
/// </summary>
/// <param name="selected">The selected values</param>
/// <param name="values">The values to check for</param>
/// <returns><c>true</c> if the <paramref name="selected"/> values contain any of the requested <paramref name="values"/></returns>
public static bool Contains(OptionSetValueCollection selected, int[] values)
{
if (selected == null)
{
return(false);
}
return(selected.Any(osv => values.Contains(osv.Value)));
}
private Entity BuildTargetEntity(EntityReference sourceEntityReference, EntityReference targetEntityReference, string[] sourceAttributes, string[] targetAttributes, ITracingService tracingService, IOrganizationService organizationService, CodeActivityContext executionContext)
{
if (sourceEntityReference == null || targetEntityReference == null || sourceAttributes == null || targetAttributes == null)
{
return(null);
}
int numberSourceAttribute = sourceAttributes.Length;
int numberTargetAttribute = targetAttributes.Length;
if (numberSourceAttribute != numberTargetAttribute)
{
tracingService.Trace("Number of source attributes ({0}) doesn't match the number of target attributes ({1}).", numberSourceAttribute, numberTargetAttribute);
return(null);
}
Entity sourceEntity = organizationService.Retrieve(sourceEntityReference.LogicalName, sourceEntityReference.Id, new ColumnSet(sourceAttributes));
tracingService.Trace("Source record has been retrieved correctly. Id:{0}", sourceEntity.Id);
Entity targetEntity = new Entity(targetEntityReference.LogicalName, targetEntityReference.Id);
string targetAttribute = null;
int attributeMappedCounter = 0;
OptionSetValueCollection sourceNewValues = null;
OptionSetValueCollection targetExistingValues = null;
for (int i = 0; i < numberSourceAttribute; i++)
{
string sourceAttribute = sourceAttributes[i];
if (sourceEntity.Contains(sourceAttribute))
{
sourceNewValues = sourceEntity[sourceAttribute] as OptionSetValueCollection;
if (typeof(OptionSetValueCollection).Equals(sourceNewValues.GetType()))
{
targetAttribute = targetAttributes[i];
targetExistingValues = GetExistingAttributeValues(targetEntity.ToEntityReference(), targetAttribute, tracingService, organizationService, executionContext);
targetEntity.Attributes.Add(targetAttribute, MergeOptionSetCollections(sourceNewValues, targetExistingValues, tracingService));
attributeMappedCounter++;
}
else
{
tracingService.Trace("Attribute '{0}' is not an Option Set", sourceAttribute);
}
}
else
{
tracingService.Trace("Attribute '{0}' wasn't found in source record", sourceAttribute);
}
}
tracingService.Trace("Target entity record has been built correctly. '{0}' of '{1}' attributes were mapped. ", attributeMappedCounter, numberSourceAttribute);
return(targetEntity);
}
public void SetValue(object target, object value)
{
OptionSetValueCollection attributeCollection = (OptionSetValueCollection)target;
IEnumerable <OptionSetValue> values = (IEnumerable <OptionSetValue>)value;
foreach (var item in values)
{
attributeCollection.Add(item);
}
}
private OptionSetValueCollection GetOptionSetValueCol(string valores)
{
var col = new OptionSetValueCollection();
foreach (var val in valores.Split(';'))
{
col.Add(new OptionSetValue(int.Parse(val)));
}
return(col);
}
public void EntityCanBeSerializedAndDeserialized()
{
Entity entity = new Entity("entity");
entity.Id = Guid.NewGuid();
EntityReference entityReference = new EntityReference("entityReference", Guid.NewGuid());
entityReference.Name = "EntityReference";
entity.Attributes.Add("entityReference", entityReference);
entity.FormattedValues.Add("entityReference", entityReference.Name);
#if !XRM_7 && !XRM_6 && !XRM_5
entity.KeyAttributes.Add("hello", "world");
#if !XRM_8
OptionSetValueCollection optionSetValues = new OptionSetValueCollection();
optionSetValues.Add(new OptionSetValue(1));
optionSetValues.Add(new OptionSetValue(2));
entity.Attributes.Add("optionSetValues", optionSetValues);
#endif
#endif
Relationship relationship = new Relationship("relationship");
Entity relatedEntity = new Entity("entity");
relatedEntity.Id = Guid.NewGuid();
entity.RelatedEntities.Add(relationship, new EntityCollection(new List <Entity> {
relatedEntity
}));
JsonSerializer serializer = new EntitySerializer();
MemoryStream memoryStream = new MemoryStream(new byte[9000], true);
using (StreamWriter writer = new StreamWriter(memoryStream))
{
serializer.Serialize(new JsonTextWriter(writer), entity);
}
Entity deserializedEntity;
memoryStream = new MemoryStream(memoryStream.ToArray());
using (StreamReader reader = new StreamReader(memoryStream))
{
deserializedEntity = (Entity)serializer.Deserialize(new JsonTextReader(reader));
}
Assert.Equal(entity.LogicalName, deserializedEntity.LogicalName);
Assert.Equal(entity.Id, deserializedEntity.Id);
Assert.Equal(entity.Attributes.Count, deserializedEntity.Attributes.Count);
#if !XRM_7 && !XRM_6 && !XRM_5
Assert.Equal(entity.KeyAttributes.Count, deserializedEntity.KeyAttributes.Count);
#if !XRM_8
OptionSetValueCollection deserializedOptionSetValues = entity.GetAttributeValue <OptionSetValueCollection>("optionSetValues");
Assert.NotNull(deserializedOptionSetValues);
Assert.Equal(optionSetValues.Count, deserializedOptionSetValues.Count);
#endif
#endif
}
private string GetSelectedValues(EntityReference sourceEntityReference, string attributeName, ITracingService tracingService, IOrganizationService organizationService)
{
if (sourceEntityReference == null || attributeName == null)
{
tracingService.Trace("Null parameters have been passed, so string will be empty");
return(string.Empty);
}
Entity sourceEntity = organizationService.Retrieve(sourceEntityReference.LogicalName, sourceEntityReference.Id, new ColumnSet(attributeName));
tracingService.Trace("Source record has been retrieved correctly. Id:{0}", sourceEntity.Id);
if (!sourceEntity.Contains(attributeName))
{
tracingService.Trace("Attribues {0} was not found", attributeName);
return(string.Empty);
}
OptionSetValueCollection optionSetValues = sourceEntity[attributeName] as OptionSetValueCollection;
if (optionSetValues == null)
{
return(string.Empty);
}
int numberOptions = optionSetValues.Count;
if (numberOptions == 0)
{
tracingService.Trace("No selected options");
return(string.Empty);
}
tracingService.Trace("Number of selected options: ", numberOptions);
StringBuilder stringBuilder = new StringBuilder();
OptionSetValue value = null;
for (int i = 0; i < numberOptions; i++)
{
value = optionSetValues[i];
stringBuilder.Append(value.Value);
if ((i + 1) < numberOptions)
{
stringBuilder.Append(",");
}
}
string values = stringBuilder.ToString();
tracingService.Trace("Values have been retrieved correctly. Values: ", values);
return(values);
}
private string GetElemsOptionSetValueCol(OptionSetValueCollection col)
{
//Dada una colección de optionset para campos de optset multiple, devuelve su
//representacion en la forma: elem1;elem2;elem3 ... así luego comparamos la cadena del tirón
var cadena = "";
var elems = col.Select(e => e.Value).ToList();
elems.Sort();
elems.ForEach(e => cadena += e + ";");
cadena = cadena.Substring(0, cadena.Length - 1);
return(cadena);
}
protected override void Execute(CodeActivityContext executionContext)
{
Common objCommon = new Common(executionContext);
objCommon.tracingService.Trace("Load CRM Service from context --- OK");
EntityReference sourceEntityReference = GetTargeteEntityReference(executionContext, objCommon.tracingService, objCommon.service);
string attributeName = GetAttributeName(executionContext, objCommon.tracingService);
OptionSetValueCollection values = GetAttributeValues(executionContext, objCommon.tracingService);
UpdateRecord(sourceEntityReference, attributeName, values, objCommon.service, objCommon.tracingService);
}
/// <summary>
/// Temporary helper method while OptionSetValueCollection does not support System.Linq Select
/// </summary>
/// <param name="optionSetValueCollection">The option set collection</param>
/// <returns>The option set values</returns>
public static IEnumerable <int> GetValues(OptionSetValueCollection optionSetValueCollection)
{
List <int> values = new List <int>();
if (optionSetValueCollection != null)
{
foreach (OptionSetValue optionSetValue in optionSetValueCollection)
{
values.Add(optionSetValue.Value);
}
}
return(values);
}
public void CreateRecord(IOrganizationService crmService)
{
//create a record
Guid accountID = new Guid("E4163CB4-6869-E811-A957-000D3A******");
// set targeted entity
Entity allData = new Entity("sk_alldatatypes");
// field type as string
allData["sk_name"] = "Default Name";
// field type as lookup
allData["sk_account"] = new EntityReference("account", accountID);
// field type as single line of text
allData["sk_yourname"] = "Shaikh Sharef";
// field type as bool/ two optionset
allData["sk_gender"] = true;
// field type as date
allData["sk_dateofbirth"] = DateTime.Now; //DateTime.Parse(empDate);
// field type as multiselect optionsets
OptionSetValueCollection multiOptionSet = new OptionSetValueCollection();
multiOptionSet.Add(new OptionSetValue(2)); //C#
multiOptionSet.Add(new OptionSetValue(5)); //power bi
allData["sk_selectyourcourses"] = new OptionSetValueCollection(multiOptionSet);
// field type as optionset
allData["sk_selectcountry"] = new OptionSetValue(2);
// field type as number
allData["sk_mobilenum"] = "8149497990";
// field type as decimal
allData["sk_empsalary"] = new Money(Convert.ToDecimal(25000.00));
// field type as money/ integer
allData["sk_salary"] = 230;
// field type as float
allData["sk_percentage"] = 72.77;
// field type as multi select optionset
allData["sk_address"] = "Mahedipatnam, Hyderabad \n TS \n 50008 ";
// execute
Guid allDataCreate = crmService.Create(allData);
}
private void UpdateRecord(EntityReference targetEntityReference, string attributeName, OptionSetValueCollection values, IOrganizationService organizationService, ITracingService tracingService)
{
if (targetEntityReference == null || attributeName == null || values == null)
{
throw new ArgumentNullException(string.Format("Unexpected null parameters when trying to update record. Record reference '{0}' - attibute name '{1}' - values '{2}'", targetEntityReference, attributeName, values));
}
Entity targetEntity = new Entity(targetEntityReference.LogicalName, targetEntityReference.Id);
targetEntity[attributeName] = values;
organizationService.Update(targetEntity);
tracingService.Trace("Multi-select option set attribute '{0}' has been updated correctly for the record type '{1}' with id '{2}'", attributeName, targetEntityReference.LogicalName, targetEntityReference.Id);
}
protected override void ExecuteWorkflowLogic()
{
if (string.IsNullOrEmpty(Values))
{
throw new InvalidPluginExecutionException("Values parameter is empty");
}
var intValues = ConvertStringToIntArray(Values).Select(o => new OptionSetValue(o)).ToList();
var record = Record;
record[FieldName] = new OptionSetValueCollection(intValues);
Context.UserService.Update(record);
}
public void Execute(IServiceProvider serviceProvider)
{
ITracingService tracingService =
(ITracingService)serviceProvider.GetService(typeof(ITracingService));
IPluginExecutionContext context = (IPluginExecutionContext)
serviceProvider.GetService(typeof(IPluginExecutionContext));
tracingService.Trace("PreCreateAccountSetMultiSelectOptionSet before assinging values.");
if (context.InputParameters.Contains("Target") &&
context.InputParameters["Target"] is Entity)
{
Entity entity = (Entity)context.InputParameters["Target"];
if (entity.LogicalName != "account")
{
return;
}
OptionSetValueCollection OrganisationTypeValue;
OptionSetValueCollection Role;
if (entity.Contains("defra_cminterimorganisationtypevalue") &&
entity["defra_cminterimorganisationtypevalue"] != null && ((int)entity["defra_cminterimorganisationtypevalue"]) != 0)
{
//set organistaion type
OrganisationTypeValue = new OptionSetValueCollection();
OrganisationTypeValue.Add(new OptionSetValue((int)entity["defra_cminterimorganisationtypevalue"]));
entity["defra_type"] = OrganisationTypeValue;
}
if (entity.Contains("defra_cminterimorganisationrolevalue") &&
entity["defra_cminterimorganisationrolevalue"] != null && ((int)entity["defra_cminterimorganisationrolevalue"]) != 0)
{
Role = new OptionSetValueCollection();
Role.Add(new OptionSetValue((int)entity["defra_cminterimorganisationrolevalue"]));
entity["defra_roles"] = Role;
}
tracingService.Trace("PreCreateAccountSetMultiSelectOptionSet after assinging values.");
}
}
public void GetAttributeValueForCsvOptionSetValueCollection()
{
var list = new List <OptionSetValue>
{
new OptionSetValue(12),
new OptionSetValue(3)
};
var input = new OptionSetValueCollection(list);
var attribute = new CrmAttributeStore(new KeyValuePair <string, object>("firstname", input))
{
AttributeType = "Microsoft.Xrm.Sdk.OptionSetValueCollection"
};
var actual = EntityConverterHelper.GetAttributeValueForCsv(attribute);
actual.Should().Be("12|3");
}
protected override bool GetIsModified(OptionSetValueCollection newVal, OptionSetValueCollection oldVal)
{
if (newVal == null)
{
return(oldVal != null);
}
if (oldVal == null)
{
return(true);
}
var newIds = newVal.Select(r => r.Value).ToList();
var oldIds = oldVal.Select(r => r.Value).ToList();
var difference = newIds.Except(oldIds).Union(oldIds.Except(newIds));
return(difference.Any());
}
/// <summary>
/// Set multi-select picklist values
/// </summary>
/// <typeparam name="T">The type of the enum corresponding to the field</typeparam>
/// <param name="entity"></param>
/// <param name="fieldName"></param>
/// <param name="values">List of selected values</param>
public static void SetOptionSetValues <T>(this Entity entity, string fieldName, params T[] values) where T : Enum
{
OptionSetValueCollection optionSetValueCollection = null;
if (values != null && values.Any())
{
optionSetValueCollection = new OptionSetValueCollection();
foreach (var value in values)
{
var intValue = value.ToInt();
if (value.ToString() != "Null" || intValue != 0)
{
optionSetValueCollection.Add(new OptionSetValue(intValue));
}
}
}
entity[fieldName] = optionSetValueCollection;
}
//private OptionSetValueCollection GetAttributeValues(CodeActivityContext executionContext, ITracingService tracingService)
private OptionSetValueCollection GetNewAttributeValues(CodeActivityContext executionContext, ITracingService tracingService)
{
string attributeValues = AttributeValues.Get <string>(executionContext) ?? throw new ArgumentNullException("Attribute Values is empty");
tracingService.Trace("Attribute Values:'{0}'", attributeValues);
if (string.IsNullOrEmpty(attributeValues))
{
tracingService.Trace("No values found. Setting attribute to null");
return(new OptionSetValueCollection());
}
string[] values = attributeValues.Split(',');
if (values == null || values.Length == 0)
{
tracingService.Trace("No values found in array. Setting attribute to null");
return(new OptionSetValueCollection());
}
OptionSetValueCollection optionSetValueCollection = new OptionSetValueCollection();
int intValue;
foreach (string value in values)
{
if (int.TryParse(value, out intValue))
{
tracingService.Trace("Value '{0}' added correctly", value);
optionSetValueCollection.Add(new OptionSetValue(intValue));
}
else
{
tracingService.Trace("Value '{0}' couldn't be parsed", value);
}
}
return(optionSetValueCollection);
}
public void When_updating_an_optionsetvaluecollection_the_context_should_reflect_changes()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var e = new Entity("contact")
{
Id = Guid.Empty
};
e["new_multiselectattribute"] = new OptionSetValueCollection()
{
new OptionSetValue(1)
};
var guid = service.Create(e);
Assert.Equal(context.Data["contact"][guid]["new_multiselectattribute"], new OptionSetValueCollection()
{
new OptionSetValue(1)
});
//now update the name
e = new Entity("contact")
{
Id = guid
};
e["new_multiselectattribute"] = new OptionSetValueCollection()
{
new OptionSetValue(2), new OptionSetValue(3)
};
service.Update(e);
Assert.Equal(context.Data["contact"][guid]["new_multiselectattribute"], new OptionSetValueCollection()
{
new OptionSetValue(2), new OptionSetValue(3)
});
}
//Requirement Changed. UpdateServiceDetail converted to CreateServiceDetail
public void UpdateServiceDetail(ServiceDetails paramservicedetails, ServiceDetailsSelection paramcheckboxes, string Id, string ContactId)
{
Guid UserId = ValidateUser();
if (UserId != null)
{
Entity enMSR = new Entity("campaign");
enMSR.Id = new Guid(Id);
enMSR["imc_projecttitle"] = paramservicedetails.Title;
enMSR["imc_businessobjective"] = paramservicedetails.BusinessObjective;
enMSR["imc_desiredlaunchdate"] = paramservicedetails.DesiredLaunchDate;
enMSR["imc_requestedby"] = new EntityReference("contact", new Guid(ContactId));
OptionSetValueCollection targetaudiences = new OptionSetValueCollection();
if (paramcheckboxes.Public)
{
targetaudiences.Add(new OptionSetValue(100000000));
}
if (paramcheckboxes.IMCPatients)
{
targetaudiences.Add(new OptionSetValue(100000001));
}
if (paramcheckboxes.IMCEmployees)
{
targetaudiences.Add(new OptionSetValue(100000002));
}
if (paramcheckboxes.Other)
{
targetaudiences.Add(new OptionSetValue(100000002));
}
enMSR["imc_targetaudiences"] = targetaudiences;
if (paramcheckboxes.Sponsor)
{
enMSR["imc_costcenterbudgetapproval"] = new OptionSetValue(100000000);
}
if (paramcheckboxes.ApprovedBudget)
{
enMSR["imc_costcenterbudgetapproval"] = new OptionSetValue(100000001);
}
byte[] bytes;
if (paramcheckboxes.Sponsor && paramservicedetails.Sponsors != null)
{
using (BinaryReader br = new BinaryReader(paramservicedetails.Sponsors.InputStream))
{
bytes = br.ReadBytes(paramservicedetails.Sponsors.ContentLength);
}
CreateNotes("Sponsors", paramservicedetails.Sponsors.FileName, bytes, Id.ToString());
}
if (paramcheckboxes.ApprovedBudget && paramservicedetails.ApprovedBudgetFromManagement != null)
{
using (BinaryReader br = new BinaryReader(paramservicedetails.ApprovedBudgetFromManagement.InputStream))
{
bytes = br.ReadBytes(paramservicedetails.ApprovedBudgetFromManagement.ContentLength);
}
CreateNotes("Approved Budget From Management", paramservicedetails.ApprovedBudgetFromManagement.FileName, bytes, Id.ToString());
}
service.Update(enMSR);
}
}
public void Events(ServiceEvents paramServiceEvents, string Id, HttpPostedFileBase Events_inputfile)
{
Guid UserId = ValidateUser();
if (UserId != null)
{
byte[] bytes;
string strLocation = "";
Entity enMSR = new Entity("campaign");
enMSR.Id = new Guid(Id);
OptionSetValueCollection locations = new OptionSetValueCollection();
if (paramServiceEvents.IMCAuditorium)
{
locations.Add(new OptionSetValue(100000000));
}
if (paramServiceEvents.IMCMainlobby)
{
locations.Add(new OptionSetValue(100000001));
}
enMSR["imc_locations"] = locations;
enMSR["imc_duration"] = Convert.ToInt32(paramServiceEvents.duration);
enMSR["imc_expectednumberofparticipants"] = Convert.ToInt32(paramServiceEvents.Expectedparticipant);
OptionSetValueCollection eventselements = new OptionSetValueCollection();
if (paramServiceEvents.AudiovisualSystem)
{
eventselements.Add(new OptionSetValue(1));
}
if (paramServiceEvents.Stage)
{
eventselements.Add(new OptionSetValue(2));
}
if (paramServiceEvents.PopupBanners)
{
eventselements.Add(new OptionSetValue(3));
}
if (paramServiceEvents.Flowers)
{
eventselements.Add(new OptionSetValue(4));
}
if (paramServiceEvents.Water)
{
eventselements.Add(new OptionSetValue(5));
}
if (paramServiceEvents.Printed)
{
eventselements.Add(new OptionSetValue(6));
}
if (paramServiceEvents.Lighting)
{
eventselements.Add(new OptionSetValue(7));
}
if (paramServiceEvents.Giveaways)
{
eventselements.Add(new OptionSetValue(8));
}
if (paramServiceEvents.VIPgifts)
{
eventselements.Add(new OptionSetValue(9));
}
if (paramServiceEvents.VIPgifts)
{
eventselements.Add(new OptionSetValue(10));
}
if (paramServiceEvents.VIPLunch)
{
eventselements.Add(new OptionSetValue(11));
}
if (paramServiceEvents.PhotoBooth)
{
eventselements.Add(new OptionSetValue(12));
}
if (paramServiceEvents.SMSInvitation)
{
eventselements.Add(new OptionSetValue(13));
}
if (paramServiceEvents.EmployeesInvitationEmails)
{
eventselements.Add(new OptionSetValue(14));
}
if (paramServiceEvents.Fulleventcoverage)
{
eventselements.Add(new OptionSetValue(15));
}
if (paramServiceEvents.ActivityItems)
{
eventselements.Add(new OptionSetValue(16));
}
if (paramServiceEvents.SocialMedia)
{
eventselements.Add(new OptionSetValue(17));
}
if (paramServiceEvents.SocialMediaconverge)
{
eventselements.Add(new OptionSetValue(18));
}
if (paramServiceEvents.IMCWebsiteBanner)
{
eventselements.Add(new OptionSetValue(19));
}
if (paramServiceEvents.IMCWebsiteAnnouncement)
{
eventselements.Add(new OptionSetValue(20));
}
enMSR["imc_eventelements"] = eventselements;
service.Update(enMSR);
if (Events_inputfile != null)
{
using (BinaryReader br = new BinaryReader(Events_inputfile.InputStream))
{
bytes = br.ReadBytes(Events_inputfile.ContentLength);
}
CreateNotes(strLocation, Events_inputfile.FileName, bytes, Id);
}
}
}
public void Designs(ServiceDesigns paramServiceDesigns, string Id, HttpPostedFileBase Design_inputfile)
{
Guid UserId = ValidateUser();
if (UserId != null)
{
byte[] bytes;
string strDesigntype = "";
Entity enMSR = new Entity("campaign");
enMSR.Id = new Guid(Id);
OptionSetValueCollection typeofdesigns = new OptionSetValueCollection();
//if (paramcheckboxes.Public)
// targetaudiences.Add(new OptionSetValue(100000000));
if (paramServiceDesigns.Booklet)
{
typeofdesigns.Add(new OptionSetValue(100000000));
}
if (paramServiceDesigns.Flyer)
{
typeofdesigns.Add(new OptionSetValue(100000001));
}
if (paramServiceDesigns.Brochure)
{
typeofdesigns.Add(new OptionSetValue(100000002));
}
if (paramServiceDesigns.InvitationCard)
{
typeofdesigns.Add(new OptionSetValue(100000003));
}
if (paramServiceDesigns.PopupBanner)
{
typeofdesigns.Add(new OptionSetValue(100000004));
}
if (paramServiceDesigns.Poster)
{
typeofdesigns.Add(new OptionSetValue(100000005));
}
enMSR["imc_typeofdesigns"] = typeofdesigns;
service.Update(enMSR);
if (paramServiceDesigns.BookletFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.BookletFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.BookletFile.ContentLength);
}
CreateNotes("Booklet", paramServiceDesigns.BookletFile.FileName, bytes, Id);
}
if (paramServiceDesigns.FlyerFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.FlyerFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.FlyerFile.ContentLength);
}
CreateNotes("Flyer", paramServiceDesigns.FlyerFile.FileName, bytes, Id);
}
if (paramServiceDesigns.BrochureFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.BrochureFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.BrochureFile.ContentLength);
}
CreateNotes("Brochure", paramServiceDesigns.BrochureFile.FileName, bytes, Id);
}
if (paramServiceDesigns.InvitationCardFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.InvitationCardFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.InvitationCardFile.ContentLength);
}
CreateNotes("InvitationCard", paramServiceDesigns.InvitationCardFile.FileName, bytes, Id);
}
if (paramServiceDesigns.PopupBannerFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.PopupBannerFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.PopupBannerFile.ContentLength);
}
CreateNotes("PopupBanner", paramServiceDesigns.PopupBannerFile.FileName, bytes, Id);
}
if (paramServiceDesigns.PosterFile != null)
{
using (BinaryReader br = new BinaryReader(paramServiceDesigns.PosterFile.InputStream))
{
bytes = br.ReadBytes(paramServiceDesigns.PosterFile.ContentLength);
}
CreateNotes("Poster", paramServiceDesigns.PosterFile.FileName, bytes, Id);
}
}
}
public UserControl CreateControlForAttribute(
IWriteToOutput iWriteToOutput
, IOrganizationServiceExtented service
, EntityMetadata entityMetadata
, AttributeMetadata attributeMetadata
, Entity entity
, object value
, bool allwaysAddToEntity
, bool showRestoreButton
)
{
if (attributeMetadata is MemoAttributeMetadata memoAttrib)
{
string initialValue = null;
if (value != null && value is string)
{
initialValue = (string)value;
}
return(new MemoAttributeMetadataControl(memoAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is StringAttributeMetadata stringAttrib)
{
string initialValue = null;
if (value != null && value is string)
{
initialValue = (string)value;
}
return(new StringAttributeMetadataControl(stringAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is IntegerAttributeMetadata intAttrib)
{
int?initialValue = null;
if (value != null && value is int)
{
initialValue = (int)value;
}
return(new IntegerAttributeMetadataControl(intAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is BigIntAttributeMetadata bigIntAttrib)
{
long?initialValue = null;
if (value != null && value is long)
{
initialValue = (long)value;
}
return(new BigIntAttributeMetadataControl(bigIntAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is DecimalAttributeMetadata decimalAttrib)
{
decimal?initialValue = null;
if (value != null && value is decimal)
{
initialValue = (decimal)value;
}
return(new DecimalAttributeMetadataControl(decimalAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is DoubleAttributeMetadata doubleAttrib)
{
double?initialValue = null;
if (value != null && value is double)
{
initialValue = (double)value;
}
return(new DoubleAttributeMetadataControl(doubleAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is MoneyAttributeMetadata moneyAttrib)
{
Money initialValue = null;
if (value != null && value is Money)
{
initialValue = (Money)value;
}
return(new MoneyAttributeMetadataControl(moneyAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is DateTimeAttributeMetadata dateTimeAttrib)
{
DateTime?initialValue = null;
if (value != null && value is DateTime)
{
initialValue = (DateTime)value;
}
return(new DateTimeAttributeMetadataControl(dateTimeAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is BooleanAttributeMetadata boolAttrib)
{
bool?initialValue = null;
if (value != null && value is bool boolValue)
{
initialValue = boolValue;
}
return(new BooleanAttributeMetadataControl(boolAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is ManagedPropertyAttributeMetadata managedPropertyAttributeMetadata)
{
if (managedPropertyAttributeMetadata.ValueAttributeTypeCode == AttributeTypeCode.Boolean)
{
BooleanManagedProperty initialValue = null;
if (value != null && value is BooleanManagedProperty booleanManagedProperty)
{
initialValue = booleanManagedProperty;
}
return(new BooleanManagedPropertyAttributeMetadataControl(managedPropertyAttributeMetadata, initialValue, allwaysAddToEntity, showRestoreButton));
}
}
if (attributeMetadata is PicklistAttributeMetadata picklistAttrib)
{
int?initialValue = null;
if (value != null && value is OptionSetValue optionSetValue)
{
initialValue = optionSetValue.Value;
}
string initialFormatedValue = string.Empty;
if (entity != null &&
entity.FormattedValues != null &&
entity.FormattedValues.ContainsKey(picklistAttrib.LogicalName) &&
!string.IsNullOrEmpty(entity.FormattedValues[picklistAttrib.LogicalName])
)
{
initialFormatedValue = entity.FormattedValues[picklistAttrib.LogicalName];
}
return(new PicklistAttributeMetadataControl(picklistAttrib, initialValue, initialFormatedValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is MultiSelectPicklistAttributeMetadata multiSelectPicklistAttributeMetadata)
{
OptionSetValueCollection initialValue = null;
if (value != null && value is OptionSetValueCollection optionSetValueCollection)
{
initialValue = optionSetValueCollection;
}
return(new MultiSelectPicklistAttributeMetadataControl(multiSelectPicklistAttributeMetadata, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is StatusAttributeMetadata statusAttrib)
{
var stateAttrib = entityMetadata.Attributes.OfType <StateAttributeMetadata>().FirstOrDefault();
if (stateAttrib != null)
{
int?initialValueStatus = null;
int?initialValueState = null;
if (value != null && value is OptionSetValue optionSetValueStatus)
{
initialValueStatus = optionSetValueStatus.Value;
}
string statusFormatedValue = string.Empty;
if (entity != null)
{
if (entity.Attributes.ContainsKey(stateAttrib.LogicalName) &&
entity.Attributes[stateAttrib.LogicalName] != null &&
entity.Attributes[stateAttrib.LogicalName] is OptionSetValue optionSetValueState
)
{
initialValueState = optionSetValueState.Value;
}
if (entity.FormattedValues != null &&
entity.FormattedValues.ContainsKey(statusAttrib.LogicalName) &&
!string.IsNullOrEmpty(entity.FormattedValues[statusAttrib.LogicalName])
)
{
statusFormatedValue = entity.FormattedValues[statusAttrib.LogicalName];
}
}
return(new StatusAttributeMetadataControl(statusAttrib, stateAttrib, initialValueStatus, initialValueState, statusFormatedValue, allwaysAddToEntity, showRestoreButton));
}
}
if (attributeMetadata is LookupAttributeMetadata lookupAttrib)
{
EntityReference initialValue = null;
if (value != null && value is EntityReference)
{
initialValue = (EntityReference)value;
}
return(new LookupAttributeMetadataControl(iWriteToOutput, service, lookupAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is EntityNameAttributeMetadata entityNameAttrib)
{
string initialValue = null;
if (value != null && value is string entityName)
{
initialValue = entityName;
}
return(new EntityNameAttributeMetadataControl(service.ConnectionData, entityNameAttrib, initialValue, allwaysAddToEntity, showRestoreButton));
}
if (attributeMetadata is UniqueIdentifierAttributeMetadata uniqueAttrib ||
attributeMetadata.AttributeType == AttributeTypeCode.Uniqueidentifier
)
{
Guid?initialValue = null;
if (value != null && value is Guid valueGuid)
{
initialValue = valueGuid;
}
return(new UniqueIdentifierAttributeMetadataControl(attributeMetadata, initialValue, allwaysAddToEntity, showRestoreButton));
}
return(null);
}
