public void AddTest() { //---------------------------------------------------------------------------------------------------- //---only init the domain records which will force a cleaning of the mx records InitDomainRecords(); MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); //---------------------------------------------------------------------------------------------------- //---make sure there are no mx records that exist Assert.Equal(0, mgr.Count()); long domainId = 1; //--we always have domain id of 1 (unless someone changed testing values in base) string SMTPName = BuildSMTPDomainName(1, 1); int preference = 10; MX mx = new MX(domainId , SMTPName , preference); mgr.Add(mx); Assert.Equal(1, mgr.Count()); mx = mgr.Get(SMTPName); Assert.Equal(domainId, mx.DomainID); Assert.Equal(SMTPName, mx.SMTPDomainName); Assert.Equal(preference, mx.Preference); }
public void FindDeviceAsync(string SearchTarget) { HTTPMessage packet = new HTTPMessage(); packet.Directive = "M-SEARCH"; packet.DirectiveObj = "*"; packet.AddTag("ST", SearchTarget); packet.AddTag("MX", MX.ToString()); packet.AddTag("MAN", "\"ssdp:discover\""); packet.AddTag("HOST", "239.255.255.250:1900"); IPAddress[] localAddresses = this.NetInfo.GetLocalAddresses(); IPEndPoint dest = new IPEndPoint(IPAddress.Parse("239.255.255.250"), 0x76c); for (int i = 0; i < localAddresses.Length; i++) { try { Socket theSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); theSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1); theSocket.Bind(new IPEndPoint(localAddresses[i], 0)); SSDPSession session = new SSDPSession(theSocket, new SSDPSession.ReceiveHandler(this.HandleAsyncSearch)); this.SSDPSessions[session] = session; session.SendTo(packet, dest); session.SendTo(packet, dest); this.Lifetime.Add(session, 7); } catch (Exception exception) { EventLogger.Log(this, EventLogEntryType.Error, "CP Failure: " + localAddresses[i].ToString()); EventLogger.Log(exception); } } }
public IActionResult Delete(MX mx) { int bikeId = mx.BikeId; _repository.Delete(mx); return(RedirectToAction("Details", "Bike", new { id = bikeId })); }
internal static bool CheckClientCertificate (TlsContext context, MX.X509CertificateCollection certificates) { if (certificates == null || certificates.Count < 1) { if (!context.SettingsProvider.AskForClientCertificate) return false; if (context.SettingsProvider.RequireClientCertificate) throw new TlsException (AlertDescription.CertificateUnknown); } if (context.SettingsProvider.HasClientCertificateParameters) { var certParams = context.SettingsProvider.ClientCertificateParameters; if (certParams.CertificateAuthorities.Count > 0) { if (!certParams.CertificateAuthorities.Contains (certificates [0].IssuerName)) throw new TlsException (AlertDescription.BadCertificate); } } var helper = context.Configuration.CertificateValidator; if (helper == null) helper = CertificateValidationHelper.CreateDefaultValidator (context.Configuration.TlsSettings); var result = helper.ValidateClientCertificate (certificates); if (result != null && result.Trusted && !result.UserDenied) return true; throw new TlsException (AlertDescription.CertificateUnknown); }
public void RemoveDomainTest() { InitMXRecords(); using (ConfigDatabase db = new ConfigDatabase(CONNSTR)) { MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); //---------------------------------------------------------------------------------------------------- //---make sure that the domains are actually there for (int t = 1; t <= MAXSMTPCOUNT; t++) { string name = BuildSMTPDomainName(1, t); MX obj = mgr.Get(db, name); Assert.NotNull(obj); } //---------------------------------------------------------------------------------------------------- //---get the first domain (knowing that domain of 1 with smtp 1 should exist since the init passed) mgr.RemoveDomain(db, 1); //---------------------------------------------------------------------------------------------------- //---there should be no items left with domain id of 1, use the count to check number of matching //---per domain as well as a loop to ensure that each entry has been removed for the given domain for (int t = 1; t <= MAXSMTPCOUNT; t++) { string name = BuildSMTPDomainName(1, t); MX obj = mgr.Get(db, name); Assert.Null(obj); } Assert.Equal(0, mgr.Count(1)); } }
public IActionResult Create(int bikeid) { MX mx = new MX { Date = DateTime.Now.Date, BikeId = bikeid }; return(View(mx)); }
public void MXConstructorTest2() { MX target = new MX(); Assert.Equal(String.Empty, target.SMTPDomainName); Assert.Equal(0, target.Preference); Assert.Equal(target.CreateDate, target.UpdateDate); }
public void UpdateDateTest() { MX target = new MX(1, "testSMTPDomainName", 1); DateTime expected = DateTime.UtcNow; DateTime actual; target.UpdateDate = expected; actual = target.UpdateDate; Assert.Equal(expected, actual); }
static SslPolicyErrors GetStatus (MX.X509ChainStatusFlags flags) { switch (flags) { case MX.X509ChainStatusFlags.NoError: return SslPolicyErrors.None; default: return SslPolicyErrors.RemoteCertificateChainErrors; } }
public void SMTPDomainNameTest() { MX target = new MX(1, "testSMTPDomainName", 1); string expected = "some.smtp.name.value"; string actual; target.SMTPDomainName = expected; actual = target.SMTPDomainName; Assert.Equal(expected, actual); }
public void PreferenceTest() { MX target = new MX(1, "testSMTPDomainName", 1); int expected = 200; int actual; target.Preference = expected; actual = target.Preference; Assert.Equal(expected, actual); }
public IActionResult Edit(MX mx) { if (ModelState.IsValid) { _repository.Update(mx); return(RedirectToAction("Details", new { id = mx.Id })); } return(View(mx)); }
public void IDTest() { MX target = new MX(1, "testSMTPDomainName", 1); long expected = 777; long actual; target.ID = expected; actual = target.ID; Assert.Equal(expected, actual); }
public void CreateDateTest() { MX target = new MX(1, "testSMTPDomainName", 1); DateTime expected = DateTime.UtcNow; DateTime actual; target.CreateDate = expected; actual = target.CreateDate; Assert.Equal(expected, actual); }
public IActionResult Delete(int id) { MX mx = _repository.GetMXById(id); if (mx == null) { return(RedirectToAction("Index, Bike")); } return(View(mx)); }
public void MXConstructorTest1() { long domainID = 1; string SMTPDomainName = "some.smtp.name.here"; MX target = new MX(domainID, SMTPDomainName); Assert.Equal(domainID, target.DomainID); Assert.Equal(SMTPDomainName, target.SMTPDomainName); Assert.Equal(0, target.Preference); Assert.Equal(target.CreateDate, target.UpdateDate); }
public void CopyFixedTest() { MX source = new MX(1, "testSMTPDomainName", 1); MX target = new MX(); target.CopyFixed(source); Assert.Equal(source.ID, target.ID); Assert.Equal(source.CreateDate, target.CreateDate); Assert.Equal(source.DomainID, target.DomainID); Assert.Equal(source.SMTPDomainName, target.SMTPDomainName); Assert.Equal(source.UpdateDate, target.UpdateDate); Assert.Equal(source.Preference, target.Preference); }
public void GetTest5() { InitMXRecords(); MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); string name = BuildSMTPDomainName(1, 1); MX mxActual = mgr.Get(name); Assert.NotNull(mxActual); //---------------------------------------------------------------------------------------------------- //---check basic values Assert.Equal(name, mxActual.SMTPDomainName); Assert.Equal(1, mxActual.DomainID); //---------------------------------------------------------------------------------------------------- //---preference should always be the same as smtp id used to create the name Assert.Equal(1, mxActual.Preference); }
internal static void CheckRemoteCertificate (TlsConfiguration config, MX.X509CertificateCollection certificates) { if (certificates == null || certificates.Count < 1) throw new TlsException (AlertDescription.CertificateUnknown); var helper = config.CertificateValidator; if (helper == null) helper = CertificateValidationHelper.CreateDefaultValidator (config.TlsSettings); var result = helper.ValidateChain (config.TargetHost, certificates); if (result != null && result.Trusted && !result.UserDenied) return; // FIXME: check other values to report correct error type. throw new TlsException (AlertDescription.CertificateUnknown); }
public void RemoveTest() { InitMXRecords(); MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); //---------------------------------------------------------------------------------------------------- //---get the first domain (knowing that domain of 1 with smtp 1 should exist since the init passed) string name = BuildSMTPDomainName(1, 1); MX obj = mgr.Get(name); Assert.NotNull(obj); mgr.Remove(name); obj = mgr.Get(name); Assert.Null(obj); }
public void UpdateTest() { MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); InitMXRecords(); //---------------------------------------------------------------------------------------------------- //---get the first domain (knowing that domain of 1 with smtp 1 should exist since the init passed) MX obj = mgr.Get(BuildSMTPDomainName(1, 1)); Assert.NotNull(obj); //---------------------------------------------------------------------------------------------------- //---since we set pref to the same as the smtp[x].domain[y].test.com x value, check it here Assert.Equal(1, obj.Preference); obj.Preference = 4; mgr.Update(obj); }
/************************************************************************* * v is the n word data vector * k is the 4 word key,128bits * n is negative for decoding * if n is zero result is 1 and no coding or decoding takes place, * otherwise the result is zero * assumes 32 bit 'long' and same endian coding and decoding **************************************************************************/ void btea(uint32_t *v, int16_t n, uint32_t *key) { const DELTA =; const MX =; uint32_t y, z, sum; uint32_t p, rounds, e; if (n > 1) { // dencrypt rounds = 6 + 52 / n; sum = 0; z = v[n - 1]; do { sum += 0x9e3779b9; e = (sum >> 2) & 3; for (p = 0; p < n - 1; p++) { y = v[p + 1]; z = v[p] += (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))); } y = v[0]; z = v[n - 1] += (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))); } while (--rounds); } else if (n < -1) { //dencrypt n = -n; rounds = 6 + 52 / n; sum = rounds * 0x9e3779b9; y = v[0]; do { e = (sum >> 2) & 3; for (p = n - 1; p > 0; p--) { z = v[p - 1]; y = v[p] -= (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))); } z = v[n - 1]; y = v[0] -= (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))); sum -= 0x9e3779b9; } while (--rounds); } }
public void RemoveTest1() { InitMXRecords(); MXManager mgr = new MXManager(new ConfigStore(CONNSTR)); //---------------------------------------------------------------------------------------------------- //---get the first domain (knowing that domain of 1 with smtp 1 should exist since the init passed) string name = BuildSMTPDomainName(1, 1); using (ConfigDatabase db = new ConfigDatabase(CONNSTR)) { MX obj = db.MXs.Get(name); Assert.NotNull(obj); mgr.Remove(db, name); db.SubmitChanges(); obj = db.MXs.Get(name); Assert.Null(obj); } }
public void ApplyChangesTest() { MX target = new MX(1, "target.smtp.name", 1); Assert.Equal(1, target.DomainID); Assert.Equal(1, target.Preference); Assert.Equal("target.smtp.name", target.SMTPDomainName); MX source = new MX(1, "source.smtp.name", 2); Assert.Equal(1, source.DomainID); Assert.Equal(2, source.Preference); Assert.Equal("source.smtp.name", source.SMTPDomainName); target.ApplyChanges(source); Assert.Equal(1, target.DomainID); Assert.Equal(source.Preference, target.Preference); Assert.Equal(source.SMTPDomainName, target.SMTPDomainName); }
internal static void CheckRemoteCertificate (TlsConfiguration config, MX.X509CertificateCollection certificates) { if (certificates == null || certificates.Count < 1) throw new TlsException (AlertDescription.CertificateUnknown); var helper = CertificateValidationHelper.GetValidator (config.TlsSettings); X509Certificate2Collection scerts = null; if (certificates != null) { scerts = new X509Certificate2Collection (); for (int i = 0; i < certificates.Count; i++) scerts.Add (new X509Certificate2 (certificates [i].RawData)); } var result = helper.ValidateChain (config.TargetHost, scerts); if (result != null && result.Trusted && !result.UserDenied) return; // FIXME: check other values to report correct error type. throw new TlsException (AlertDescription.CertificateUnknown); }
internal static bool VerifyServerCertificate (TlsContext context, MX.X509Certificate certificate, ExchangeAlgorithmType algorithm) { if (context.NegotiatedProtocol == TlsProtocolCode.Tls12 && certificate.Version < 3) throw new TlsException (AlertDescription.UnsupportedCertificate, "X.509v3 server certificate required"); if (certificate.KeyAlgorithm != null && !certificate.KeyAlgorithm.Equals (OidKeyAlgorithmRsa)) return false; if (certificate.SignatureAlgorithm != null && !VerifySignatureAlgorithm (certificate.SignatureAlgorithm)) return false; switch (algorithm) { case ExchangeAlgorithmType.Rsa: return VerifyKeyUsage (certificate, KeyUsages.keyEncipherment, OidServerAuth); case ExchangeAlgorithmType.Dhe: case ExchangeAlgorithmType.EcDhe: return VerifyKeyUsage (certificate, KeyUsages.digitalSignature, OidServerAuth); default: throw new TlsException (AlertDescription.InternalError); } }
internal static void CheckClientCertificate (TlsContext context, MX.X509CertificateCollection certificates) { if (context.SettingsProvider.HasClientCertificateParameters) { var certParams = context.SettingsProvider.ClientCertificateParameters; if (certParams.CertificateAuthorities.Count > 0) { if (!certParams.CertificateAuthorities.Contains (certificates [0].IssuerName)) throw new TlsException (AlertDescription.BadCertificate); } } var helper = CertificateValidationHelper.GetValidator (context.Configuration.TlsSettings); X509Certificate2Collection scerts = null; if (certificates != null) { scerts = new X509Certificate2Collection (); for (int i = 0; i < certificates.Count; i++) scerts.Add (new X509Certificate2 (certificates [i].RawData)); } var result = helper.ValidateClientCertificate (scerts); if (result == null || !result.Trusted || result.UserDenied) throw new TlsException (AlertDescription.CertificateUnknown); }
protected override void ProcessRecord() { this.SetOptions(); this.SetScope(Server); this.SetManagementPath(Identity); ManagementObject wmiRecord = this.Get(); WmiRecordClass WmiRecordClassName = (WmiRecordClass)Enum.Parse(typeof(WmiRecordClass), (String)wmiRecord.Properties["__CLASS"].Value); String NewPath = String.Empty; #region Parameter Set validation Boolean Terminate = false; switch (ParameterSetName) { case "PS0": break; case "PS1": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_AType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_AAAAType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_WKSType) { Terminate = true; } break; case "PS2": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_CNAMEType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MBType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MDType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MFType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_NSType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_PTRType) { Terminate = true; } break; case "PS3": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MGType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MRType) { Terminate = true; } break; case "PS4": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_TXTType) { Terminate = true; } break; case "PS5": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_HINFOType) { Terminate = true; } break; case "PS6": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_ISDNType) { Terminate = true; } break; case "PS7": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MINFOType) { Terminate = true; } break; case "PS8": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_NXTType) { Terminate = true; } break; case "PS9": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_RPType) { Terminate = true; } break; case "PS10": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_AFSDBType) { Terminate = true; } break; case "PS11": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_MXType & WmiRecordClassName != WmiRecordClass.MicrosoftDNS_RTType) { Terminate = true; } break; case "PS12": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_X25Type) { Terminate = true; } break; case "PS13": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_SOAType) { Terminate = true; } break; case "PS14": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_SRVType) { Terminate = true; } break; case "PS15": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_WINSType) { Terminate = true; } break; case "PS16": if (WmiRecordClassName != WmiRecordClass.MicrosoftDNS_WINSRType) { Terminate = true; } break; } if (Terminate) { ThrowTerminatingError( new ErrorRecord( new PSInvalidOperationException("InvalidParameterSetForRecordType"), "InvalidOperation", ErrorCategory.InvalidOperation, typeof(ManagementCmdlet))); } #endregion if (ShouldProcess((String)wmiRecord.Properties["TextRepresentation"].Value)) { switch (WmiRecordClassName) { case WmiRecordClass.MicrosoftDNS_AType: A ARecord = new A(wmiRecord, Server); NewPath = ARecord.Modify(TTL, Address.ToString()); break; case WmiRecordClass.MicrosoftDNS_AAAAType: AAAA AAAARecord = new AAAA(wmiRecord, Server); NewPath = AAAARecord.Modify(TTL, Address.ToString()); break; case WmiRecordClass.MicrosoftDNS_AFSDBType: AFSDB AFSDBRecord = new AFSDB(wmiRecord, Server); NewPath = AFSDBRecord.Modify(TTL, SubType, TargetName); break; case WmiRecordClass.MicrosoftDNS_CNAMEType: CNAME CNAMERecord = new CNAME(wmiRecord, Server); NewPath = CNAMERecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_HINFOType: HINFO HINFORecord = new HINFO(wmiRecord, Server); NewPath = HINFORecord.Modify(TTL, CPU, OS); break; case WmiRecordClass.MicrosoftDNS_ISDNType: ISDN ISDNRecord = new ISDN(wmiRecord, Server); NewPath = ISDNRecord.Modify(TTL, ISDNNumber, SubAddress); break; case WmiRecordClass.MicrosoftDNS_MBType: MB MBRecord = new MB(wmiRecord, Server); NewPath = MBRecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_MDType: MD MDRecord = new MD(wmiRecord, Server); NewPath = MDRecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_MFType: MF MFRecord = new MF(wmiRecord, Server); NewPath = MFRecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_MGType: MG MGRecord = new MG(wmiRecord, Server); NewPath = MGRecord.Modify(TTL, MailboxName); break; case WmiRecordClass.MicrosoftDNS_MINFOType: MINFO MINFORecord = new MINFO(wmiRecord, Server); NewPath = MINFORecord.Modify(TTL, ResponsibleMailbox, ErrorMailbox); break; case WmiRecordClass.MicrosoftDNS_MRType: MR MRRecord = new MR(wmiRecord, Server); NewPath = MRRecord.Modify(TTL, MailboxName); break; case WmiRecordClass.MicrosoftDNS_MXType: MX MXRecord = new MX(wmiRecord, Server); NewPath = MXRecord.Modify(TTL, Preference, TargetName); break; case WmiRecordClass.MicrosoftDNS_NSType: NS NSRecord = new NS(wmiRecord, Server); NewPath = NSRecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_NXTType: NXT NXTRecord = new NXT(wmiRecord, Server); NewPath = NXTRecord.Modify(TTL, NextDomainName, Types); break; case WmiRecordClass.MicrosoftDNS_PTRType: PTR PTRRecord = new PTR(wmiRecord, Server); NewPath = PTRRecord.Modify(TTL, Hostname); break; case WmiRecordClass.MicrosoftDNS_RPType: RP RPRecord = new RP(wmiRecord, Server); NewPath = RPRecord.Modify(TTL, ResponsibleMailbox, TXTDomainName); break; case WmiRecordClass.MicrosoftDNS_RTType: RT RTRecord = new RT(wmiRecord, Server); NewPath = RTRecord.Modify(TTL, Preference, TargetName); break; case WmiRecordClass.MicrosoftDNS_SOAType: SOA SOARecord = new SOA(wmiRecord, Server); NewPath = SOARecord.Modify(TTL, SerialNumber, SOAServer, ResponsibleMailbox, RefreshInterval, RetryDelay, ExpireLimit, MinimumTTL); break; case WmiRecordClass.MicrosoftDNS_SRVType: SRV SRVRecord = new SRV(wmiRecord, Server); NewPath = SRVRecord.Modify(TTL, Priority, Weight, Port, TargetName); break; case WmiRecordClass.MicrosoftDNS_TXTType: TXT TXTRecord = new TXT(wmiRecord, Server); NewPath = TXTRecord.Modify(TTL, Text); break; case WmiRecordClass.MicrosoftDNS_WINSType: WINS WINSRecord = new WINS(wmiRecord, Server); NewPath = WINSRecord.Modify(TTL, MappingFlag, LookupTimeout, CacheTimeout, String.Join(" ", WinsServers)); break; case WmiRecordClass.MicrosoftDNS_WINSRType: WINSR WINSRRecord = new WINSR(wmiRecord, Server); NewPath = WINSRRecord.Modify(TTL, MappingFlag, LookupTimeout, CacheTimeout, ResultDomain); break; case WmiRecordClass.MicrosoftDNS_WKSType: WKS WKSRecord = new WKS(wmiRecord, Server); NewPath = WKSRecord.Modify(Address, TTL, IPProtocol, String.Join(" ", Services)); break; case WmiRecordClass.MicrosoftDNS_X25Type: X25 X25Record = new X25(wmiRecord, Server); NewPath = X25Record.Modify(TTL, PSDNAddress); break; default: ThrowTerminatingError( new ErrorRecord( new PSNotSupportedException("Unsupported Record Type"), "RecordModificationNotSupported", ErrorCategory.NotImplemented, typeof(ManagementCmdlet))); break; } if (PassThru) { this.SetManagementPath(NewPath); wmiRecord = this.Get(); WriteRecord(wmiRecord); } } }
internal static bool VerifyKeyUsage (MX.X509Certificate certificate, KeyUsages keyUsages, string purpose) { if (certificate.Extensions == null) return true; KeyUsageExtension kux = null; ExtendedKeyUsageExtension eku = null; var xtn = certificate.Extensions [OidKeyUsage]; if (xtn != null) kux = new KeyUsageExtension (xtn); xtn = certificate.Extensions [OidExtendedKeyUsage]; if (xtn != null) eku = new ExtendedKeyUsageExtension (xtn); if ((kux != null) && (eku != null)) { // RFC3280 states that when both KeyUsageExtension and // ExtendedKeyUsageExtension are present then BOTH should // be valid if (!kux.Support (keyUsages)) return false; return eku.KeyPurpose.Contains (purpose); } else if (kux != null) { return kux.Support (keyUsages); } else if (eku != null) { return eku.KeyPurpose.Contains (purpose); } return true; }
public void DrawFrame(MX.Frame frame, ITransformable transformObj, IRenderable renderableObj) { if (transformObj.X + this.Width - Camera.X > 0 && transformObj.Y + this.Height - Camera.Y > 0 && transformObj.X - Camera.X < Width && transformObj.Y - Camera.Y < Height && renderableObj.Visible) { Vector3 Position = new Vector3((float)transformObj.Position.X, (float)transformObj.Position.Y, 0); Position.X -= (float)Camera.X; Position.Y -= (float)Camera.Y; SetTransform((float)frame._BaseWidth, (float)frame._BaseHeight, (float)transformObj.X, (float)transformObj.Y, (float)transformObj.W, (float)transformObj.H, (float)transformObj.Rotation); SpriteBatch.Draw(frame.Texture.Surface, frame.FrameArea, Vector3.Empty, Position, renderableObj.Color.ToArgb()); } }
public void DrawFrame(MX.Animation animation, ITransformable transformObj, IRenderable renderableObj) { DrawFrame(animation.Frames[animation.CurrentFrame], transformObj, renderableObj); }
public IActionResult Edit(int id) { MX mx = _repository.GetMXById(id); return(View(mx)); }
public MXDetailPage(MX mx) { InitializeComponent(); BindingContext = ViewModel = new MXDetailsViewModel(); ViewModel.SetData(mx); }
public void ApplyChangesTest() { MX target = new MX(1, "target.smtp.name",1); Assert.Equal(1, target.DomainID); Assert.Equal(1, target.Preference); Assert.Equal("target.smtp.name", target.SMTPDomainName); MX source = new MX(1, "source.smtp.name",2); Assert.Equal(1, source.DomainID); Assert.Equal(2, source.Preference); Assert.Equal("source.smtp.name", source.SMTPDomainName); target.ApplyChanges(source); Assert.Equal(1, target.DomainID); Assert.Equal(source.Preference, target.Preference); Assert.Equal(source.SMTPDomainName, target.SMTPDomainName); }
public void SetData(MX finalsession) { MX = finalsession; }
internal void SetTransform(MX.ITransformable objTransformable) { //rotation Quaternion rotate = new Quaternion(); rotate.RotateYawPitchRoll(0, 0, (float)objTransformable.Rotation); //scaling Vector3 scale = new Vector3((float)(objTransformable.Size.X / objTransformable.W), (float)(objTransformable.Size.Y / objTransformable.H), 1.0f); Vector3 translation = Vector3.Empty; if (scale.X != 1 || scale.Y != 1) translation = new Vector3((float)(Camera.X * (scale.X - 1)), (float)(Camera.Y * (1 - scale.Y)), 0); this.SpriteBatch.Transform = Matrix.Transformation( new Vector3((float)objTransformable.Position.X, (float)objTransformable.Position.Y, 0), //scales from top left Quaternion.Identity, scale, new Vector3((float)(objTransformable.Position.X + objTransformable.Size.X / 2), (float)(objTransformable.Position.Y + objTransformable.Size.Y / 2), 0.0f), //rotates from center rotate, translation); }
public void DrawSprite(MX.Sprite sprite) { if (sprite.X + this.Width - Camera.X > 0 && sprite.Y + this.Height - Camera.Y > 0 && sprite.X - Camera.X < Width && sprite.Y - Camera.Y < Height && sprite.Visible) { Vector3 Position = new Vector3((float)(sprite.Position.X - sprite.CurrentFrame.Offset.X), (float)(sprite.Position.Y - sprite.CurrentFrame.Offset.Y), 0); Position.X -= (float)Camera.X; Position.Y -= (float)Camera.Y; SetTransform((float)sprite.CurrentFrame._BaseWidth, (float)sprite.CurrentFrame._BaseHeight, (float)sprite.X, (float)sprite.Y, (float)sprite.W, (float)sprite.H, (float)sprite.Rotation); SpriteBatch.Draw(sprite.CurrentFrame.Texture.Surface, sprite.CurrentFrame.FrameArea, Vector3.Empty, Position, sprite.Color.ToArgb()); } }
public void MXConstructorTest() { long domainID = 1; string SMTPDomainName = "some.smtp.name.here"; short preference = 777; MX target = new MX(domainID, SMTPDomainName, preference); Assert.Equal(domainID, target.DomainID); Assert.Equal(SMTPDomainName, target.SMTPDomainName); Assert.Equal(preference, target.Preference); Assert.Equal(target.CreateDate, target.UpdateDate); }