Master Data Services : outil de mises à jour de requêtes Excel

Hi

This small tool allows you to Load, Edit, and save MDS queries with operators that are not available in current mds add-in
232951
you can download the source code (.Net C# 4.0 Client Profile, VS2010) of my tool here (FREE) HERE
OR
binary only: HERE

very easy to use:

Load your already generated query

then choose a new Operator and edit the criteria

and then save the updated query

you can use all these operators:
[Description("")] NotSpecified,
[Description("=")] IsEqual,
[Description("<>")] IsNotEqual,
[Description("LIKE")] Like,
[Description("NOT LIKE")] NotLike,
[Description(">")] GreaterThan,
[Description("< ")] LessThan, [Description(">=")] GreaterThanOrEqual,
[Description("< =")] LessThanOrEqual,
[Description("MATCH")] Matches,
[Description("NOT MATCH")] NotMatches,
[Description("REGEX")] ContainsPattern,
[Description("NOT REGEX")] NotContainsPattern,
[Description("IS NULL")] IsNull,
[Description("IS NOT NULL")] IsNotNull,
[Description("IN")] In,
[Description("NOT IN")] NotIn,
[Description("DIRECT DECENDANTS")] DirectDecendants,
[Description("ALL DECENDANTS")] AllDecendants,

More info on sql mds 2012 MSDN blog

Deux livres sur Microsoft SQL Server 2008 R2 Master Data Services

A ma connaissance, il existe 2 livres principaux(en anglais seulement),
traitant de SQL 2008 R2 Master Data Services, la solution de MDM de Microsoft,
qui est incluse dans la suite SQL Server 2008 R2.

J’ai eu l’occasion d’échanger personnellement quelques discussions avec les auteurs de ces 2 livres
(principalement via internet, sur le forum Microsoft MDS ou par email, téléphone),
qui m’ont gentiment offert un exemplaire de leur livre, afin de pouvoir exposer mon point de vue.

Voici donc une présentation des deux livres,
le but n’étant pas de mettre des notes et de dire si l’un ou l’autre est mieux, mais plutôt
de présenter les différences et le contenu.

Le 1er livre que j’ai pu lire donc, il y a déjà quelques mois, étant celui de

 Suzanne Selhorn et Tyler Graham,
de l’équipe MDS Microsoft elle-même :

Microsoft SQL Server 2008 R2 Master Data Services: 

Implementation & Administration

(360 pages)

Ce livre fut pour moi, ayant découvert MDS quasiment à sa sortie, comme un livre de chevet, si j’ose dire. Les pages usées peuvent en témoigner !
J’ai eu l’occasion de me servir de cet ouvrage à de nombreuses reprises, notamment pour avoir des références, comme j’utiliserais un dictionnaire.

Voici le plan du livre:

Chapitre 1 : Introduction à MDS

-          qu’est-ce que le master data management

-          histoire du master data management

-          un aperçu des solutions de MDM

-          la solution MDM de Microsoft

-          à propos de l’exemple “société’

-          résumé

Chapitre 2: installation et configuration

-          déterminer le périmètre initial de votre projet

-          préparer votre serveur web

-          installer MDS

-          créer une base de donnée MDS

-          créer l’application web de gestion des Master Data

-          sécuriser votre application Web

-          obtenir la dernière version de MDS

-          résumé

Chapitre 3 : commencer un projet MDS

-          Comment reconnaitre des données de référence quand j’en vois

-          Modèles de processus métier

-          Rôles système

-          Associer les données (mapping)

-          Un exemple : la société « Main Street Clothing »

-          Déterminer les types de sytème

-          Nettoyage des données pour l’import initial vers MDS

-          Résumé

Chapitre 4 : Création de votre modèle

-          Concepts de modélisation MDS

-          Créer un modèle

-          Déployer un modèle

-          A propos des modèles

-          A propos des entités

-          A propos des membres

-          A propos des attributs

-          A propos des groupes d’attributs

-          Utilisation des services Web

-          Résumé

Chapitre 5 : Intégration de MDS avec d’autres systèmes

-          Architecture de « staging »

-          Préparation des données pour l‘import

-          Chargement des membres

-          Chargement des attributs

-          Chargement des relations

-          Import des données dans les tables de « staging »

-          Initialisation du processus de « staging »

-          Utilisation des services web pour établir les données

-          Les erreurs qui peuvent se produires pendant le « staging »

-          Comment voir la table de « staging batch »

-          Résumé

Chapitre 6 : travailler avec les hierarchies et les collections

-          Hiérarchies « nichées » (en anglais : « ragged ») et hiérarchies basées sur un niveau

-          Création de hiérarchies dérivées

-          Paramétrage du système pour les hiérarchies

-          Création de hiérarchies explicites

-          Hiérarchies récursives

-          Hiérarchies dérivées incluant une hiérarchie explicite

-          Collections

-          Création de hiérarchies avec les services Web

-          Résumé

Chapitre 7 : travailler avec les données de référence

-          Comment voir l’entité de base

-          Filtrer des données dans la grille

-          Tri et pagination

-          Edition des attributs

-          Export des membres

-          Travailler avec les données hiérarchiques

-          Transactions

-          Commentaires

-          Métadonnées

-          Utilisation des services Web pour agir sur les membres

-          Résumé

Chapitre 8 : utilisation des règles métier

-          Apercu des règles métier

-          Création d’une règle métier

-          Configuration de l’expression d’une règle

-          Publication d’une règle

-          Application des règles métier

-          D’autres fonctions des règles métier

-          Configuration des notifications par e-mail

-          Création et déclenchement d’un flux de travail (« Workflow »)

-          Utilisation des services Web pour gérer les règles métier

-          Résumé

Chapitre 9 : création des versions de données

-          Aperçu des versions

-          Mise à jour du nom et de la description de votre version

-          Statuts des versions

-          Validation d’une version

-          Revue et retour-arrière sur des transactions

-          Publier et copier une version

-          Indicateurs de version («version flags »)

-          Voir les ancêtres d’une version

-          Utilisation des services Web pour travailler sur les versions

-          Résumé

 Chapitre 10 : utilisation des métadonnées

-          Le modèle de métadonnées

-          Ajouter des métadonnées

-          Enrichir le modèle de métadonnées

-          Utilisation des métadonnées via les services Web

-          Résumé

Chapitre 11 : implémentation de la sécurité

-          Apercu de la sécurité

-          Utilisateurs et groupes

-          Administrateurs

-          Tester les permissions

-          Permissions fonctionnelles localisées

-          Permissions sur le modèle objet

-          Supprimer des permissions

-          Permissions des membres hiérarchiques

-          Déterminer quelles permissions appliquer

-          Paramétrer la sécurité en utilisant les services Web

-          Résumé

Chapitre 12 : publication des données vers des systèmes externes

-          Export des données vers les systèmes de souscription

-          Formats des vue de souscription (« subscription views » en anglais)

-          Architecture de la vue commune

-          vues de souscription et déploiement de modèle

-          création d’une vue de souscription avec les services Web

-          comment la société « Main Street Clothing » utilise les vues de soucscription

-          résumé

chapitre 13 : extension de MDS avec les services Web

-          exposition du service Web

-          exposition du WSDL

-          création d’un projet MDS dans Visual Studio

-          création d’une couche d’abstraction

-          actions du service Web MDS

-          Les actions les plus courantes

-          Gestion des erreurs dans le service Web

-          Résumé


Voici le 2ème livre sorti, à ma connaissance, sur MDS,
par  Jeremy Kashel, Tim Kent et Martyn Bullerwell

 

Microsoft SQL Server 2008 R2 Master Data Services

 

(337 pages)

Chapitre 1 : la gestion des données de référence

  • le besoin de gérer les données de référence
  • mises à jour manuelles
  • des descriptions différentes pour les mêmes attributs
  • fusions et acquisitions
  • apercu de la gestion des données de référence
  • qualité des données
  • gestion des données de référence opérationnelle et analytique
  • MDM analytique
  • MDM opérationnel
  • Différentes approches du MDM
  • « hub » de transactions
  • Registre
  • Hybride
  • Gouvernance des données
  • « data stewardship »
  • Changements politiques et organisationnels
  • Résumé
  • Références

Chapitre 2 : aperçu de Master Data Services

-          Aperçu de master data services

-          Architecture de MDS

  • Base de données MDS SQL Server
  • IIS

-          Master Data Manager

  • Accéder au Master Data Manager

-          Résumé

Chapitre 3 : installation et configuration de MDS

-          Planification d’une installation de MDS

  • Topologie du serveur
  • Compte de service de la base de données
  • Compte administrateur

-          Installation de Master Data Services

-          Gestionnaire de configuration de MDS

  • Configuration de MDS à la 1ère utilisation

-          Installation des modèles d’exemple

-          Résumé

Chapitre 4 : création et utilisation des modèles

-          Aperçu du modèle objet MDS

-          Modèles

-          Entités et attributs

  • Attributs
  • Attributs de domaine et relation inter-entités
  • Création d’une entité
  • Edition d’une entité

-          Membres

  • L’explorateur du « Master Data Manager »

-          Groupes d’attributs

  • Création de groupes d’attributs
  • Utilisation des groupes d’attributs

-          Hiérarchies

  • Hiérarchies dérivées
  • Hiérarchies explicites

-          Collections

  • Création d’une collection

-          Métadonnées MDS

  • Modification des metadonnées MDS par défaut
  • Voir les métadonnées
  • Métadonnées définies par l’utilisateur

-          Résumé

Chapitre 5 : Gestion des versions

-          Introduction aux versions

  • Le besoin des versions
  • L’interface des versions
  • Statut des versions

-          Création et gestion des versions

  • Copie d’une version
  • Gestion des versions
  • Utilisation des versions

-          Validation des versions

  • Statut de validation de membre
  • Valider une version

-          Verrouiller, déverrouiller, et publier des versions

  • Notifications
  • Verrouiller des versions
  • Déverrouiller des versions
  • Publier des versions

-          Gestion des indicateurs (« flags », en anglais »)

-          Transactions

-          Résumé

Chapitre 6 : importer des données dans MDS

-          Le processus de chargement des « staging »

  • Introduction

-          Peupler MDS – étape 1 : peupler les tables de « staging »

  • Création de nouveaux membres
  • Création de nouvelles collections
  • Ajout de membres à des collections
  • Mise à jour d’attributs de membre
  • Suppression d’un membre (ou d’une collection)

-          Peupler MDS –étape 2 : invoquer le processus de « staging »

-          Peupler MDS – étape 3 : valider le modèle

-          Effacer les tables de « staging »

-          Erreurs dans le processus de staging

  • Codes de réussite
  • Codes d’avertissements
  • Codes d’erreur

-          Automatiser le processus de chargement de MDS avec SSIS

-          Résumé

Chapitre 7 : Règles métier et flux de travail

-          Introduction aux règles métier dans MDS

  • Exécuter les règles métier
  • Aperçu technique

-          Conditions et actions

  • Conditions
  • Actions

-          Interface des règles métier

-          Création des règles métier

  • Créer les attributs de règles métier requis
  • Créer les règles métier pour les tailles du magasin (« Store Size » , en anglais)

-          Notifications

-          Flux de travail et SharePoint

  • Installation
  • Règle métier d’approbation du magasin
  • Résumé

Chapitre 8 : extraction des données de MDS

-          Introduction

  • Livraison de données de référence
  • Vue de souscription
  • Formats
  • Création de vue de souscription
  • Livraison de données de référence avec BizTalk
  • Cadre du scénario d’exemple
  • Création de la base d’exemple
  • Création du projet BizTalk
  • Déploiement de la solution BizTalk
  • Test de la solution BizTalk
  • Résumé

Chapitre 9 : interface de programmation appliquée (API)

-          Introduction à l’API MDS

  • Qu’est-ce qu’un service WCF ?

-          Débuter avec l’API des services Web

  • Créer un projet de services Web
  • Explorer les métadonnées de MDS

-          Les « assemblies » MDS

  • Création d’un projet avec les « assemblies » MDS
  • Mettre en œuvre une connexion

-          Création d’un « Web Part » MDS SharePoint

  • Installation
  • Création du « Web Part »
  • Récupération de données de MDS

-          Intégration du flux de travail SharePoint

  • Déploiement de la solution du flux de travail
  • Exécution du flux de travail SharePoint

-          Résumé

Chapitre 10 : Sécurité dans Master Data Services

-          Aperçu de la sécurité de Master Data Services

-          Administration d’utilisateur et de groupe

  • Ajouter un utilisateur
  • Modifier un utilisateur
  • Maintenance des groupes

-          Permissions d’utilisateur et de groupe

  • Permissions sur les fonctions
  • Permissions de modèle
  • Permissions sur les membres de hiérarchie

-          Résumé


Conclusion

Ces 2 livres abordent MDS différemment mais on y trouve des similitudes - forcément.

A noter qu’ils proposent des téléchargements des codes source utilisés, ce qui est plutôt appréciable,
 si l’on veut éviter de retaper tous les codes proposés (en C# principalement).

lien vers les codes sources du livre de Microsoft 

lien vers les codes sources du livre de PacktPub

Ces 2 livres se complètent assez bien. Le 1er
 (celui publié de Microsoft) est comme un dictionnaire MDS pour moi,
 et traite plus spécialement
, comme indiqué dans son titre,
 de l’implémentation et de l’administration, 
tandis que le second (celui publié par Packt publishing) porte plutôt l’accent sur le coté réalisation technique
 (import avec SSIS, association avec Biztalk, et Sharepoint, notamment) et,
 à mon avis, se destine davantage à des techniciens ou au moins à un public averti.

Remarque : vous pouvez voir une excellente revue complète
 du livre de Jeremy Kashel sur le blog de mon ami et collègue Marius Zaharia (en anglais)


Master Data Services : Copie / Import / Export des Business Rules (Inter modèles)

updated article (Oct 2011)

(code refactored)

Hi All,

One other missing feature of MDS is Import / Export / Copy Business rules from a model to another (or copy business rules to the same model)

my code is still in beta, but it is already (partially) working.

you can find it on my “MDS Manager” tool on codeplex:

http://mdsmanager.codeplex.com


Get business rules from modelId, quite easy with service client method “business rules get”, returns a business rule set

 public BusinessRules GetBusinessRules(string fileName)
        {
            BusinessRules brs = null;
            Stream str = null;
            try
            {

                if (File.Exists(fileName))
                {
                    str = new FileStream(@fileName, FileMode.Open, FileAccess.Read, FileShare.Read);

                    if (str == null)
                    {
                        throw new BusinessRulesException("error while opening file!");
                    }

                    XmlSerializer xs = new XmlSerializer(typeof(BusinessRules));
                    // Load the object saved above by using the Deserialize function
                     brs = (BusinessRules)xs.Deserialize(str);

                }
                else
                {
                    throw new BusinessRulesException("Cannot find specified file!");
                }

                return brs;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {

                // Cleanup                 if (str != null)
                    str.Close();

            }

        }
then we export business rules to a XML file
note:
//this is needed to avoid a serialization error (more info on http://www.johnsoer.com/blog/?p=125 ) :
 //XmlSerializer xs = new XmlSerializer(typeof(BusinessRules), new Type[] { typeof(BRAttributeValueArgument),typeof(BRBlankArgument)
   //                                                                                     ,typeof(BRDomainBasedAttributeArgument)});
here is the export method :
 public void ExportBusinessRules(string exportFileName, BusinessRules brs)
        {
            TextWriter WriteFileStream = null;
            try
            {

                //new type needed to avoir error because serialization of an inherited class                 XmlSerializer xs = new XmlSerializer(typeof(BusinessRules), new Type[] { typeof(Common.ServiceReference1.BRAttributeValueArgument) });
//update oct 2011!
//new type needed to avoir error because serialization of an inherited class

               XmlSerializer xs = new XmlSerializer(typeof(BusinessRules), new Type[] { typeof(BRAttributeValueArgument),typeof(BRBlankArgument)
                                                                                        ,typeof(BRDomainBasedAttributeArgument)});
              // Create a new file stream to write the serialized object to a file                 WriteFileStream = new StreamWriter(@exportFileName);
                xs.Serialize(WriteFileStream, brs);

               //custom exception class , but not required              throw new BusinessRulesException("Business Rules successfully exported to file " + exportFileName);

            }
            catch (Exception exc)
            {
                throw exc;
            }
            finally
            {
               // Cleanup                 if (WriteFileStream != null)
                    WriteFileStream.Close();
            }
        }

then we would like to import this XML file to another model:
here is the method to get business rules set from a previously exported XML file :
  public BusinessRules GetBusinessRules(string fileName)
        {
            BusinessRules brs = null;
            Stream str = null;
            try
            {

                if (File.Exists(fileName))
                {
                    str = new FileStream(@fileName, FileMode.Open, FileAccess.Read, FileShare.Read);

                    if (str == null)
                    {
                        throw new BusinessRulesException("error while opening file!");
                    }

                    XmlSerializer xs = new XmlSerializer(typeof(BusinessRules));
                   // Load the object saved above by using the Deserialize function                    brs = (BusinessRules)xs.Deserialize(str);

                }
                else
                {
                    throw new BusinessRulesException("Cannot find specified file!");
                }

                return brs;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {

              // Cleanup 
          if (str != null)
                    str.Close();

            }

        }

//then we can get the source modelID
 sourceModelId =brs.BusinessRulesMember.First().Identifier.ModelId as Identifier;
// and then clone business rule set with updated modelId:
//brs is the business rule set
//sourceModelId is the source Model Identifier (taken above from the Rules set from the XML file)
//target ModelId is the model Identifier for the model we want to import back the B. rules to
CloneBusinessRules(brs,sourceModelId, targetModelId));
Here is the CloneBusinessRules Method:
public string CloneBusinessRules(BusinessRules brs, Identifier SourceModelId, Identifier targetModelId)
        {

            OperationResult or = null;
            //instanciate new BR members
            try
            {
                int cptMissingEntity = 0;
                StringBuilder sb = new StringBuilder("these business rule related entities does not exists in target model:");
                sb.AppendLine();
                BusinessRules newBRS = new BusinessRules();
                foreach (BusinessRule br in brs.BusinessRulesMember)
                {
                    Identifier EntityId = null;
                    //this is used to get the target entity Id with matching its name 
                    using (ServiceClient c = new ServiceClientWrapper().CreateServiceClient())
                    {
                        EntityId = GetEntityIdFromName(c, c.Endpoint.Address.Uri.OriginalString, targetModelId, br.Identifier.EntityId.Name);

                    }
                    if (EntityId != null)
                    {
                        newBRS.BusinessRulesMember = new Collection<BusinessRule>();

                        //create a new business rule based on the source one, and applying on it the target identifiers and names 
                        BusinessRule newBR = BusinessRuleInstanciate(Guid.NewGuid(), br.Identifier.Name, targetModelId.Name, br.Identifier.EntityId.Name,
                            br.Identifier.MemberType, br.Priority, br.BRActions, br.Identifier.InternalId, br.RuleActionText, br.RuleConditionText);
                        //some required parameters to instanciate below:

                        //instanciate BRActions
                        newBRS.BRActions = BRActionsInstanciate(brs.BRActions, newBR.Identifier);
                        //instanciate BRConditions
                        newBRS.BRConditions = BRConditionsInstanciate(brs.BRConditions, newBR.Identifier);
                        //instanciate BRConditionTreeNodes
                        newBRS.BRConditionTreeNodes = BRConditionTreeNodesInstanciate(brs.BRConditionTreeNodes, newBR.Identifier);
                        newBRS.BusinessRulesMember.Add(newBR);
                    }
                    else
                    {
                        sb.AppendLine(br.Identifier.EntityId.Name);
                        cptMissingEntity++;
                        //these business rule related entities do not exist in target model
                    }
                    //then we clone modified BRSet
                    using (ServiceClient c = new ServiceClientWrapper().CreateServiceClient())
                    {

                        or = c.BusinessRulesClone(new International(), newBRS);
                        string err = Tools.HandleErrors(or);
                        if (!string.IsNullOrEmpty(err))
                        {
                            throw new Exception(err);
                        }
                    }
                    if (cptMissingEntity == 0)
                    {
                        sb = new StringBuilder();
                    }
                }

                return sb.ToString();
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }

update oct 2011 code for BRActionsInstanciate, BRConditionsInstanciate,BRConditionTreeNodesInstanciate

 private Collection<BRConditionTreeNode> BRConditionTreeNodesInstanciate(Collection<BRConditionTreeNode> BRConditionTreeNodes, MemberTypeContextIdentifier BRId)
        {

            try
            {
                //Add BRConditionTreeNode to BRConditionTreeNode Collection

                Collection<BRConditionTreeNode> newBRConditionTreeNodes = new Collection<BRConditionTreeNode>();

                foreach (BRConditionTreeNode brctn in BRConditionTreeNodes)
                {
                    BRConditionTreeNode BRConditionTreeNodeItem = new BRConditionTreeNode();
                    //Add Attribute and Action type to the collection
                    BRConditionTreeNodeItem.BRConditions = BRConditionsInstanciate(brctn.BRConditions, BRId);
                    BRConditionTreeNodeItem.BusinessRuleId = BRId;
                    BRConditionTreeNodeItem.ConditionTreeChildNodes = brctn.ConditionTreeChildNodes;
                    BRConditionTreeNodeItem.ConditionTreeParentNode = brctn.ConditionTreeParentNode;
                    BRConditionTreeNodeItem.LogicalOperator = brctn.LogicalOperator;
                    BRConditionTreeNodeItem.Identifier = new Identifier() { Name = brctn.Identifier.Name, Id = Guid.NewGuid() };

                    //All Action and Condition Items must have a sequence greater that zero
                    BRConditionTreeNodeItem.Sequence = brctn.Sequence;
                    newBRConditionTreeNodes.Add(BRConditionTreeNodeItem);
                }
                return newBRConditionTreeNodes;
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }

        private Collection<BRAction> BRActionsInstanciate(Collection<BRAction> BRActions, MemberTypeContextIdentifier BRId)
        {

            try
            {
                //Add Action to Action Collection

                Collection<BRAction> newBRActions = new Collection<BRAction>();

                foreach (BRAction bra in BRActions)
                {
                    BRAction BRActionItem = new BRAction() { Identifier = new Identifier() { Id = Guid.NewGuid(), Name = bra.Identifier.Name }, BusinessRuleId = BRId };
                    //Add Attribute and Action type to the collection
                    BRActionItem.PrefixArgument = new BRAttributeArgument();
                    BRActionItem.PrefixArgument.PropertyName = bra.PrefixArgument.PropertyName;
                    BRActionItem.PrefixArgument.AttributeId = new Identifier();
                    BRActionItem.PrefixArgument.AttributeId.Id = Guid.NewGuid();
                    BRActionItem.PrefixArgument.AttributeId.Name = bra.PrefixArgument.AttributeId.Name;
                    BRActionItem.Operator = bra.Operator;
                    var colBRffa = new Collection<object>();
                    foreach (var brffa in bra.PostfixArguments)
                    {
                        BRBlankArgument BRba = brffa as BRBlankArgument;
                        BRFreeformArgument BRffa = brffa as BRFreeformArgument;
                        if (BRba != null)
                        {
                            colBRffa.Add(new BRBlankArgument() { Identifier = new Identifier() { Id = Guid.NewGuid(), Name = BRba.Identifier.Name }, PropertyName = BRba.PropertyName });

                        }
                        else
                        {
                            if (BRffa != null)
                            {
                                colBRffa.Add(new BRFreeformArgument() { Identifier = new Identifier() { Id = Guid.NewGuid(), Name = BRffa.Identifier.Name }, Value = BRffa.Value, PropertyName = BRffa.PropertyName });

                            }
                        }
                    }
                    BRActionItem.PostfixArguments = colBRffa;
                    BRActionItem.Text = bra.Text;

                    //All Action and Condition Items must have a sequence greater that zero
                    BRActionItem.Sequence = bra.Sequence;
                    newBRActions.Add(BRActionItem);
                }
                return newBRActions;
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }
        public Collection<BRCondition> BRConditionsInstanciate(Collection<BRCondition> BRconditions, MemberTypeContextIdentifier BRId)
        {

            try
            {
                //Add Action to Action Collection

                Collection<BRCondition> newBRconditions = new Collection<BRCondition>();
                BRCondition BRConditionItem = new BRCondition();

                foreach (BRCondition brc in BRconditions)
                {
                    //Add Attribute and Action type to the collection
                    BRConditionItem.BusinessRuleId = BRId;

                    BRConditionItem.ConditionTreeNodeId = new Identifier() { Name = brc.ConditionTreeNodeId.Name };
                    BRConditionItem.Identifier = new Identifier() { Id = Guid.NewGuid(), Name = brc.Identifier.Name };
                    BRConditionItem.Operator = brc.Operator;
                    BRConditionItem.PrefixArgument = brc.PrefixArgument;
                    BRConditionItem.PostfixArguments = brc.PostfixArguments;
                    //All Action and Condition Items must have a sequence greater that zero
                    BRConditionItem.Sequence = brc.Sequence;
                    BRConditionItem.Text = brc.Text;
                    newBRconditions.Add(BRConditionItem);
                }
                return newBRconditions;
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }

Master Data Services : Getting Errors out of a ModelMembersBulkUpdate/Merge with API

In fact, you can get the error codes on MDS website : in “Integration Management/Staging Batches” clicking on the batch you want and clicking on button “view details for selected batch”
in order to do the same thing with API (get error codes), you’ll need to get back the batch after it is inserted. 

//get information related to a staging batch
public Collection<StagingBatch> StagingGet(Collection<Identifier> stagingBatch, bool ReturnAllCriteria, bool ReturnMembers, bool ReturnAttributes, bool ReturnRelationShips, ref OperationResult or)
{
Collection<StagingUnbatchedInformation> colUnbatched = new Collection<StagingUnbatchedInformation>();
Collection<StagingBatch> colBatches = new Collection<StagingBatch>();
using (ServiceClient c = MDS_WSConnect.CreateMdsProxy())
{
or = new OperationResult();
colBatches = c.StagingGet(new International(), true, new StagingResultCriteria() { All = ReturnAllCriteria, Attributes = ReturnAttributes, Members = ReturnMembers, Relationships = ReturnRelationShips },
new StagingSearchCriteria() { StagingBatches = stagingBatch, StagingDataStatus= StagingDataStatus.All }, out or, out colUnbatched);
List<string> lstErr = new List<string>();
//...do what you need with the error collection
foreach (<strong>StagingBatchError err in colBatches.First().Errors</strong>)
{
lstErr.Add(err.ErrorCode + " - " + err.TargetCode);
}

return colBatches;
}
}
so, complete process would be:
DateTime dtBefore = DateTime.Now; 
OperationResult or = new OperationResult();
//filling new staging batch with entityMembers
Collection<Identifier> colStaging = ModelMembersBulkMerge(colEntMembers);
//initiating the staging process (not sure I really need that here in fact)
Collection<StagingBatch> colBatches = StagingGet(colStaging, true, true, true, false, ref or);
//triggering staging
ProcessUnbatchedStaging(pModelId, pVersionId);

DateTime dtAfter = DateTime.Now;
TimeSpan ts = dtAfter.Subtract(dtBefore);

MessageBox.Show("members (bulk) inserted : " + colEntMembers.First().Members.Count() + "\r\n" + "time elapsed (seconds):" + ts.TotalSeconds.ToString());
//get back the batch to see if any errors

colBatches = StagingGet(colStaging, true, true, true, false, ref or);
note: StagingDataStatus= StagingDataStatus.All –> get all including Errors