Example #1
0
        public object GetLicenseInfo()
        {
            string lic = Database.Invoke(db => db.GetConfiguration("LicenseKey"));
            var    sn  = new SerialNumber();

            if (!string.IsNullOrEmpty(lic))
            {
                Call.Execute(() =>
                {
                    sn = SerialNumber.DeSerialize(lic.Substring(8), "Monkey", Global.Config.InstallTime);
                });
            }

            List <object> array = new List <object>();

            array.Add(new { name = "Version", value = "2.0.0" });
            array.Add(new { name = "LicenseType", value = sn.LicenseType.ToString() });
            array.Add(new { name = "MachineId", value = sn.MachineId });
            array.Add(new { name = "CreateTime", value = sn.CreateTime > DateTime.MinValue ? sn.CreateTime.ToLongDateString() : null });
            array.Add(new { name = "ExpireTime", value = sn.ExpireTime > DateTime.MinValue ? sn.ExpireTime.ToLongDateString() : null });
            array.Add(new { name = "IsValid", value = sn.IsValid() });
            array.Add(new { name = "Website", value = "<a href='http://www.ultragis.com' target='_blank'>http://www.ultragis.com</a>" });
            array.Add(new { name = "Support", value = "<a href='mailto:[email protected]' target='_blank'>[email protected]</a>" });
            return(new { total = array.Count, rows = array.ToArray() });
        }
Example #2
0
        public static char KTCLuhn(String BarCode)
        {
            string IntSerialNumber;
            double Year, Month, SerialNumber;

            // Manufacturer

            IntSerialNumber = BarCode.Substring(0, 2);

            // Year

            Year            = Int64.Parse(BarCode.Substring(2, 2), System.Globalization.NumberStyles.HexNumber, null);
            IntSerialNumber = IntSerialNumber + Year.ToString().PadLeft(2, '0');

            // Month
            Month           = Int64.Parse(BarCode.Substring(4, 1), System.Globalization.NumberStyles.HexNumber, null);
            IntSerialNumber = IntSerialNumber + Month.ToString().PadLeft(2, '0');

            // Serialnumber
            SerialNumber    = Int64.Parse(BarCode.Substring(5, 5), System.Globalization.NumberStyles.HexNumber, null);
            IntSerialNumber = IntSerialNumber + SerialNumber.ToString().PadLeft(7, '0');

            // Calculate the checknumber
            return(Luhn(IntSerialNumber));
        }
        /// <summary>
        /// Returns true if DuplicateEquipmentViewModel instances are equal
        /// </summary>
        /// <param name="other">Instance of DuplicateEquipmentViewModel to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(DuplicateEquipmentViewModel other)
        {
            if (other is null)
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return
                ((
                     Id == other.Id ||
                     Id.Equals(other.Id)
                     ) &&
                 (
                     DistrictName == other.DistrictName ||
                     DistrictName != null &&
                     DistrictName.Equals(other.DistrictName)
                 ) &&
                 (
                     SerialNumber == other.SerialNumber ||
                     SerialNumber != null &&
                     SerialNumber.Equals(other.SerialNumber)
                 ) &&
                 (
                     DuplicateEquipment == other.DuplicateEquipment ||
                     DuplicateEquipment != null &&
                     DuplicateEquipment.Equals(other.DuplicateEquipment)
                 ));
        }
        public string WriteMsg()
        {
            UserDataAll += SerialNumber.ToString("X").PadLeft(4, '0');
            UserDataAll += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
            if (List_Identifier != null && List_Identifier.Count > 0)
            {
                foreach (Identifier iden in List_Identifier)
                {
                    UserDataAll += iden.GetHexStr();
                }
            }

            byte[]             UserDataBytesAllTmp;
            WaterBaseMessage[] MsgListTmp;
            string             msg = WaterBaseMessageService.GetMsgList_WriteMsg(this, UserDataAll, out UserDataBytesAllTmp, out MsgListTmp);

            if (msg == "")
            {
                UserDataBytesAll = UserDataBytesAllTmp;
                MsgList          = MsgListTmp;
            }
            else
            {
                if (ShowLog)
                {
                    logHelper.Error(msg);
                }
            }
            return(msg);
        }
Example #5
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (Guid.Length != 0)
            {
                hash ^= Guid.GetHashCode();
            }
            if (Name.Length != 0)
            {
                hash ^= Name.GetHashCode();
            }
            if (SerialNumber.Length != 0)
            {
                hash ^= SerialNumber.GetHashCode();
            }
            if (Type != global::WarehouseGrpc.EquipmentType.Rtv)
            {
                hash ^= Type.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
        /// <summary>
        /// Gets the hash code
        /// </summary>
        /// <returns>Hash code</returns>
        public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;

                // Suitable nullity checks
                hash = hash * 59 + Id.GetHashCode();

                if (DistrictName != null)
                {
                    hash = hash * 59 + DistrictName.GetHashCode();
                }

                if (SerialNumber != null)
                {
                    hash = hash * 59 + SerialNumber.GetHashCode();
                }

                if (DuplicateEquipment != null)
                {
                    hash = hash * 59 + DuplicateEquipment.GetHashCode();
                }

                return(hash);
            }
        }
Example #7
0
        public string WriteMsg()
        {
            UserDataAll += SerialNumber.ToString("X").PadLeft(4, '0');
            UserDataAll += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
            UserDataAll += Iden_F1.GetHexStr();
            Identifier_45 iden = new Identifier_45();

            iden.AlarmStateV = "0".PadLeft(32, '0');
            iden.AlarmStateV = (isUsed ? "1" : "0").PadRight(10, '0').PadLeft(32, '0');
            UserData        += iden.GetHexStr();

            byte[]             UserDataBytesAllTmp;
            WaterBaseMessage[] MsgListTmp;
            string             msg = WaterBaseMessageService.GetMsgList_WriteMsg(this, UserDataAll, out UserDataBytesAllTmp, out MsgListTmp);

            if (msg == "")
            {
                UserDataBytesAll = UserDataBytesAllTmp;
                MsgList          = MsgListTmp;
            }
            else
            {
                if (ShowLog)
                {
                    logHelper.Error(msg);
                }
            }
            return(msg);
        }
Example #8
0
        private void UpdateLicenseInfo(object state)
        {
            try
            {
                Global.Config.SerialKey  = null;
                Global.Config.LicenseKey = null;

                string path = Path.Combine(Path.GetDirectoryName(Application.StartupPath), "license.sn");
                if (File.Exists(path))
                {
                    var config = _storage.GetConfigurations();
                    bfbd.UltraRecord.Global.Config.SetConfigurations(config);

                    TraceLogger.Instance.WriteLineVerbos("License file exists.");
                    string lic = File.ReadAllText(path);
                    var    sn  = SerialNumber.DeSerialize(lic.Substring(8), Global.Config.InstallTime);
                    TraceLogger.Instance.WriteLineVerbos(string.Format("SN: {0}: {1}, {2}", sn.License, sn.CreateTime, sn.ExpireTime));
                    if (sn.IsValid())
                    {
                        TraceLogger.Instance.WriteLineVerbos("License file valid: " + lic.Length);
                        Global.Config.SerialKey  = sn.MachineId;
                        Global.Config.LicenseKey = lic.Substring(8);
                    }
                }
            }
            catch (Exception ex) { TraceLogger.Instance.WriteException(ex); throw; }
        }
        public override int GetHashCode()
        {
            int hash = 1;

            if (Path.Length != 0)
            {
                hash ^= Path.GetHashCode();
            }
            if (SerialNumber.Length != 0)
            {
                hash ^= SerialNumber.GetHashCode();
            }
            hash ^= subjectAltNames_.GetHashCode();
            if (DaysUntilExpiration != 0UL)
            {
                hash ^= DaysUntilExpiration.GetHashCode();
            }
            if (validFrom_ != null)
            {
                hash ^= ValidFrom.GetHashCode();
            }
            if (expirationTime_ != null)
            {
                hash ^= ExpirationTime.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Example #10
0
        public string WriteMsg()
        {
            UserDataAll += SerialNumber.ToString("X").PadLeft(4, '0');
            UserDataAll += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
            UserDataAll += Iden_F1.GetHexStr();
            for (int i = 0; i < stateDec.Length; i++)
            {
                if (States.Count > i)
                {
                    UserDataAll += States[i].ToString("X").PadLeft(4, '0');
                }
                else
                {
                    UserDataAll += "0000";
                }
            }

            byte[]             UserDataBytesAllTmp;
            WaterBaseMessage[] MsgListTmp;
            string             msg = WaterBaseMessageService.GetMsgList_WriteMsg(this, UserDataAll, out UserDataBytesAllTmp, out MsgListTmp);

            if (msg == "")
            {
                UserDataBytesAll = UserDataBytesAllTmp;
                MsgList          = MsgListTmp;
            }
            else
            {
                if (ShowLog)
                {
                    logHelper.Error(msg);
                }
            }
            return(msg);
        }
Example #11
0
        public override string ToString()
        {
            string res = "";

            res += string.Format("SD Type: {0}\n", Type);
            res += string.Format("Manufacturer ID: 0x{0}\n", ManufacturerID.ToString("X"));
            res += string.Format("OEM ID: {0}\n", OEMID);
            res += string.Format("Product: {0}\n", string.Join("", ProductVersion.Select(p => (char)p)));
            res += string.Format("Version: {0}{1}\n", MajorVersion, MinorVersion);
            res += string.Format("Serial number: 0x{0}\n", SerialNumber.ToString("X"));
            res += string.Format("Manufacturing date: {0}/{1}\n", ManufacturingDateMonth, ManufacturingDateYear);
            res += string.Format("CardSize: {0} MB\n", CardSize);
            res += string.Format("FlashEraseSize: {0}\n", FlashEraseSize);
            res += string.Format("EraseSingleBlock: {0}\n", EraseSingleBlock);
            res += string.Format("Volume is FAT{0}\n", (int)FatType);
            res += string.Format("BlocksPerCluster: {0}\n", BlocksPerCluster);
            res += string.Format("ClusterCount: {0}\n", ClusterCount);
            res += string.Format("FreeClusters: {0}\n", FreeClusters);
            res += string.Format("FreeSpace: {0} MB\n", FreeSpace);
            res += string.Format("FatStartBlock: {0}\n", FatStartBlock);
            res += string.Format("FatCount: {0}\n", FatCount);
            res += string.Format("BlocksPerFat: {0}\n", BlocksPerFat);
            res += string.Format("RootDirStart: {0}\n", RootDirStart);
            res += string.Format("DataStartBlock: {0}", DataStartBlock);
            return(res);
        }
Example #12
0
        public void TestVerifier_Full()
        {
            var expireDate = DateTime.Parse("2100-01-01", CultureInfo.InvariantCulture);
            var license    = Lic.Builder
                             .WithRsaPrivateKey(LicTest.PrivateKey)
                             .WithHardwareIdentifier(HardwareIdentifier.ForCurrentComputer())
                             .WithSerialNumber(SerialNumber.Create("ABC"))
                             .ExpiresOn(expireDate)
                             .WithProperty("Prop1", "Value1")
                             .WithProperty("Prop2", "Value2")
                             .SignAndCreate();

            var verifiedLicense = Lic.Verifier
                                  .WithRsaPublicKey(LicTest.PublicKey)
                                  .WithApplicationCode("ABC")
                                  .LoadAndVerify(license.Serialize());

            Assert.AreEqual(license.Serialize(), verifiedLicense.Serialize());

            verifiedLicense = Lic.Verifier
                              .WithRsaPublicKey(LicTest.PublicKey)
                              .WithApplicationCode("ABC")
                              .LoadAndVerify(license.SerializeAsPlainText());

            Assert.AreEqual(license.Serialize(), verifiedLicense.Serialize());
        }
Example #13
0
        private bool DrawSerialField(SerialNumber serialNumber)
        {
            bool shouldBeRemoved = false;

            EditorGUILayout.BeginVertical(EditorStyles.helpBox);

            EditorGUILayout.LabelField("Platform " + serialNumber.platform);

            EditorGUILayout.BeginHorizontal();
            serialNumber.serial = EditorGUILayout.TextArea(serialNumber.serial);

            var prevColor = GUI.backgroundColor;

            GUI.backgroundColor = new Color(1f, 0.45f, 0.44f);

            if (GUILayout.Button("Remove", GUILayout.Width(60)))
            {
                if (EditorUtility.DisplayDialog("Confirmation", "Are you sure you want to remove serial for " + serialNumber.platform,
                                                "Yes", "Nope!"))
                {
                    shouldBeRemoved = true;
                }
            }

            GUI.backgroundColor = prevColor;

            EditorGUILayout.EndHorizontal();
            EditorGUILayout.EndVertical();

            return(shouldBeRemoved);
        }
        public async Task Submit_Succeeds()
        {
            // Arrange
            var serial       = Guid.NewGuid().ToString();
            var serialNumber = SerialNumber.CreateNewSerialNumber(serial);

            var firstName    = Guid.NewGuid().ToString();
            var lastName     = Guid.NewGuid().ToString();
            var emailAddress = $"{Guid.NewGuid().ToString()}@{Guid.NewGuid().ToString()}.com";

            // Act
            await sut.Submit(firstName, lastName, new EmailAddress(emailAddress), serialNumber);

            await Context.SaveChangesAsync();


            // Assert
            var submission = await Context.DrawSubmissions
                             .Include(x => x.SerialNumber) // Loads the adjacent entity to only roundtrip the database once
                             .SingleOrDefaultAsync();

            Assert.NotNull(submission);

            Assert.That(submission.FirstName, Is.EqualTo(firstName));
            Assert.That(submission.LastName, Is.EqualTo(lastName));
            Assert.That(submission.EmailAddress.Value, Is.EqualTo(emailAddress));

            Assert.That(submission.SerialNumber.UsageCount, Is.EqualTo(1));

            eventDispathcerMock.Verify(x => x.Publish(It.IsAny <IDomainEvent>()));
        }
Example #15
0
        public string WriteMsg()
        {
            UserData  = "";
            UserData += SerialNumber.ToString("X").PadLeft(4, '0');
            UserData += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');

            int count = (Ps.Length - 1) / 8 + 1;

            UserData += Ps.Length.ToString("X").PadLeft(2, '0');
            string s = "";

            for (int i = 0; i < Ps.Length; i++)
            {
                if (Ps[i])
                {
                    s = "1" + s;
                }
                else
                {
                    s = "0" + s;
                }
            }
            s         = s.PadLeft(8 * ((count - 1) / 8 + 1), '0');
            UserData += HexStringUtility.BinStringToHexString(s);

            UserDataBytes = HexStringUtility.HexStringToByteArray(UserData);
            return(WriteMsgBase());
        }
Example #16
0
        public string WriteMsg()
        {
            /*UserData = "";
             * UserData += SerialNumber.ToString("X").PadLeft(4, '0');
             * UserData += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
             *
             * UserData += YellowLevel.ToString("X").PadLeft(4, '0');
             * UserData += OrangeLevel.ToString("X").PadLeft(4, '0');
             * UserData += RedLevel.ToString("X").PadLeft(4, '0');
             *
             * UserDataBytes = HexStringUtility.HexStringToByteArray(UserData);
             * return WriteMsgBase();*/
            UserDataAll += SerialNumber.ToString("X").PadLeft(4, '0');
            UserDataAll += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
            UserDataAll += YellowLevel.ToString("X").PadLeft(4, '0');
            UserDataAll += OrangeLevel.ToString("X").PadLeft(4, '0');
            UserDataAll += RedLevel.ToString("X").PadLeft(4, '0');
            byte[]             UserDataBytesAllTmp;
            WaterBaseMessage[] MsgListTmp;
            string             msg = WaterBaseMessageService.GetMsgList_WriteMsg(this, UserDataAll, out UserDataBytesAllTmp, out MsgListTmp);

            if (msg == "")
            {
                UserDataBytesAll = UserDataBytesAllTmp;
                MsgList          = MsgListTmp;
            }
            else
            {
                if (ShowLog)
                {
                    logHelper.Error(msg);
                }
            }
            return(msg);
        }
Example #17
0
        public string WriteMsg()
        {
            UserDataAll += SerialNumber.ToString("X").PadLeft(4, '0');
            UserDataAll += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');
            UserDataAll += Iden_F1.GetHexStr();
            VersionL     = (byte)HexStringUtility.StrToByteArray(VersionC).Length;
            UserDataAll += VersionL.ToString("X").PadLeft(2, '0');
            UserDataAll += HexStringUtility.StrToHexString(VersionC);

            byte[]             UserDataBytesAllTmp;
            WaterBaseMessage[] MsgListTmp;
            string             msg = WaterBaseMessageService.GetMsgList_WriteMsg(this, UserDataAll, out UserDataBytesAllTmp, out MsgListTmp);

            if (msg == "")
            {
                UserDataBytesAll = UserDataBytesAllTmp;
                MsgList          = MsgListTmp;
            }
            else
            {
                if (ShowLog)
                {
                    logHelper.Error(msg);
                }
            }
            return(msg);
        }
        // Create the Doc Method
        public static void CreateWordDocument(object filename, object SaveAs, int copies)
        {
            // the instance of word
            Word.Application wordApp   = new Word.Application();
            Word.Document    myWordDoc = null;
            wordApp.Visible = true;

            if (!File.Exists((string)filename))
            {
                throw new IOException("File not Found!");
            }

            for (int i = 1; i <= copies; i++)
            {
                // The passed in document
                myWordDoc = wordApp.Documents.Open(ref filename);

                myWordDoc.Activate();

                //find and replace ---------------------------------------------------------
                SerialNumber oldNum = new SerialNumber(WhatToFind(myWordDoc));
                FindAndReplace(wordApp, oldNum.ToString(), oldNum.Increment(i).ToString());

                //Save as
                object name = (string)SaveAs + i;
                myWordDoc.SaveAs2(ref name);

                myWordDoc.Close();
            }
            wordApp.Quit();
            MessageBox.Show("Success!");
        }
Example #19
0
        public Result Verify(ILicensedProduct licensedProduct)
        {
            if (licensedProduct == null)
            {
                throw new ArgumentNullException(nameof(licensedProduct));
            }

            if (!Signed)
            {
                throw new InvalidOperationException("This license already is not signed.");
            }

            if (ExpirationTime.Expired)
            {
                return(Result.Fail("This license is expired."));
            }

            if (!ProductName.Equals(licensedProduct.ProductName, StringComparison.Ordinal))
            {
                return(Result.Fail("This license is not for this product."));
            }

            if (!ProductVersion.Equals(licensedProduct.ProductVersion, StringComparison.Ordinal))
            {
                return(Result.Fail("This license is not for this product."));
            }

            if (!SerialNumber.Equals(licensedProduct.SerialNumber, StringComparison.Ordinal))
            {
                return(Result.Fail("This license is not for this machine."));
            }

            return(Result.Ok());
        }
            public SerialNumber Increment(int n)
            {
                SerialNumber s = new SerialNumber(this.ToString());

                s.id += n;
                return(s);
            }
        public SerialNumber GetSingleSerialNum(string id, long companyId)
        {
            long         longId = Convert.ToInt64(id);
            SerialNumber entity = this.Context.SerialNumbers.FirstOrDefault(x => x.Id == longId && x.CompanyId == companyId);

            return(entity);
        }
Example #22
0
        //--------------------------------------------------------------------------------

        public long GetNewSerialNumber()
        {
            using (var context = _rfContextFactory.Create())
            {
                var id           = 1;
                var serialNumber = new SerialNumber {
                    Number = 1
                };
                if (!context.SerialNumbers.Any())
                {
                    context.SerialNumbers.Add(serialNumber);
                }
                else
                {
                    serialNumber = context.SerialNumbers.Find(id);
                }

                if (serialNumber != null)
                {
                    var num = ++serialNumber.Number;

                    SaveChanges(context);

                    return(num);
                }

                throw new Exception("Unable to find Serial Number");
            }
        }
Example #23
0
 /// <summary>
 ///   TODO: Update Comments
 ///
 /// </summary>
 /// <returns>
 ///     A int value...
 /// </returns>
 public override int GetHashCode()
 {
     unchecked
     {
         return((NetworkAddress.GetHashCode() * 397) ^ SerialNumber.GetHashCode());
     }
 }
Example #24
0
    List <string> GetSolutionOrder()
    {
        List <string> solutionOrder = new List <string>(new string[] { "©", "★", "☆", "⊛", "ټ", "Җ", "Ω", "Ѭ", "Ѽ" });
        SerialNumber  sn            = SceneManager.Instance.Bomb.Serial;

        //Serial number starts with number
        if (sn && !char.IsLetter(sn.GetSerialString()[0]))
        {
            return(new List <string>(new string[] { "Җ", "Ѽ", "★", "©", "⊛", "ټ", "Ω", "Ѭ", "☆" }));
        }

        foreach (KeypadButton button in buttons)
        {
            if (button.GetText() == "Ѭ")
            {
                return(new List <string>(new string[] { "Ѭ", "Җ", "©", "Ѽ", "★", "☆", "Ω", "⊛", "ټ" }));
            }
        }

        foreach (KeypadButton button in buttons)
        {
            if (button.GetText() == "Җ")
            {
                return(new List <string>(new string[] { "Ѽ", "★", "Ω", "ټ", "☆", "Ѭ", "Җ", "©", "⊛" }));
            }
        }

        return(solutionOrder);
    }
        public override void WriteXml(System.Xml.XmlWriter writer)
        {
            TypeConverter bc = TypeDescriptor.GetConverter(typeof(bool));

            writer.WriteElementString("SerialNumber", SerialNumber.ToString(CultureInfo.InvariantCulture));
            writer.WriteElementString("ServoCount", _servoCount.ToString(CultureInfo.InvariantCulture));
            writer.WriteStartElement("Servos");
            for (int i = 0; i < _servoCount; i++)
            {
                writer.WriteStartElement("Servo");
                writer.WriteElementString("SpeedRamping", bc.ConvertToString(_servos[i].SpeedRamping));
                writer.WriteElementString("VelocityLimit", _servos[i].VelocityLimit.ToString(CultureInfo.InvariantCulture));
                writer.WriteElementString("Acceleration", _servos[i].Acceleration.ToString(CultureInfo.InvariantCulture));
                _servos[i].Calibration.Write(writer);

                writer.WriteElementString("Type", _servos[i].ServoType.ToString());
                writer.WriteElementString("MinPulse", _servos[i].ServoMinPulseWidth.ToString(CultureInfo.InvariantCulture));
                writer.WriteElementString("MaxPulse", _servos[i].ServoMaxPulseWidth.ToString(CultureInfo.InvariantCulture));
                writer.WriteElementString("MaxVelocity", _servos[i].ServoMaxVelocity.ToString(CultureInfo.InvariantCulture));
                writer.WriteElementString("Travel", _servos[i].ServoDegrees.ToString(CultureInfo.InvariantCulture));

                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }
        public async Task SubmitDraw_Succeeds_ReturnsSuccess()
        {
            // Arrange
            var serialNumber = SerialNumber.CreateNewSerialNumber(Guid.NewGuid().ToString());
            var emailStr     = $"{Guid.NewGuid().ToString()}@{Guid.NewGuid().ToString()}.com";
            var dto          = new SubmitDrawRequest
            {
                FirstName    = Guid.NewGuid().ToString(),
                LastName     = Guid.NewGuid().ToString(),
                EmailAddress = emailStr,
                SerialNumber = serialNumber.Serial,
            };

            var email = new EmailAddress(emailStr);

            serialNumberRepositoryMock.Setup(x => x.GetSerialNumber(serialNumber.Serial))
            .ReturnsAsync(() => serialNumber);

            drawSubmissionsServiceMock.Setup(x => x.Submit(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <EmailAddress>(), It.IsAny <SerialNumber>()))
            .ReturnsAsync(() => new DrawSubmission(dto.FirstName, dto.LastName, email, serialNumber));

            // Act
            var response = await sut.SubmitDraw(dto);

            // Assert
            Assert.IsInstanceOf <OkObjectResult>(response);

            var payload      = (response as OkObjectResult).Value;
            var typedPayLoad = payload as DrawSubmissionListingDto;

            Assert.That(typedPayLoad.FirstName, Is.EqualTo(dto.FirstName));
            Assert.That(typedPayLoad.LastName, Is.EqualTo(dto.LastName));
            Assert.That(typedPayLoad.SerialNumber, Is.EqualTo(dto.SerialNumber));
            Assert.That(typedPayLoad.EmailAddress, Is.EqualTo(dto.EmailAddress));
        }
        public override byte[] WriteMsg()
        {
            string data = "";

            data += UserNo.PadLeft(8, '0');
            data += SerialNumber.PadLeft(8, '0');
            data += StartTime.ToString("yyyyMMddHHmmss").Substring(2).PadLeft(12, '0');
            data += ((int)(StartResidualWater * 10)).ToString().PadLeft(8, '0');
            data += ((int)(StartResidualElectric * 10)).ToString().PadLeft(8, '0');
            data += EndTime.ToString("yyyyMMddHHmmss").Substring(2).PadLeft(12, '0');
            data += ((int)(EndResidualWater * 10)).ToString().PadLeft(8, '0');
            data += ((int)(EndResidualElectric * 10)).ToString().PadLeft(8, '0');
            data += ((int)(WaterUsed * 10)).ToString().PadLeft(8, '0');
            data += ((int)(ElectricUsed * 10)).ToString().PadLeft(8, '0');
            data += ((int)(YearElectricUsed * 10)).ToString().PadLeft(8, '0');
            data += ((int)(YearWaterUsed * 10)).ToString().PadLeft(8, '0');
            data += ((int)(YearExploitation * 10)).ToString().PadLeft(8, '0');
            data += ((int)(YearSurplus * 10)).ToString().PadLeft(8, '0');

            data += RecordType.ToString("X").PadLeft(2, '0');
            data += REV1.ToString("X").PadLeft(2, '0');
            data += REV2.ToString("X").PadLeft(2, '0');
            data += CRC8.ToString("X").PadLeft(2, '0');

            IsPW = false;
            PW   = "";
            IsTP = false;
            TP   = "";

            UserData = data;

            UserDataBytes = HexStringUtility.HexStringToByteArray(UserData);

            return(WriteMsg2());
        }
Example #28
0
        public string WriteMsg()
        {
            try
            {
                if (Iden_04 == null)
                {
                    return("时间步长码出错");
                }

                if (Iden == null)
                {
                    return("要素标识符非法");
                }

                UserData  = "";
                UserData += SerialNumber.ToString("X").PadLeft(4, '0');
                UserData += SendTime.ToString("yyMMddHHmmss").PadLeft(12, '0');

                UserData += StartTime.ToString("yyMMddHH").PadLeft(8, '0');
                UserData += EndTime.ToString("yyMMddHH").PadLeft(8, '0');

                UserData += Iden_04.GetHexStr();
                UserData += Iden.GetHexStrHead();

                UserDataBytes = HexStringUtility.HexStringToByteArray(UserData);
                return(WriteMsgBase());
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
        }
Example #29
0
        public override int GetHashCode()
        {
            int hashProductID    = ProductID.GetHashCode();
            int hashSerialNumber = SerialNumber.GetHashCode();

            return(hashProductID ^ hashSerialNumber);
        }
Example #30
0
 public override void Encode()
 {
     encodeBuf.Clear();
     encodeBuf.AddRange(AddString(DeviceId, 8));
     encodeBuf.AddRange(AddString(TxnGroupNumber.PadLeft(2, '0'), 2));
     encodeBuf.AddRange(AddString(SerialNumber.PadLeft(8, '0'), 8));
     encodeBuf.AddRange(AddString(StationId, 4));
     encodeBuf.AddRange(AddString(TxnType, 2));
     encodeBuf.AddRange(AddString(TicketMainType, 2));
     encodeBuf.AddRange(AddString(TicketSubType, 2));
     encodeBuf.AddRange(AddString(TicketPriceCode, 2));
     encodeBuf.AddRange(AddString(SamCardNumber, 8));
     encodeBuf.AddRange(AddString(TicketLogicalId, 16));
     encodeBuf.AddRange(AddString(TicketWriteCouter.PadLeft(6, '0'), 6));
     encodeBuf.AddRange(AddString(ThisTicketOperateAmt.PadLeft(8, '0'), 8));
     encodeBuf.AddRange(AddString(TicketRemainAmt.PadLeft(8, '0'), 8));
     encodeBuf.AddRange(AddString(TxnTime, 14));
     encodeBuf.AddRange(AddString(LastTxnDeviceId, 8));
     encodeBuf.AddRange(AddString(LastTxnSerialNumber.PadLeft(8, '0'), 8));
     encodeBuf.AddRange(AddString(LastTxnAmt.PadLeft(8, '0'), 8));
     encodeBuf.AddRange(AddString(LastTxnTime, 14));
     encodeBuf.AddRange(AddString(TACCode, 8));
     encodeBuf.AddRange(AddString(DegradeMode, 4));
     encodeBuf.AddRange(AddString(EntryStationId, 4));
     encodeBuf.AddRange(AddString(EntryDeviceId, 4));
     encodeBuf.AddRange(AddString(EntryTime, 14));
     encodeBuf.AddRange(AddString(Spare.PadLeft(18, '0'), 18));
 }
Example #31
0
        public void Shuffle_atDifferentTimes_produceDifferentOrders()
        {
            // arrange:
            SerialNumber number = new SerialNumber();
            IDeck deck = new Deck(number);
            DateTime time = DateTime.Now;

            // act:
            deck.Shuffle(time);
            Card[] afterFirstShuffle = deck.ToArray();
            deck.Shuffle(time + new TimeSpan(100)); // just to be sure :-D
            Card[] afterSecondShuffle = deck.ToArray();

            // assert:
            Assert.IsFalse(afterFirstShuffle.SequenceEqual(afterSecondShuffle));
        }
Example #32
0
        public void GetEnumerator_afterAShuffle_dontChangeTheCardsOrderOnHisOwn()
        {
            // arrange:
            SerialNumber number = new SerialNumber();
            IDeck deck = new Deck(number);
            DateTime time = DateTime.Now;

            // act:
            deck.Shuffle(time);
            Card[] firstRead = deck.ToArray();
            Thread.Sleep(1000); // just to be sure :-)
            Card[] secondRead = deck.ToArray();

            // assert:
            Assert.IsTrue(firstRead.SequenceEqual(secondRead));
        }
Example #33
0
        public void Shuffle_withTheSameTimeOnTheSameDeck_isIdempotent()
        {
            // arrange:
            SerialNumber number = new SerialNumber();
            IDeck deck = new Deck(number);
            DateTime time = DateTime.Now;

            // act:
            deck.Shuffle(time);
            Card[] afterFirstShuffle = deck.ToArray();
            deck.Shuffle(time);
            Card[] afterSecondShuffle = deck.ToArray();

            // assert:
            for(int i = 0; i < deck.Count(); ++i)
            {
                Assert.AreSame(afterFirstShuffle[i], afterSecondShuffle[i]);
            }
        }
        /// <summary>
        /// Used to de-serialize the items
        /// </summary>
        /// <param name="byteArray">A Byte array</param>
        /// <param name="currentIndex">Start position</param>
        /// <param name="lengthOfItems">The length of the items</param>
        protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
        {
            int index = currentIndex;
            this.RevisionExtendedGUID = BasicObject.Parse<ExGuid>(byteArray, ref index);
            this.RevisionMappingExtendedGUID = BasicObject.Parse<ExGuid>(byteArray, ref index);
            this.RevisionMappingSerialNumber = BasicObject.Parse<SerialNumber>(byteArray, ref index);

            if (index - currentIndex != lengthOfItems)
            {
                throw new StreamObjectParseErrorException(currentIndex, "StorageIndexRevisionMapping", "Stream object over-parse error", null);
            }

            currentIndex = index;
        }
        /// <summary>
        /// Deserialize items from byte array.
        /// </summary>
        /// <param name="byteArray">The byte array which contains response message.</param>
        /// <param name="currentIndex">The index special where to start.</param>
        /// <param name="lengthOfItems">The length of items.</param>
        protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
        {
            int index = currentIndex;

            this.DataElementExtendedGUID = BasicObject.Parse<ExGuid>(byteArray, ref index);
            this.SerialNumber = BasicObject.Parse<SerialNumber>(byteArray, ref index);

            if (index - currentIndex != lengthOfItems)
            {
                throw new StreamObjectParseErrorException(currentIndex, "PutChangesResponseSerialNumberReassign", "Stream object over-parse error", null);
            }

            currentIndex = index;
        }
Example #36
0
 /// <summary>
 /// Use the DecodeCSHOW decoder to decode the CSHOW command
 /// result.  It will return an AdcpConfiguration with all the
 /// Adcp configurations.
 /// </summary>
 /// <param name="buffer">Result string from CSHOW command.</param>
 /// <param name="serial">Serial number for the system.</param>
 /// <returns>AdcpConfiguration containing all the configurations found from CSHOW.</returns>
 public static AdcpConfiguration DecodeCSHOW(string buffer, SerialNumber serial)
 {
     DecodeCSHOW decoder = new DecodeCSHOW();
     return decoder.Decode(buffer, serial);
 }
Example #37
0
            /// <summary>
            /// Decoding a command set is similar to decoding CSHOW except
            /// in the command set, each line is a command for a subsystem where
            /// in CSHOW each line contain multiple subsystems for 1 command line.
            /// 
            /// This will combine all the commands to make the command set similar
            /// to the CSHOW output.
            /// 
            /// </summary>
            /// <param name="buffer">Buffer of the command set.</param>
            /// <param name="serial">Serial number.</param>
            /// <returns>ADCP configuration.</returns>
            public static AdcpConfiguration DecodeCommandSet(string buffer, SerialNumber serial)
            {
                Dictionary<string, string> commands = new Dictionary<string, string>();

                // Convert the commandset in to CSHOW
                string[] results = buffer.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
                for (int x = 0; x < results.Length; x++)
                {
                    // Get the command for each line
                    string[] cmd = results[x].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

                    // Get the cmd
                    if(cmd.Length > 1)
                    {
                        // If the command is CEPO
                        // Get the subsystem code to add to the serial number
                        if(cmd[0] == CMD_CEPO)
                        {
                            var cepoList = cmd[1].ToCharArray();
                            for(int cepoIndex = 0; cepoIndex < cepoList.Length; cepoIndex++ )
                            {
                                var subsys = new Subsystem((byte)cepoList[cepoIndex]);
                                serial.AddSubsystem(subsys);
                            }
                        }

                        // Command all the parameters
                        string param = "";
                        for (int y = 1; y < cmd.Length; y++ )
                        {
                            param += cmd[y];
                        }

                        // Append to the end if the key exist
                        if (commands.ContainsKey(cmd[0]))
                        {
                            commands[cmd[0]] += param;
                        }
                        else
                        {
                            commands.Add(cmd[0], param);
                        }
                    }
                    else
                    {
                        // No command, just add it
                        commands.Add(results[x], "");
                    }
                }

                // Combine all the values into the same format as CSHOW
                StringBuilder sb = new StringBuilder();

                foreach(var val in commands.Keys)
                {
                    sb.AppendLine(string.Format("{0} {1}", val, commands[val]));
                }

                DecodeCSHOW decoder = new DecodeCSHOW();
                return decoder.Decode(sb.ToString(), serial);
            }
Example #38
0
 public static extern int GetSerialNumber(uint zano, ref SerialNumber out_serialNumber);
        /// <summary>
        /// This method is used to deserialize the items of the cell knowledge entry from the byte array.
        /// </summary>
        /// <param name="byteArray">Specify the byte array.</param>
        /// <param name="currentIndex">Specify the start index from the byte array.</param>
        /// <param name="lengthOfItems">Specify the current length of items in the cell knowledge entry.</param>
        protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
        {
            int index = currentIndex;
            this.SerialNumber = BasicObject.Parse<SerialNumber>(byteArray, ref index);

            if (index - currentIndex != lengthOfItems)
            {
                throw new StreamObjectParseErrorException(currentIndex, "CellKnowledgeEntry", "Stream object over-parse error", null);
            }

            currentIndex = index;
        }
        /// <summary>
        /// ���´���ĺ��Թ���
        /// </summary>
        /// <returns></returns>
        private string UpdateAnswerIgnore()
        {
            if (Request["sn"] != null && Request["mid"] != null && Request["qid"] != null && Request["aid"] != null && Request["igtype"] != null && Request["param"] != null)
            {
                try
                {
                    SerialNumber sn = new SerialNumber(Request["sn"]);
                    int mid = Convert.ToInt32(Request["mid"]);
                    int qid = Convert.ToInt32(Request["qid"]);
                    int aid = Convert.ToInt32(Request["aid"]);

                    IgnoreType igtype = (IgnoreType)Convert.ToInt16(Request["igtype"]);
                    PaperFile pf = PaperFile.Load(sn);

                    AnswerFile af = pf[mid][qid][aid];

                    if (af != null)
                    {
                        af.Ignore = igtype;
                        if (igtype == IgnoreType.None)
                        {
                            af.IgnoreCollection.Clear();
                        }
                        else
                        {
                            string ids = Request["param"].Trim();
                            if (!String.IsNullOrEmpty(ids))
                            {
                                af.AddIgnoreObject(igtype, ids.IndexOf(',') == -1 ? new string[] { ids } : ids.Split(','));
                            }
                        }
                    }

                    pf.Save();
                    return @"ok,���º��Թ������";
                }
                catch
                {
                    throw;
                }
            }
            return @"failed,���º��Թ���ʧ��";
        }
Example #41
0
            public EnsembleDataSet(int ValueType, int NumElements, int ElementsMultiplier, int Imag, int NameLength, string Name,
                                    int EnsembleNumber, int NumBins, int NumBeams, int DesiredPingCount, int ActualPingCount,
                                    SerialNumber SysSerialNumber, Firmware SysFirmware, SubsystemConfiguration SubsystemConfig, Status Status,
                                    int Year, int Month, int Day, int Hour, int Minute, int Second, int HSec)
                : base(ValueType, NumElements, ElementsMultiplier, Imag, NameLength, Name)
            {
                //this.UniqueId = UniqueId;
                this.EnsembleNumber = EnsembleNumber;
                this.NumBins = NumBins;
                this.NumBeams = NumBeams;
                this.DesiredPingCount = DesiredPingCount;
                this.ActualPingCount = ActualPingCount;
                this.SysSerialNumber = SysSerialNumber;
                this.SysFirmware = SysFirmware;
                this.SubsystemConfig = SubsystemConfig;
                this.Status = Status;
                this.Year = Year;
                this.Month = Month;
                this.Day = Day;
                this.Hour = Hour;
                this.Minute = Minute;
                this.Second = Second;
                this.HSec = HSec;
                //this.EnsDateTime = EnsDateTime;

                // Set the time and date
                ValidateDateTime(Year, Month, Day, Hour, Minute, Second, HSec / 10);

                // Create UniqueId
                UniqueId = new UniqueID(EnsembleNumber, EnsDateTime);
            }
Example #42
0
            /// <summary>
            /// Get all the information about the Ensemble.
            /// </summary>
            /// <param name="data">Byte array containing the Ensemble data type.</param>
            private void Decode(byte[] data)
            {
                EnsembleNumber = MathHelper.ByteArrayToInt32(data, GenerateIndex(0));
                NumBins = MathHelper.ByteArrayToInt32(data, GenerateIndex(1));
                NumBeams = MathHelper.ByteArrayToInt32(data, GenerateIndex(2));
                DesiredPingCount = MathHelper.ByteArrayToInt32(data, GenerateIndex(3));
                ActualPingCount = MathHelper.ByteArrayToInt32(data, GenerateIndex(4));
                Status = new Status(MathHelper.ByteArrayToInt32(data, GenerateIndex(5)));
                Year = MathHelper.ByteArrayToInt32(data, GenerateIndex(6));
                Month = MathHelper.ByteArrayToInt32(data, GenerateIndex(7));
                Day = MathHelper.ByteArrayToInt32(data, GenerateIndex(8));
                Hour = MathHelper.ByteArrayToInt32(data, GenerateIndex(9));
                Minute = MathHelper.ByteArrayToInt32(data, GenerateIndex(10));
                Second = MathHelper.ByteArrayToInt32(data, GenerateIndex(11));
                HSec = MathHelper.ByteArrayToInt32(data, GenerateIndex(12));

                // Revision D additions
                if (NumElements >= NUM_DATA_ELEMENTS_REV_D && data.Length >= NUM_DATA_ELEMENTS_REV_D * Ensemble.BYTES_IN_INT32)
                {
                    // Get the System Serial Num
                    // Start at index 13
                    byte[] serial = new byte[SERIAL_NUM_INT * Ensemble.BYTES_IN_INT32];
                    System.Buffer.BlockCopy(data, GenerateIndex(13), serial, 0, SERIAL_NUM_INT * Ensemble.BYTES_IN_INT32);
                    SysSerialNumber = new SerialNumber(serial);

                    // Get the firmware number
                    // Start at index 21
                    byte[] firmware = new byte[FIRMWARE_NUM_INT * Ensemble.BYTES_IN_INT32];
                    System.Buffer.BlockCopy(data, GenerateIndex(21), firmware, 0, FIRMWARE_NUM_INT * Ensemble.BYTES_IN_INT32);
                    SysFirmware = new Firmware(firmware);

                    // FOR BACKWARDS COMPATITBILITY
                    // Old subsystems in the ensemble were set by the Subsystem Index in Firmware.
                    // This means the that a subsystem code of 0 could be passed because
                    // the index was 0 to designate the first subsystem index.  Firmware revision 0.2.13 changed
                    // SubsystemIndex to SubsystemCode.  This will check which Firmware version this ensemble is
                    // and convert to the new type using SubsystemCode.
                    //
                    // Get the correct subsystem by getting the index found in the firmware and getting
                    // subsystem code from the serial number.
                    //if (SysFirmware.FirmwareMajor <= 0 && SysFirmware.FirmwareMinor <= 2 && SysFirmware.FirmwareRevision <= 13 && GetSubSystem().IsEmpty())
                    //{
                    //    // Set the correct subsystem based off the serial number
                    //    // Get the index for the subsystem
                    //    byte index = SysFirmware.SubsystemCode;

                    //    // Ensure the index is not out of range of the subsystem string
                    //    if (SysSerialNumber.SubSystems.Length > index)
                    //    {
                    //        // Get the Subsystem code from the serialnumber based off the index found
                    //        string code = SysSerialNumber.SubSystems.Substring(index, 1);

                    //        // Create a subsystem with the code and index
                    //        Subsystem ss = new Subsystem(Convert.ToByte(code), index);

                    //        // Set the new subsystem code to the firmware
                    //        //SysFirmware.SubsystemCode = Convert.ToByte(code);

                    //        // Remove the old subsystem and add the new one to the dictionary
                    //        SysSerialNumber.SubSystemsDict.Remove(Convert.ToByte(index));
                    //        SysSerialNumber.SubSystemsDict.Add(Convert.ToByte(index), ss);

                    //    }
                    //}

                }
                else
                {
                    SysSerialNumber = new SerialNumber();
                    SysFirmware = new Firmware();

                }

                // Revision H additions
                if (NumElements >= NUM_DATA_ELEMENTS_REV_H && data.Length >= NUM_DATA_ELEMENTS_REV_H * Ensemble.BYTES_IN_INT32)
                {
                    // Get the Subsystem Configuration
                    // Start at index 22
                    byte[] subConfig = new byte[SUBSYSTEM_CONFIG_NUM_INT * Ensemble.BYTES_IN_INT32];
                    System.Buffer.BlockCopy(data, GenerateIndex(22), subConfig, 0, SUBSYSTEM_CONFIG_NUM_INT * Ensemble.BYTES_IN_INT32);
                    SubsystemConfig = new SubsystemConfiguration(SysFirmware.GetSubsystem(SysSerialNumber), subConfig);
                }
                else
                {
                    // Create a default SubsystemConfig with a configuration of 0
                    SubsystemConfig = new SubsystemConfiguration(SysFirmware.GetSubsystem(SysSerialNumber), 0, 0);
                }

                // Set the time and date
                ValidateDateTime(Year, Month, Day, Hour, Minute, Second, HSec / 10);

                // Create UniqueId
                UniqueId = new UniqueID(EnsembleNumber, EnsDateTime);
            }
Example #43
0
            /// <summary>
            /// Create a Ensemble data set.  This will create a blank dataset.  The user must fill in the data for all
            /// the important values.
            /// </summary>
            /// <param name="valueType">Whether it contains 32 bit Integers or Single precision floating point </param>
            /// <param name="numElments">Number of Elements.</param>
            /// <param name="elementMultiplier">Element Multipliers.</param>
            /// <param name="imag"></param>
            /// <param name="nameLength">Length of name</param>
            /// <param name="name">Name of data type</param>
            /// <param name="numBins">Number of Bin</param>
            /// <param name="numBeams">Number of beams</param>
            public EnsembleDataSet(int valueType, int numElments, int elementMultiplier, int imag, int nameLength, string name, int numBins, int numBeams)
                : base(valueType, numElments, elementMultiplier, imag, nameLength, name)
            {
                // Set the ensemble number to the default ensemble number
                EnsembleNumber = DEFAULT_ENS_NUM;

                // Set time to the current time
                SetTime();

                // Create UniqueId
                UniqueId = new UniqueID(EnsembleNumber, EnsDateTime);

                // Set the number of beams
                NumBeams = numBeams;

                // Set the number of bins
                NumBins = numBins;

                // Use a blank serial number
                SysSerialNumber = new SerialNumber();

                // Create blank firmware
                SysFirmware = new Firmware();

                // Create Blank Subsystem configuration
                SubsystemConfig = new SubsystemConfiguration();

                // Create a blank status
                Status = new Status(0);
            }
Example #44
0
            // Dataset ID
            /// <summary>
            /// Create a Ensemble data set.  This will create a blank dataset.  The user must fill in the data for all
            /// the important values.
            /// </summary>
            public EnsembleDataSet()
                : base(DataSet.Ensemble.DATATYPE_INT,                         // Type of data stored (Float or Int)
                            NUM_DATA_ELEMENTS,                              // Number of elements
                            DataSet.Ensemble.DEFAULT_NUM_BEAMS_NONBEAM,     // Element Multiplier
                            DataSet.Ensemble.DEFAULT_IMAG,                  // Default Image
                            DataSet.Ensemble.DEFAULT_NAME_LENGTH,           // Default Image length
                            DataSet.Ensemble.EnsembleDataID)
            {
                // Set the ensemble number to the default ensemble number
                EnsembleNumber = DEFAULT_ENS_NUM;

                // Set time to the current time
                SetTime();

                // Create UniqueId
                UniqueId = new UniqueID(EnsembleNumber, EnsDateTime);

                // Set the number of beams
                //NumBeams = numBeams;

                // Set the number of bins
                //NumBins = numElements;

                // Use a blank serial number
                SysSerialNumber = new SerialNumber();

                // Create blank firmware
                SysFirmware = new Firmware();

                // Create Blank Subsystem configuration
                SubsystemConfig = new SubsystemConfiguration();

                // Create a blank status
                Status = new Status(0);
            }
        /// <summary>
        /// �����ʾ��ļ��Ľ���
        /// </summary>
        /// <returns></returns>
        private string UpdatePaperConclusions()
        {
            if (Request["sn"] != null)
            {
                try
                {
                    SerialNumber sn = new SerialNumber(Request["sn"].Trim());
                    PaperFile pf = PaperFile.Load(sn);

                    foreach (Conclusion con in Paper.GetConclusions(sn))
                    {
                        if (!pf.ContainsConclusion(con.Id))
                        {
                            pf.ConclusionFiles.Add(ConclusionFile.Create(con));
                        }
                        else
                        {
                            ConclusionFile cf=pf.GetConclusionFileById(con.Id);
                            cf.Range = con.Range;
                            cf.Content = con.Content;
                            cf.Advice = con.Advice;
                        }
                    }
                    pf.Save();
                    return @"ok,�������";
                }
                catch
                {
                    throw;
                }
            }
            return @"failed,����ʧ��";
        }
Example #46
0
            /// <summary>
            /// Read the JSON object and convert to the object.  This will allow the serializer to
            /// automatically convert the object.  No special instructions need to be done and all
            /// the properties found in the JSON string need to be used.
            /// 
            /// DataSet.EnsembleDataSet decodedEns = Newtonsoft.Json.JsonConvert.DeserializeObject{DataSet.EnsembleDataSet}(encodedEns)
            /// 
            /// </summary>
            /// <param name="reader">NOT USED. JSON reader.</param>
            /// <param name="objectType">NOT USED> Type of object.</param>
            /// <param name="existingValue">NOT USED.</param>
            /// <param name="serializer">Serialize the object.</param>
            /// <returns>Serialized object.</returns>
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                if (reader.TokenType != JsonToken.Null)
                {
                    // Load the object
                    JObject jsonObject = JObject.Load(reader);

                    // Decode the data
                    int NumElements = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMELEMENTS];
                    int ElementsMultiplier = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ELEMENTSMULTIPLIER];

                    // EnsembleNumber
                    int EnsembleNumber = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ENSEMBLENUMBER];

                    // NumBins
                    int NumBins = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMBINS];

                    // NumBeams
                    int NumBeams = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMBEAMS];

                    // DesiredPingCount
                    int DesiredPingCount = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DESIREDPINGCOUNT];

                    // ActualPingCount
                    int ActualPingCount = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ACTUALPINGCOUNT];

                    // SysSerialNumber
                    SerialNumber SysSerialNumber = new SerialNumber((string)jsonObject[DataSet.BaseDataSet.STR_JSON_SERIALNUMBER_SERIALNUMBERSTRING]);

                    // SysFirmware
                    ushort major = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREMAJOR];
                    ushort minor = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREMINOR];
                    ushort rev = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREREVISION];
                    byte code = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEMCODE].ToObject<byte>();
                    Firmware SysFirmware = new Firmware(code, major, minor, rev);

                    // SubsystemConfig
                    ushort index = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_INDEX];
                    byte ssCode = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_CODE].ToObject<byte>();
                    byte cepoIndex = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_CEPOINDEX].ToObject<byte>();
                    byte configNum = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SSCONFIG_INDEX].ToObject<byte>();
                    SubsystemConfiguration SubsystemConfig = new SubsystemConfiguration(new Subsystem(ssCode, index), cepoIndex, configNum);

                    // Status
                    Status status = new Status((int)jsonObject[DataSet.BaseDataSet.JSON_STR_STATUS]);

                    // Year
                    int Year = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_YEAR];

                    // Month
                    int Month = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MONTH];

                    // Day
                    int Day = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DAY];

                    // Hour
                    int Hour = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HOUR];

                    // Minute
                    int Minute = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MINUTE];

                    // Second
                    int Second = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_SECOND];

                    // HSec
                    int HSec = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HSEC];

                    // Create the object
                    // Need to call the constructor to create
                    // the correct EnsDateTime and UniqueID
                    var data = new EnsembleDataSet(DataSet.Ensemble.DATATYPE_INT, NumElements, ElementsMultiplier, DataSet.Ensemble.DEFAULT_IMAG, DataSet.Ensemble.DEFAULT_NAME_LENGTH, DataSet.Ensemble.EnsembleDataID,
                                                    EnsembleNumber, NumBins, NumBeams, DesiredPingCount, ActualPingCount,
                                                    SysSerialNumber, SysFirmware, SubsystemConfig, status,
                                                    Year, Month, Day, Hour, Minute, Second, HSec);

                    return data;
                }

                return null;
            }
        private bool FlashFpga()
        {
            this.flashed = false;
            int packetSize = 32;//hardwareInterface.WriteControlMaxLength ();
            int packetsPerCommand = 64;

            if (packetSize <= 0)
                return false;

            string fwName;
            try
            {
                LabNation.Common.SerialNumber s = new SerialNumber(this.Serial);
                fwName = String.Format("SmartScope_{0}.bin", Base36.Encode((long)s.model, 3).ToUpper());
            }
            catch (Exception)
            {
                return false;
            }

            byte [] firmware = null;
            DateTime firmwareModified = DateTime.Now;
            int killMeNow = 2048 / 8;

            //Data to send to keep clock running after all data was sent
            byte [] dummyData = new byte[packetSize];
            for (int i = 0; i < dummyData.Length; i++)
                dummyData [i] = 255;

            //Get FW contents
            try {
                firmware = Resources.Load(fwName);
            } catch (Exception e) {
                Logger.Error("Opening FPGA FW file failed");
                Logger.Error(e.Message);
                return false;
            }
            if(firmware == null) {
                Logger.Error("Failed to read FW");
                return false;
            }

            Logger.Debug("Got firmware of length " + firmware.Length);

            //Send FW to FPGA
            try {
                Stopwatch flashStopwatch = new Stopwatch ();
                flashStopwatch.Start ();
                String fwModifiedString = Utils.GetPrettyDate (firmwareModified);
                Logger.Debug("Firmware was created " + fwModifiedString);
                UInt16 commands = (UInt16) (firmware.Length / packetSize + killMeNow);
                //PIC: enter FPGA flashing mode
                byte[] msg = new byte[] {
                    SmartScopeUsbInterfaceHelpers.HEADER_CMD_BYTE,
                    (byte)SmartScopeUsbInterfaceHelpers.PIC_COMMANDS.PROGRAM_FPGA_START,
                    (byte) (commands >> 8),
                    (byte) (commands),
                };
                hardwareInterface.WriteControlBytes(msg, false);

                //FIXME: this sleep is found necessary on android tablets.
                /* The problem occurs when a scope is initialised the *2nd*
                 * time after the app starts, i.e. after replugging it.
                 * A possible explanation is that in the second run, caches
                 * are hit and the time between the PROGRAM_FPGA_START command
                 * and the first bitstream bytes is smaller than on the first run.
                 *
                 * Indeed, if this time is smaller than the time for the INIT bit
                 * (see spartan 6 ug380 fig 2.4) to rise, the first bitstream data
                 * is missed and the configuration fails.
                 */
                System.Threading.Thread.Sleep(10);
                hardwareInterface.FlushDataPipe();

                int bytesSent = 0;
                int commandSize = packetsPerCommand * packetSize;
                while (bytesSent < firmware.Length) {
                    if (bytesSent + commandSize > firmware.Length)
                        commandSize = firmware.Length - bytesSent;
                    hardwareInterface.WriteControlBytesBulk(firmware, bytesSent, commandSize, false);
                    bytesSent += commandSize;
                }
                flashStopwatch.Stop ();
                for (int j = 0; j < killMeNow; j++) {
                    hardwareInterface.WriteControlBytesBulk(dummyData, false);
                }

                //Send finish flashing command
                hardwareInterface.SendCommand(SmartScopeUsbInterfaceHelpers.PIC_COMMANDS.PROGRAM_FPGA_END);
                Logger.Debug(String.Format("Flashed FPGA in {0:0.00}s", (double)flashStopwatch.ElapsedMilliseconds / 1000.0));
                Logger.Debug("Flushing data pipe");
                //Flush whatever might be left in the datapipe
                hardwareInterface.FlushDataPipe();
                if(GetFpgaFirmwareVersion() == FPGA_VERSION_UNFLASHED) {
                    Logger.Error("Got firmware version of unflashed FPGA");
                    return false;
                }
                this.flashed = true;
            } catch (ScopeIOException e) {
                Logger.Error("Flashing FPGA failed failed");
                Logger.Error(e.Message);
                return false;
            }
            return true;
        }
        /// <summary>
        /// �����ʾ��ļ��е�ģ�����
        /// </summary>
        /// <returns></returns>
        private string UpdateModuleConclusions()
        {
            if (Request["sn"] != null && Request["mid"]!=null)
            {
                try
                {
                    SerialNumber sn = new SerialNumber(Request["sn"].Trim());
                    PaperFile pf = PaperFile.Load(sn);
                    int mid = Convert.ToInt32(Request["mid"]);

                    ModuleFile mf = pf[mid];
                    if (mf == null)
                    {
                        return "failed,ģ�鲻����";
                    }

                    mf.Conclusions.Clear();
                    foreach (Conclusion con in Module.GetConclusions(mid))
                    {
                        mf.Conclusions.Add(ConclusionFile.Create(con));
                    }
                    mf.Conclusions.Sort(new ConclusionScoreRangeLowerComparer());
                    pf.Save();
                    return @"ok,�������";
                }
                catch
                {
                    throw;
                }
            }
            return @"failed,����ʧ��";
        }
 /// <summary>
 /// �����ʾ�
 /// </summary>
 /// <returns></returns>
 private string PublishPaperFile()
 {
     if (Request["sn"] != null)
     {
         try
         {
             SerialNumber sn = new SerialNumber(Request["sn"]);
             Paper.SetStatus(sn, PaperStatus.Published);
             return @"ok,�����ʾ����";
         }
         catch
         {
             throw;
         }
     }
     return @"failed,�����ʾ�ʧ��";
 }
Example #50
0
 public Deck(SerialNumber serial)
 {
     if(null == serial)
         throw new ArgumentNullException("serial");
     _serial = serial;
 }
        /// <summary>
        /// ɾ�����ӽ���
        /// </summary>
        /// <returns></returns>
        private string DeleteAdditiveConclusion()
        {
            if (Request["sn"] != null && Request["conid"] != null && Request["addconid"] != null)
            {
                try
                {
                    SerialNumber sn = new SerialNumber(Request["sn"].Trim());
                    PaperFile pf = PaperFile.Load(sn);
                    ConclusionFile cf = pf.GetConclusionFileById(Convert.ToInt32(Request["conid"]));

                    cf.RemoveAdditive(Request["addconid"]);

                    pf.Save();
                    return @"ok,ɾ�����";
                }
                catch
                {
                    throw;
                }
            }
            return @"failed,ɾ��ʧ��";
        }
 /// <summary>
 /// ɾ���༭�е��ʾ��ļ���������Ӧ���ʾ�����Ϊ���ʾ�״̬
 /// </summary>
 /// <returns></returns>
 private string RemoveEditingPaperFile()
 {
     if (Request["param"] != null)
     {
         try
         {
             SerialNumber sn = new SerialNumber(Request["param"]);
             PaperFile.Remove(sn);
             return @"ok,ɾ�����";
         }
         catch
         {
             //
         }
     }
     return @"failed,ɾ��ʧ��";
 }