public static void InitializeConnection(DataConnectionType connectionType)
{
//if (connectionType == DataConnectionType.SqlConnectionType)
//{
Connection = new SqlDataConnection();
//}
}
private string Port(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
string[] ipAndPort = hostPort.Split(',');
byte[] ipAddress = new byte[4];
byte[] port = new byte[2];
for (int i = 0; i < 4; i++)
{
ipAddress[i] = Convert.ToByte(ipAndPort[i]);
}
for (int i = 4; i < 6; i++)
{
port[i - 4] = Convert.ToByte(ipAndPort[i]);
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse(port);
}
_dataEndpoint = new IPEndPoint(new IPAddress(ipAddress), BitConverter.ToInt16(port, 0));
return("200 Data Connection Established");
}
private void HandlePort(string hostPort)
{
if (!_userAuthenticated)
{
return;
}
_dataConnectionType = DataConnectionType.Active;
var ipAndPort = hostPort.Split(',');
var ipAddress = new byte[4];
var port = new byte[2];
for (var i = 0; i < 4; i++)
{
ipAddress[i] = Convert.ToByte(ipAndPort[i]);
}
for (var i = 4; i < 6; i++)
{
port[i - 4] = Convert.ToByte(ipAndPort[i]);
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse(port);
}
_dataEndpoint = new IPEndPoint(new IPAddress(ipAddress), BitConverter.ToInt16(port, 0));
_clientStream.SendFtpResult(FtpCode.CommandOk, "Data Connection Established");
}
private void HandlePassive()
{
if (!_userAuthenticated)
{
return;
}
_dataConnectionType = DataConnectionType.Passive;
_passiveListener = new TcpListener(GetClientIp(), 0);
_passiveListener.Start();
var passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
var address = passiveListenerEndpoint.Address.GetAddressBytes();
var port = (short)passiveListenerEndpoint.Port;
var portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(portArray);
}
_clientStream.SendFtpResult(FtpCode.EnteringPassiveMode,
$"Entering Passive Mode ({address[0]},{address[1]},{address[2]},{address[3]},{portArray[0]},{portArray[1]}).");
}
private void PopulateCommandTypes()
{
string connection = null;
CommandTypeList.DataSource = null;
if (DataConnectionList.SelectedItem != null)
{
connection = ((DataConnection)DataConnectionList.SelectedItem).Name;
}
if (!String.IsNullOrEmpty(connection))
{
DataConnection c = DataConnection.GetByName(connection);
if (c != null)
{
DataConnectionType ct = c.GetConnectionType();
if (ct != null)
{
CommandTypeList.DataSource = ct.CommandTypes;
}
}
}
CommandTypeList.Text = "";
}
private string Passive()
{
_dataConnectionType = DataConnectionType.Passive;
if (_passiveListener == null)
{
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
Log.TraceMessage(Log.Nav.NavIn, "Creating new Passive Listener at " + localIp + ":" + 65432, Log.LogType.Info);
_passiveListener = new TcpListener(localIp, 65432);
Log.TraceMessage(Log.Nav.NavOut, "Starting the Listener", Log.LogType.Info);
_passiveListener.Start();
}
else
{
Log.TraceMessage(Log.Nav.NavOut, "Passive Listener already set up->Continuing", Log.LogType.Info);
}
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
byte[] address = passiveListenerEndpoint.Address.GetAddressBytes();
short port = (short)passiveListenerEndpoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(portArray);
}
return(string.Format("227 Entering Passive Mode ({0},{1},{2},{3},{4},{5})", address[0], address[1], address[2], address[3], portArray[0], portArray[1]));
//return "502 Not Implemented";
}
private void SaveDataConnectionType()
{
DataConnectionType item = new DataConnectionType();
item.Name = ItemName.Text;
Configuration.GetInstance().DataConnectionTypes.Add(item);
DataConnectionType.Save(item);
}
public DataConnection(FtpSession session, Socket listenSocket, int port)
{
m_Session = session;
m_Address = session.Config.Ip;
SecureProtocol = session.Context.DataSecureProtocol;
m_Listener = listenSocket;
m_Port = port;
_dataConnectionType = DataConnectionType.Passive;
}
public DataConnection(FtpSession session, IPAddress address, int port)
{
m_Session = session;
Address = session.Config.Ip;
SecureProtocol = session.Context.DataSecureProtocol;
m_Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
m_ipAddress = address;
Port = port;
_dataConnectionType = DataConnectionType.Active;
}
public string PostUserGameConnectionData(string SocialConnectionID, string GameConnTypeID, string Data)
{
Hashtable ht = new Hashtable();
Hashtable htObj = (Hashtable)JSON.JsonDecode(Data);
DataConnectionType typeID = (DataConnectionType)Enum.Parse(typeof(DataConnectionType), GameConnTypeID);
ht.Add("Result", bcGamertag.PostUserGameConnectionData(SocialConnectionID, typeID, htObj));
return(JSON.JsonEncode(ht));
}
public static object GetUserGameConnectionData(string ID, SocialConnectionType SocConnType, DataConnectionType DataConnType)
{
GamervineDataContext dContext = new GamervineDataContext();
var gvUserId = from usc in dContext.UserSocialConnections
where usc.ConnectionUserId == ID && usc.Type == SocConnType.GetHashCode()
select usc.UserId;
if (gvUserId.Count() > 0)
{
var gamertag = from gt in dContext.Gamertags
where gt.Type == DataConnType.GetHashCode() && gt.UserId == gvUserId.First()
select new
{
gt.TagId,
gt.Tag
};
if (gamertag.Count() > 0)
{
var jobs = from j in dContext.Jobs
where j.TagId == gamertag.First().TagId
select new
{
j.JobId,
j.Type,
j.Frequency,
j.FrequencyUnits
};
var gtSocialConns = from gtsc in dContext.GamertagSocialConnections
join usc in dContext.UserSocialConnections on gtsc.UserSocialConnectionId equals usc.UserSocialConnectionId
where gtsc.TagId == gamertag.First().TagId
select new
{
usc.Type
};
return new
{
TagId = gamertag.First().TagId,
Tag = gamertag.First().Tag,
Jobs = jobs,
GamertagSocialConnections = gtSocialConns
};
}
else
return new { TagId = string.Empty };
}
else
return new { Error = "Social connection ID \"" + ID + "\" does not exist."};
}
private string EPassive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
_passiveListener = new TcpListener(localIp, 0);
_passiveListener.Start();
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
return(string.Format("229 Entering Extended Passive Mode (|||{0}|)", passiveListenerEndpoint.Port));
}
public static IDataConnector GetDataConnectorForType(int Type)
{
DataConnectionType dcType = (DataConnectionType)Enum.Parse(typeof(DataConnectionType), Type.ToString());
switch (dcType)
{
case DataConnectionType.Xbox360:
return(new XboxDataConnector());
default:
throw new Exception("DataConnector doesn't exist for type \"" + Type + "\".");
}
}
public IDataCommandProvider GetProvider(DataConnection connection)
{
IDataCommandProvider retVal = null;
if (this.Connections.ContainsKey(connection.Name))
{
//get cached data command provider
retVal = this.Connections[connection.Name];
}
else
{
//add data command provider to cache
DataConnectionType connectionType = connection.GetConnectionType();
if (connectionType != null)
{
if (!String.IsNullOrEmpty(connectionType.Class) && !String.IsNullOrEmpty(connectionType.Assembly))
{
try
{
Assembly providerAssembly = Assembly.Load(connectionType.Assembly);
if (providerAssembly != null)
{
Type type = providerAssembly.GetType(connectionType.Class, true, true);
if (type != null)
{
ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
retVal = constructor.Invoke(null) as IDataCommandProvider;
retVal.Initialize(connectionType.Settings);
this.Connections.Add(connection.Name, retVal);
}
}
}
catch {
//silent error
}
}
}
}
if (retVal == null)
{
throw new Exception(String.Format("No valid data command provider found for connection {0}", connection.Name));
}
return(retVal);
}
public List <object> GetItems(string folder, string name)
{
List <object> retVal = new List <object>();
if (String.IsNullOrEmpty(name))
{
retVal = new List <object>(Configuration.GetInstance().DataConnectionTypes.Cast <object>());
}
else
{
retVal.Add(DataConnectionType.GetByName(name));
}
return(retVal);
}
public static DatabaseFacade Create(
string serverName,
string databaseName,
string userName,
string password,
DataConnectionType type)
{
switch (type)
{
case DataConnectionType.MsSqlServer:
return(new SqlServerDatabaseFacade(serverName, databaseName, userName, password));
default:
throw new BasicException("Database type is not yet supported.", string.Format("Connection Type: {0}", type));
}
}
private string EPort(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
char delimiter = hostPort[0];
string[] rawSplit = hostPort.Split(new char[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
char ipType = rawSplit[0][0];
string ipAddress = rawSplit[1];
string port = rawSplit[2];
_dataEndpoint = new IPEndPoint(IPAddress.Parse(ipAddress), int.Parse(port));
return("200 Data Connection Established");
}
private string Port(string hostPort)
{
dataConnectionType = DataConnectionType.Active;
string[] ipAndPort = hostPort.Split(',');
byte[] ipAdress = ipAndPort.Take(4).Select(s => Convert.ToByte(s)).ToArray();
byte[] port = ipAndPort.Skip(4).Select(s => Convert.ToByte(s)).ToArray();
if (BitConverter.IsLittleEndian)
{
Array.Reverse(port);
}
dataEndpoint = new IPEndPoint(new IPAddress(ipAdress), BitConverter.ToInt16(port, 0));
return("200 OK");
}
public string GetUserGameConnectionData(string SocialConnectionID, string SocialConnTypeID, string DataConnTypeID)
{
Hashtable ht = new Hashtable();
DataConnectionType dataConnType = (DataConnectionType)Enum.Parse(typeof(DataConnectionType), DataConnTypeID);
SocialConnectionType socialConnType = (SocialConnectionType)Enum.Parse(typeof(DataConnectionType), SocialConnTypeID);
object o = bcGamertag.GetUserGameConnectionData(SocialConnectionID, socialConnType, dataConnType);
foreach (PropertyInfo pi in o.GetType().GetProperties())
{
object propVal = pi.GetValue(o, null);
if (propVal is IQueryable)
{
IQueryable iqPropVal = (IQueryable)propVal;
Hashtable htPropVal = new Hashtable();
int count = 0;
foreach (var item in iqPropVal)
{
Hashtable htObject = new Hashtable();
foreach (PropertyInfo piPropVal in item.GetType().GetProperties())
{
htObject.Add(piPropVal.Name, piPropVal.GetValue(item, null));
}
htPropVal.Add(count, htObject);
count++;
}
htPropVal.Add("Count", count);
ht.Add(pi.Name, htPropVal);
}
else
{
ht.Add(pi.Name, pi.GetValue(o, null));
}
}
return(JSON.JsonEncode(ht));
}
private string Passive(string arguments)
{
IPAddress localAddress = ((IPEndPoint)ControlClient.Client.LocalEndPoint).Address;
PassiveListener = new TcpListener(localAddress, 0);
PassiveListener.Start();
IPEndPoint localEndPoint = ((IPEndPoint)PassiveListener.LocalEndpoint);
byte[] address = localEndPoint.Address.GetAddressBytes();
short port = (short)localEndPoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(portArray);
}
DataConnectionType = DataConnectionType.Passive;
return(string.Format("227 Entering passive mode on ({0},{1},{2},{3},{4},{5})", address[0], address[1], address[2], address[3],
portArray[0], portArray[1]));
}
private string EPassive()
{
_dataConnectionType = DataConnectionType.Passive;
if (_passiveListener == null)
{
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
Log.TraceMessage(Log.Nav.NavIn, "Creating new Passive Listener at " + localIp + ":" + 65432, Log.LogType.Info);
_passiveListener = new TcpListener(localIp, 65432);
Log.TraceMessage(Log.Nav.NavOut, "Starting the Listener", Log.LogType.Info);
_passiveListener.Start();
}
else
{
Log.TraceMessage(Log.Nav.NavOut, "Passive Listener already set up->Continuing", Log.LogType.Info);
}
return(string.Format("229 Entering Extended Passive Mode (|||{0}|)", 65432));
}
public IDataCommandProvider GetProvider(DataConnection connection)
{
IDataCommandProvider retVal = null;
if (this.Connections.ContainsKey(connection.Name))
{
//get cached data command provider
retVal = this.Connections[connection.Name];
}
else
{
//add data command provider to cache
DataConnectionType connectionType = connection.GetConnectionType();
if (connectionType != null)
{
if (!String.IsNullOrEmpty(connectionType.Class) && !String.IsNullOrEmpty(connectionType.Assembly))
{
try
{
retVal = Common.CreateInstance(connectionType.Assembly, connectionType.Class) as IDataCommandProvider;
retVal.Initialize(connectionType.Settings);
this.Connections.Add(connection.Name, retVal);
}
catch {
//silent error
}
}
}
}
if (retVal == null)
{
throw new Exception(String.Format("No valid data command provider found for connection {0}", connection.Name));
}
return(retVal);
}
private string Passive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
_passiveListener = new TcpListener(localIp, 0);
_passiveListener.Start();
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
byte[] address = passiveListenerEndpoint.Address.GetAddressBytes();
short port = (short)passiveListenerEndpoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(portArray);
}
return(string.Format("227 Entering Passive Mode ({0},{1},{2},{3},{4},{5})", address[0], address[1], address[2], address[3], portArray[0], portArray[1]));
}
private string Passive()
{
this.dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)this.controlClient.Client.LocalEndPoint).Address;
this.passiveListener = new TcpListener(localIp, 0);
this.passiveListener.Start();
IPEndPoint passiveListenerEndpoint = (IPEndPoint)this.passiveListener.LocalEndpoint;
byte[] address = passiveListenerEndpoint.Address.GetAddressBytes();
short port = (short)passiveListenerEndpoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(portArray);
}
return($"227 Entering Passive Mode ({address[0]},{address[1]},{address[2]},{address[3]},{portArray[0]},{portArray[1]})");
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
string DataConnectionName = null;
StandardValuesCollection list = null;
if (context.Instance is DataCommand)
{
DataCommand command = (DataCommand)context.Instance;
if (String.IsNullOrEmpty(command.DataConnection))
{
DataConnectionName = Configuration.GetInstance().App.DefaultConnection;
}
else
{
DataConnectionName = command.DataConnection;
}
if (!String.IsNullOrEmpty(DataConnectionName))
{
DataConnection connection = Configuration.GetInstance().DataConnections.Where(c => c.Name.ToLower() == DataConnectionName.ToLower()).SingleOrDefault();
if (connection != null)
{
DataConnectionType connectionType = Configuration.GetInstance().DataConnectionTypes.Where(c => c.Name.ToLower() == connection.DataConnectionType.ToLower()).SingleOrDefault();
if (connectionType != null)
{
list = new StandardValuesCollection(connectionType.CommandTypes);
}
}
}
}
return(list);
}
public static object GetUserGameConnectionData(string ID, SocialConnectionType SocConnType, DataConnectionType DataConnType)
{
GamervineDataContext dContext = new GamervineDataContext();
var gvUserId = from usc in dContext.UserSocialConnections
where usc.ConnectionUserId == ID && usc.Type == SocConnType.GetHashCode()
select usc.UserId;
if (gvUserId.Count() > 0)
{
var gamertag = from gt in dContext.Gamertags
where gt.Type == DataConnType.GetHashCode() && gt.UserId == gvUserId.First()
select new
{
gt.TagId,
gt.Tag
};
if (gamertag.Count() > 0)
{
var jobs = from j in dContext.Jobs
where j.TagId == gamertag.First().TagId
select new
{
j.JobId,
j.Type,
j.Frequency,
j.FrequencyUnits
};
var gtSocialConns = from gtsc in dContext.GamertagSocialConnections
join usc in dContext.UserSocialConnections on gtsc.UserSocialConnectionId equals usc.UserSocialConnectionId
where gtsc.TagId == gamertag.First().TagId
select new
{
usc.Type
};
return(new
{
TagId = gamertag.First().TagId,
Tag = gamertag.First().Tag,
Jobs = jobs,
GamertagSocialConnections = gtSocialConns
});
}
else
{
return new { TagId = string.Empty }
};
}
else
{
return new { Error = "Social connection ID \"" + ID + "\" does not exist." }
};
}
public static object PostUserGameConnectionData(string ID, DataConnectionType TypeID, Hashtable Data)
{
try
{
GamervineDataContext dContext = new GamervineDataContext();
var gvUser = from usc in dContext.UserSocialConnections
where usc.ConnectionUserId == ID && usc.Type == TypeID.GetHashCode()
select usc;
if (gvUser.Count() > 0)
{
var dGamertag = from gt in dContext.Gamertags
where gt.Type == TypeID.GetHashCode() && gt.UserId == gvUser.First().UserId
select gt;
bool isStatusJobEnabled = false;
bool isSummaryJobEnabled = false;
bool isFacebookEnabled = false;
//bool isTagInsert = false;
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Status"])["Enabled"]) == 1)
{
isStatusJobEnabled = true;
}
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Summary"])["Enabled"]) == 1)
{
isSummaryJobEnabled = true;
}
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["GamertagSocialConnections"])["Facebook"])["Enabled"]) == 1)
{
isFacebookEnabled = true;
}
Gamertag gamertag = new Gamertag();
if (dGamertag.Count() == 0)
{
//isTagInsert = true;
gamertag = Insert(gvUser.First().UserId, TypeID.GetHashCode(), Data);
}
else
{
gamertag = dGamertag.First();
gamertag.Tag = Utility.ToString(((Hashtable)Data["Data"])["Tag"]);
var statusPost = from j in dContext.Jobs
where j.TagId == gamertag.TagId &&
j.Type == JobTypes.Status.GetHashCode()
select j;
var summaryPost = from j in dContext.Jobs
where j.TagId == gamertag.TagId &&
j.Type == JobTypes.Summary.GetHashCode()
select j;
var fbConnection = from gtsc in dContext.GamertagSocialConnections
where gtsc.TagId == gamertag.TagId &&
gtsc.UserSocialConnectionId == gvUser.First().UserSocialConnectionId
select gtsc;
if (isStatusJobEnabled)
{
Hashtable statusData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Status"];
Job statusJob = new Job();
//We have an existing status job and the enabled flag is true - persist settings
if (statusPost.Count() > 0)
{
statusJob = statusPost.First();
}
else
{
statusJob.JobId = Guid.NewGuid().ToString();
statusJob.LastRunTime = null;
statusJob.TagId = gamertag.TagId;
statusJob.PostFormat = string.Empty;
statusJob.Type = JobTypes.Status.GetHashCode();
dContext.Jobs.InsertOnSubmit(statusJob);
}
statusJob.Frequency = Utility.ToInt(statusData["Frequency"]);
statusJob.FrequencyUnits = Utility.ToInt(statusData["FrequencyUnits"]);
statusJob.NextRunTime = statusJob.CalculateNextRunTime();
}
else
{
//The enabled flag is false and if we have an existing status job - delete the job
if (statusPost.Count() > 0)
{
dContext.Jobs.DeleteOnSubmit(statusPost.First());
}
}
if (isSummaryJobEnabled)
{
Hashtable summaryData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Summary"];
Job summaryJob = new Job();
//We have an existing summary job and the enabled flag is true - persist settings
if (summaryPost.Count() > 0)
{
summaryJob = summaryPost.First();
}
else
{
summaryJob.JobId = Guid.NewGuid().ToString();
summaryJob.LastRunTime = null;
summaryJob.TagId = gamertag.TagId;
summaryJob.PostFormat = string.Empty;
summaryJob.Type = JobTypes.Summary.GetHashCode();
dContext.Jobs.InsertOnSubmit(summaryJob);
}
summaryJob.Frequency = Utility.ToInt(summaryData["Frequency"]);
summaryJob.FrequencyUnits = Utility.ToInt(summaryData["FrequencyUnits"]);
summaryJob.NextRunTime = summaryJob.CalculateNextRunTime();
}
else
{
//The enabled flag is false and if we have an existing summary job - delete the job
if (summaryPost.Count() > 0)
{
dContext.Jobs.DeleteOnSubmit(summaryPost.First());
}
}
if (isFacebookEnabled)
{
Hashtable fbData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["GamertagSocialConnections"])["Facebook"];
GamertagSocialConnection fbSocialConn = new GamertagSocialConnection();
//We have an existing summary job and the enabled flag is true - persist settings
if (fbConnection.Count() > 0)
{
fbSocialConn = fbConnection.First();
}
else
{
fbSocialConn.TagId = gamertag.TagId;
fbSocialConn.UserSocialConnectionId = gvUser.First().UserSocialConnectionId;
dContext.GamertagSocialConnections.InsertOnSubmit(fbSocialConn);
}
}
else
{
//The enabled flag is false and if we have an existing facebook connection - delete the connection
if (fbConnection.Count() > 0)
{
dContext.GamertagSocialConnections.DeleteOnSubmit(fbConnection.First());
}
}
}
dContext.SubmitChanges();
return(string.Empty);
}
else
{
return new { Error = "Social connection ID \"" + ID + "\" does not exist." }
};
}
catch (Exception ex)
{
return(new { Error = ex.ToString() });
}
}
public IDataConnection CreateDataConnection(DataConnectionType type)
{
return(new Connections.DataConnection(type));
}
public void Load(XDocument doc, string folder)
{
DataConnectionType.Load(doc);
}
public static object PostUserGameConnectionData(string ID, DataConnectionType TypeID, Hashtable Data)
{
try
{
GamervineDataContext dContext = new GamervineDataContext();
var gvUser = from usc in dContext.UserSocialConnections
where usc.ConnectionUserId == ID && usc.Type == TypeID.GetHashCode()
select usc;
if (gvUser.Count() > 0)
{
var dGamertag = from gt in dContext.Gamertags
where gt.Type == TypeID.GetHashCode() && gt.UserId == gvUser.First().UserId
select gt;
bool isStatusJobEnabled = false;
bool isSummaryJobEnabled = false;
bool isFacebookEnabled = false;
//bool isTagInsert = false;
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Status"])["Enabled"]) == 1)
isStatusJobEnabled = true;
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Summary"])["Enabled"]) == 1)
isSummaryJobEnabled = true;
if (Utility.ToInt(((Hashtable)((Hashtable)((Hashtable)Data["Data"])["GamertagSocialConnections"])["Facebook"])["Enabled"]) == 1)
isFacebookEnabled = true;
Gamertag gamertag = new Gamertag();
if (dGamertag.Count() == 0)
{
//isTagInsert = true;
gamertag = Insert(gvUser.First().UserId, TypeID.GetHashCode(), Data);
}
else
{
gamertag = dGamertag.First();
gamertag.Tag = Utility.ToString(((Hashtable)Data["Data"])["Tag"]);
var statusPost = from j in dContext.Jobs
where j.TagId == gamertag.TagId
&& j.Type == JobTypes.Status.GetHashCode()
select j;
var summaryPost = from j in dContext.Jobs
where j.TagId == gamertag.TagId
&& j.Type == JobTypes.Summary.GetHashCode()
select j;
var fbConnection = from gtsc in dContext.GamertagSocialConnections
where gtsc.TagId == gamertag.TagId
&& gtsc.UserSocialConnectionId == gvUser.First().UserSocialConnectionId
select gtsc;
if (isStatusJobEnabled)
{
Hashtable statusData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Status"];
Job statusJob = new Job();
//We have an existing status job and the enabled flag is true - persist settings
if (statusPost.Count() > 0)
statusJob = statusPost.First();
else
{
statusJob.JobId = Guid.NewGuid().ToString();
statusJob.LastRunTime = null;
statusJob.TagId = gamertag.TagId;
statusJob.PostFormat = string.Empty;
statusJob.Type = JobTypes.Status.GetHashCode();
dContext.Jobs.InsertOnSubmit(statusJob);
}
statusJob.Frequency = Utility.ToInt(statusData["Frequency"]);
statusJob.FrequencyUnits = Utility.ToInt(statusData["FrequencyUnits"]);
statusJob.NextRunTime = statusJob.CalculateNextRunTime();
}
else
{
//The enabled flag is false and if we have an existing status job - delete the job
if (statusPost.Count() > 0)
dContext.Jobs.DeleteOnSubmit(statusPost.First());
}
if (isSummaryJobEnabled)
{
Hashtable summaryData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["Jobs"])["Summary"];
Job summaryJob = new Job();
//We have an existing summary job and the enabled flag is true - persist settings
if (summaryPost.Count() > 0)
summaryJob = summaryPost.First();
else
{
summaryJob.JobId = Guid.NewGuid().ToString();
summaryJob.LastRunTime = null;
summaryJob.TagId = gamertag.TagId;
summaryJob.PostFormat = string.Empty;
summaryJob.Type = JobTypes.Summary.GetHashCode();
dContext.Jobs.InsertOnSubmit(summaryJob);
}
summaryJob.Frequency = Utility.ToInt(summaryData["Frequency"]);
summaryJob.FrequencyUnits = Utility.ToInt(summaryData["FrequencyUnits"]);
summaryJob.NextRunTime = summaryJob.CalculateNextRunTime();
}
else
{
//The enabled flag is false and if we have an existing summary job - delete the job
if (summaryPost.Count() > 0)
dContext.Jobs.DeleteOnSubmit(summaryPost.First());
}
if (isFacebookEnabled)
{
Hashtable fbData = (Hashtable)((Hashtable)((Hashtable)Data["Data"])["GamertagSocialConnections"])["Facebook"];
GamertagSocialConnection fbSocialConn = new GamertagSocialConnection();
//We have an existing summary job and the enabled flag is true - persist settings
if (fbConnection.Count() > 0)
fbSocialConn = fbConnection.First();
else
{
fbSocialConn.TagId = gamertag.TagId;
fbSocialConn.UserSocialConnectionId = gvUser.First().UserSocialConnectionId;
dContext.GamertagSocialConnections.InsertOnSubmit(fbSocialConn);
}
}
else
{
//The enabled flag is false and if we have an existing facebook connection - delete the connection
if (fbConnection.Count() > 0)
dContext.GamertagSocialConnections.DeleteOnSubmit(fbConnection.First());
}
}
dContext.SubmitChanges();
return string.Empty;
}
else
return new { Error = "Social connection ID \"" + ID + "\" does not exist." };
}
catch (Exception ex)
{
return new { Error = ex.ToString() };
}
}
private Response EPassive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)ControlClient.Client.LocalEndPoint).Address;
_passiveListener = PassiveListeners.GetListener(localIp);
try
{
_passiveListener.Start();
}
catch
{
_log.Error("No more ports available");
return GetResponse(FtpResponses.UNABLE_TO_OPEN_DATA_CONNECTION);
}
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
return GetResponse(FtpResponses.ENTERING_EXTENDED_PASSIVE_MODE.SetData(passiveListenerEndpoint.Port));
}
/// <summary>
/// PORT Command - RFC 959 - Section 4.1.2
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
private Response Port(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
string[] ipAndPort = hostPort.Split(',');
byte[] ipAddress = ipAndPort.Take(4).Select(s => Convert.ToByte(s, CultureInfo.InvariantCulture)).ToArray();
byte[] port = ipAndPort.Skip(4).Select(s => Convert.ToByte(s, CultureInfo.InvariantCulture)).ToArray();
if (BitConverter.IsLittleEndian)
Array.Reverse(port);
_dataEndpoint = new IPEndPoint(new IPAddress(ipAddress), BitConverter.ToInt16(port, 0));
return GetResponse(FtpResponses.OK);
}
/// <summary>
/// PASV Command - RFC 959 - Section 4.1.2
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
private Response Passive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)ControlClient.Client.LocalEndPoint).Address;
_passiveListener = PassiveListeners.GetListener(localIp);
try
{
_passiveListener.Start();
}
catch
{
_log.Error("No more ports available");
return GetResponse(FtpResponses.UNABLE_TO_OPEN_DATA_CONNECTION);
}
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
byte[] address = passiveListenerEndpoint.Address.GetAddressBytes();
ushort port = (ushort)passiveListenerEndpoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
Array.Reverse(portArray);
return GetResponse(FtpResponses.ENTERING_PASSIVE_MODE.SetData(address[0], address[1], address[2], address[3], portArray[0], portArray[1]));
}
private string Passive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
_passiveListener = new TcpListener(localIp, 0);
_passiveListener.Start();
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
byte[] address = passiveListenerEndpoint.Address.GetAddressBytes();
short port = (short)passiveListenerEndpoint.Port;
byte[] portArray = BitConverter.GetBytes(port);
if (BitConverter.IsLittleEndian)
Array.Reverse(portArray);
return string.Format("227 Entering Passive Mode ({0},{1},{2},{3},{4},{5})", address[0], address[1], address[2], address[3], portArray[0], portArray[1]);
}
private string EPassive()
{
_dataConnectionType = DataConnectionType.Passive;
IPAddress localIp = ((IPEndPoint)_controlClient.Client.LocalEndPoint).Address;
_passiveListener = new TcpListener(localIp, 0);
_passiveListener.Start();
IPEndPoint passiveListenerEndpoint = (IPEndPoint)_passiveListener.LocalEndpoint;
return string.Format("229 Entering Extended Passive Mode (|||{0}|)", passiveListenerEndpoint.Port);
}
private string EPort(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
var delimiter = hostPort[0];
var rawSplit = hostPort.Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
var ipType = rawSplit[0][0];
var ipAddress = rawSplit[1];
var port = rawSplit[2];
_dataEndpoint = new IPEndPoint(IPAddress.Parse(ipAddress), int.Parse(port));
return "200 Data Connection Established";
}
private Response EPort(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
char delimiter = hostPort[0];
string[] rawSplit = hostPort.Split(new char[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
char ipType = rawSplit[0][0];
string ipAddress = rawSplit[1];
string port = rawSplit[2];
_dataEndpoint = new IPEndPoint(IPAddress.Parse(ipAddress), int.Parse(port));
return GetResponse(FtpResponses.OK);
}
private string Port(string hostPort)
{
_dataConnectionType = DataConnectionType.Active;
string[] ipAndPort = hostPort.Split(',');
byte[] ipAddress = new byte[4];
byte[] port = new byte[2];
for (int i = 0; i < 4; i++)
{
ipAddress[i] = Convert.ToByte(ipAndPort[i]);
}
for (int i = 4; i < 6; i++)
{
port[i - 4] = Convert.ToByte(ipAndPort[i]);
}
if (BitConverter.IsLittleEndian)
Array.Reverse(port);
_dataEndpoint = new IPEndPoint(new IPAddress(ipAddress), BitConverter.ToInt16(port, 0));
return "200 Data Connection Established";
}
public int GetCounts(string folder, string name)
{
return(DataConnectionType.GetItemCount(name));
}
public void Save(object configurationItem)
{
DataConnectionType.Save((DataConnectionType)configurationItem);
}
