コード例 #1
0
 public Publisher GetById(PublisherId id)
 {
     using (var context = new ApplicationContext())
     {
         var entity = LoadWithNoTracking(context, id);
         return(GetDomainResult(entity));
     }
 }
コード例 #2
0
        public async Task ChangePublisher(Book a, PublisherId publisherId)
        {
            var book = await Context.Books.FindAsync(a.Id).ConfigureAwait(false);

            var publisher = await GetPublisherAsync(publisherId).ConfigureAwait(false);

            book.SetPublisher(publisher);
            await Context.SaveChangesAsync().ConfigureAwait(false);
        }
コード例 #3
0
        private static string PublisherIdToString(PublisherId publisherId, int payloadLength, INTV.Core.Utility.BinaryReader reader)
        {
            var publisher      = string.Empty;
            var shouldReadMore = false;

            switch (publisherId)
            {
            case PublisherId.MattelElectronics:
                publisher = "Mattel Electronics";
                break;

            case PublisherId.INTVCorp:
                publisher = "INTV Corporation";
                break;

            case PublisherId.Imagic:
                publisher = "Imagic";
                break;

            case PublisherId.Activision:
                publisher = "Activision";
                break;

            case PublisherId.Atarisoft:
                publisher = "Atarisoft";
                break;

            case PublisherId.Coleco:
                publisher = "Coleco";
                break;

            case PublisherId.CBS:
                publisher = "CBS";
                break;

            case PublisherId.ParkerBros:
                publisher = "Parker Brothers";
                break;

            case PublisherId.Other:
            default:
                shouldReadMore = true;
                break;
            }
            var remainingPayload = payloadLength - sizeof(PublisherId);

            if (remainingPayload > 0)
            {
                var publisherData = reader.ParseStringFromMetadata((uint)remainingPayload, allowLineBreaks: false);
                if (shouldReadMore)
                {
                    publisher = publisherData;
                }
            }
            return(publisher);
        }
コード例 #4
0
ファイル: DismAppxPackage.cs プロジェクト: johnwtt/UUP
 /// <summary>
 /// Serves as a hash function for a particular type.
 /// </summary>
 /// <returns>A hash code for the current <see cref="T:System.Object" />.</returns>
 public override int GetHashCode()
 {
     return(Architecture.GetHashCode()
            ^ DisplayName?.GetHashCode() ?? 0
            ^ InstallLocation?.GetHashCode() ?? 0
            ^ PackageName?.GetHashCode() ?? 0
            ^ PublisherId?.GetHashCode() ?? 0
            ^ ResourceId?.GetHashCode() ?? 0
            ^ Version.GetHashCode());
 }
コード例 #5
0
        private PublisherEntity LoadWithNoTracking(ApplicationContext context, PublisherId id)
        {
            var entity = context.Publisher
                         .AsNoTracking()
                         .Include(p => p.PublisherAccounts)
                         .ThenInclude(pa => pa.SocialAccount)
                         .FirstOrDefault(p => p.Id == id.Value);

            return(entity);
        }
コード例 #6
0
        public static Task CreateInvalidPublisher()
        {
            var connectionString = ConnectivityService.GetConnectionString("TEMP");
            var context          = new BookOrganizer2DbContext(connectionString);
            var repository       = new PublisherRepository(context);
            var publisherService = new PublisherService(repository);

            var publisherId = new PublisherId(SequentialGuid.NewSequentialGuid());
            var command     = new Commands.Create {
                Id = publisherId
            };

            return(publisherService.Handle(command));
        }
コード例 #7
0
        // DELETE
        public static Task RemovePublisher(PublisherId id)
        {
            var connectionString = ConnectivityService.GetConnectionString("TEMP");
            var context          = new BookOrganizer2DbContext(connectionString);
            var repository       = new PublisherRepository(context);

            var publisherService = new PublisherService(repository);
            var command          = new Commands.DeletePublisher
            {
                Id = id,
            };

            return(publisherService.Handle(command));
        }
コード例 #8
0
        public override string ToString()
        {
            var sb = new StringBuilder();

            sb.Append("Key       : ");
            sb.AppendLine(Key);
            sb.Append("Mod Hash  : ");
            sb.AppendLine(Hash.ToString("x"));
            sb.Append("Mod PubId : ");
            sb.AppendLine(PublisherId.ToString());
            sb.Append("Mod String: ");
            sb.AppendLine(Name);

            return(sb.ToString());
        }
コード例 #9
0
        public static Task UpdatePublisherDescription(PublisherId id, string description)
        {
            var connectionString = ConnectivityService.GetConnectionString("TEMP");
            var context          = new BookOrganizer2DbContext(connectionString);
            var repository       = new PublisherRepository(context);

            var publisherService = new PublisherService(repository);
            var command          = new Commands.SetDescription()
            {
                Id          = id,
                Description = description
            };

            return(publisherService.Handle(command));
        }
コード例 #10
0
        public static Task UpdatePublisherLogoPath(PublisherId id, string path)
        {
            var connectionString = ConnectivityService.GetConnectionString("TEMP");
            var context          = new BookOrganizer2DbContext(connectionString);
            var repository       = new PublisherRepository(context);

            var publisherService = new PublisherService(repository);
            var command          = new Commands.SetLogoPath
            {
                Id       = id,
                LogoPath = path
            };

            return(publisherService.Handle(command));
        }
コード例 #11
0
        static void Main(string[] args)
        {
            PublisherId id = new PublisherId(Guid.Parse("6679C0E9-1C2C-4F99-9EB1-ED892225176B"));       // John

            PublisherRepository repository = new PublisherRepository();
            var publisher = repository.GetById(id);

            var account = publisher.AssignedSocialAccounts.FirstOrDefault(asa => asa.Email == "*****@*****.**");

            publisher.ChangePublisherName("Derick");
            publisher.ChangeAccountEmail(account, "*****@*****.**");

            repository.Update(publisher);

            Console.ReadKey();
        }
コード例 #12
0
        public virtual void Validate(ValidationResult result)
        {
            Title.ValidateRequired(result, nameof(Title));

            Title.ValidateMaxLength(result, nameof(Title), 150);

            Category.ValidateRequired(result, nameof(Category));

            DatePublished.ValidateRequired(result, nameof(DatePublished));

            PublisherId.ValidateRequired(result, nameof(PublisherId));

            foreach (var page in Pages)
            {
                page.Validate(result);
            }
        }
コード例 #13
0
        /// <summary>
        /// Decode the stream from decoder parameter and produce a Dataset
        /// </summary>
        /// <param name="binaryDecoder"></param>
        /// <param name="dataSetReaders"></param>
        /// <returns></returns>
        public void DecodeSubscribedDataSets(BinaryDecoder binaryDecoder, IList <DataSetReaderDataType> dataSetReaders)
        {
            if (dataSetReaders == null || dataSetReaders.Count == 0)
            {
                return;
            }

            try
            {
                List <DataSetReaderDataType> dataSetReadersFiltered = new List <DataSetReaderDataType>();

                // 1. decode network message header (PublisherId & DataSetClassId)
                DecodeNetworkMessageHeader(binaryDecoder);

                //ignore network messages that are not dataSet messages
                if (m_uadpNetworkMessageType != UADPNetworkMessageType.DataSetMessage)
                {
                    return;
                }

                /* 6.2.8.1 PublisherId
                 * The parameter PublisherId defines the Publisher to receive NetworkMessages from.
                 * If the value is null, the parameter shall be ignored and all received NetworkMessages pass the PublisherId filter. */
                foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
                {
                    //check Enabled & publisher id
                    if (dataSetReader.PublisherId.Value == null ||
                        (PublisherId != null && PublisherId.Equals(dataSetReader.PublisherId.Value)))
                    {
                        dataSetReadersFiltered.Add(dataSetReader);
                    }
                }
                if (dataSetReadersFiltered.Count == 0)
                {
                    return;
                }
                dataSetReaders = dataSetReadersFiltered;

                //continue filtering
                dataSetReadersFiltered = new List <DataSetReaderDataType>();

                // 2. decode WriterGroupId
                DecodeGroupMessageHeader(binaryDecoder);

                /* 6.2.8.2 WriterGroupId
                 * The parameter WriterGroupId with DataType UInt16 defines the identifier of the corresponding WriterGroup.
                 * The default value 0 is defined as null value, and means this parameter shall be ignored.*/
                foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
                {
                    //check WriterGroupId id
                    if (dataSetReader.WriterGroupId == 0 || dataSetReader.WriterGroupId == WriterGroupId)
                    {
                        dataSetReadersFiltered.Add(dataSetReader);
                    }
                }
                if (dataSetReadersFiltered.Count == 0)
                {
                    return;
                }
                dataSetReaders = dataSetReadersFiltered;

                // 3. decode payload header
                DecodePayloadHeader(binaryDecoder);
                // 4.
                DecodeExtendedNetworkMessageHeader(binaryDecoder);
                // 5.
                DecodeSecurityHeader(binaryDecoder);

                //6.1
                DecodePayloadSize(binaryDecoder);

                // the list of decode dataset messages for this network message
                List <UaDataSetMessage> dataSetMessages = new List <UaDataSetMessage>();

                /* 6.2.8.3 DataSetWriterId
                 * The parameter DataSetWriterId with DataType UInt16 defines the DataSet selected in the Publisher for the DataSetReader.
                 * If the value is 0 (null), the parameter shall be ignored and all received DataSetMessages pass the DataSetWriterId filter.*/
                foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
                {
                    List <UaDataSetMessage> uadpDataSetMessages = new List <UaDataSetMessage>(DataSetMessages);
                    //if there is no information regarding dataSet in network message, add dummy datasetMessage to try decoding
                    if (uadpDataSetMessages.Count == 0)
                    {
                        uadpDataSetMessages.Add(new UadpDataSetMessage());
                    }
                    // 6.2 Decode payload into DataSets
                    // Restore the encoded fields (into dataset for now) for each possible dataset reader
                    foreach (UadpDataSetMessage uadpDataSetMessage in uadpDataSetMessages)
                    {
                        if (uadpDataSetMessage.DataSet != null)
                        {
                            continue; // this dataset message was already decoded
                        }
                        if (dataSetReader.DataSetWriterId == 0 || uadpDataSetMessage.DataSetWriterId == dataSetReader.DataSetWriterId)
                        {
                            //atempt to decode dataset message using the reader
                            uadpDataSetMessage.DecodePossibleDataSetReader(binaryDecoder, dataSetReader);
                            if (uadpDataSetMessage.DataSet != null)
                            {
                                dataSetMessages.Add(uadpDataSetMessage);
                            }
                        }
                    }
                }

                if (m_uaDataSetMessages.Count == 0)
                {
                    // set the list of dataset messages to the network message
                    m_uaDataSetMessages.AddRange(dataSetMessages);
                }
            }
            catch (Exception ex)
            {
                // Unexpected exception in DecodeSubscribedDataSets
                Utils.Trace(ex, "UadpNetworkMessage.DecodeSubscribedDataSets");
            }
        }
コード例 #14
0
        /// <summary>
        /// Decode the stream from decoder parameter and produce a Dataset
        /// </summary>
        /// <param name="jsonDecoder"></param>
        /// <param name="dataSetReaders"></param>
        /// <returns></returns>
        public void DecodeSubscribedDataSets(JsonDecoder jsonDecoder, IEnumerable <DataSetReaderDataType> dataSetReaders)
        {
            try
            {
                List <DataSetReaderDataType> dataSetReadersFiltered = new List <DataSetReaderDataType>();

                // 1. decode network message header (PublisherId & DataSetClassId)
                DecodeNetworkMessageHeader(jsonDecoder);

                // ignore network messages that are not dataSet messages
                if (m_jsonNetworkMessageType != JSONNetworkMessageType.DataSetMessage)
                {
                    return;
                }

                //* 6.2.8.1 PublisherId
                // The parameter PublisherId defines the Publisher to receive NetworkMessages from.
                // If the value is null, the parameter shall be ignored and all received NetworkMessages pass the PublisherId filter. */
                foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
                {
                    if (dataSetReader.PublisherId == Variant.Null)
                    {
                        dataSetReadersFiltered.Add(dataSetReader);
                    }
                    // publisher id
                    else if ((NetworkMessageContentMask & JsonNetworkMessageContentMask.PublisherId) != 0 &&
                             PublisherId != null &&
                             PublisherId.Equals(dataSetReader.PublisherId.Value.ToString()))
                    {
                        dataSetReadersFiltered.Add(dataSetReader);
                    }
                }
                if (dataSetReadersFiltered.Count == 0)
                {
                    return;
                }
                dataSetReaders = dataSetReadersFiltered;

                object        messagesToken    = null;
                List <object> messagesList     = null;
                string        messagesListName = string.Empty;
                if (jsonDecoder.ReadField(kFieldMessages, out messagesToken))
                {
                    messagesList = messagesToken as List <object>;
                    if (messagesList == null)
                    {
                        // this is a SingleDataSetMessage encoded as the conteten of Messages
                        jsonDecoder.PushStructure(kFieldMessages);
                        messagesList = new List <object>();
                    }
                    else
                    {
                        messagesListName = kFieldMessages;
                    }
                }
                else if (jsonDecoder.ReadField(JsonDecoder.RootArrayName, out messagesToken))
                {
                    messagesList     = messagesToken as List <object>;
                    messagesListName = JsonDecoder.RootArrayName;
                }
                else
                {
                    // this is a SingleDataSetMessage encoded as the conteten of json
                    messagesList = new List <object>();
                }
                if (messagesList != null)
                {
                    // atempt decoding for each data set reader
                    foreach (DataSetReaderDataType dataSetReader in dataSetReaders)
                    {
                        JsonDataSetReaderMessageDataType jsonMessageSettings = ExtensionObject.ToEncodeable(dataSetReader.MessageSettings)
                                                                               as JsonDataSetReaderMessageDataType;
                        if (jsonMessageSettings == null)
                        {
                            // The reader MessageSettings is not set up corectly
                            continue;
                        }
                        JsonNetworkMessageContentMask networkMessageContentMask =
                            (JsonNetworkMessageContentMask)jsonMessageSettings.NetworkMessageContentMask;
                        if ((networkMessageContentMask & NetworkMessageContentMask) != NetworkMessageContentMask)
                        {
                            // The reader MessageSettings.NetworkMessageContentMask is not set up corectly
                            continue;
                        }

                        // initialize the dataset message
                        JsonDataSetMessage jsonDataSetMessage = new JsonDataSetMessage();
                        jsonDataSetMessage.DataSetMessageContentMask = (JsonDataSetMessageContentMask)jsonMessageSettings.DataSetMessageContentMask;
                        jsonDataSetMessage.SetFieldContentMask((DataSetFieldContentMask)dataSetReader.DataSetFieldContentMask);
                        // set the flag that indicates if dataset message shall have a header
                        jsonDataSetMessage.HasDataSetMessageHeader = (networkMessageContentMask & JsonNetworkMessageContentMask.DataSetMessageHeader) != 0;

                        jsonDataSetMessage.DecodePossibleDataSetReader(jsonDecoder, messagesList.Count, messagesListName, dataSetReader);
                        if (jsonDataSetMessage.DataSet != null)
                        {
                            m_uaDataSetMessages.Add(jsonDataSetMessage);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // Unexpected exception in DecodeSubscribedDataSets
                Utils.Trace(ex, "JsonNetworkMessage.DecodeSubscribedDataSets");
            }
        }
コード例 #15
0
 public ValueTask <Publisher> GetPublisherAsync(PublisherId publisherId)
 => Context.Publishers.FindAsync(publisherId);
 public override string ToString()
 {
     return(PublisherId.ToString());
 }