public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
SqlCommand command = SelectDeleteRelationshipDescriptorsMetadataCommand(connectionAbstraction.Connection, transactionWrapper.RelationshipParameter.Value);
connectionAbstraction.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
Relationship deletedRelationship = new Relationship();
deletedRelationship.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedRelationship, TransactionType.DeleteRelationship));
if (reader.NextResult())
{
while (reader.Read())
{
Descriptor deletedDescriptor = new Descriptor();
deletedDescriptor.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedDescriptor, TransactionType.DeleteRelationship));
}
}
if (reader.NextResult())
{
while (reader.Read())
{
Metadata deletedMetadata = new Metadata();
deletedMetadata.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedMetadata, TransactionType.DeleteRelationship));
}
}
transactionWrapper.ResponseParameter.Value = deletedRelationship.RelationshipUid;
}
connectionAbstraction.Close();
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
SqlCommand command = SelectDeleteMetadataCommand(connectionAbstraction.Connection, transactionWrapper.MetadataParameter.Value);
connectionAbstraction.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
Metadata deletedMetadata = new Metadata();
deletedMetadata.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedMetadata, TransactionType.DeleteMetadata));
transactionWrapper.ResponseParameter.Value = deletedMetadata.MetadataId;
}
connectionAbstraction.Close();
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
Descriptor newDescriptor = new Descriptor();
newDescriptor.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
newDescriptor.NodeUid = transactionWrapper.NodeParameter.Value;
newDescriptor.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
Guid newDescriptorId;
SqlCommand command = CreateDescriptorCommand(connectionAbstraction.Connection, out newDescriptorId, newDescriptor);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newDescriptor.DescriptorUid = newDescriptorId;
response.Changes.Add(new MapChange(transaction.TransactionId, newDescriptor, TransactionType.CreateDescriptor));
transactionWrapper.ResponseParameter.Value = newDescriptorId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Relationship newRelationship = new Relationship();
newRelationship.RelationshipTypeUid = transaction.RelationshipTypeUid.Value;
newRelationship.DomainUid = transactionWrapper.DomainParameter.Value;
if (transactionWrapper.RootMapParameter != null)
{
newRelationship.RootMapUid = transactionWrapper.RootMapParameter.Value;
}
else
{
newRelationship.RootMapUid = null;
}
newRelationship.Created = currentTime;
newRelationship.Modified = currentTime;
newRelationship.CreatedBy = transaction.User;
newRelationship.ModifiedBy = transaction.User;
Guid newRelationshipId;
SqlCommand command = CreateRelationshipCommand(connectionAbstraction.Connection, out newRelationshipId, newRelationship);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newRelationship.RelationshipUid = newRelationshipId;
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, newRelationship, TransactionType.CreateRelationship));
transactionWrapper.ResponseParameter.Value = newRelationshipId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now.ToUniversalTime();
Relationship updatedRelationship = new Relationship();
updatedRelationship.DomainUid = transactionWrapper.DomainParameter.Value;
updatedRelationship.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
updatedRelationship.RelationshipTypeUid = transaction.RelationshipTypeUid.Value;
updatedRelationship.Modified = currentTime;
updatedRelationship.ModifiedBy = transaction.User;
SqlCommand updateRelationshipCommand = UpdateRelationshipCommand(connectionAbstraction.Connection, updatedRelationship);
connectionAbstraction.Open();
updateRelationshipCommand.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedRelationship, TransactionType.UpdateRelationship));
transactionWrapper.ResponseParameter.Value = updatedRelationship.RelationshipUid;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Node updatedNode = new Node();
updatedNode.DomainUid = transactionWrapper.DomainParameter.Value;
updatedNode.NodeUid = transactionWrapper.NodeParameter.Value;
updatedNode.NodeTypeUid = transaction.NodeTypeUid.Value;
updatedNode.Modified = currentTime;
updatedNode.ModifiedBy = transaction.User;
SqlCommand updateNodeCommand = UpdateNodeCommand(connectionAbstraction.Connection, updatedNode);
connectionAbstraction.Open();
updateNodeCommand.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedNode, TransactionType.UpdateNode));
transactionWrapper.ResponseParameter.Value = updatedNode.NodeUid;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now.ToUniversalTime();
Metadata updatedMetadata = new Metadata();
updatedMetadata.MetadataId = transactionWrapper.MetadataParameter.Value;
updatedMetadata.MetadataName = transaction.MetadataName;
updatedMetadata.MetadataValue = transaction.MetadataValue;
updatedMetadata.Modified = currentTime;
updatedMetadata.ModifiedBy = transaction.User;
SqlCommand command = UpdateMetadataCommand(connectionAbstraction.Connection, updatedMetadata);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedMetadata, TransactionType.UpdateMetadata));
transactionWrapper.ResponseParameter.Value = updatedMetadata.MetadataId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
Descriptor updatedDescriptor = new Descriptor();
updatedDescriptor.NodeUid = transactionWrapper.NodeParameter.Value;
updatedDescriptor.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
updatedDescriptor.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
SqlCommand command = UpdateDescriptorCommand(connectionAbstraction.Connection, updatedDescriptor);
connectionAbstraction.Open();
object descriptorUidAsObject = command.ExecuteScalar();
connectionAbstraction.Close();
if (descriptorUidAsObject != null && descriptorUidAsObject != DBNull.Value)
{
updatedDescriptor.DescriptorUid = (Guid)descriptorUidAsObject;
}
else
{
// This case occurs if the relationship type has been changed and previously this descriptor didn't exist for this relationship type.
Guid newDescriptorUid;
SqlCommand createDescriptorCommand = CreateDescriptorCommand(connectionAbstraction.Connection, out newDescriptorUid, updatedDescriptor);
updatedDescriptor.DescriptorUid = newDescriptorUid;
connectionAbstraction.Open();
createDescriptorCommand.ExecuteNonQuery();
connectionAbstraction.Close();
}
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedDescriptor, TransactionType.UpdateDescriptor));
transactionWrapper.ResponseParameter.Value = updatedDescriptor.DescriptorUid;
}
public void Maps()
{
var builder = new UpdateMap.Builder()
.WithBucketType("maps")
.WithBucket("customers")
.WithKey("ahmed_info");
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Initial import of Ahmed's data and contact");
var mapOperation = new UpdateMap.MapOperation();
// Ahmed's first name
mapOperation.SetRegister("first_name", "Ahmed");
// Ahmed's phone number
mapOperation.SetRegister("phone_number", "5551234567");
builder.WithMapOperation(mapOperation);
MapResponse response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Set Ahmed to NOT be an enterprise customer right now");
mapOperation = new UpdateMap.MapOperation();
mapOperation.SetFlag("enterprise_customer", false);
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("enterprise_customer flag value");
Map ahmedMap = response.Value;
Console.WriteLine("Ahmed enterprise_customer: {0}", ahmedMap.Flags["enterprise_customer"]);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Add page visits counter for Ahmed");
mapOperation = new UpdateMap.MapOperation();
mapOperation.IncrementCounter("page_visits", 1);
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Add Ahmed's interests set");
var interestsAdds = new[] { "robots", "opera", "motorcycles" };
mapOperation = new UpdateMap.MapOperation();
mapOperation.AddToSet("interests", interestsAdds);
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
ahmedMap = response.Value;
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("opera"));
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Updating Ahmed's interests");
mapOperation = new UpdateMap.MapOperation();
mapOperation.AddToSet("interests", "indie pop");
mapOperation.RemoveFromSet("interests", "opera");
builder
.WithMapOperation(mapOperation)
.WithContext(response.Context);
response = SaveMap(builder);
ahmedMap = response.Value;
Assert.False(ahmedMap.Sets.GetValue("interests").Contains("opera"));
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("indie pop"));
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("robots"));
Assert.True(ahmedMap.Sets.GetValue("interests").Contains("motorcycles"));
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Adding Annika map");
mapOperation = new UpdateMap.MapOperation();
UpdateMap.MapOperation annikaInfoOperation = mapOperation.Map("annika_info");
annikaInfoOperation.SetRegister("first_name", "Annika");
annikaInfoOperation.SetRegister("last_name", "Weiss");
annikaInfoOperation.SetRegister("phone_number", "5559876543");
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Annika's first name");
ahmedMap = response.Value;
Console.WriteLine(ahmedMap.Maps["annika_info"].Registers.GetValue("first_name"));
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Removing Annika's first name");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info").RemoveRegister("first_name");
builder
.WithMapOperation(mapOperation)
.WithContext(response.Context);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Storing Annika's plan flags");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info")
.SetFlag("enterprise_plan", false)
.SetFlag("family_plan", false)
.SetFlag("free_plan", true);
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Is Annika on enterprise plan?");
ahmedMap = response.Value;
Console.WriteLine(ahmedMap.Maps["annika_info"].Flags["enterprise_plan"]);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Adding Annika's widget_purchases counter");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info").IncrementCounter("widget_purchases", 1);
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Adding Annika's interests in a set");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info").AddToSet("interests", "tango dancing");
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Remove \"tango dancing\" from Annika's interests");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info").RemoveFromSet("interests", "tango dancing");
builder
.WithMapOperation(mapOperation)
.WithContext(response.Context);
response = SaveMap(builder);
Console.WriteLine("------------------------------------------------------------------------\n");
Console.WriteLine("Add specific purchase info to Annika's data");
mapOperation = new UpdateMap.MapOperation();
mapOperation.Map("annika_info").Map("purchase")
.SetFlag("first_purchase", true)
.SetRegister("amount", "1271")
.AddToSet("items", "large widget");
builder.WithMapOperation(mapOperation);
response = SaveMap(builder);
Console.WriteLine("Context: {0}", Convert.ToBase64String(response.Context));
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Node newNode = new Node();
newNode.NodeTypeUid = transaction.NodeTypeUid.Value;
newNode.DomainUid = transactionWrapper.DomainParameter.Value;
if (transactionWrapper.RootMapParameter != null)
{
newNode.RootMapUid = transactionWrapper.RootMapParameter.Value;
}
else
{
newNode.RootMapUid = null;
}
newNode.Created = currentTime;
newNode.Modified = currentTime;
newNode.CreatedBy = transaction.User;
newNode.ModifiedBy = transaction.User;
Guid newNodeId;
SqlCommand command = CreateNodeCommand(connectionAbstraction.Connection, out newNodeId, newNode);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newNode.NodeUid = newNodeId;
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, newNode, TransactionType.CreateNode));
transactionWrapper.ResponseParameter.Value = newNodeId;
}
public void Should_Construct_MapResponse_From_DtFetchResp()
{
var key = new RiakString("riak_generated_key");
var context = new RiakString("1234");
var fetchResp = new DtFetchResp();
fetchResp.type = DtFetchResp.DataType.MAP;
fetchResp.value = new DtValue();
fetchResp.context = context;
Func <IEnumerable <MapEntry> > createMapEntries = () =>
{
var mapEntries = new List <MapEntry>();
var mapField = new MapField();
mapField.type = MapField.MapFieldType.COUNTER;
mapField.name = new RiakString("counter_1");
var mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.counter_value = 50;
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.SET;
mapField.name = new RiakString("set_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.set_value.Add(RiakString.ToBytes("value_1"));
mapEntry.set_value.Add(RiakString.ToBytes("value_2"));
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.REGISTER;
mapField.name = new RiakString("register_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.register_value = RiakString.ToBytes("1234");
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.FLAG;
mapField.name = new RiakString("flag_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.flag_value = true;
mapEntries.Add(mapEntry);
return(mapEntries);
};
fetchResp.value.map_value.AddRange(createMapEntries());
var map_1_field = new MapField();
map_1_field.type = MapField.MapFieldType.MAP;
map_1_field.name = new RiakString("map_1");
var map_1_entry = new MapEntry();
map_1_entry.field = map_1_field;
map_1_entry.map_value.AddRange(createMapEntries());
fetchResp.value.map_value.Add(map_1_entry);
Action <Map> verifyMap = (map) =>
{
Assert.AreEqual(50, map.Counters["counter_1"]);
Assert.AreEqual(RiakString.ToBytes("value_1"), map.Sets["set_1"][0]);
Assert.AreEqual(RiakString.ToBytes("value_2"), map.Sets["set_1"][1]);
Assert.AreEqual(RiakString.ToBytes("1234"), map.Registers["register_1"]);
Assert.IsTrue(map.Flags["flag_1"]);
};
var fetch = new FetchMap.Builder()
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(key)
.Build();
fetch.OnSuccess(fetchResp);
MapResponse response = fetch.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(RiakString.ToBytes(context), response.Context);
verifyMap(response.Value);
verifyMap(response.Value.Maps["map_1"]);
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
Descriptor updatedDescriptor = new Descriptor();
updatedDescriptor.NodeUid = transactionWrapper.NodeParameter.Value;
updatedDescriptor.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
updatedDescriptor.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
SqlCommand command = UpdateDescriptorCommand(connectionAbstraction.Connection, updatedDescriptor);
connectionAbstraction.Open();
object descriptorUidAsObject = command.ExecuteScalar();
connectionAbstraction.Close();
if (descriptorUidAsObject != null && descriptorUidAsObject != DBNull.Value)
{
updatedDescriptor.DescriptorUid = (Guid)descriptorUidAsObject;
}
else
{
// This case occurs if the relationship type has been changed and previously this descriptor didn't exist for this relationship type.
Guid newDescriptorUid;
SqlCommand createDescriptorCommand = CreateDescriptorCommand(connectionAbstraction.Connection, out newDescriptorUid, updatedDescriptor);
updatedDescriptor.DescriptorUid = newDescriptorUid;
connectionAbstraction.Open();
createDescriptorCommand.ExecuteNonQuery();
connectionAbstraction.Close();
}
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedDescriptor, TransactionType.UpdateDescriptor));
transactionWrapper.ResponseParameter.Value = updatedDescriptor.DescriptorUid;
}
public FloodingServiceTests()
{
var mockConfirmAttributeFromOptions = new Mock <IOptions <ConfirmAttributeFormOptions> >();
mockConfirmAttributeFromOptions
.SetupGet(_ => _.Value)
.Returns(new ConfirmAttributeFormOptions
{
FloodingSourceReported = new List <Config>
{
new Config
{
Type = "river",
Value = "RIV"
},
new Config
{
Type = "culverted",
Value = "CULV"
}
},
CommercialOrDomestic = new List <Config>
{
new Config
{
Type = "home",
Value = "DOM"
},
new Config
{
Type = "business",
Value = "COM"
}
},
FloodLocationInProperty = new List <Config>
{
new Config
{
Type = "yes",
Value = "GARA"
}
}
});
var mockPavementVerintOptions = new Mock <IOptions <VerintOptions> >();
mockPavementVerintOptions
.SetupGet(_ => _.Value)
.Returns(new VerintOptions
{
FloodingLocations = new List <Config>
{
new Config
{
Type = "pavement",
Value = "Pavement"
}
},
Options = new List <Option>
{
new Option
{
EventCode = 2002592,
Type = "pavement",
ServiceCode = "HWAY",
SubjectCode = "CWFD",
ClassCode = "SERV"
},
new Option
{
EventCode = 0013254,
Type = "home",
ServiceCode = "HWAY",
SubjectCode = "CWFD",
ClassCode = "SERV"
}
}
});
_mockVerintServiceGateway
.Setup(_ => _.CreateVerintOnlineFormCase(It.IsAny <VerintOnlineFormRequest>()))
.ReturnsAsync(new HttpResponse <VerintOnlineFormResponse>
{
ResponseContent = new VerintOnlineFormResponse
{
VerintCaseReference = "tes ref"
},
StatusCode = HttpStatusCode.OK
});
_mockStreetHelper
.Setup(_ => _.GetStreetUniqueId(It.IsAny <Map>()))
.ReturnsAsync(new FloodingAddress
{
UniqueId = "123456",
USRN = "654321",
Name = "TestName"
});
_mockStreetHelper
.Setup(_ => _.GetStreetDetails(It.IsAny <Address>()))
.ReturnsAsync(new FloodingAddress
{
UniqueId = "123456",
USRN = "654321",
Name = "TestName",
Easting = "123456",
Northing = "098765"
});
var mapResponse = new MapResponse
{
features = new List <Feature> {
new Feature {
properties = new Properties {
EastingNorthing = "56789,123456"
}
}
}
};
_mockGateway
.Setup(_ => _.GetAsync(It.IsAny <string>()))
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(mapResponse))
});
_floodingService = new FloodingService(
_mockVerintServiceGateway.Object,
_mockMailHelper.Object,
mockPavementVerintOptions.Object,
mockConfirmAttributeFromOptions.Object,
_mockStreetHelper.Object,
_mockGateway.Object,
_mockLogger.Object);
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now.ToUniversalTime();
Relationship updatedRelationship = new Relationship();
updatedRelationship.DomainUid = transactionWrapper.DomainParameter.Value;
updatedRelationship.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
updatedRelationship.RelationshipTypeUid = transaction.RelationshipTypeUid.Value;
updatedRelationship.Modified = currentTime;
updatedRelationship.ModifiedBy = transaction.User;
SqlCommand updateRelationshipCommand = UpdateRelationshipCommand(connectionAbstraction.Connection, updatedRelationship);
connectionAbstraction.Open();
updateRelationshipCommand.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedRelationship, TransactionType.UpdateRelationship));
transactionWrapper.ResponseParameter.Value = updatedRelationship.RelationshipUid;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Metadata newMetadata = new Metadata();
newMetadata.MetadataTypeUid = transaction.MetadataTypeUid.Value;
newMetadata.DomainUid = transactionWrapper.DomainParameter.Value;
if (transactionWrapper.RootMapParameter != null)
{
newMetadata.RootMapUid = transactionWrapper.RootMapParameter.Value;
}
else
{
newMetadata.RootMapUid = null;
}
newMetadata.Created = currentTime;
newMetadata.Modified = currentTime;
newMetadata.CreatedBy = transaction.User;
newMetadata.ModifiedBy = transaction.User;
if (transactionWrapper.NodeParameter == null)
{
newMetadata.NodeUid = null;
}
else
{
newMetadata.NodeUid = transactionWrapper.NodeParameter.Value;
}
if (transactionWrapper.RelationshipParameter == null)
{
newMetadata.RelationshipUid = null;
}
else
{
newMetadata.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
}
if (transaction.DescriptorTypeUid == null)
{
newMetadata.DescriptorTypeUid = null;
}
else
{
newMetadata.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
}
newMetadata.MetadataName = transaction.MetadataName;
newMetadata.MetadataValue = transaction.MetadataValue;
Guid newMetadataId;
SqlCommand command = CreateMetadataCommand(connectionAbstraction.Connection, out newMetadataId, newMetadata);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newMetadata.MetadataId = newMetadataId;
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, newMetadata, TransactionType.CreateMetadata));
transactionWrapper.ResponseParameter.Value = newMetadataId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
Descriptor newDescriptor = new Descriptor();
newDescriptor.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
newDescriptor.NodeUid = transactionWrapper.NodeParameter.Value;
newDescriptor.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
Guid newDescriptorId;
SqlCommand command = CreateDescriptorCommand(connectionAbstraction.Connection, out newDescriptorId, newDescriptor);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newDescriptor.DescriptorUid = newDescriptorId;
response.Changes.Add(new MapChange(transaction.TransactionId, newDescriptor, TransactionType.CreateDescriptor));
transactionWrapper.ResponseParameter.Value = newDescriptorId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
SqlCommand command = SelectDeleteMetadataCommand(connectionAbstraction.Connection, transactionWrapper.MetadataParameter.Value);
connectionAbstraction.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
Metadata deletedMetadata = new Metadata();
deletedMetadata.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedMetadata, TransactionType.DeleteMetadata));
transactionWrapper.ResponseParameter.Value = deletedMetadata.MetadataId;
}
connectionAbstraction.Close();
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
SqlCommand command = SelectDeleteNodeRelationshipsDescriptorsMetadataCommand(connectionAbstraction.Connection, transactionWrapper.NodeParameter.Value);
connectionAbstraction.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
Node deletedNode = new Node();
deletedNode.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedNode, TransactionType.DeleteNode));
if (reader.NextResult())
{
while (reader.Read())
{
Metadata deletedMetadata = new Metadata();
deletedMetadata.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedMetadata, TransactionType.DeleteMetadata));
}
}
if (reader.NextResult())
{
while (reader.Read())
{
Relationship deletedRelationship = new Relationship();
deletedRelationship.LoadElement(reader);
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, deletedRelationship, TransactionType.DeleteRelationship));
}
}
transactionWrapper.ResponseParameter.Value = deletedNode.NodeUid;
}
connectionAbstraction.Close();
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Metadata newMetadata = new Metadata();
newMetadata.MetadataTypeUid = transaction.MetadataTypeUid.Value;
newMetadata.DomainUid = transactionWrapper.DomainParameter.Value;
if (transactionWrapper.RootMapParameter != null)
{
newMetadata.RootMapUid = transactionWrapper.RootMapParameter.Value;
}
else
{
newMetadata.RootMapUid = null;
}
newMetadata.Created = currentTime;
newMetadata.Modified = currentTime;
newMetadata.CreatedBy = transaction.User;
newMetadata.ModifiedBy = transaction.User;
if (transactionWrapper.NodeParameter == null)
{
newMetadata.NodeUid = null;
}
else
{
newMetadata.NodeUid = transactionWrapper.NodeParameter.Value;
}
if (transactionWrapper.RelationshipParameter == null)
{
newMetadata.RelationshipUid = null;
}
else
{
newMetadata.RelationshipUid = transactionWrapper.RelationshipParameter.Value;
}
if (transaction.DescriptorTypeUid == null)
{
newMetadata.DescriptorTypeUid = null;
}
else
{
newMetadata.DescriptorTypeUid = transaction.DescriptorTypeUid.Value;
}
newMetadata.MetadataName = transaction.MetadataName;
newMetadata.MetadataValue = transaction.MetadataValue;
Guid newMetadataId;
SqlCommand command = CreateMetadataCommand(connectionAbstraction.Connection, out newMetadataId, newMetadata);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
newMetadata.MetadataId = newMetadataId;
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, newMetadata, TransactionType.CreateMetadata));
transactionWrapper.ResponseParameter.Value = newMetadataId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now.ToUniversalTime();
Metadata updatedMetadata = new Metadata();
updatedMetadata.MetadataId = transactionWrapper.MetadataParameter.Value;
updatedMetadata.MetadataName = transaction.MetadataName;
updatedMetadata.MetadataValue = transaction.MetadataValue;
updatedMetadata.Modified = currentTime;
updatedMetadata.ModifiedBy = transaction.User;
SqlCommand command = UpdateMetadataCommand(connectionAbstraction.Connection, updatedMetadata);
connectionAbstraction.Open();
command.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedMetadata, TransactionType.UpdateMetadata));
transactionWrapper.ResponseParameter.Value = updatedMetadata.MetadataId;
}
public void ExecuteTransaction(IDbConnectionAbstraction connectionAbstraction, MapTransactionWrapper transactionWrapper, ref MapResponse response)
{
IMapTransaction transaction = (IMapTransaction)transactionWrapper;
DateTime currentTime = DateTime.Now;
Node updatedNode = new Node();
updatedNode.DomainUid = transactionWrapper.DomainParameter.Value;
updatedNode.NodeUid = transactionWrapper.NodeParameter.Value;
updatedNode.NodeTypeUid = transaction.NodeTypeUid.Value;
updatedNode.Modified = currentTime;
updatedNode.ModifiedBy = transaction.User;
SqlCommand updateNodeCommand = UpdateNodeCommand(connectionAbstraction.Connection, updatedNode);
connectionAbstraction.Open();
updateNodeCommand.ExecuteNonQuery();
connectionAbstraction.Close();
response.Changes.Add(new MapChange(transaction.TransactionId, transactionWrapper.ResponseParameter.Id, updatedNode, TransactionType.UpdateNode));
transactionWrapper.ResponseParameter.Value = updatedNode.NodeUid;
}
public ActionResult <Response <MapResponse> > GetMap([FromHeader] int playerID)
{
try
{
Player player = new Player(playerID);
//Get the player from the database
Response <Player> playerResponse = new PlayerDAL().GetPlayerByID(playerID);
if (!playerResponse.IsSuccessful())
{
return(new Response <MapResponse>(playerResponse.ErrorMessage, playerResponse.ErrorCode));
}
//Call the data access layer to get the last known locations
Response <List <Photo> > getLastPhotoLocationsResponse = new PhotoDAL().GetLastKnownLocations(player);
if (!getLastPhotoLocationsResponse.IsSuccessful())
{
return(new Response <MapResponse>(getLastPhotoLocationsResponse.ErrorMessage, getLastPhotoLocationsResponse.ErrorCode));
}
//If the response was successful compress the photo to remove any unneccessary data needed for the map
foreach (var photo in getLastPhotoLocationsResponse.Data)
{
photo.CompressForMapRequest();
}
MapResponse map;
//if the player is not a BR player return the list of photos
if (!playerResponse.Data.IsBRPlayer())
{
map = new MapResponse()
{
Photos = getLastPhotoLocationsResponse.Data,
IsBR = false,
Latitude = 0,
Longitude = 0,
Radius = 0
};
}
//otherwise, calculate the currenct radius
else
{
map = new MapResponse()
{
Photos = getLastPhotoLocationsResponse.Data,
IsBR = true,
Latitude = playerResponse.Data.Game.Latitude,
Longitude = playerResponse.Data.Game.Longitude,
Radius = playerResponse.Data.Game.CalculateRadius()
};
}
return(new Response <MapResponse>(map));
}
//Catch any error associated with invalid model data
catch (InvalidModelException e)
{
return(new Response <MapResponse>(e.Msg, e.Code));
}
//Catch any unhandled / unexpected server errrors
catch
{
return(StatusCode(500));
}
}
