/// <summary> Subscriptions </summary>
void MergeSubscriptions()
{
SubscriptionModel[] subscriptions = Source.Subscriptions();
if (subscriptions.Length == 0)
{
return;
}
SubscriptionModel[] destinationSubscriptions = Destination.Subscriptions();
foreach (SubscriptionModel subscriptionModel in subscriptions)
{
// WHERE NOT EXISTS(SELECT * FROM Subscriptions WHERE reftype = 17 AND RefID = {model.TicketID} AND UserID = {proxy.UserID})
if (!destinationSubscriptions.Where(s => s.User.UserID == subscriptionModel.User.UserID).Any())
{
SubscriptionProxy subscriptionProxy = new SubscriptionProxy()
{
RefType = ReferenceType.Tickets,
RefID = Destination.TicketID,
UserID = subscriptionModel.User.UserID
};
Data_API.Create(Destination, subscriptionProxy);
}
Data_API.Delete(subscriptionModel);
}
}
void MergeRelationships()
{
TicketRelationshipProxy[] proxies = Data_API.Read <TicketRelationshipProxy[]>(Source);
TicketRelationshipModel idNode;
foreach (TicketRelationshipProxy proxy in proxies)
{
switch (GetState(proxy))
{
case TicketRelationship.SourceIsDestination:
idNode = new TicketRelationshipModel(Source, Destination, proxy.TicketRelationshipID);
Data_API.Delete(idNode); // circular reference
break;
case TicketRelationship.SourceTicket2:
TicketModel ticket2 = new TicketModel(Source.Connection, proxy.Ticket2ID);
idNode = new TicketRelationshipModel(Source, ticket2, proxy.TicketRelationshipID);
Data_API.Update(idNode, new UpdateArguments("Ticket1ID", Destination.TicketID));
break;
case TicketRelationship.Ticket1Source:
TicketModel ticket1 = new TicketModel(Source.Connection, proxy.Ticket1ID);
idNode = new TicketRelationshipModel(ticket1, Source, proxy.TicketRelationshipID);
Data_API.Update(idNode, new UpdateArguments("Ticket2ID", Destination.TicketID));
break;
}
}
}
/// <summary> Merge1 </summary>
public void Merge1()
{
if (!Connection.CanEdit()) // sufficient permissions?
{
return;
}
MergeAssets();
MergeChildren();
MergeContacts();
MergeCustomers();
MergeReminders();
MergeTagLinks();
MergeSubscriptions();
MergeTaskAssociations();
MergeRelationships(); // 1 and 2
MergeQueuedTickets();
MergeActions();
Data_API.Delete(Source);
//Source = null;
//DataAPI.DataAPI.Update(Destination, null); // update Date Modified
}
void MergeContacts()
{
UserTicketModel[] contacts = Source.UserTickets();
if (contacts.Length == 0)
{
return;
}
UserTicketModel[] destinationContacts = Destination.UserTickets();
foreach (UserTicketModel contact in contacts)
{
// WHERE NOT EXISTS(SELECT * FROM UserTickets WHERE TicketID ={model.TicketID} and UserID ={proxy.UserID})
if (!destinationContacts.Where(c => c.User.UserID == contact.User.UserID).Any())
{
ContactProxy contactProxy = new ContactProxy()
{
UserID = contact.User.UserID
};
Data_API.Create(Destination, contactProxy);
}
Data_API.Delete(contact);
}
}
void MergeCustomers()
{
OrganizationTicketModel[] customers = Source.OrganizationTickets();
if (customers.Length == 0)
{
return;
}
OrganizationTicketModel[] destinationCustomers = Destination.OrganizationTickets();
foreach (OrganizationTicketModel customer in customers)
{
// WHERE NOT EXISTS(SELECT * FROM OrganizationTickets WHERE TicketID ={model.TicketID} and OrganizationId ={proxy.OrganizationID})
if (!destinationCustomers.Where(c => c.Organization.OrganizationID == customer.Organization.OrganizationID).Any())
{
CustomerProxy customerProxy = new CustomerProxy()
{
OrganizationID = customer.Organization.OrganizationID
};
Data_API.Create(Destination, customerProxy);
}
Data_API.Delete(customer);
}
}
void MergeAssets()
{
AssetTicketModel[] assetTickets = Source.AssetTickets();
if (assetTickets.Length == 0)
{
return;
}
AssetTicketModel[] destinationAssetTickets = Destination.AssetTickets();
UpdateArguments args = new UpdateArguments("TicketID", Destination.TicketID);
foreach (AssetTicketModel assetTicket in assetTickets)
{
// WHERE NOT EXISTS (Select AssetTickets WITH (NOLOCK) WHERE AssetId = {asset} AND TicketId ={sourceTicket.TicketID})
if (!destinationAssetTickets.Where(a => a.Asset.AssetID == assetTicket.Asset.AssetID).Any())
{
Data_API.Update(assetTicket, args);
}
else
{
Data_API.Delete(assetTicket);
}
}
}
public static string DeleteAttachment(int attachmentID, AttachmentProxy.References verifyRefType, int?verifyRefID = null)
{
string result = null;
try
{
using (ConnectionContext connection = new ConnectionContext())
{
// validate args
AttachmentProxy proxy = Data_API.ReadRefTypeProxy <AttachmentProxy>(connection, attachmentID);
result = proxy.FileName;
if (verifyRefType == AttachmentProxy.References.None) // support delete no matter the type?
{
verifyRefType = proxy.RefType;
}
if (!verifyRefID.HasValue) // if no explicit refID provided, use the proxy
{
verifyRefID = proxy.RefID;
}
// type safe construction
IAttachmentDestination model = null;
switch (verifyRefType)
{
case AttachmentProxy.References.Actions:
model = new ActionModel(connection, verifyRefID.Value);
if (!(model as ActionModel).CanEdit()) // is user authorized to do the delete?
{
return(null);
}
break;
case AttachmentProxy.References.Assets:
model = new AssetModel(connection, verifyRefID.Value);
break;
//case AttachmentProxy.References.ChatAttachments:
// break;
case AttachmentProxy.References.CompanyActivity:
{
int organizationID = connection._db.ExecuteQuery <int>($"Select RefID from Notes WITH (NOLOCK) WHERE NoteID = {verifyRefID.Value}").Min();
model = new NoteModel(new OrganizationModel(connection, organizationID), verifyRefID.Value);
}
break;
case AttachmentProxy.References.ContactActivity:
{
int userID = connection._db.ExecuteQuery <int>($"Select RefID from Notes WITH (NOLOCK) WHERE NoteID = {verifyRefID.Value}").Min();
model = new NoteModel(new UserModel(connection, userID), verifyRefID.Value);
}
break;
//case AttachmentProxy.References.Contacts:
// break;
//case AttachmentProxy.References.CustomerHubLogo:
// break;
//case AttachmentProxy.References.None:
// break;
case AttachmentProxy.References.Organizations:
model = new OrganizationModel(connection, verifyRefID.Value);
break;
case AttachmentProxy.References.ProductVersions:
model = new ProductVersionModel(connection, verifyRefID.Value);
break;
case AttachmentProxy.References.Tasks:
model = new TaskModel(connection, verifyRefID.Value);
break;
case AttachmentProxy.References.UserPhoto:
case AttachmentProxy.References.Users:
model = new UserModel(connection, verifyRefID.Value);
break;
case AttachmentProxy.References.WaterCooler:
model = new WatercoolerMsgModel(connection, verifyRefID.Value);
break;
default:
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw new Exception($"unrecognized RefType {verifyRefType} in DeleteAttachment");
}
// do the delete
Data_API.Delete(new AttachmentModel(model, attachmentID));
AttachmentFile file = new AttachmentFile(model, proxy);
file.Delete();
}
}
catch (Exception ex)
{
Data_API.LogMessage(ActionLogType.Delete, ReferenceType.Attachments, attachmentID, "Unable to delete attachment", ex);
}
return(result);
}