public EntityCollection<CatalogsEntity> GetAllParent(SortExpression sort)
{
EntityCollection<CatalogsEntity> cats = new EntityCollection<CatalogsEntity>();
SortExpression _sort = new SortExpression();
if (sort != null)
{
_sort = sort;
}
else
{
_sort.Add(CatalogsFields.CatalogName | SortOperator.Ascending);
}
IPredicateExpression predicate = new PredicateExpression();
predicate.Add(CatalogsFields.ParentId == 0);
predicate.AddWithAnd(CatalogsFields.IsVisible == true);
RelationPredicateBucket filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(predicate);
using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
{
adapter.FetchEntityCollection(cats, filter, 0, _sort);
}
return cats;
}
public JArray getValuesFromLists(EntityCollection lists, bool translate, bool allAttributes)
{
var jsonLists = new JArray();
foreach (var list in lists.Entities)
{
var jsonList = new JObject();
foreach (var prop in list.GetType().GetProperties())
{
if (prop.Name != "Item")
{
var val = prop.GetValue(list, null);
if (allAttributes | val != null)
jsonList[prop.Name] = val == null ? null : val.ToString();
}
}
jsonLists.Add(jsonList);
}
if (translate)
{
jsonLists = translateToDisplayName(jsonLists, "list");
}
return jsonLists;
}
internal void InitPos(EntityCollection collection)
{
sw.WriteLine("Init position");
saveCollection(collection);
sw.WriteLine("End init position");
sw.Flush();
}
public ExpressionContext(ISession session, EntityCollection entityCollection, string scopeQualifier, string dynamicPropertiesContainerName)
{
this.Session = session;
this.EntityCollection = entityCollection;
this.ScopeQualifier = scopeQualifier;
this.DynamicPropertiesContainerName = dynamicPropertiesContainerName;
}
public static EntityCollection GetCollection()
{
EntityCollection tempList = null;
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
using (SqlCommand myCommand = new SqlCommand("usp_GetEntity", myConnection))
{
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@QueryId", SelectTypeEnum.GetCollection);
myConnection.Open();
using (SqlDataReader myReader = myCommand.ExecuteReader())
{
if (myReader.HasRows)
{
tempList = new EntityCollection();
while (myReader.Read())
{
tempList.Add(FillDataRecord(myReader));
}
}
myReader.Close();
}
}
}
return tempList;
}
public static EntityCollection LoadFromDatabase(string connectionString)
{
var entities = new EntityCollection();
var schemaInfo = DatabaseSchemaInfo.LoadFromDatabase(connectionString);
foreach (var table in schemaInfo.Tables)
{
var entity = new Entity
{
Name = table.Name,
Schema = table.Schema,
Database = table.Database
};
entities.Add(entity);
foreach (var column in table.Columns)
{
var member = new EntityMember
{
Name = column.Name,
DataType = DataTypeInfo.FromSqlDataTypeName(column.DataType, column.IsNullable),
MaxLength = column.MaxLength,
DecimalPlaces = column.DecimalPlaces,
IsNullable = column.IsNullable,
IsPrimaryKey = column.IsPrimaryKey,
IsIdentity = column.IsIdentity,
IsComputed = column.IsComputed,
OrdinalPosition = column.OrdinalPosition
};
entity.Members.Add(member);
}
}
return entities;
}
public List<decimal> GetjournalSum(int periodId, int typeid, int entityid)
{
using (RecordAccessClient _Client = new RecordAccessClient(EndpointName.RecordAccess))
{
if (typeid.Equals(2))
{
// Entity _entity =
EntityAccessClient _enClient = new EntityAccessClient(EndpointName.EntityAccess);
EntityCollection _accountcollection = new EntityCollection(_enClient.QueryAllSubEntity(entityid));
List<decimal> _allandsub = new List<decimal>();
decimal _base = 0;
decimal _sgd = 0;
_accountcollection.Add(_enClient.Query2(entityid)[0]);
foreach (Entity _entity in _accountcollection)
{
if (_Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList().Count > 0)
{
_base += _Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList()[0];
_sgd += _Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList()[1];
}
}
_allandsub.Add(_base);
_allandsub.Add(_sgd);
return _allandsub.ToList();
}
else
{
return _Client.GetjournalSum(periodId, typeid, entityid).ToList();
}
}
}
public Guid Create( Entity entity )
{
// TODO: can the ID be assigned manually? I can't remember
Guid id = Guid.NewGuid();
entity.Id = id;
string name = entity.GetType().Name;
if( data.ContainsKey( name ) == false ) {
data.Add( name, new EntityCollection() );
}
if( name == "Entity" ) {
Entity de = ( Entity )entity;
// We set name here to support DynamicEntity
name = de.LogicalName;
de[name + "id"] = id;
}
else {
entity.GetType().GetProperty( name + "id" ).SetValue( entity, id, null );
}
if( !data.ContainsKey( name ) ) {
data[ name ] = new EntityCollection();
}
data[ name ].Entities.Add( entity );
if( m_persist ) {
PersistToDisk( m_filename );
}
return id;
}
public override void Reset()
{
this.Trucks = new EntityCollection<TruckType>();
this.VehicleGPSSet = new EntityCollection<VehicleGPSType>();
this.DerivedVehicleGPSSet = new EntityCollection<DerivedVehicleGPSType>();
this.VehicleGPSSetInGPS = new EntityCollection<VehicleGPSType>();
}
/// <summary>
/// Получаем набор неуправляемых решений для организации
/// </summary>
/// <param name="service">сервис</param>
/// <returns></returns>
public static EntityCollection GetSolutions(IOrganizationService service)
{
var solutions = new EntityCollection();
QueryExpression q = new QueryExpression("solution");
//Берем только неуправляемые решения
q.Criteria.AddCondition(new ConditionExpression("ismanaged", ConditionOperator.Equal, false));
//не берем специальные CRMные солюшены
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Active Solution"));
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Default Solution"));
q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Basic Solution"));
q.Orders.Add(new OrderExpression("createdon", OrderType.Descending));
q.ColumnSet = new ColumnSet("friendlyname", "uniquename", "version", "installedon");
q.PageInfo = new PagingInfo()
{
Count = 200,
PageNumber = 1
};
EntityCollection ec;
do
{
ec = service.RetrieveMultiple(q);
solutions.Entities.AddRange(ec.Entities);
q.PageInfo.PageNumber++;
q.PageInfo.PagingCookie = ec.PagingCookie;
} while (ec.MoreRecords);
return solutions;
}
public Int64? InsertArea1(ForestArea forestArea, CadastralPoint[] cadastralPoints)
{
using (var db = new DefaultCS())
{
try
{
if (cadastralPoints != null)
{
EntityCollection<CadastralPoint> cp = new EntityCollection<CadastralPoint>();
foreach (var cpp in cadastralPoints)
{
cp.Add(cpp);
}
forestArea.CadastralPoints1 = cp;
}
forestArea.CreatedDate = DateTime.Now;
db.ForestAreas.AddObject(forestArea);
db.SaveChanges();
return forestArea.Id;
}
catch (Exception ex)
{
return null;
}
}
}
public ActionsQueue(EntityCollection gameCollection, GameField field)
{
_field = field;
_queue = new List<Action>();
_size = _queue.Count;
_gameCollection = gameCollection;
}
private static void Go(long userId)
{
var settings = new MongoServerSettings
{
Server = new MongoServerAddress("127.0.0.1", 27017),
SafeMode = SafeMode.False
};
var mongoServer = new MongoServer(settings);
var database = mongoServer.GetDatabase("Test");
var map = new NoteMap();
var collection = new EntityCollection<Note>(database, map.GetDescriptor(), true);
var note = new Note
{
NoteID = "1",
Title = "This is a book.",
Content = "Oh yeah",
UserID = 123321L
};
// collection.InsertOnSubmit(note);
// collection.SubmitChanges();
// var data = collection.SelectTo(n => new { n.NoteID, n.UserID });
collection.Log = Console.Out;
var a = 4;
collection.Update(
n => new Note { },
n => true);
}
internal static IQueryable<BL.DomainModel.Supplier> AdaptSupplier(EntityCollection<Supplier> supplierCollection)
{
if (supplierCollection.IsLoaded == false) return null;
var suppliers = from s in supplierCollection.AsEnumerable()
select AdaptSupplier(s);
return suppliers.AsQueryable();
}
public Boom(Cell cell, GameTime gameTime, EntityCollection parent)
{
Texture = LogicService.boom;
this.Cell = cell;
startedTime = gameTime.Total.TotalSeconds;
this.parent = parent;
Order = 6;
}
public Person()
{
Trips = new EntityCollection<Trip>();
friends = new EntityCollection<Person>((DataSourceManager.GetCurrentDataSource<TripPinServiceDataSource>()).People);
Emails = new Collection<string>();
AddressInfo = new Collection<Location>();
this.Concurrency = DateTime.UtcNow.Ticks;
}
public void Execute(EntityCollection entities)
{
if (!this.contentLoaded) {
throw new InvalidOperationException("Content not loaded");
}
this.ExecuteImpl(entities);
}
public ChartRenderingInfo(EntityCollection entities)
{
base.\u002Ector();
ChartRenderingInfo chartRenderingInfo = this;
this.chartArea = (Rectangle2D) new Rectangle2D.Double();
this.plotInfo = new PlotRenderingInfo(this);
this.entities = entities;
}
protected override void ExecuteImpl(EntityCollection entities)
{
var bulletP = new Entity("bullet") {
Textured.Instance,
Order2Update.Instance,
new CustomOnEscape(new BoundingBox2(
new Vector2(0, 0),
new Vector2(640, 480)
), (e) => {
entities.EnqueueDestroy(e);
}),
{ Textured.Texture, this.bulletTexture },
{ Properties.DestroysEnemies, true },
{ Properties.Damage, 10.0f },
{
Collidable.Body,
new Body(new ShapePrimitive[] {
new CircleShape(Vector2.Zero, 8)
})
},
};
var basicWeapon = new Entity {
new CustomBulletEmitter((e, weaponOwner) => {
var bullet = bulletP.Create();
bullet.Set(Located.Position, e.Get(Located.Position) + weaponOwner.Get(Located.Position));
bullet.Set(Located.Velocity, e.Get(Located.Velocity));
bullet.Set(Properties.Owner, weaponOwner);
entities.EnqueueSpawn(bullet);
})
};
var weapons = new[] {
basicWeapon.Create("top").Configure((e) => {
e.Set(Located.Position, new Vector2(0, 0));
e.Set(Located.Velocity, new Vector2(7, 0));
}),
basicWeapon.Create("bottom").Configure((e) => {
e.Set(Located.Position, new Vector2(0, 30));
e.Set(Located.Velocity, new Vector2(7, 0));
}),
basicWeapon.Create("center").Configure((e) => {
e.Set(Located.Position, new Vector2(0, 15));
e.Set(Located.Velocity, new Vector2(7, 0));
}),
};
this.weaponConfigs = new[] {
new[] { weapons[2], },
new[] { weapons[0], weapons[1], },
new[] { weapons[0], weapons[1], weapons[2], },
};
}
public MapSimulator(MapTemplate template)
{
// We assign the map inside here
GameMap = GameMap.FromTemplate(template);
EntityCollection = new EntityCollection();
// Register all the services we want here
RegisterServices();
}
public void GetProductsTest()
{
var _products = new EntityCollection<Product>().AsQueryable();
mockProductRepository.Setup(x => x.GetAll()).Returns(_products);
var products = purcService.GetProducts();
Assert.IsNotNull(products);
Assert.IsInstanceOfType(products, typeof(IQueryable<IMaster>));
mockProductRepository.Verify(x => x.GetAll());
}
public Scene(String name, Game game)
{
this.Name = name;
this.Game = game;
Content = new ContentManager(Game.Services);
Content.RootDirectory = Game.Content.RootDirectory + @"\" + name;
Entities = new EntityCollection();
Camera = new Camera(this);
}
internal static IQueryable<BL.DomainModel.User> AdaptUsers(EntityCollection<User> userCollection)
{
if (userCollection.IsLoaded == false)
return null;
var users = from r in userCollection.AsEnumerable()
select AdaptUser(r);
return users.AsQueryable();
}
internal static IQueryable<BL.DomainModel.Role> AdaptRoles(EntityCollection<Role> roleCollection)
{
if (roleCollection.IsLoaded == false)
return null;
var roles = from r in roleCollection.AsEnumerable()
select AdaptRole(r);
return roles.AsQueryable();
}
internal static IQueryable<BL.DomainModel.Address> AdaptAddresses(EntityCollection<Address> addressCollection)
{
if (addressCollection.IsLoaded == false)
return null;
var addresses = from a in addressCollection.AsEnumerable()
select AdaptAddress(a);
return addresses.AsQueryable();
}
public static EntityCollection entityCollectioin(EntityCollection ec, EntityCollection entityCollection)
{
foreach (var entity in entityCollection)
{
ec.Add(entity);
if (entity.SubEntities.Count() > 0)
entityCollectioin(ec, entity.SubEntities);
}
return ec;
}
internal static IQueryable<BL.DomainModel.Order> AdaptOrders(EntityCollection<Order> orderCollection, BL.DomainModel.Customer c)
{
if (orderCollection.IsLoaded == false)
{
return null;
}
var orders = from o in orderCollection.AsEnumerable()
select AdaptOrder(o, c);
return orders.AsQueryable();
}
private EntityCollection GetCollectionSafe(uint tag)
{
EntityCollection collection = _entitiesByTag.TryGetValue(tag);
if (collection == null)
{
collection = new EntityCollection();
_entitiesByTag.Add(tag, collection);
}
return collection;
}
/// <summary>
/// Initialises a new instance of the <see cref="EntityGroup"/> class.
/// </summary>
public EntityGroup()
{
this.entities = new EntityCollection();
this.selectedItems = new ObservableCollection<object>();
this.entities.WhenItemChanged.Subscribe(this.OnEntityChanged);
this.entities.SelectionChanged += this.OnSelectionChanged;
this.clearFilterCommand = new DelegateCommand(this.ClearFilter, this.CanClearFilter);
this.resetCommand = new DelegateCommand(this.Reset, this.CanReset);
this.selectAllCommand = new DelegateCommand(this.SelectAll, this.CanSelectAll);
}
public void EmailConnection_1_Account_1_Existing()
{
//Arrange
XrmFakedWorkflowContext workflowContext = new XrmFakedWorkflowContext {
PrimaryEntityId = Guid.NewGuid()
};
Guid id = Guid.NewGuid();
Entity email = new Entity("email")
{
Id = id,
["activityid"] = id
};
Guid id2 = Guid.NewGuid();
Entity activityParty = new Entity("activityparty")
{
Id = id2,
["activitypartyid"] = id2,
["activityid"] = email.ToEntityReference(),
["partyid"] = new EntityReference("contact", Guid.NewGuid()),
["participationtypemask"] = new OptionSetValue(2)
};
EntityCollection to = new EntityCollection();
to.Entities.Add(activityParty);
email["to"] = to;
Entity account = new Entity("account")
{
Id = Guid.NewGuid(),
["emailaddress1"] = "*****@*****.**",
["statecode"] = new OptionSetValue(0)
};
Entity connectionRole = new Entity("connectionrole")
{
Id = Guid.NewGuid()
};
Entity connection = new Entity("connection")
{
Id = Guid.NewGuid(),
["record1id"] = new EntityReference("systemuser", workflowContext.PrimaryEntityId),
["record1objecttypecode"] = new OptionSetValue(8),
["record2id"] = account.ToEntityReference(),
["record2objecttypecode"] = new OptionSetValue(1),
["record2roleid"] = connectionRole.Id
};
var inputs = new Dictionary <string, object>
{
{ "EmailToSend", email.ToEntityReference() },
{ "ConnectionRole", connectionRole.ToEntityReference() },
{ "IncludeOppositeConnection", false },
{ "SendEmail", false }
};
XrmFakedContext xrmFakedContext = new XrmFakedContext();
xrmFakedContext.Initialize(new List <Entity> {
email, account, connectionRole, connection, activityParty
});
var fakeRetrieveMetadataChangesRequest = new FakeRetrieveMetadataChangesRequestExecutor("account");
xrmFakedContext.AddFakeMessageExecutor <RetrieveMetadataChangesRequest>(fakeRetrieveMetadataChangesRequest);
const int expected = 2;
//Act
var result = xrmFakedContext.ExecuteCodeActivity <EmailConnection>(workflowContext, inputs);
//Assert
Assert.AreEqual(expected, result["UsersAdded"]);
}
/// <summary>
/// Generate Email and Task both
/// </summary>
/// <param name="relatedEntities">list of related entities</param>
/// <param name="partylist">party list</param>
/// <param name="globalConfiguration">notification global configuration object</param>
/// <param name="templateId">Email template unique identifier</param>
/// <param name="emailTemplateOption">email template option</param>
/// <param name="service">organization service</param>
/// <returns>Collection of email objects</returns>
internal static EntityCollection GenerateEmailAndTask(List <Entity> relatedEntities, List <PartyList> partylist, Dictionary <string, dynamic> globalConfiguration, Guid?templateId, int?emailTemplateOption, IOrganizationService service)
{
var toUserPartyList = GetToUserPartyList(partylist, relatedEntities[0].LogicalName).ToList <PartyList>();
var carbonCopyPartyList = GetCCPartyList(partylist, relatedEntities[0].LogicalName).ToList <PartyList>();
var bccPartyList = GetBCCPartyList(partylist, relatedEntities[0].LogicalName).ToList <PartyList>();
var toOtherPartyList = GetToOtherPartyList(partylist, relatedEntities[0].LogicalName).ToList <PartyList>();
// Create Entity Collection to send email in bulk through action calling
EntityCollection sendEmailList = new EntityCollection();
sendEmailList.EntityName = "email";
foreach (Entity ent in relatedEntities)
{
// Get Email object using Email Template
Entity emailObject = GetEmailUsingTemplate(ent, templateId, emailTemplateOption, service);
var toUserRelatedPartyList = GetToUserRelatedPartyList(partylist, ent.LogicalName, ent.Id).ToList <PartyList>();
toUserRelatedPartyList.AddRange(toUserPartyList);
toUserRelatedPartyList = toUserRelatedPartyList.GroupBy(x => x.PartyId).Select(p => p.First()).ToList <PartyList>();
var carbonCopyRelatedPartyList = GetCCRelatedPartyList(partylist, ent.LogicalName, ent.Id).ToList <PartyList>();
carbonCopyRelatedPartyList.AddRange(carbonCopyPartyList);
carbonCopyRelatedPartyList = carbonCopyRelatedPartyList.GroupBy(x => x.PartyId).Select(p => p.First()).ToList <PartyList>();
var bccRelatedPartyList = GetBCCRelatedPartyList(partylist, ent.LogicalName, ent.Id).ToList <PartyList>();
bccRelatedPartyList.AddRange(bccPartyList);
bccRelatedPartyList = bccRelatedPartyList.GroupBy(x => x.PartyId).Select(p => p.First()).ToList <PartyList>();
var toOtherRelatedPartyList = GetToOtherRelatedPartyList(partylist, ent.LogicalName, ent.Id).ToList <PartyList>();
toOtherRelatedPartyList.AddRange(toOtherPartyList);
toOtherRelatedPartyList = toOtherRelatedPartyList.GroupBy(x => x.PartyId).Select(p => p.First()).ToList <PartyList>();
foreach (PartyList lst in toUserRelatedPartyList)
{
Entity task = NotificationActivityHandler.CreateTask(ent, lst, service);
List <PartyList> plist = new List <PartyList>();
plist.Add(lst);
Entity emailEnt = NotificationActivityHandler.CreateEmailInstance(ent, plist, carbonCopyRelatedPartyList, bccRelatedPartyList, task, globalConfiguration, emailObject);
sendEmailList.Entities.Add(emailEnt);
}
if (toOtherPartyList.Count > 0)
{
Entity emailEnt = NotificationActivityHandler.CreateEmailInstance(ent, toOtherRelatedPartyList, carbonCopyRelatedPartyList, bccRelatedPartyList, null, globalConfiguration, emailObject);
sendEmailList.Entities.Add(emailEnt);
}
}
// Call Glocal action SendEmailActivity to send bulk email
/*if (isSendEmail)
* {
* OrganizationRequest req = new OrganizationRequest("didd_SendEmailActivity");
* req["EmailActivities"] = sendEmailList;
* service.Execute(req);
* }*/
return(sendEmailList);
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// a Contract Template and several Contracts are created, demonstrating how to
/// create and work with the Contract entity.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
#region Create Contract Template
// First, attempt to retrieve the Contract Template. Otherwise,
// create the template.
QueryExpression templateQuery = new QueryExpression()
{
EntityName = ContractTemplate.EntityLogicalName,
ColumnSet = new ColumnSet("contracttemplateid"),
Criteria =
{
Conditions =
{
new ConditionExpression("abbreviation", ConditionOperator.Equal, "SCT")
}
}
};
EntityCollection ec = _serviceProxy.RetrieveMultiple(templateQuery);
if (ec.Entities.Count > 0)
{
_contractTemplateId = ec.Entities[0].Id;
Console.Write("Template retrieved, ");
}
else
{
ContractTemplate contractTemplate = new ContractTemplate()
{
Name = "Sample Contract Template",
BillingFrequencyCode = new OptionSetValue((int)ContractTemplateBillingFrequencyCode.Monthly),
Abbreviation = "SCT",
AllotmentTypeCode = new OptionSetValue((int)ContractTemplateAllotmentTypeCode.NumberofCases),
EffectivityCalendar =
"--------+++++++++---------------+++++++++---------------+++++++++---------------+++++++++---------------+++++++++-------------------------------------------------------"
};
_contractTemplateId = _serviceProxy.Create(contractTemplate);
Console.Write("Template created, ");
}
#endregion
#region Create Contract
// Create a Contract from the Contract Template.
Contract contract = new Contract()
{
Title = "Sample Contract",
ContractTemplateId = new EntityReference
{
Id = _contractTemplateId,
LogicalName = ContractTemplate.EntityLogicalName
},
CustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
BillingCustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
ActiveOn = new DateTime(2015, 1, 1),
ExpiresOn = new DateTime(2020, 1, 1),
BillingStartOn = new DateTime(2015, 1, 1),
BillingEndOn = new DateTime(2020, 1, 1)
};
_contractId = _serviceProxy.Create(contract);
Console.Write("parent contract created, ");
// Create a contract line item.
ContractDetail contractLineItem = new ContractDetail()
{
Title = "Sample Contract Line Item",
ContractId = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
CustomerId = new EntityReference
{
Id = _accountId,
LogicalName = Account.EntityLogicalName
},
ActiveOn = new DateTime(2015, 1, 1),
ExpiresOn = new DateTime(2020, 1, 1),
Price = new Money(20.0M),
TotalAllotments = 20
};
_serviceProxy.Create(contractLineItem);
Console.Write("contract line attached, ");
#endregion
#region Clone contract twice
// Create the first clone of the contract.
CloneContractRequest cloneRequest = new CloneContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = false
};
CloneContractResponse cloneResponse =
(CloneContractResponse)_serviceProxy.Execute(cloneRequest);
_firstCloneId = ((Contract)cloneResponse.Entity).ContractId.Value;
Console.Write("first clone created, ");
// Create the second clone of the contract.
cloneRequest = new CloneContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = true
};
cloneResponse =
(CloneContractResponse)_serviceProxy.Execute(cloneRequest);
_secondCloneId = ((Contract)cloneResponse.Entity).ContractId.Value;
Console.Write("second clone created. \n");
// Retrieve all Contracts.
QueryExpression contractQuery = new QueryExpression()
{
EntityName = Contract.EntityLogicalName,
ColumnSet = new ColumnSet("contractid"),
Criteria =
{
Conditions =
{
new ConditionExpression("customerid", ConditionOperator.Equal, _accountId)
}
}
};
EntityCollection contracts = _serviceProxy.RetrieveMultiple(contractQuery);
// Display the retrieved Contract Ids.
for (int i = 0; i < contracts.Entities.Count; i++)
{
Console.WriteLine("Retrieved contract with Id: {0}",
((Contract)contracts.Entities[i]).ContractId);
}
#endregion
#region Deactivate a cloned contract
// In order to deactivate a contract (put it on hold), it is first
// necessary to invoice the contract.
SetStateRequest setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _firstCloneId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Invoiced),
Status = new OptionSetValue(2)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("Contract invoiced, ");
// Now that the contract has been invoiced, it is possible to put
// the contract on hold.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _firstCloneId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.OnHold),
Status = new OptionSetValue(4)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("and put on hold.\n");
#endregion
#region Renew an invoiced contract
// In order to renew a contract, it must be invoiced first, and
// then canceled.
// Invoice the contract.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Invoiced),
Status = new OptionSetValue(3)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("Contract invoiced, ");
// Cancel the contract.
setStateRequest = new SetStateRequest()
{
EntityMoniker = new EntityReference
{
Id = _contractId,
LogicalName = Contract.EntityLogicalName
},
State = new OptionSetValue((int)ContractState.Canceled),
Status = new OptionSetValue(5)
};
_serviceProxy.Execute(setStateRequest);
Console.Write("canceled, ");
// Renew the canceled contract.
RenewContractRequest renewRequest = new RenewContractRequest()
{
ContractId = _contractId,
IncludeCanceledLines = true,
Status = 1
};
RenewContractResponse renewResponse =
(RenewContractResponse)_serviceProxy.Execute(renewRequest);
// Retrieve Id of renewed contract.
_renewedId = ((Contract)renewResponse.Entity).ContractId.Value;
// Display the Id of the renewed contract.
Console.WriteLine("and renewed.");
#endregion
DeleteRequiredRecords(promptforDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public void CreateTeamFromAccount()
{
var serviceProvider = new StubIServiceProvider();
var pluginContext = new StubIPluginExecutionContext();
var organizationService = new StubIOrganizationService();
pluginContext.PrimaryEntityNameGet = () => "account";
pluginContext.PrimaryEntityIdGet = () => Guid.NewGuid();
pluginContext.BusinessUnitIdGet = () => Guid.NewGuid();
pluginContext.DepthGet = () => - 1;
var entity = new Entity();
entity.LogicalName = "account";
entity.Attributes.Add("accountid", Guid.NewGuid());
entity.Attributes.Add("name", "Mock Account Name");
ParameterCollection paramCollection = new ParameterCollection();
paramCollection.Add("Target", entity);
pluginContext.InputParametersGet = () => paramCollection;
//// Mole the basic Plugin objects
Helper.Helper.PluginVariables(serviceProvider, pluginContext, organizationService, 40, "Create", null);
organizationService.RetrieveMultipleQueryBase = query =>
{
var entityCollection = new EntityCollection();
var entity1 = new Entity();
switch (((QueryExpression)query).EntityName)
{
case "team":
break;
case "account":
entityCollection.Entities.Add(entity1);
break;
case "role":
var entityRole = new Entity();
entityRole.LogicalName = "role";
entityRole.Attributes.Add("roleid", Guid.NewGuid());
entityRole.Attributes.Add("name", "Provider");
entityCollection.Entities.Add(entityRole);
break;
}
return(entityCollection);
};
organizationService.RetrieveStringGuidColumnSet = delegate(string _entity, Guid guid, ColumnSet secondaryUserColumnSet)
{
if (_entity == "incident")
{
Entity incident = new Entity(_entity);
incident["smp_issurveyservicerequest"] = true;
incident["smp_cancelledforreclassification"] = true;
incident.Id = Guid.NewGuid();
return(incident);
}
return(null);
};
organizationService.UpdateEntity = param => { };
organizationService.CreateEntity = parameter =>
{
return(new Guid());
};
var pluginClass = new PostProviderCreateTeam();
pluginClass.Execute(serviceProvider);
}
public static void UpdateBulk(EntityCollection ec, bool continueOnError = true)
{
var service = Connection.Service;
var loopCount = (ec.Entities.Count / 1000) + (ec.Entities.Count % 1000 != 0 ? 1 : 0);
for (var i = 0; i < loopCount; i++)
{
try
{
var multipleRequest = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = continueOnError,
ReturnResponses = true,
},
Requests = new OrganizationRequestCollection()
};
var start = (i * 1000);
var end = ec.Entities.Count <= (i + 1) * 1000 ? ec.Entities.Count : (i + 1) * 1000;
for (var j = start; j < end; j++)
{
var updateRequest = new UpdateRequest()
{
Target = ec.Entities.ElementAt(j)
};
multipleRequest.Requests.Add(updateRequest);
}
// Execute all the requests in the request collection using a single web method call.
var multipleResponse = (ExecuteMultipleResponse)service.Execute(multipleRequest);
if (!multipleResponse.Responses.Any())
{
continue;
}
foreach (var response in multipleResponse.Responses)
{
if (response.Fault == null)
{
continue;
}
if (response.Fault.InnerFault != null)
{
//error
if (!continueOnError)
{
throw new Exception(JsonConvert.SerializeObject(response.Fault.InnerFault) +
Environment.NewLine +
JsonConvert.SerializeObject(
ec.Entities[(i * 1000) + response.RequestIndex]));
}
}
else
{
//error
if (!continueOnError)
{
throw new Exception(JsonConvert.SerializeObject(response.Fault) + Environment.NewLine +
JsonConvert.SerializeObject(
ec.Entities[(i * 1000) + response.RequestIndex]));
}
}
}
}
catch (Exception)
{
throw;
}
}
}
/// <summary>
/// Gets information from Dynamics entity based on FetchXML query
/// </summary>
/// <param name="FetchXML">Quer</param>
/// <param name="top">True for top 50 or all rows</param>
/// <returns></returns>
public DataTable GetData(String FetchXML, Boolean top)
{
if (string.IsNullOrEmpty(FetchXML))
{
throw new Exception("FetchXML query is empty");
}
try
{
if (service == null)
{
throw new Exception("No Organization Service Available");
}
DataTable dTable = new DataTable();
EntityCollection result = new EntityCollection();
bool AddCol = true;
int page = 1;
AttributeMetadata mdta;
System.Xml.Linq.XElement xe = XElement.Parse(FetchXML.Trim());
if (xe.Attribute("mapping") == null)
{
xe.SetAttributeValue("mapping", "logical");
}
do
{
if (top)
{
if (xe.Attribute("distinct") == null)
{
xe.SetAttributeValue("distinct", "false");
}
if (xe.Attribute("count") == null)
{
xe.SetAttributeValue("count", "50");
}
else
{
xe.Attribute("count").SetValue("50");
}
result = service.RetrieveMultiple(new FetchExpression(xe.ToString()));
result.MoreRecords = false;
}
else
{
if (xe.Attribute("paging-cookie") == null)
{
xe.SetAttributeValue("paging-cookie", result.PagingCookie);
}
else
{
xe.Attribute("paging-cookie").SetValue(result.PagingCookie);
}
if (xe.Attribute("count") == null)
{
xe.SetAttributeValue("count", "5000");
}
if (xe.Attribute("page") == null)
{
xe.SetAttributeValue("page", System.Convert.ToString(page));
}
else
{
xe.Attribute("page").SetValue(System.Convert.ToString(page));
}
page++;
result = service.RetrieveMultiple(new FetchExpression(xe.ToString()));
}
RetrieveEntityRequest mdRequest = new RetrieveEntityRequest()
{
EntityFilters = EntityFilters.Attributes,
LogicalName = result.EntityName,
RetrieveAsIfPublished = false
};
RetrieveEntityResponse entityResponse = (RetrieveEntityResponse)service.Execute(mdRequest);
entMetadata = entityResponse.EntityMetadata;
if (AddCol)
{
foreach (Entity entity in result.Entities)
{
for (int iElement = 0; iElement <= entity.Attributes.Count - 1; iElement++)
{
string columnName = entity.Attributes.Keys.ElementAt(iElement);
if (!dTable.Columns.Contains(columnName))
{
mdta = entMetadata.Attributes.FirstOrDefault(m => m.LogicalName == columnName);
if (SupportedTypes.isValidAttribute(mdta))
{
switch (mdta.AttributeType.Value)
{
// break;
case AttributeTypeCode.BigInt:
dTable.Columns.Add(columnName, typeof(Int64));
break;
case AttributeTypeCode.Boolean:
dTable.Columns.Add(columnName, typeof(bool));
break;
case AttributeTypeCode.DateTime:
dTable.Columns.Add(columnName, typeof(DateTime));
break;
case AttributeTypeCode.Decimal:
dTable.Columns.Add(columnName, typeof(decimal));
break;
case AttributeTypeCode.Double:
case AttributeTypeCode.Money:
dTable.Columns.Add(columnName, typeof(float));
break;
case AttributeTypeCode.Integer:
case AttributeTypeCode.Picklist:
case AttributeTypeCode.State:
case AttributeTypeCode.Status:
dTable.Columns.Add(columnName, typeof(Int32));
break;
case AttributeTypeCode.Uniqueidentifier:
case AttributeTypeCode.Customer:
case AttributeTypeCode.Lookup:
case AttributeTypeCode.PartyList:
case AttributeTypeCode.Owner:
dTable.Columns.Add(columnName, typeof(Guid));
break;
default:
dTable.Columns.Add(columnName, typeof(string));
break;
}
}
}
}
}
}
else
{
AddCol = false;
}
foreach (Entity entity in result.Entities)
{
DataRow dRow = dTable.NewRow();
for (int i = 0; i <= entity.Attributes.Count - 1; i++)
{
string colName = entity.Attributes.Keys.ElementAt(i);
mdta = entMetadata.Attributes.FirstOrDefault(m => m.LogicalName == colName);
if (mdta != null)
{
switch (mdta.AttributeType.Value)
{
//case AttributeTypeCode.Boolean:
// dRow[colName] = entity.Attributes.Values.ElementAt(i).ToString() == "1" || entity.Attributes.Values.ElementAt(i).ToString().Trim().ToLower() == "true";
// break;
case AttributeTypeCode.Picklist:
case AttributeTypeCode.State:
case AttributeTypeCode.Status:
dRow[colName] = ((Microsoft.Xrm.Sdk.OptionSetValue)entity.Attributes.Values.ElementAt(i)).Value;
break;
case AttributeTypeCode.Customer:
case AttributeTypeCode.Lookup:
case AttributeTypeCode.PartyList:
case AttributeTypeCode.Owner:
dRow[colName] = (Guid)((Microsoft.Xrm.Sdk.EntityReference)entity.Attributes.Values.ElementAt(i)).Id;
break;
case AttributeTypeCode.BigInt:
dRow[colName] = (Int64?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Decimal:
dRow[colName] = (decimal?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Double:
dRow[colName] = (double?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Integer:
dRow[colName] = (int?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Money:
dRow[colName] = ((Microsoft.Xrm.Sdk.Money)entity.Attributes.Values.ElementAt(i)).Value;
break;
case AttributeTypeCode.DateTime:
dRow[colName] = (DateTime?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Uniqueidentifier:
dRow[colName] = (Guid?)entity.Attributes.Values.ElementAt(i);
break;
case AttributeTypeCode.Boolean:
dRow[colName] = (bool?)entity.Attributes.Values.ElementAt(i);
break;
default:
dRow[colName] = (string)entity.Attributes.Values.ElementAt(i);
break;
}
}
}
dTable.Rows.Add(dRow);
}
}while (result.MoreRecords);
return(dTable);
}
catch (Exception e)
{
throw e;
}
}
public void EntityAttachmentToEmail(string _FileName, string ParentId, EntityReference email, bool _RetrieveActivityMimeAttachment)
{
#region "Query Attachments"
string fetchXML = "";
if (_RetrieveActivityMimeAttachment == false)
{
fetchXML = @"
<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
<entity name='annotation'>
<attribute name='filename' />
<attribute name='annotationid' />
<attribute name='subject' />
<attribute name='documentbody' />
<attribute name='mimetype' />
<filter type='and'>
<condition attribute='filename' operator='like' value='%" + _FileName + @"%' />
<condition attribute='isdocument' operator='eq' value='1' />
<condition attribute='objectid' operator='eq' value='" + ParentId + @"' />
</filter>
</entity>
</fetch>";
}
else
{
fetchXML = @"
<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
<entity name='activitymimeattachment'>
<attribute name='filename' />
<attribute name='attachmentid' />
<attribute name='subject' />
<attribute name='body' />
<attribute name='mimetype' />
<filter type='and'>
<condition attribute='filename' operator='like' value='%" + _FileName + @"%' />
<condition attribute='activityid' operator='eq' value='" + ParentId + @"' />
</filter>
</entity>
</fetch>";
}
if (tracing != null)
{
tracing.Trace(String.Format("FetchXML: {0} ", fetchXML));
}
EntityCollection attachmentFiles = service.RetrieveMultiple(new FetchExpression(fetchXML));
if (attachmentFiles.Entities.Count == 0)
{
if (tracing != null)
{
tracing.Trace(String.Format("No Attachment Files found."));
}
return;
}
#endregion
#region "Add Attachments to Email"
int i = 1;
foreach (Entity file in attachmentFiles.Entities)
{
Entity _Attachment = new Entity("activitymimeattachment");
_Attachment["objectid"] = new EntityReference("email", email.Id);
_Attachment["objecttypecode"] = "email";
_Attachment["attachmentnumber"] = i;
i++;
if (file.Attributes.Contains("subject"))
{
_Attachment["subject"] = file.Attributes["subject"].ToString();
}
if (file.Attributes.Contains("filename"))
{
_Attachment["filename"] = file.Attributes["filename"].ToString();
}
if (file.Attributes.Contains("documentbody"))
{
_Attachment["body"] = file.Attributes["documentbody"].ToString();
}
if (file.Attributes.Contains("mimetype"))
{
_Attachment["mimetype"] = file.Attributes["mimetype"].ToString();
}
service.Create(_Attachment);
}
#endregion
}
public void SalesLiteratureToEmail(string _FileName, string salesLiteratureId, string emailid)
{
if (_FileName == "*")
{
_FileName = "";
}
_FileName = _FileName.Replace("*", "%");
#region "Query Attachments"
string fetchXML = @"
<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
<entity name='salesliteratureitem'>
<attribute name='filename' />
<attribute name='salesliteratureitemid' />
<attribute name='title' />
<attribute name='documentbody' />
<attribute name='mimetype' />
<filter type='and'>
<condition attribute='filename' operator='like' value='%" + _FileName + @"%' />
<condition attribute='salesliteratureid' operator='eq' value='" + salesLiteratureId + @"' />
</filter>
</entity>
</fetch>";
if (tracing != null)
{
tracing.Trace(String.Format("FetchXML: {0} ", fetchXML));
}
EntityCollection attachmentFiles = service.RetrieveMultiple(new FetchExpression(fetchXML));
if (attachmentFiles.Entities.Count == 0)
{
if (tracing != null)
{
tracing.Trace(String.Format("No Attachment Files found."));
}
return;
}
#endregion
#region "Add Attachments to Email"
int i = 1;
foreach (Entity file in attachmentFiles.Entities)
{
Entity _Attachment = new Entity("activitymimeattachment");
_Attachment["objectid"] = new EntityReference("email", new Guid(emailid));
_Attachment["objecttypecode"] = "email";
_Attachment["attachmentnumber"] = i;
i++;
if (file.Attributes.Contains("title"))
{
_Attachment["subject"] = file.Attributes["title"].ToString();
}
if (file.Attributes.Contains("filename"))
{
_Attachment["filename"] = file.Attributes["filename"].ToString();
}
if (file.Attributes.Contains("documentbody"))
{
_Attachment["body"] = file.Attributes["documentbody"].ToString();
}
if (file.Attributes.Contains("mimetype"))
{
_Attachment["mimetype"] = file.Attributes["mimetype"].ToString();
}
service.Create(_Attachment);
}
#endregion
}
private static void ProcessStatusChange(IOrganizationService service, Entity entity, ITracingService trace, Entity problemType, Entity problemClass, Entity preEntity)
{
try
{
EntityCollection configurationCollection = ServiceRequestHelper.GetConfigurationValueCollection(service);
List <Entity> toEmail = new List <Entity>();
List <Entity> ccEmail = new List <Entity>();
string fromUserDomainName = configurationCollection.Entities.Where(x => x["smp_title"].ToString().Equals(CRMAttributesResource.EmailSenderDomainName)).First()["smp_value"].ToString();
Guid senderId = ServiceRequestHelper.GetCrmUserId(service, fromUserDomainName);
EntityReference contact = entity.Attributes.Contains(CRMAttributesResource.ServiceRequestContact) ? (EntityReference)entity[CRMAttributesResource.ServiceRequestContact] : null;
EntityReference requester = entity.Attributes.Contains(CRMAttributesResource.ServiceRequestRequester) ? (EntityReference)entity[CRMAttributesResource.ServiceRequestRequester] : null;
EntityReference cC = entity.Attributes.Contains(CRMAttributesResource.ServiceRequestCC) ? (EntityReference)entity[CRMAttributesResource.ServiceRequestCC] : null;
EntityReference approver = entity.Attributes.Contains(CRMAttributesResource.ServiceRequestApprovalManager) ? (EntityReference)entity[CRMAttributesResource.ServiceRequestApprovalManager] : null;
OptionSetValue currentStatus = entity.Attributes.Contains(CRMAttributesResource.StatusCodeAttribute) ? (OptionSetValue)entity[CRMAttributesResource.StatusCodeAttribute] : null;
EntityReference provider = entity.Attributes.Contains(CRMAttributesResource.ServiceRequestProvider) ? (EntityReference)entity[CRMAttributesResource.ServiceRequestProvider] : null;
Entity contactDetails = null;
Entity requesterDetails = (requester == null) ? null : ServiceRequestHelper.GetContactDetails(service, requester.Id);
Entity ccDetails = (cC == null) ? null : ServiceRequestHelper.GetContactDetails(service, cC.Id);
bool allowEmailNotification = false;
bool cancelledForReclassification = false;
bool contact_AllowEmailNotification = false;
string contactLanguageCode = string.Empty;
if (contact != null)
{
contactDetails = ServiceRequestHelper.GetContactDetails(service, contact.Id);
contact_AllowEmailNotification = contactDetails.Attributes.Contains("smp_allowemailnotification") ? (bool)contactDetails["smp_allowemailnotification"] : false;
contactLanguageCode = contactDetails.Attributes.Contains("smp_preferredlanguage") ? contactDetails["smp_preferredlanguage"].ToString() : "en-us";
}
allowEmailNotification = entity.Attributes.Contains("smp_allowemailnotification") ? (bool)entity["smp_allowemailnotification"] : false;
cancelledForReclassification = entity.Attributes.Contains("smp_cancelledforreclassification") ? (bool)entity["smp_cancelledforreclassification"] : false;
var fromParty = new Entity("activityparty");
fromParty["partyid"] = new EntityReference(CRMAttributesResource.SystemUserEntity, senderId);
if (currentStatus.Value == Convert.ToInt32(CRMAttributesResource.DeclinedStatus, CultureInfo.InvariantCulture) && allowEmailNotification == true)
{
trace.Trace("In Declined Status");
if (requester != null)
{
var toRequestor = new Entity("activityparty");
toRequestor["partyid"] = new EntityReference("contact", requester.Id);
toEmail.Add(toRequestor);
}
if (contact != null)
{
if (requester.Id != contact.Id)
{
var ccContact = new Entity("activityparty");
ccContact["partyid"] = new EntityReference("contact", contact.Id);
toEmail.Add(ccContact);
}
}
if (approver != null)
{
var toApprover = new Entity("activityparty");
toApprover["partyid"] = new EntityReference("contact", approver.Id);
ccEmail.Add(toApprover);
}
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestApprovalRejectionTemplate, configurationCollection);
}
else if (currentStatus.Value == Convert.ToInt32(CRMAttributesResource.CancelledStatus, CultureInfo.InvariantCulture))
{
trace.Trace("In cancelled Status");
if (cancelledForReclassification == false)
{
if (requester != null)
{
var toRequester = new Entity("activityparty");
toRequester["partyid"] = new EntityReference("contact", requester.Id);
toEmail.Add(toRequester);
}
if (contact != null)
{
if (contact.Id != requester.Id)
{
var ccContact = new Entity("activityparty");
ccContact["partyid"] = new EntityReference("contact", contact.Id);
ccEmail.Add(ccContact);
}
}
if (cC != null)
{
if (contact.Id != cC.Id && cC.Id != requester.Id)
{
var toCC = new Entity("activityparty");
toCC["partyid"] = new EntityReference("contact", cC.Id);
ccEmail.Add(toCC);
}
}
////End of Code Changes made by Mihika G on 03-12-2017
////Send email
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestCancelledTemplate, configurationCollection);
}
else if (cancelledForReclassification == true)
{
////Code Commented By Mihika G
if (provider != null)
{
var toProvider = new Entity("activityparty");
toProvider["partyid"] = new EntityReference("account", provider.Id);
toEmail.Add(toProvider);
}
trace.Trace("in cancelled");
////End OF Code Changes
if (requester != null)
{
if (contact.Id != requester.Id)
{
var toRequester = new Entity("activityparty");
toRequester["partyid"] = new EntityReference("contact", requester.Id);
ccEmail.Add(toRequester);
}
}
if (contact != null)
{
var toContact = new Entity("activityparty");
toContact["partyid"] = new EntityReference("contact", contact.Id);
toEmail.Add(toContact);
}
//// Code Changes made by Mihika G on 03-12-2017
if (cC != null)
{
if (contact.Id != cC.Id && cC.Id != requester.Id)
{
var toCC = new Entity("activityparty");
toCC["partyid"] = new EntityReference("contact", cC.Id);
ccEmail.Add(toCC);
}
}
trace.Trace("before email");
trace.Trace("Template : " + CRMAttributesResource.ServiceRequestReclassifiedTemplate);
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestReclassifiedTemplate, configurationCollection);
////end of code change for reclassification email
}
}
else if (currentStatus.Value == Convert.ToInt32(CRMAttributesResource.CompletedStatus, CultureInfo.InvariantCulture))
{
trace.Trace("In Completed Status");
bool noSurvey = (bool)problemClass["smp_donotallowsurvey"] || (bool)problemType["smp_donotallowsurvey"];
bool ccSurvey = false; //Whether the CC contact receives a survey
if (requester != null && canReceiveEmail(requesterDetails))
{
((canReceiveSurvey(requesterDetails) && !noSurvey) ? toEmail : ccEmail).Add(getEmailParty(requester));
}
if (contact != null && contact.Id != requester.Id && canReceiveEmail(contactDetails))
{
((canReceiveSurvey(contactDetails) && !noSurvey) ? toEmail : ccEmail).Add(getEmailParty(contact));
}
if ((cC != null && canReceiveEmail(ccDetails)))
{
ccSurvey = canReceiveSurvey(ccDetails) && toEmail.Count > 0; //Doesn't make sense to send it just for the CC
if (ccSurvey)
{
toEmail.Add(getEmailParty(cC));
}
else
{
ccEmail.Add(getEmailParty(cC));
}
}
//Promote the first contact to primary, since we can only have one for the survey generator
List <Entity> primary = new List <Entity>();
if (toEmail.Count != 0)
{
primary.Add(toEmail[0]);
toEmail.RemoveAt(0);
EmailHelper.SendTranslatedEmail(service, entity, fromParty, primary, toEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestCompletedTemplate, configurationCollection);
}
primary.Clear();
if (ccEmail.Count != 0)
{
primary.Add(ccEmail[0]);
ccEmail.RemoveAt(0);
EmailHelper.SendTranslatedEmail(service, entity, fromParty, primary, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestCompletedTemplateWithoutSurvey, configurationCollection);
}
}
else if (currentStatus.Value == Convert.ToInt32(CRMAttributesResource.WaitingForApprovalStatus, CultureInfo.InvariantCulture))
{
trace.Trace("In Waiting for Approval status");
if (contact_AllowEmailNotification == false)
{
}
else
{
if (allowEmailNotification == true)
{
if (approver != null)
{
var toApprover = new Entity("activityparty");
toApprover["partyid"] = new EntityReference("contact", approver.Id);
toEmail.Add(toApprover);
}
if (requester != null)
{
if (requester.Id != contact.Id)
{
var toRequester = new Entity("activityparty");
toRequester["partyid"] = new EntityReference("contact", requester.Id);
ccEmail.Add(toRequester);
}
}
if (contact != null)
{
var toContact = new Entity("activityparty");
toContact["partyid"] = new EntityReference("contact", contact.Id);
ccEmail.Add(toContact);
}
////Send email
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestWaitingForApprovalTemplate, configurationCollection);
}
}
}
else
{
trace.Trace("In Final Else ");
if (((OptionSetValue)preEntity["statuscode"]).Value != 1 && (currentStatus.Value == 180620017 || currentStatus.Value == 180620007 || currentStatus.Value == 180620008 || currentStatus.Value == 180620009))
{
if (((OptionSetValue)preEntity["statuscode"]).Value != currentStatus.Value)
{
if (contact_AllowEmailNotification == true)
{
}
else
{
if (allowEmailNotification == true)
{
if (requester != null)
{
var toRequestor = new Entity("activityparty");
toRequestor["partyid"] = new EntityReference("contact", requester.Id);
toEmail.Add(toRequestor);
}
if (contact != null)
{
if (contact.Id != requester.Id)
{
var ccContact = new Entity("activityparty");
ccContact["partyid"] = new EntityReference("contact", contact.Id);
ccEmail.Add(ccContact);
}
}
if (cC != null)
{
if (cC.Id != contact.Id && cC.Id != requester.Id)
{
var toCC = new Entity("activityparty");
toCC["partyid"] = new EntityReference("contact", cC.Id);
ccEmail.Add(toCC);
}
}
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestStatusChangeTemplate, configurationCollection);
}
}
}
}
else
{
trace.Trace("In Final Else--Else");
if (((OptionSetValue)preEntity["statuscode"]).Value == 1 && currentStatus.Value == 2)
{
if (contact_AllowEmailNotification)
{
}
else
{
if (requester != null)
{
var toRequester = new Entity("activityparty");
toRequester["partyid"] = new EntityReference("contact", requester.Id);
toEmail.Add(toRequester);
}
if (contact != null)
{
if (contact.Id != requester.Id)
{
var ccContact = new Entity("activityparty");
ccContact["partyid"] = new EntityReference("contact", contact.Id);
ccEmail.Add(ccContact);
}
}
if (cC != null)
{
if (contact.Id != cC.Id && cC.Id != requester.Id)
{
var toCC = new Entity("activityparty");
toCC["partyid"] = new EntityReference("contact", cC.Id);
ccEmail.Add(toCC);
}
}
EmailHelper.SendTranslatedEmail(service, entity, fromParty, toEmail, ccEmail, contactLanguageCode, CRMAttributesResource.ServiceRequestAcknowledgementTemplate, configurationCollection);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task AddClaimsAsync(ApplicationUser user, IEnumerable <Claim> claims, CancellationToken cancellationToken)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (claims == null)
{
throw new ArgumentNullException(nameof(claims));
}
// avoid multiple enumerations
claims = claims.ToList();
try
{
var existingClaims = await GetClaimsAsync(user, cancellationToken);
var newClaimEntities = new EntityCollection <IdentityUserClaimEntity>();
foreach (var claim in claims)
{
// only add claims that do not exist already
if (existingClaims.Any(c => c.Type == claim.Type && c.Value == claim.Value))
{
continue;
}
if (Constants.ClaimType.GetTeamRelatedClaimTypes().Contains(claim.Type))
{
await AddTeamRelatedClaimAsync(user, claim, cancellationToken);
continue;
}
if (Constants.ClaimType.GetProgrammaticClaimTypes().Contains(claim.Type))
{
var ex = new ArgumentException($"Programmatic claim type '{claim.Type}' cannot be stored.");
_logger.LogError(ex.Message, ex);
throw ex;
}
newClaimEntities.Add(new IdentityUserClaimEntity
{
UserId = user.Id, ClaimType = claim.Type, ClaimValue = claim.Value,
ValueType = claim.ValueType, Issuer = claim.Issuer
});
}
if (newClaimEntities.Count > 0)
{
await _appDb.GenericRepository.SaveEntitiesAsync(newClaimEntities, false, false, cancellationToken);
}
}
catch (Exception e)
{
var msg = $"Claim types '{string.Join(", ", claims.Select(c => c.Type))}' could not be added";
_logger.LogError(msg, e);
throw;
}
}
/// <summary>Creates the entity collection and stores it in destination if destination is null</summary>
/// <typeparam name="T">type of the element to store in the collection</typeparam>
/// <typeparam name="TFactory">The type of the factory to pass to the entitycollection ctor.</typeparam>
/// <param name="navigatorName">Name of the property this collection is for.</param>
/// <param name="setContainingEntityInfo">if set to <see langword="true"/> the collection is for an 1:n relationship, and the containing entity info has to be set</param>
/// <param name="forMN">if set to <see langword="true"/> the collection is for an m:n relationship, otherwise for an 1:n relationship</param>
/// <param name="destination">The destination member variable.</param>
/// <returns>the collection referred to by destination if destination isn't null, otherwise the newly created collection (which is then stored in destination</returns>
protected EntityCollection <T> GetOrCreateEntityCollection <T, TFactory>(string navigatorName, bool setContainingEntityInfo, bool forMN, ref EntityCollection <T> destination)
where T : EntityBase2, IEntity2
{
if (destination == null)
{
destination = new EntityCollection <T>(EntityFactoryCache2.GetEntityFactory(typeof(TFactory)));
if (forMN)
{
((IEntityCollectionCore)destination).IsForMN = true;
}
else
{
if (setContainingEntityInfo)
{
destination.SetContainingEntityInfo(this, navigatorName);
}
}
destination.ActiveContext = this.ActiveContext;
}
return(destination);
}
public IList <BookingAllocationResponse> PrepareBookingAllocation(EntityCollection bookingCollection, List <ChildHotelTeam> childTeam)
{
if (bookingCollection == null || bookingCollection.Entities.Count == 0)
{
logger.LogWarning("No booking records found to process in CRM for the schedule.");
return(null);
}
if (childTeam == null || childTeam.Count == 0)
{
logger.LogWarning("No child Teams found to process in CRM for the schedule.");
return(null);
}
var bookingAllocationResponse = new List <BookingAllocationResponse>();
for (int i = 0; i < bookingCollection.Entities.Count; i++)
{
var booking = bookingCollection.Entities[i];
if (booking == null)
{
continue;
}
var response = new BookingAllocationResponse();
if (booking.Contains(Attributes.Booking.BookingId) && booking[Attributes.Booking.BookingId] != null)
{
response.BookingId = Guid.Parse(booking.Attributes[Attributes.Booking.BookingId].ToString());
}
if (booking.Contains(Attributes.Booking.Name) && booking.Attributes[Attributes.Booking.Name] != null)
{
response.BookingNumber = booking.Attributes[Attributes.Booking.Name].ToString();
}
response.BookingOwner = GetOwner(booking, Attributes.Booking.Owner, false);
var fieldStartDate = AliasName.AccommodationAliasName + Attributes.BookingAccommodation.StartDateandTime;
var fieldEndDate = AliasName.AccommodationAliasName + Attributes.BookingAccommodation.EndDateandTime;
var fieldHotelOwner = AliasName.HotelAliasName + Attributes.Hotel.Owner;
var fieldHotelName = AliasName.HotelAliasName + Attributes.Hotel.Name;
var fieldCustomer = AliasName.RoleAliasName + Attributes.CustomerBookingRole.Customer;
var fieldAccountOwner = AliasName.AccountAliasName + Attributes.Customer.Owner;
var fieldContactOwner = AliasName.ContactAliasName + Attributes.Customer.Owner;
if (booking.Contains(fieldStartDate) && booking[fieldStartDate] != null)
{
response.AccommodationStartDate = DateTime.Parse(((AliasedValue)booking[fieldStartDate]).Value.ToString());
}
if (booking.Contains(fieldEndDate) && booking[fieldEndDate] != null)
{
response.AccommodationEndDate = DateTime.Parse(((AliasedValue)booking[fieldEndDate]).Value.ToString());
}
if (booking.Contains(fieldHotelName) && booking[fieldHotelName] != null)
{
response.HotelName = ((AliasedValue)booking[fieldHotelName]).Value.ToString();
}
var fieldBusinessUnit = GetBusinessUnitField(booking);
if (!string.IsNullOrWhiteSpace(fieldBusinessUnit) && booking.Contains(fieldBusinessUnit) && booking[fieldBusinessUnit] != null)
{
var hotelOwner = GetOwner(booking, fieldHotelOwner, true);
if (hotelOwner != null)
{
response.HotelOwner = hotelOwner;
var businessUnit = (EntityReference)((AliasedValue)booking[fieldBusinessUnit]).Value;
response.SourceMarketBusinessUnit = businessUnit.Name;
var team = childTeam.Find(t => t.ParentTeamId == hotelOwner.Id && t.BusinessUnitId == businessUnit.Id);
if (team != null && team.ChildTeamId != Guid.Empty)
{
response.ChildHotelTeam = new Owner {
Id = team.ChildTeamId, Name = team.ChildTeamName, OwnerType = OwnerType.Team
};
}
}
}
if (booking.Contains(fieldCustomer) && booking[fieldCustomer] != null)
{
var customer = (EntityReference)((AliasedValue)booking[fieldCustomer]).Value;
CustomerType customerType;
Owner owner;
if (customer.LogicalName == EntityName.Contact)
{
customerType = CustomerType.Contact;
}
else
{
customerType = CustomerType.Account;
}
if (booking.Contains(fieldContactOwner) && booking[fieldContactOwner] != null)
{
owner = GetOwner(booking, fieldContactOwner, true);
}
else
{
owner = GetOwner(booking, fieldAccountOwner, true);
}
response.Customer = new Common.Models.Customer()
{
Id = customer.Id, Name = customer.Name, CustomerType = customerType, Owner = owner
};
}
bookingAllocationResponse.Add(response);
}
return(bookingAllocationResponse);
}
/// <summary>
/// This method creates any entity records that this sample requires.
/// </summary>
public void CreateRequiredRecords()
{
// Create a managed solution for the Install or upgrade a solution sample
Guid _tempPublisherId = new Guid();
System.String _tempCustomizationPrefix = "ds";
Guid _tempSolutionsSampleSolutionId = new Guid();
Random rn = new Random();
System.String _TempGlobalOptionSetName = "_TempSampleGlobalOptionSetName" + rn.Next();
Boolean _publisherCreated = false;
Boolean _solutionCreated = false;
//Define a new publisher
Publisher _crmSdkPublisher = new Publisher
{
//UniqueName = "dsleadintegration",
//FriendlyName = "Dotsquares Ltd.",
UniqueName = Constants.PublisherUniqueName,
FriendlyName = Constants.PublisherFriendlyName,
SupportingWebsiteUrl = Constants.PublisherSupportingWebsiteUrl,
CustomizationPrefix = Constants.PublisherCustomizationPrefix,
EMailAddress = Constants.PublisherEmailAddress,
Description = Constants.PublisherDescription
};
//Does publisher already exist?
QueryExpression querySDKSamplePublisher = new QueryExpression
{
EntityName = Publisher.EntityLogicalName,
ColumnSet = new ColumnSet("publisherid", "customizationprefix"),
Criteria = new FilterExpression()
};
querySDKSamplePublisher.Criteria.AddCondition("uniquename", ConditionOperator.Equal, _crmSdkPublisher.UniqueName);
EntityCollection querySDKSamplePublisherResults = _serviceProxy.RetrieveMultiple(querySDKSamplePublisher);
Publisher SDKSamplePublisherResults = null;
//If it already exists, use it
if (querySDKSamplePublisherResults.Entities.Count > 0)
{
SDKSamplePublisherResults = (Publisher)querySDKSamplePublisherResults.Entities[0];
_tempPublisherId = (Guid)SDKSamplePublisherResults.PublisherId;
_tempCustomizationPrefix = SDKSamplePublisherResults.CustomizationPrefix;
}
//If it doesn't exist, create it
if (SDKSamplePublisherResults == null)
{
_tempPublisherId = _serviceProxy.Create(_crmSdkPublisher);
_tempCustomizationPrefix = _crmSdkPublisher.CustomizationPrefix;
_publisherCreated = true;
}
//Upload only configuration page
UploadConfigurationPageForSolution();
//SetWebResourceConfigurationForSolution();
//Create a Solution
//Define a solution
Solution solution = new Solution
{
//UniqueName = "dsleadintegration",
//FriendlyName = "Dotsquares Lead Integration Solution",
//PublisherId = new EntityReference(Publisher.EntityLogicalName, _tempPublisherId),
//Description = "This solution was created by the Dotsquares in the Microsoft Dynamics CRM SDK samples.",
//Version = "1.0",
UniqueName = Constants.SolutionUniqueName,
FriendlyName = Constants.SolutionFriendlyName,
PublisherId = new EntityReference(Publisher.EntityLogicalName, _tempPublisherId),
Description = Constants.SolutionDescription,
Version = Constants.SolutionVersion,
ConfigurationPageId = new EntityReference(WebResource.EntityLogicalName, _webResourceIdForSolution[0])
};
//Check whether it already exists
QueryExpression querySampleSolution = new QueryExpression
{
EntityName = Solution.EntityLogicalName,
ColumnSet = new ColumnSet(),
Criteria = new FilterExpression()
};
querySampleSolution.Criteria.AddCondition("uniquename", ConditionOperator.Equal, solution.UniqueName);
EntityCollection querySampleSolutionResults = _serviceProxy.RetrieveMultiple(querySampleSolution);
Solution SampleSolutionResults = null;
if (querySampleSolutionResults.Entities.Count > 0)
{
SampleSolutionResults = (Solution)querySampleSolutionResults.Entities[0];
_tempSolutionsSampleSolutionId = (Guid)SampleSolutionResults.SolutionId;
}
if (SampleSolutionResults == null)
{
_tempSolutionsSampleSolutionId = _serviceProxy.Create(solution);
_solutionCreated = true;
}
// Add a solution Component
OptionSetMetadata optionSetMetadata = new OptionSetMetadata()
{
Name = _tempCustomizationPrefix + _TempGlobalOptionSetName,
DisplayName = new Label("Example Option Set", _languageCode),
IsGlobal = true,
OptionSetType = OptionSetType.Picklist,
Options =
{
new OptionMetadata(new Label("Option A", _languageCode), null),
new OptionMetadata(new Label("Option B", _languageCode), null)
}
};
CreateOptionSetRequest createOptionSetRequest = new CreateOptionSetRequest
{
OptionSet = optionSetMetadata,
SolutionUniqueName = solution.UniqueName
};
_serviceProxy.Execute(createOptionSetRequest);
//delete webform entity
if (IsEntityExist(_customEntityName) > 0)
{
DeleteEntityRequest customEntityNameFormField = new DeleteEntityRequest()
{
LogicalName = _customEntityName,
};
_serviceProxy.Execute(customEntityNameFormField);
}
// Create the webform entity.
WebForm.WebForm.DotsWebFormEntity();
//delete webfield entity
if (IsEntityExist(_customFieldEntityName) > 0)
{
DeleteEntityRequest customFieldEntityNameFormField = new DeleteEntityRequest()
{
LogicalName = _customFieldEntityName,
};
_serviceProxy.Execute(customFieldEntityNameFormField);
}
// Create the webfield entity.
WebForm.WebForm.DotsWebFieldEntity();
//create relationship with webform and field entity
WebForm.WebForm.CreateRelationShip();
//delete webformconfig entity
if (IsEntityExist(_customConfigurationEntityName) > 0)
{
DeleteEntityRequest customEntityConfigNameFormField = new DeleteEntityRequest()
{
LogicalName = _customConfigurationEntityName,
};
_serviceProxy.Execute(customEntityConfigNameFormField);
}
// Create the config entity.
WebForm.WebForm.DotsWebFormConfigEntity();
// assign entity sample form entity to solution
//##################### Start Assign WebForm Entity #############################
RetrieveEntityRequest retrievepowertEntityRequest = new RetrieveEntityRequest
{
EntityFilters = EntityFilters.Entity,
LogicalName = _customEntityName
};
RetrieveEntityResponse retrievepowerEntityResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrievepowertEntityRequest);
AddSolutionComponentRequest addReq = new AddSolutionComponentRequest()
{
ComponentType = 1,
ComponentId = (Guid)retrievepowerEntityResponse.EntityMetadata.MetadataId,
SolutionUniqueName = solution.UniqueName,
AddRequiredComponents = true
};
_serviceProxy.Execute(addReq);
//##################### End Assign WebForm Entity #############################
// assign entity webfield entity to solution
//##################### Start Assign WebField Entity #############################
RetrieveEntityRequest retrievewebfieldEntityRequest = new RetrieveEntityRequest
{
EntityFilters = EntityFilters.Entity,
LogicalName = _customEntityName
};
RetrieveEntityResponse retrievefieldEntityResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrievewebfieldEntityRequest);
AddSolutionComponentRequest addFieldEntityReq = new AddSolutionComponentRequest()
{
ComponentType = 1,
ComponentId = (Guid)retrievefieldEntityResponse.EntityMetadata.MetadataId,
SolutionUniqueName = solution.UniqueName,
AddRequiredComponents = true
};
_serviceProxy.Execute(addFieldEntityReq);
//##################### End Assign WebField Entity #############################
//assign configuration entity to solution
//##################### End Assign WebConfig Entity #############################
RetrieveEntityRequest retrieveconfigurationtEntityRequest = new RetrieveEntityRequest
{
EntityFilters = EntityFilters.Entity,
LogicalName = _customConfigurationEntityName
};
RetrieveEntityResponse retrieveconfigEntityResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrieveconfigurationtEntityRequest);
AddSolutionComponentRequest addConfigReq = new AddSolutionComponentRequest()
{
ComponentType = 1,
ComponentId = (Guid)retrieveconfigEntityResponse.EntityMetadata.MetadataId,
SolutionUniqueName = solution.UniqueName,
AddRequiredComponents = true
};
_serviceProxy.Execute(addConfigReq);
//##################### End Assign WebConfig Entity #############################
//assign web resource to slution
CreateWebResource(solution.UniqueName);
//assign configuration page above creted to solution
AssiginConfigurationPageToSolution(_webResourceIdForSolution[0], solution.UniqueName);
////assign sitemap to solution
//RetrieveEntityRequest retrieveSiteEntityRequest = new RetrieveEntityRequest
//{
// EntityFilters = EntityFilters.Entity,
// LogicalName = SiteMap.EntityLogicalName,
//};
//RetrieveEntityResponse retrieveSiteEntityResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrieveSiteEntityRequest);
//AddSolutionComponentRequest addReq2 = new AddSolutionComponentRequest()
//{
// ComponentType = 1,
// ComponentId = (Guid)retrieveSiteEntityResponse.EntityMetadata.MetadataId,
// SolutionUniqueName = solution.UniqueName,
// AddRequiredComponents = true
//};
//_serviceProxy.Execute(addReq2);
//Export an a solution
ExportSolutionRequest exportSolutionRequest = new ExportSolutionRequest();
exportSolutionRequest.Managed = false;
exportSolutionRequest.SolutionName = solution.UniqueName;
ExportSolutionResponse exportSolutionResponse = (ExportSolutionResponse)_serviceProxy.Execute(exportSolutionRequest);
byte[] exportXml = exportSolutionResponse.ExportSolutionFile;
System.IO.Directory.CreateDirectory(_outputDir);
File.WriteAllBytes(_managedSolutionLocation, exportXml);
// Delete the solution and the components so it can be installed.
DeleteOptionSetRequest delOptSetReq = new DeleteOptionSetRequest {
Name = (_tempCustomizationPrefix + _TempGlobalOptionSetName).ToLower()
};
_serviceProxy.Execute(delOptSetReq);
DeleteEntityRequest delEntReq = new DeleteEntityRequest {
LogicalName = (_customEntityName)
};
_serviceProxy.Execute(delEntReq);
DeleteEntityRequest delFieldEntReq = new DeleteEntityRequest {
LogicalName = (_customFieldEntityName)
};
_serviceProxy.Execute(delFieldEntReq);
DeleteEntityRequest delEntReqConfig = new DeleteEntityRequest {
LogicalName = (_customConfigurationEntityName)
};
_serviceProxy.Execute(delEntReqConfig);
if (_solutionCreated)
{
_serviceProxy.Delete(Solution.EntityLogicalName, _tempSolutionsSampleSolutionId);
//delete webresorce
foreach (var _id in _webResourceIds)
{
_serviceProxy.Delete(WebResource.EntityLogicalName, _id);
}
//for configuration page above created delete
_serviceProxy.Delete(WebResource.EntityLogicalName, _webResourceIdForSolution[0]);
}
if (_publisherCreated)
{
_serviceProxy.Delete(Publisher.EntityLogicalName, _tempPublisherId);
}
Console.WriteLine("Managed Solution created and copied to {0}", _managedSolutionLocation);
}
public void UpdateChildRecords(string relationshipName, string parentEntityType, string parentEntityId, string parentFieldNameToUpdate, string setValueToUpdate, string childFieldNameToUpdate, bool _UpdateonlyActive)
{
//1) Get child lookup field name
RetrieveRelationshipRequest req = new RetrieveRelationshipRequest()
{
Name = relationshipName
};
RetrieveRelationshipResponse res = (RetrieveRelationshipResponse)service.Execute(req);
OneToManyRelationshipMetadata rel = (OneToManyRelationshipMetadata)res.RelationshipMetadata;
string childEntityType = rel.ReferencingEntity;
string childEntityFieldName = rel.ReferencingAttribute;
//2) retrieve all child records
QueryByAttribute querybyattribute = new QueryByAttribute(childEntityType);
querybyattribute.ColumnSet = new ColumnSet(childEntityFieldName);
if (!_UpdateonlyActive)
{
querybyattribute.Attributes.AddRange(childEntityFieldName);
querybyattribute.Values.AddRange(new Guid(parentEntityId));
}
else
{
querybyattribute.Attributes.AddRange(childEntityFieldName, "statecode");
querybyattribute.Values.AddRange(new Guid(parentEntityId), 0);
}
EntityCollection retrieved = service.RetrieveMultiple(querybyattribute);
//2') retrieve parent fielv value
var valueToUpdate = new object();
if (parentFieldNameToUpdate != null && parentFieldNameToUpdate != "")
{
Entity retrievedEntity = (Entity)service.Retrieve(parentEntityType, new Guid(parentEntityId), new ColumnSet(parentFieldNameToUpdate));
if (retrievedEntity.Attributes.Contains(parentFieldNameToUpdate))
{
valueToUpdate = retrievedEntity.Attributes[parentFieldNameToUpdate];
}
else
{
valueToUpdate = null;
}
}
else
{
valueToUpdate = setValueToUpdate;
}
//3) update each child record
foreach (Entity child in retrieved.Entities)
{
if (childEntityType.ToLower() == "dynamicpropertyinstance")
{
//pending...
UpdateProductPropertiesRequest req2 = new UpdateProductPropertiesRequest();
// req2.
break;
}
RetrieveAttributeRequest reqAtt = new RetrieveAttributeRequest();
reqAtt.EntityLogicalName = childEntityType;
reqAtt.LogicalName = childFieldNameToUpdate;
RetrieveAttributeResponse resAtt = (RetrieveAttributeResponse)service.Execute(reqAtt);
bool valueToUpdateBool = false;
AttributeMetadata meta = resAtt.AttributeMetadata;
Entity entUpdate = new Entity(childEntityType);
entUpdate.Id = child.Id;
if (meta.AttributeType.Value.ToString() == "Boolean")
{
if (valueToUpdate == "1")
{
entUpdate.Attributes.Add(childFieldNameToUpdate, true);
}
else
{
entUpdate.Attributes.Add(childFieldNameToUpdate, false);
}
}
else
{
if (meta.AttributeType.Value.ToString() == "Picklist" || meta.AttributeType.Value.ToString() == "Status")
{
if (valueToUpdate == null)
{
entUpdate.Attributes.Add(childFieldNameToUpdate, null);
}
else
{
if (valueToUpdate is OptionSetValue)
{
valueToUpdate = ((OptionSetValue)valueToUpdate).Value;
}
OptionSetValue opt = new OptionSetValue(Convert.ToInt32(valueToUpdate));
entUpdate.Attributes.Add(childFieldNameToUpdate, opt);
}
}
else
{
entUpdate.Attributes.Add(childFieldNameToUpdate, valueToUpdate);
}
}
service.Update(entUpdate);
}
}
private IEnumerable <Entity> GetByQuery(QueryBase query, int?first = null, int?skip = null)
{
int skipRemaining = 0;
int firstRemaining = first ?? 0;
PagingInfo pageInfo = BuildPagingInfo(500);
if (skip.HasValue && skip.Value != 0)
{
pageInfo.PageNumber = Math.DivRem(skip.Value, pageInfo.Count, out skipRemaining) + 1;
}
SetQueryPagingInfo(query, pageInfo);
bool isCompleted = false;
do
{
EntityCollection tempCollection = CrmContext.OrganizationProxy.RetrieveMultiple(query);
if (tempCollection != null && tempCollection.Entities != null && tempCollection.Entities.Count != 0)
{
int resultCount = tempCollection.Entities.Count;
IEnumerable <Entity> result = tempCollection.Entities;
if (skipRemaining > 0)
{
result = result.Skip(skipRemaining);
resultCount -= skipRemaining;
skipRemaining = 0;
}
if (first.HasValue)
{
if (firstRemaining <= resultCount)
{
result = result.Take(firstRemaining);
isCompleted = true;
}
else
{
firstRemaining -= resultCount;
}
}
foreach (var item in result)
{
yield return(item);
}
if (tempCollection.MoreRecords && !isCompleted)
{
pageInfo.PageNumber++;
pageInfo.PagingCookie = tempCollection.PagingCookie;
SetQueryPagingInfo(query, pageInfo);
}
else
{
isCompleted = true;
}
}
else
{
isCompleted = true;
}
} while (!isCompleted);
}
public static bool IsNullOrEmpty(EntityCollection entityCollection)
{
return(entityCollection == null ||
entityCollection.Entities == null ||
entityCollection.Entities.Count == 0);
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <RetrieveMultipleRequest>(orgRequest);
var queryExpr = request.Query as QueryExpression;
var fetchExpr = request.Query as FetchExpression;
var queryByAttr = request.Query as QueryByAttribute;
if (fetchExpr != null)
{
queryExpr = XmlHandling.FetchXmlToQueryExpression(fetchExpr.Query);
}
else if (queryByAttr != null)
{
queryExpr = Utility.QueryByAttributeToQueryExpression(queryByAttr);
}
if (queryExpr.EntityName == null)
{
throw new FaultException("The 'RetrieveMultiple' method does not support entities of type 'none'");
}
FillAliasIfEmpty(queryExpr);
var collection = new EntityCollection();
db.PrefillDBWithOnlineData(queryExpr);
var linkEntities = new Dictionary <string, IEnumerable <Entity> >();
var linkToEntities = queryExpr.LinkEntities.GroupBy(x => x.LinkToEntityName);
foreach (var linkToEntity in linkToEntities)
{
linkEntities.Add(linkToEntity.Key, db.GetEntities(linkToEntity.Key));
}
var rows = db.GetEntities(queryExpr.EntityName, queryExpr.Criteria.Conditions);
foreach (var row in rows)
{
var entity = row;
var toAdd = core.GetStronglyTypedEntity(entity, core.GetEntityMetadata(queryExpr.EntityName), null);
if (queryExpr.LinkEntities.Count > 0)
{
foreach (var linkEntity in queryExpr.LinkEntities)
{
var alliasedValues = GetAliasedValuesFromLinkentity(linkEntity, entity, toAdd, db);
collection.Entities.AddRange(
alliasedValues
.Where(e => Utility.MatchesCriteria(e, queryExpr.Criteria)));
}
}
else if (Utility.MatchesCriteria(toAdd, queryExpr.Criteria))
{
collection.Entities.Add(toAdd);
}
}
var filteredEntities = new EntityCollection();
filteredEntities.Entities.AddRange(collection.Entities.Where(e => security.HasPermission(e, AccessRights.ReadAccess, userRef)));
var orders = queryExpr.Orders;
var orderedCollection = new EntityCollection();
// TODO: Check the order that the orders are executed in is correct
if (orders.Count > 2)
{
throw new MockupException("Number of orders are greater than 2, unsupported in crm");
}
else if (orders.Count == 1)
{
if (orders.First().OrderType == OrderType.Ascending)
{
orderedCollection.Entities.AddRange(filteredEntities.Entities.OrderBy(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName)));
}
else
{
orderedCollection.Entities.AddRange(filteredEntities.Entities.OrderByDescending(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName)));
}
}
else if (orders.Count == 2)
{
if (orders[0].OrderType == OrderType.Ascending && orders[1].OrderType == OrderType.Ascending)
{
orderedCollection.Entities.AddRange(filteredEntities.Entities
.OrderBy(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName))
.ThenBy(x => Utility.GetComparableAttribute(x.Attributes, orders[1].AttributeName)));
}
else if (orders[0].OrderType == OrderType.Ascending && orders[1].OrderType == OrderType.Descending)
{
orderedCollection.Entities.AddRange(filteredEntities.Entities
.OrderBy(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName))
.ThenByDescending(x => Utility.GetComparableAttribute(x.Attributes, orders[1].AttributeName)));
}
else if (orders[0].OrderType == OrderType.Descending && orders[1].OrderType == OrderType.Ascending)
{
orderedCollection.Entities.AddRange(filteredEntities.Entities
.OrderByDescending(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName))
.ThenBy(x => Utility.GetComparableAttribute(x.Attributes, orders[1].AttributeName)));
}
else if (orders[0].OrderType == OrderType.Descending && orders[1].OrderType == OrderType.Descending)
{
orderedCollection.Entities.AddRange(filteredEntities.Entities
.OrderByDescending(x => Utility.GetComparableAttribute(x.Attributes, orders[0].AttributeName))
.ThenByDescending(x => Utility.GetComparableAttribute(x.Attributes, orders[1].AttributeName)));
}
}
var colToReturn = new EntityCollection();
if (orderedCollection.Entities.Count != 0)
{
foreach (var entity in orderedCollection.Entities)
{
KeepAttributesAndAliasAttributes(entity, queryExpr.ColumnSet);
}
colToReturn = orderedCollection;
}
else
{
foreach (var entity in filteredEntities.Entities)
{
KeepAttributesAndAliasAttributes(entity, queryExpr.ColumnSet);
}
colToReturn = filteredEntities;
}
#if !(XRM_MOCKUP_2011 || XRM_MOCKUP_2013)
foreach (var enitity in colToReturn.Entities)
{
ExecuteCalculatedFields(enitity);
}
#endif
// According to docs, should return -1 if ReturnTotalRecordCount set to false
colToReturn.TotalRecordCount = queryExpr.PageInfo.ReturnTotalRecordCount ? colToReturn.Entities.Count : -1;
var resp = new RetrieveMultipleResponse();
resp.Results["EntityCollection"] = colToReturn;
return(resp);
}
/// <summary>Gets the member collections queue from the queue (base first)</summary>
/// <param name="collectionsQueue">The collections queue.</param>
protected override void GetFromMemberEntityCollectionsQueue(Queue <IEntityCollection2> collectionsQueue)
{
base.GetFromMemberEntityCollectionsQueue(collectionsQueue);
this._products = (EntityCollection <ProductEntity>)collectionsQueue.Dequeue();
this._categoriesCollectionViaProducts = (EntityCollection <CategoryEntity>)collectionsQueue.Dequeue();
}
/// <summary>Gets the member collections queue from the queue (base first)</summary>
/// <param name="collectionsQueue">The collections queue.</param>
protected override void GetFromMemberEntityCollectionsQueue(Queue <IEntityCollection2> collectionsQueue)
{
base.GetFromMemberEntityCollectionsQueue(collectionsQueue);
this._specialOfferProducts = (EntityCollection <SpecialOfferProductEntity>)collectionsQueue.Dequeue();
}
public void GetAndSetFetchXml(string entityLogicalName, Guid primaryKeyId, IOrganizationService orgSvc)
{
Entity e = new Entity("gqs_globalquicksearchconfig");
e["gqs_globalquicksearchconfigid"] = primaryKeyId;
e["gqs_quicksearchfetchxml"] = null;
e["gqs_quicksearchformattedfetchxml"] = null;
e["gqs_message"] = null;
QueryExpression query = new QueryExpression();
query.EntityName = "savedquery";
query.ColumnSet.AddColumns("returnedtypecode", "fetchxml", "layoutxml");
query.Criteria.AddCondition(new ConditionExpression("returnedtypecode", ConditionOperator.Equal, entityLogicalName));
query.Criteria.AddCondition(new ConditionExpression("querytype", ConditionOperator.Equal, 4));
query.Criteria.AddCondition(new ConditionExpression("isdefault", ConditionOperator.Equal, true));
EntityCollection ec = null;
try
{
ec = orgSvc.RetrieveMultiple(query);
}
catch (FaultException <OrganizationServiceFault> Ex)
{
e["gqs_message"] = Ex.Detail.Message;
orgSvc.Update(e);
throw;
}
if (ec != null && ec.Entities.Count > 0)
{
#region If True
string _fetchXml = ec.Entities[0]["fetchxml"].ToString();
XDocument xDoc = XDocument.Parse(_fetchXml);
Dictionary <string, string> cells = GetLayout(ec.Entities[0]["layoutxml"].ToString());
RetrieveEntityRequest entityMetadataReq = new RetrieveEntityRequest();
entityMetadataReq.LogicalName = entityLogicalName;
entityMetadataReq.EntityFilters = Microsoft.Xrm.Sdk.Metadata.EntityFilters.Entity | Microsoft.Xrm.Sdk.Metadata.EntityFilters.Attributes;
RetrieveEntityResponse entityMetadataRes = (RetrieveEntityResponse)orgSvc.Execute(entityMetadataReq);
if (entityMetadataRes != null && entityMetadataRes.EntityMetadata != null)
{
XElement entityXmlElement = xDoc.Root.Element("entity");
entityXmlElement.SetAttributeValue("displayName", entityMetadataRes.EntityMetadata.DisplayCollectionName.UserLocalizedLabel.Label);
int _displayOrder = 1;
foreach (KeyValuePair <string, string> cell in cells)
{
//string _logicalname = cell.Key;
XElement attributeXml = entityXmlElement.Elements("attribute").Where(a => a.Attribute("name").Value == cell.Key).FirstOrDefault <XElement>();
if (attributeXml != null)
{
string _logicalname = attributeXml.Attribute("name").Value;
AttributeMetadata atm = entityMetadataRes.EntityMetadata.Attributes.Where(a => a.LogicalName == _logicalname).FirstOrDefault <AttributeMetadata>();
attributeXml.SetAttributeValue("displayName", atm.DisplayName.UserLocalizedLabel.Label);
attributeXml.SetAttributeValue("displayOrder", _displayOrder++);
attributeXml.SetAttributeValue("columnWidth", cell.Value);
if (atm.IsPrimaryId.Value)
{
attributeXml.SetAttributeValue("isPk", true);
}
else
{
attributeXml.SetAttributeValue("isPk", false);
}
//if (atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Lookup ||
// atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Picklist ||
// atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Customer)
//{
// foreach (XElement conditionXml in entityXmlElement.Descendants("condition").Where(a => a.Attribute("attribute").Value == _logicalname))
// {
// conditionXml.SetAttributeValue("attribute", _logicalname + "name");
// }
//}
}
#region Commented Code
//foreach (XElement attributeXml in entityXmlElement.Elements("attribute"))
//{
// string _logicalname = attributeXml.Attribute("name").Value;
// AttributeMetadata atm = entityMetadataRes.EntityMetadata.Attributes.Where(a => a.LogicalName == _logicalname).FirstOrDefault<AttributeMetadata>();
// attributeXml.SetAttributeValue("displayName", atm.DisplayName.UserLocalizedLabel.Label);
// if (atm.IsPrimaryId.Value)
// {
// attributeXml.SetAttributeValue("isPk", true);
// }
// else
// {
// attributeXml.SetAttributeValue("isPk", false);
// }
// if (atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Lookup ||
// atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Picklist ||
// atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Customer)
// {
// foreach (XElement conditionXml in entityXmlElement.Descendants("condition").Where(a => a.Attribute("attribute").Value == _logicalname))
// {
// conditionXml.SetAttributeValue("attribute", _logicalname + "name");
// }
// }
//}
#endregion
}
//Removing related entity with name = link-entity
entityXmlElement.Descendants("link-entity").Remove <XElement>();
//Removing condition element which has value !="{0}"
entityXmlElement.Descendants("condition").Where(a => a.Attribute("value").Value != "{0}").Remove <XElement>();
foreach (XElement conditionXml in entityXmlElement.Descendants("condition"))
{
string _logicalname = conditionXml.Attribute("attribute").Value;
AttributeMetadata atm = entityMetadataRes.EntityMetadata.Attributes.Where(a => a.LogicalName == _logicalname).FirstOrDefault <AttributeMetadata>();
if (atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Lookup ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Picklist ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Customer ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Owner ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Status ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.State ||
atm.AttributeType == Microsoft.Xrm.Sdk.Metadata.AttributeTypeCode.Boolean)
{
conditionXml.SetAttributeValue("attribute", _logicalname + "name");
}
}
e["gqs_quicksearchfetchxml"] = _fetchXml;
e["gqs_quicksearchformattedfetchxml"] = xDoc.ToString();
}
else
{
e["gqs_message"] = string.Format("Unable to retrieve Entity Metadata for given Entity Logical Name: {0}", entityLogicalName);
}
#endregion
}
else
{
e["gqs_message"] = string.Format("Given Entity Logical Name: {0}, is invalid, please give correct entity logical name and save the record", entityLogicalName);
}
orgSvc.Update(e);
}
public void Execute(IServiceProvider serviceProvider)
{
var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
var factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
var service = factory.CreateOrganizationService(context.UserId);
var image = (Entity)context.PostEntityImages["PostImage"];
try
{
if (!image.Attributes.Contains("blu_reporttype"))
{
return;
}
var productEr = image.GetAttributeValue <EntityReference>("blu_reporttype");
#region Update Sales Order Product > Product Inventory Lookup
propertyId = image.GetAttributeValue <EntityReference>("blu_property").Id;
#region query Sales Order Product
var fetchXmlSalesOrderProduct = string.Empty;
fetchXmlSalesOrderProduct += "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>";
fetchXmlSalesOrderProduct += " <entity name='salesorderdetail'>";
fetchXmlSalesOrderProduct += " <attribute name='salesorderdetailid'/>";
fetchXmlSalesOrderProduct += " <filter type='and'>";
fetchXmlSalesOrderProduct += " <condition attribute='blu_productinventory' operator='null'/>";
fetchXmlSalesOrderProduct += " </filter>";
fetchXmlSalesOrderProduct += " <link-entity name='product' from='productid' to='productid' link-type='inner'>";
fetchXmlSalesOrderProduct += " <filter type='and'>";
fetchXmlSalesOrderProduct += " <condition attribute='blu_stockingproduct' operator='eq' value='" + productEr.Id.ToString() + "'/>";
fetchXmlSalesOrderProduct += " </filter>";
fetchXmlSalesOrderProduct += " </link-entity>";
fetchXmlSalesOrderProduct += " <link-entity name='salesorder' from='salesorderid' to='salesorderid' link-type='inner'>";
fetchXmlSalesOrderProduct += " <attribute name='blu_regardingpropertyid'/>";
fetchXmlSalesOrderProduct += " <filter type='and'>";
fetchXmlSalesOrderProduct += " <condition attribute='blu_regardingpropertyid' operator='eq' value='" + propertyId.ToString() + "'/>";
fetchXmlSalesOrderProduct += " <condition attribute='statecode' operator='eq' value='0'/>";
fetchXmlSalesOrderProduct += " </filter>";
fetchXmlSalesOrderProduct += " </link-entity>";
fetchXmlSalesOrderProduct += " </entity>";
fetchXmlSalesOrderProduct += "</fetch>";
#endregion
EntityCollection ecSalesOrderProduct = service.RetrieveMultiple(new FetchExpression(fetchXmlSalesOrderProduct));
if (ecSalesOrderProduct.Entities.Count > 0)
{
foreach (var enSalesOrderProduct in ecSalesOrderProduct.Entities)
{
enSalesOrderProduct["blu_productinventory"] = new EntityReference("blu_productinventory", context.PrimaryEntityId);
service.Update(enSalesOrderProduct);
}
}
#endregion
}
catch (FaultException <OrganizationServiceFault> ex)
{
throw new InvalidPluginExecutionException("An error occurred in the InspectionDetailPostCreate plug-in.", ex);
}
catch (Exception ex)
{
throw;
}
}
protected override void InitializeCollections()
{
NodeType = "SalesTaxRate";
StateProvince = new EntityCollection <StateProvince>(Wrapper, Members.StateProvince);
}
/// <summary>
/// Add party list from custom Party query
/// </summary>
/// <param name="entColl">collection of entities retrieved from custom party query</param>
/// <param name="partylist">collection of party list</param>
/// <param name="participationType">participation type</param>
/// <param name="service">organization service</param>
private static void AddPartyListFromCustomQuery(EntityCollection entColl, List <PartyList> partylist, int participationType, IOrganizationService service)
{
foreach (Entity ent in entColl.Entities)
{
if (ent.LogicalName == "systemuser")
{
// If entity collection is of type system user
EntityReference user = new EntityReference(ent.LogicalName, ent.Id);
partylist.Add(new PartyList()
{
ParticipationType = participationType, PartyId = user, RelatedEntityId = user.Id, RelatedEntityLogicalName = user.LogicalName
});
}
else if (ent.LogicalName == "team")
{
// if entity collection type is of Team
EntityReference team = new EntityReference(ent.LogicalName, ent.Id);
AddTeamMembertoPartyList(team, null, partylist, participationType, service);
}
else
{
if (ent.Attributes.Count == 1 && ent.Attributes.Where(a => a.Value.GetType().ToString() == "System.Guid").Count() == 1)
{
// if Custom query has only primary guid attribute
EntityReference eref = new EntityReference(ent.LogicalName, ent.Id);
partylist.Add(new PartyList()
{
ParticipationType = participationType, PartyId = eref, RelatedEntityId = eref.Id, RelatedEntityLogicalName = eref.LogicalName
});
}
else
{
// seperate out Entityreference for normal and Aliased type of attributes
var attribute = ent.Attributes.Where(a => (a.Value.GetType().ToString() == "Microsoft.Xrm.Sdk.EntityReference" ||
(a.Value.GetType().ToString() == "Microsoft.Xrm.Sdk.AliasedValue" &&
((AliasedValue)a.Value).Value.GetType().ToString() == "Microsoft.Xrm.Sdk.EntityReference")));
foreach (KeyValuePair <string, object> val in attribute)
{
// get only entity reference type attribute
EntityReference eref = null;
if (val.Value.GetType().ToString() == "Microsoft.Xrm.Sdk.EntityReference")
{
eref = (EntityReference)val.Value;
}
else
{
eref = (EntityReference)((AliasedValue)val.Value).Value;
}
if (eref.LogicalName == "team")
{
// add team member to party list
AddTeamMembertoPartyList(eref, ent, partylist, participationType, service);
}
else
{
// add user and other entity attribute to partylist
partylist.Add(new PartyList {
ParticipationType = participationType, PartyId = eref, RelatedEntityId = ent.Id, RelatedEntityLogicalName = ent.LogicalName
});
}
}
}
}
}
}
/// <summary>Gets the member collections queue from the queue (base first)</summary>
/// <param name="collectionsQueue">The collections queue.</param>
protected override void GetFromMemberEntityCollectionsQueue(Queue <IEntityCollection2> collectionsQueue)
{
base.GetFromMemberEntityCollectionsQueue(collectionsQueue);
this._postTag = (EntityCollection <PostTagEntity>)collectionsQueue.Dequeue();
this._postCollectionViaPostTag = (EntityCollection <PostEntity>)collectionsQueue.Dequeue();
}
/// <summary>Gets the member collections queue from the queue (base first)</summary>
/// <param name="collectionsQueue">The collections queue.</param>
protected override void GetFromMemberEntityCollectionsQueue(Queue <IEntityCollection2> collectionsQueue)
{
base.GetFromMemberEntityCollectionsQueue(collectionsQueue);
this._businessEntityAddresses = (EntityCollection <BusinessEntityAddressEntity>)collectionsQueue.Dequeue();
this._businessEntityContacts = (EntityCollection <BusinessEntityContactEntity>)collectionsQueue.Dequeue();
}
//Created By : Jerome Anthony Gerero, Created On : 5/6/2016
public Entity CreateExtendedPriceListItemRecord(Entity priceListItemEntity)
{
if (CheckifExtendedPriceListItemExist(priceListItemEntity))
{
return(null);
}
;
_tracingService.Trace("Started CreateManyToManyRelationship method..");
var priceList = priceListItemEntity.GetAttributeValue <EntityReference>("pricelevelid") != null
? priceListItemEntity.GetAttributeValue <EntityReference>("pricelevelid")
: null;
var priceListId = Guid.Empty;
var priceListName = String.Empty;
if (priceList != null)
{
priceListId = priceList.Id;
priceListName = priceList.Name;
}
var productId = priceListItemEntity.GetAttributeValue <EntityReference>("productid") != null
? priceListItemEntity.GetAttributeValue <EntityReference>("productid").Id
: Guid.Empty;
_tracingService.Trace("1");
EntityCollection productCollection = CommonHandler.RetrieveRecordsByOneValue("product", "productid", productId, _organizationService, null, OrderType.Ascending,
new[] { "name", "gsc_optioncode", "gsc_modelcode", "gsc_modelyear", "gsc_vehiclemodelid" });
_tracingService.Trace("2");
if (productCollection != null && productCollection.Entities.Count > 0)
{
Entity product = productCollection.Entities[0];
_tracingService.Trace("3");
var productName = product.Contains("name")
? product.GetAttributeValue <String>("name")
: String.Empty;
_tracingService.Trace("4");
//Create Extended Price List Item record on Price List Item create
Entity extendedPriceListItem = new Entity("gsc_cmn_extendedpricelistitem");
extendedPriceListItem["gsc_extendedpricelistitempn"] = priceListName + "-" + productName;
extendedPriceListItem["gsc_productid"] = new EntityReference("product", product.Id);
extendedPriceListItem["gsc_pricelistid"] = new EntityReference("pricelevel", priceListId);
extendedPriceListItem["gsc_modeldescription"] = productName;
extendedPriceListItem["gsc_modelcode"] = product.Contains("gsc_modelcode")
? product.GetAttributeValue <String>("gsc_modelcode")
: String.Empty;
extendedPriceListItem["gsc_optioncode"] = product.Contains("gsc_optioncode")
? product.GetAttributeValue <String>("gsc_optioncode")
: String.Empty;
extendedPriceListItem["gsc_modelyear"] = product.Contains("gsc_modelyear")
? product.GetAttributeValue <String>("gsc_modelyear")
: String.Empty;
extendedPriceListItem["gsc_basemodel"] = product.GetAttributeValue <EntityReference>("gsc_vehiclemodelid") != null
? product.GetAttributeValue <EntityReference>("gsc_vehiclemodelid").Name
: String.Empty;
_tracingService.Trace("5");
Guid extendedPriceListItemId = _organizationService.Create(extendedPriceListItem);
_tracingService.Trace("6");
//Collection of entities to be associated to Price List Item
EntityReferenceCollection extendedPriceListItemCollection = new EntityReferenceCollection();
extendedPriceListItemCollection.Add(new EntityReference("gsc_cmn_extendedpricelistitem", extendedPriceListItemId));
_tracingService.Trace("7");
//Associate Extended Price List Item with Price List Item
_organizationService.Associate("productpricelevel", priceListItemEntity.Id, new Relationship("gsc_gsc_cmn_extendedpricelistitem_productpric"), extendedPriceListItemCollection);
}
_tracingService.Trace("Ended CreateManyToManyRelationship method..");
return(priceListItemEntity);
}
/// <summary>
/// Initializes a new instance of the <see cref="Circuit"/> class.
/// </summary>
/// <param name="comparer">The <see cref="IEqualityComparer{T}" /> implementation to use when comparing entity names, or <c>null</c> to use the default <see cref="EqualityComparer{T}"/>.</param>
public Circuit(IEqualityComparer <string> comparer)
{
Entities = new EntityCollection(comparer);
}
/// <summary>Gets the member collections queue from the queue (base first)</summary>
/// <param name="collectionsQueue">The collections queue.</param>
protected override void GetFromMemberEntityCollectionsQueue(Queue <IEntityCollection2> collectionsQueue)
{
base.GetFromMemberEntityCollectionsQueue(collectionsQueue);
this._userGroups = (EntityCollection <UserGroupEntity>)collectionsQueue.Dequeue();
}
public string GetNextPermitNumber()
{
//Retrieve the autonumbering record
QueryExpression query = new QueryExpression("defra_autonumbering")
{
ColumnSet = new ColumnSet("defra_locked"),
Criteria = new FilterExpression()
{
Conditions =
{
new ConditionExpression("statecode", ConditionOperator.Equal, 0)
//new ConditionExpression("defra_name", ConditionOperator.Equal, "Waste");
}
}
};
EntityCollection results = Service.RetrieveMultiple(query);
//Throw an exception if the autonumbering record does not exist
if (results.Entities.Count == 0)
{
throw new InvalidPluginExecutionException("The autonumbering record cannot be found!");
}
//Pre-lock the autonumbering table. Refer to the Microsoft Scalability White Paper for more details https://www.microsoft.com/en-us/download/details.aspx?id=45905
Entity autoNum = new Entity(results.Entities[0].LogicalName)
{
Id = results.Entities[0].Id
};
autoNum["defra_locked"] = true;
Service.Update(autoNum);
//Retrieve safely the autonumbering record
var lockedAutonumber = Service.Retrieve(autoNum.LogicalName, autoNum.Id, new ColumnSet(new string[] { "defra_prefix", "defra_suffix", "defra_currentnumber" }));
var currentNumber = (int)lockedAutonumber["defra_currentnumber"];
var prefix = lockedAutonumber.GetAttributeValue <string>("defra_prefix");
var suffix = lockedAutonumber.GetAttributeValue <string>("defra_suffix");
// Increment suffix
if (currentNumber == 9999)
{
currentNumber = 1;
suffix = GetNextSuffix(suffix);
}
else
{
++currentNumber;
}
TracingService.Trace("CurrentNumber: {0}", currentNumber.ToString("0000"));
TracingService.Trace("Suffix: {0}", suffix);
var nextPermitNumber = string.Format("{0}{1}{2}", prefix, currentNumber.ToString("0000"), suffix);
//Update the sequence number
var counterUpdater = new Entity(autoNum.LogicalName);
counterUpdater.Id = autoNum.Id;
counterUpdater["defra_currentnumber"] = currentNumber;
counterUpdater["defra_suffix"] = suffix;
counterUpdater["defra_locked"] = false;
Service.Update(counterUpdater);
TracingService.Trace("Exiting GetNextPermitNumber, Correlation Id: {0}", Context.CorrelationId);
return(nextPermitNumber);
}
public RetrieveMultipleResponse(EntityCollection results)
{
this.EntityCollection = results;
}
internal static IQueryable<BL.DomainModel.OrderDetail> AdaptOrderDetails(EntityCollection<OrderDetail> orderDetailCollection, BL.DomainModel.Order o)
{
if (orderDetailCollection.IsLoaded == false)
{
return null;
}
var orderDetails = from d in orderDetailCollection.AsEnumerable()
select AdaptOrderDetail(d, o);
return orderDetails.AsQueryable();
}
