public void ExecuteGetUser(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Functions.CRMFunctions CRMFunctions = new Functions.CRMFunctions(Utilities.FunctionsUtils.GetCRMConfig(serviceBroker.Service.ServiceConfiguration));

            Functions.CRMUser CRMUserInput  = new Functions.CRMUser();
            Functions.CRMUser CRMUserResult = null;

            try
            {
                CRMUserInput.UserFQN = inputs.Where(p => p.Name.Equals("userfqn", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();

                CRMUserResult = CRMFunctions.CRMGetUser(CRMUserInput);

                if (CRMUserResult != null)
                {
                    returns.Where(p => p.Name.Equals("userfqn")).First().Value        = CRMUserInput.UserFQN;
                    returns.Where(p => p.Name.Equals("userid")).First().Value         = CRMUserResult.UserId;
                    returns.Where(p => p.Name.Equals("responsestatus")).First().Value = ResponseStatus.Success;
                }
                else
                {
                    throw new Exception("CRMUserResult is null.");
                }
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }

            serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 2
0
        public void ExecuteListSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            Dictionary <string, string> SourceIds = new Dictionary <string, string>();

            SourceIds.Add("8413cd39-2156-4e00-b54d-11efd9abdb89", "Local SharePoint Results");
            SourceIds.Add("b09a7990-05ea-4af9-81ef-edfab16c4e31", "Local People Results");
            SourceIds.Add("203fba36-2763-4060-9931-911ac8c0583b", "Local Reports And Data Results");
            SourceIds.Add("78b793ce-7956-4669-aa3b-451fc5defebf", "Local Video Results");
            SourceIds.Add("e7ec8cee-ded8-43c9-beb5-436b54b31e84", "Documents");
            SourceIds.Add("5dc9f503-801e-4ced-8a2c-5d1237132419", "Items matching a content type");
            SourceIds.Add("e1327b9c-2b8c-4b23-99c9-3730cb29c3f7", "Items matching a tag");
            SourceIds.Add("48fec42e-4a92-48ce-8363-c2703a40e67d", "Items related to current user");
            SourceIds.Add("5c069288-1d17-454a-8ac6-9c642a065f48", "Items with same keyword as this item");
            SourceIds.Add("5e34578e-4d08-4edc-8bf3-002acf3cdbcc", "Pages");
            SourceIds.Add("38403c8c-3975-41a8-826e-717f2d41568a", "Pictures");
            SourceIds.Add("97c71db1-58ce-4891-8b64-585bc2326c12", "Popular");
            SourceIds.Add("ba63bbae-fa9c-42c0-b027-9a878f16557c", "Recently changed items");
            SourceIds.Add("ec675252-14fa-4fbe-84dd-8d098ed74181", "Recommended Items");
            SourceIds.Add("9479bf85-e257-4318-b5a8-81a180f5faa1", "Wiki");

            foreach (var Source in SourceIds)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"]   = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }
        }
        private Validation GetRequiredProperties(string method)
        {
            RequiredProperties properties = new RequiredProperties();
            Validation         validation = null;

            validation = new Validation();
            switch (method)
            {
            case "ExcelList":
                #region properties
                properties.Add(new Property("ExcelDocumentPath", "System.String", SoType.File, new MetaData("ExcelDocumentPath", "Excel Document Path Value")));
                properties.Add(new Property("ExcelSheetName", "System.String", SoType.Text, new MetaData("ExcelSheetName", "Excel Sheet Name")));
                properties.Add(new Property("RowNumber", "System.Int32", SoType.Number, new MetaData("RowNumber", "RowNumber")));
                break;

            case "SaveData":
                properties.Add(new Property("ExcelDocumentPath", "System.String", SoType.File, new MetaData("ExcelDocumentPath", "Excel Document Path Value")));
                properties.Add(new Property("RowNumber", "System.Int32", SoType.Number, new MetaData("RowNumber", "RowNumber")));
                properties.Add(new Property("ExcelSheetName", "System.String", SoType.Text, new MetaData("ExcelSheetName", "Excel Sheet Name")));
                properties.Add(new Property("TableName", "System.String", SoType.Text, new MetaData("TableName", "SmartObjectName")));
                break;

                #endregion
            }
            validation.RequiredProperties = properties;
            return(validation);
        }
Ejemplo n.º 4
0
        public void DeleteQueues(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();
            NamespaceManager namespaceManager = null;

            try
            {
                string queuepath = string.Empty;
                if (inputs.Length == 0)
                {
                    queuepath = serviceObject.MetaData.DisplayName;
                }
                else
                {
                    queuepath = inputs.Where(p => p.Name.Equals("queue")).First().Value.ToString();
                }

                namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());
                namespaceManager.DeleteQueue(queuepath);
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Success;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = "Queue deleted";
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }
            finally
            {
                namespaceManager = null;
            }

            serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 5
0
        private Validation GetRequiredProperties(string method)
        {
            RequiredProperties properties = new RequiredProperties();
            Validation         validation = null;

            validation = new Validation();
            switch (method)
            {
            case "IsInRole":
                #region properties
                properties.Add(new Property("Role_Name", "System.String", SoType.Text, new MetaData("Role_Name", "Role_Name")));
                properties.Add(new Property("Username", "System.String", SoType.Text, new MetaData("Username", "Username")));

                break;

            case "GetRoleUsersEmailAddress":
                properties.Add(new Property("Role_Name", "System.String", SoType.Text, new MetaData("Role_Name", "Role_Name")));
                break;

            case "GetRoleUsersEmailsonIndex":
                properties.Add(new Property("Role_Name", "System.String", SoType.Text, new MetaData("Role_Name", "Role_Name")));
                properties.Add(new Property("UserIndex", "System.Int32", SoType.Number, new MetaData("UserIndex", "UserIndex")));
                break;

            case "GetRoleUsersEmails":
                properties.Add(new Property("Role_Name", "System.String", SoType.Text, new MetaData("Role_Name", "Role_Name")));
                //properties.Add(new Property("UserIndex", "System.Int32", SoType.Number, new MetaData("UserIndex", "UserIndex")));
                break;

                #endregion
            }
            validation.RequiredProperties = properties;
            return(validation);
        }
        public void GetAllAttachments(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            System.Data.DataRow dr;
            Helper h = new Helper(serviceBroker);

            string mailbox       = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid           = string.Empty;
            string subjectfilter = string.Empty;

            uid = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();

            AE.Net.Mail.MailMessage       m           = null;
            List <AE.Net.Mail.Attachment> attachments = new List <AE.Net.Mail.Attachment>();

            try
            {
                using (var ic = h.GetImapClient())
                {
                    m = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }

                    attachments = m.Attachments as List <AE.Net.Mail.Attachment>;

                    foreach (Attachment a in attachments)
                    {
                        dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                        dr["body"]    = a.Body;
                        dr["charset"] = a.Charset;
                        dr["contenttransferencoding"] = a.ContentTransferEncoding;
                        dr["contenttype"]             = a.ContentType;
                        dr["filename"]   = a.Filename;
                        dr["rawheaders"] = a.RawHeaders;
                        dr["onserver"]   = a.OnServer;

                        dr["mailbox"] = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
                        dr["uid"]     = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();

                        serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                    }

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
        }
        /// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            this.GetConfiguration();

            if (serviceObject.Methods[0].Name.Equals("spsearch") || serviceObject.Methods[0].Name.Equals("spsearchraw") || serviceObject.Methods[0].Name.Equals("deserializesearchresults"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchread") || serviceObject.Methods[0].Name.Equals("spsearchrawread"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listsourceidsstatic"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteListSourceIds(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listothersourceidsstatic"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteListOtherSourceIds(inputs, required, returns, methodType, serviceObject);
            }


            if (serviceObject.Methods[0].Name.Equals("spsearchusers") || serviceObject.Methods[0].Name.Equals("deserializeusersearchresults"))
            {
                SPSearchUser spsearchuser = new SPSearchUser(serviceBroker, this.Configuration);
                spsearchuser.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchusersread"))
            {
                SPSearchUser spsearchuser = new SPSearchUser(serviceBroker, this.Configuration);
                spsearchuser.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }


            if (serviceObject.Methods[0].Name.Equals("spsearchdocuments") || serviceObject.Methods[0].Name.Equals("deserializedocumentsearchresults"))
            {
                SPSearchDocument spsearchdocumet = new SPSearchDocument(serviceBroker, this.Configuration);
                spsearchdocumet.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchdocumentsread"))
            {
                SPSearchDocument spsearchdocumet = new SPSearchDocument(serviceBroker, this.Configuration);
                spsearchdocumet.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }
        }
Ejemplo n.º 8
0
 public ConfigurationEntry ToEntry()
 {
     return(new ConfigurationEntry
     {
         ConfigurationType = ConcreteType,
         Data = Data,
         Description = Description,
         PluginType = InterfaceType,
         Name = Name,
         Tags = Tags,
         RequiredProperties = new Properties(RequiredProperties.ToDictionary(nvp => nvp.Name, nvp => nvp.Value))
     });
 }
        private Validation GetRequiredProperties(string method)
        {
            RequiredProperties properties = new RequiredProperties();
            Validation         validation = null;

            validation = new Validation();
            switch (method)
            {
            case "ActionWorklistItem":
            {
                properties.Add(_so.Properties["SerialNumber"]);
                properties.Add(_so.Properties["ActionName"]);
                break;
            }

            case "OpenWorklistItem":
            {
                properties.Add(_so.Properties["SerialNumber"]);
                break;
            }

            case "ReleaseWorklistItem":
            {
                properties.Add(_so.Properties["SerialNumber"]);
                break;
            }

            case "RedirectWorklistItem":
            {
                properties.Add(_so.Properties["SerialNumber"]);
                break;
            }

            case "RedirectManagedUserWorklistItem":
            {
                properties.Add(_so.Properties["SerialNumber"]);
                break;
            }

            case "GetWorklistItemActions":
            {
                properties.Add(new Property("SerialNumber", "System.String", SoType.Text, new MetaData("SerialNumber", "SerialNumber")));
                break;
            }
            }
            validation.RequiredProperties = properties;
            return(validation);
        }
Ejemplo n.º 10
0
        public void ExecuteListOtherSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            foreach (var Source in SPSearchSource.GetOtherSourceIds())
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"]   = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Caches all properties.
        /// </summary>
        protected void CacheProperties()
        {
            // Get binding flags for properties.
            var bindingFlags = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic;

            // Get properties with binding flags.
            var properties = TypeInfo.GetProperties(bindingFlags);

            // Cache all properties and required properties.
            foreach (var propertyInfo in properties)
            {
                // Create property.
                var property = new Property <TEntity>(propertyInfo);

                // If property belongs to entity and is foreign key.
                if (property.IsEntityChild && property.IsForeignKey)
                {
                    // Cache relations.
                    var relationMetadata = EntityMeta <TEntity> .GetPropertyRelations(property);

                    property.CacheRelations(relationMetadata);
                }

                // If property belongs to entity and is it plain field.
                else if (property.IsEntityChild && !property.IsForeignKey)
                {
                    // Get field properties.
                    ColumnMetadata columnMetada = EntityMeta <TEntity> .GetFieldAttributes(property);

                    // Set field properties.
                    property.AssignFieldProperty(columnMetada);

                    // Cache data reader specific get value method.
                    property.CacheDataReaderGetValue();
                }

                // Add to collection.
                Properties.Add(propertyInfo.Name, property);

                // To required collection.
                if ((property.IsRequired || property.IsPrimaryKey) && !property.IsIdentity && !property.IsLanguageCode)
                {
                    RequiredProperties.Add(property);
                }
            }
        }
Ejemplo n.º 12
0
        internal virtual Validation GetRequiredProperties(Method method)
        {
            var props = new RequiredProperties();

            switch (method)
            {
            case Method.ExcelBulkImport:
            case Method.ExcelImport:
                props.Add(_serviceObject.Properties[PropertyConstants.File]);
                props.Add(_serviceObject.Properties[PropertyConstants.SmartObjectName]);
                break;

            case Method.ExcelBulkImportWithTransaction:
            case Method.ExcelImportWithTransaction:
                props.Add(_serviceObject.Properties[PropertyConstants.File]);
                props.Add(_serviceObject.Properties[PropertyConstants.SmartObjectName]);
                props.Add(_serviceObject.Properties[PropertyConstants.TransactionIdProperty]);
                props.Add(_serviceObject.Properties[PropertyConstants.TransactionIdValue]);
                break;

            case Method.CsvBulkImport:
            case Method.CsvImport:
                props.Add(_serviceObject.Properties[PropertyConstants.File]);
                props.Add(_serviceObject.Properties[PropertyConstants.SmartObjectName]);
                break;

            case Method.CsvBulkImportWithTransaction:
            case Method.CsvImportWithTransaction:
                props.Add(_serviceObject.Properties[PropertyConstants.File]);
                props.Add(_serviceObject.Properties[PropertyConstants.SmartObjectName]);
                props.Add(_serviceObject.Properties[PropertyConstants.TransactionIdProperty]);
                props.Add(_serviceObject.Properties[PropertyConstants.TransactionIdValue]);
                break;
            }

            var validation = new Validation
            {
                RequiredProperties = props
            };

            return(validation);
        }
Ejemplo n.º 13
0
        /// <summary>
        /// <para>
        ///     Sets the property as a required property for the model.
        ///     When a database action is ran it will check for these constraints.
        /// </para>
        /// <para>
        ///     If the property given is set to be ignored, it will not add the given property to the list of required properties
        /// </para>
        /// </summary>
        /// <param name="property">The property to set required</param>
        public void IsRequired(Expression <Func <TModel, object> > property)
        {
            // Get the property from the expression
            MemberInfo prop = ((property.Body as UnaryExpression)?.Operand as MemberExpression)?.Member;

            // If the property is already set as ignored
            // Return and do nothing
            if (IgnoredProperties.Contains(prop))
            {
                return;
            }

            // If the property is already set to be required
            // Return and do nothing
            if (RequiredProperties.Contains(prop))
            {
                return;
            }

            // Add the property to the ignored properties
            RequiredProperties.Add(prop);
        }
        internal virtual Validation GetRequiredProperties(string method)
        {
            RequiredProperties props      = new RequiredProperties();
            Validation         validation = null;

            validation = new Validation();
            switch (method)
            {
            case "GetWorklistItems":
            {
                break;
            }

            case "LoadWorklistItem":
            {
                props.Add(this._svcObject.Properties["SerialNumber"]);
                break;
            }
            }
            validation.RequiredProperties = props;
            return(validation);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// SmartObject execution. HTTP calls and mapping return xml to SmartObject properties
        /// </summary>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            if (serviceObject.Methods[0].Name.Equals("getmailbox") || serviceObject.Methods[0].Name.Equals("getinbox"))
            {
                Mailbox mailbox = new Mailbox(serviceBroker);
                mailbox.GetMailbox(inputs, required, returns, methodType, serviceObject);
            }



            if (serviceObject.Methods[0].Name.Equals("getallmessages") || serviceObject.Methods[0].Name.Equals("getmessages") || serviceObject.Methods[0].Name.Equals("searchmessagesbysubject") || serviceObject.Methods[0].Name.Equals("searchmessagesbybody") || serviceObject.Methods[0].Name.Equals("searchmessagesbyfrom"))
            {
                MailMessage msg = new MailMessage(serviceBroker);
                msg.GetMessages(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("getmessagebyuid") || serviceObject.Methods[0].Name.Equals("getmessagebysubject"))
            {
                MailMessage msg = new MailMessage(serviceBroker);
                msg.GetMessageBy(inputs, required, returns, methodType, serviceObject);
            }



            if (serviceObject.Methods[0].Name.Equals("getallattachments"))
            {
                MailAttachment attach = new MailAttachment(serviceBroker);
                attach.GetAllAttachments(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("getattachment"))
            {
                MailAttachment attach = new MailAttachment(serviceBroker);
                attach.GetAttachment(inputs, required, returns, methodType, serviceObject);
            }
        }
Ejemplo n.º 16
0
        public void GetMailbox(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            Helper h = new Helper(serviceBroker);

            try
            {
                using (var ic = h.GetImapClient())
                {
                    string mailbox = string.Empty;
                    if (serviceObject.Methods[0].Name.Equals("getmailbox"))
                    {
                        mailbox = inputs.Where(p => p.Name.Equals("name")).FirstOrDefault().Value.ToString();
                    }
                    else
                    {
                        mailbox = "INBOX";
                    }


                    AE.Net.Mail.Imap.Mailbox mb = ic.SelectMailbox(mailbox);

                    returns.Where(p => p.Name.Equals("name")).FirstOrDefault().Value                   = mb.Name;
                    returns.Where(p => p.Name.Equals("numberofmessages")).FirstOrDefault().Value       = mb.NumMsg;
                    returns.Where(p => p.Name.Equals("numberofnewmessages")).FirstOrDefault().Value    = mb.NumNewMsg;
                    returns.Where(p => p.Name.Equals("numberofunseenmessages")).FirstOrDefault().Value = mb.NumUnSeen;
                    returns.Where(p => p.Name.Equals("iswritable")).FirstOrDefault().Value             = mb.IsWritable;

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                serviceObject.Properties.BindPropertiesToResultTable();
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 17
0
        public void ExecuteListOtherSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            Dictionary <string, string> SourceIds = new Dictionary <string, string>();

            SourceIds.Add("64cde128-76be-4943-b960-146e613a7e1e", "InternetSearchResults");
            SourceIds.Add("1dd9c4dc-8a6a-48a2-88b7-54dc3d97bf15", "InternetSearchSuggestions");
            SourceIds.Add("495318b6-0d9a-4d0f-939b-41cc17b49abd", "LocalPeopleSearchIndex");
            SourceIds.Add("5b557a96-b0ef-443c-8f55-fdcceb1e142a", "LocalSearchIndex");

            foreach (var Source in SourceIds)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"]   = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }
        }
        public void ExecuteSearchRead(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            SPExecute Excute = new SPExecute(this.serviceBroker, this.Configuration);

            Excute.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
        }
 public static RESTSearchResultsSerialized ExecuteSharePointUserSearch(Property[] inputs, RequiredProperties required, Configuration Configuration, ServiceAssemblyBase serviceBroker)
 {
     SearchInputs SearchInputs = Utilities.BrokerUtils.GetUserSearchInputs(inputs);
     return ExecuteSearch(SearchInputs, Configuration, serviceBroker);
 }
        public void ExecuteListSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            Dictionary<string, string> SourceIds = new Dictionary<string, string>();
            SourceIds.Add("8413cd39-2156-4e00-b54d-11efd9abdb89", "Local SharePoint Results");
            SourceIds.Add("b09a7990-05ea-4af9-81ef-edfab16c4e31", "Local People Results");
            SourceIds.Add("203fba36-2763-4060-9931-911ac8c0583b", "Local Reports And Data Results");
            SourceIds.Add("78b793ce-7956-4669-aa3b-451fc5defebf", "Local Video Results");
            SourceIds.Add("e7ec8cee-ded8-43c9-beb5-436b54b31e84", "Documents");
            SourceIds.Add("5dc9f503-801e-4ced-8a2c-5d1237132419", "Items matching a content type");
            SourceIds.Add("e1327b9c-2b8c-4b23-99c9-3730cb29c3f7", "Items matching a tag");
            SourceIds.Add("48fec42e-4a92-48ce-8363-c2703a40e67d", "Items related to current user");
            SourceIds.Add("5c069288-1d17-454a-8ac6-9c642a065f48", "Items with same keyword as this item");
            SourceIds.Add("5e34578e-4d08-4edc-8bf3-002acf3cdbcc", "Pages");
            SourceIds.Add("38403c8c-3975-41a8-826e-717f2d41568a", "Pictures");
            SourceIds.Add("97c71db1-58ce-4891-8b64-585bc2326c12", "Popular");
            SourceIds.Add("ba63bbae-fa9c-42c0-b027-9a878f16557c", "Recently changed items");
            SourceIds.Add("ec675252-14fa-4fbe-84dd-8d098ed74181", "Recommended Items");
            SourceIds.Add("9479bf85-e257-4318-b5a8-81a180f5faa1", "Wiki");

            foreach (var Source in SourceIds)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"] = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }

        }
        public void GetMessages(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            System.Data.DataRow dr;
            Helper h = new Helper(serviceBroker);

            string subjectfilter = string.Empty;
            string bodyfilter    = string.Empty;
            string fromfilter    = string.Empty;

            string startindex       = string.Empty;
            string numberofmessages = string.Empty;

            string mailbox     = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            bool   headersonly = bool.Parse(inputs.Where(p => p.Name.Equals("headersonly")).FirstOrDefault().Value.ToString());
            bool   setseen     = bool.Parse(inputs.Where(p => p.Name.Equals("setseen")).FirstOrDefault().Value.ToString());;

            AE.Net.Mail.MailMessage mtemp = new AE.Net.Mail.MailMessage();
            try
            {
                using (var ic = h.GetImapClient())
                {
                    AE.Net.Mail.MailMessage[]        m  = null;
                    Lazy <AE.Net.Mail.MailMessage>[] mm = null;

                    bool isLazy = false;

                    switch (serviceObject.Methods[0].Name.ToLower())
                    {
                    case "getallmessages":
                        m      = ic.GetMessages(0, ic.GetMessageCount(), headersonly, setseen);
                        isLazy = false;
                        break;

                    case "getmessages":
                        startindex       = inputs.Where(p => p.Name.Equals("startindex")).FirstOrDefault().Value.ToString();
                        numberofmessages = inputs.Where(p => p.Name.Equals("numberofmessages")).FirstOrDefault().Value.ToString();
                        m      = ic.GetMessages(int.Parse(startindex), int.Parse(numberofmessages), headersonly, setseen);
                        isLazy = false;
                        break;

                    case "searchmessagesbysubject":
                        subjectfilter = inputs.Where(p => p.Name.Equals("subjectfilter")).FirstOrDefault().Value.ToString();
                        mm            = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Subject(subjectfilter)));
                        isLazy        = true;
                        break;

                    case "searchmessagesbybody":
                        bodyfilter = inputs.Where(p => p.Name.Equals("bodyfilter")).FirstOrDefault().Value.ToString();
                        mm         = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Body(bodyfilter))).ToArray();
                        isLazy     = true;
                        break;

                    case "searchmessagesbyfrom":
                        fromfilter = inputs.Where(p => p.Name.Equals("fromfilter")).FirstOrDefault().Value.ToString();
                        mm         = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.From(fromfilter))).ToArray();
                        isLazy     = true;
                        break;
                    }

                    //AE.Net.Mail.MailMessage[] mm = ic.GetMessages(0, ic.GetMessageCount(), headersonly, setseen);

                    if (isLazy)
                    {
                        foreach (System.Lazy <AE.Net.Mail.MailMessage> msg in mm)
                        {
                            AE.Net.Mail.MailMessage mmsg = msg.Value;
                            dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                            MapMailMessage(dr, mmsg);

                            dr["mailbox"]     = mailbox;
                            dr["headersonly"] = headersonly;
                            dr["setseen"]     = setseen;

                            switch (serviceObject.Methods[0].Name.ToLower())
                            {
                            case "searchmessagesbysubject":
                                dr["subjectfilter"] = subjectfilter;
                                break;

                            case "searchmessagesbybody":
                                dr["bodyfilter"] = bodyfilter;
                                break;

                            case "searchmessagesbyfrom":
                                dr["fromfilter"] = fromfilter;
                                break;
                            }


                            dr["startindex"]       = startindex;
                            dr["numberofmessages"] = numberofmessages;

                            serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                        }
                    }
                    else
                    {
                        foreach (AE.Net.Mail.MailMessage msg in m.OrderByDescending(p => p.Date))
                        {
                            mtemp = msg;
                            dr    = serviceBroker.ServicePackage.ResultTable.NewRow();

                            MapMailMessage(dr, msg);

                            dr["mailbox"]     = mailbox;
                            dr["headersonly"] = headersonly;
                            dr["setseen"]     = setseen;
                            switch (serviceObject.Methods[0].Name.ToLower())
                            {
                            case "searchmessagesbysubject":
                                dr["subjectfilter"] = subjectfilter;
                                break;

                            case "searchmessagesbybody":
                                dr["bodyfilter"] = bodyfilter;
                                break;

                            case "searchmessagesbyfrom":
                                dr["fromfilter"] = fromfilter;
                                break;
                            }
                            dr["startindex"]       = startindex;
                            dr["numberofmessages"] = numberofmessages;

                            serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                        }
                    }

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(mtemp.Subject);
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            //serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 22
0
        public void ExecuteCreateTask(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Functions.CRMFunctions CRMFunctions = new Functions.CRMFunctions(Utilities.FunctionsUtils.GetCRMConfig(serviceBroker.Service.ServiceConfiguration));

            Functions.CRMTask CRMTaskInput = new Functions.CRMTask();
            Functions.CRMTask CRMTaskResult = null;

            try
            {

                PropertyInfo[] PropInfoCRMTask = CRMTaskResult.GetType().GetProperties(BindingFlags.Public);

                foreach (Property prop in inputs)
                {
                    if (prop.Value != null)
                    {
                        //PropertyInfo RefProp = PropInfoCRMTask.Where(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).First();
                        PropertyInfo RefProp = PropInfoCRMTask.GetType().GetProperty(prop.Name);
                        if (RefProp != null)
                        {
                            //prop.Value = Utilities.ReflectionUtils.GetPropValue(CRMTaskResult, RefProp.Name);
                            Utilities.ReflectionUtils.SetPropValue<Functions.CRMTask>(CRMTaskInput, prop.Name, prop.Value);

                        }
                    }
                }


                //required
                //CRMTaskInput.Category = inputs.Where(p => p.Name.Equals("category", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                //CRMTaskInput.Description = inputs.Where(p => p.Name.Equals("description", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                ////required
                //CRMTaskInput.DueDate = DateTime.Parse(inputs.Where(p => p.Name.Equals("duedate", StringComparison.OrdinalIgnoreCase)).First().Value.ToString());

                ////required
                //CRMTaskInput.Duration = int.Parse(inputs.Where(p => p.Name.Equals("duration", StringComparison.OrdinalIgnoreCase)).First().Value.ToString());
                
                //CRMTaskInput.OwnerFQN = inputs.Where(p => p.Name.Equals("ownerfqn", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                //CRMTaskInput.Owner = inputs.Where(p => p.Name.Equals("owner", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                //CRMTaskInput.OwnerId = inputs.Where(p => p.Name.Equals("ownerid", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                ////required
                //CRMTaskInput.Priority = int.Parse(inputs.Where(p => p.Name.Equals("priority", StringComparison.OrdinalIgnoreCase)).First().Value.ToString());
                
                //CRMTaskInput.Regarding = inputs.Where(p => p.Name.Equals("regarding", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                //CRMTaskInput.RegardingId = inputs.Where(p => p.Name.Equals("regardingid", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                ////required
                //CRMTaskInput.State = int.Parse(inputs.Where(p => p.Name.Equals("state", StringComparison.OrdinalIgnoreCase)).First().Value.ToString());
                
                ////required
                //CRMTaskInput.Status = int.Parse(inputs.Where(p => p.Name.Equals("status", StringComparison.OrdinalIgnoreCase)).First().Value.ToString());
                
                ////required
                //CRMTaskInput.Subcategory = inputs.Where(p => p.Name.Equals("subcategory", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                ////required
                //CRMTaskInput.Subject = inputs.Where(p => p.Name.Equals("subject", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                
                //CRMTaskInput.K2SerialNumber = inputs.Where(p => p.Name.Equals("k2serialnumber", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                //CRMTaskInput.K2ProcessName = inputs.Where(p => p.Name.Equals("k2processname", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();
                //CRMTaskInput.K2ActivityName = inputs.Where(p => p.Name.Equals("k2activityname", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();

                //int procInstId;
                //if (int.TryParse(inputs.Where(p => p.Name.Equals("k2processinstanceid", StringComparison.OrdinalIgnoreCase)).First().Value.ToString(), out procInstId))
                //{
                //    CRMTaskInput.K2ProcessInstanceId = procInstId;
                //}
                
                CRMTaskResult = CRMFunctions.CRMCreateTask(CRMTaskInput);

                //List<string> OProps = new List<string>();
                //OProps.Where(p => p == "").First();

                if (CRMTaskResult != null)
                {

                    //foreach(PropertyInfo prop in CRMTaskResult.GetType().GetProperties(BindingFlags.Public))
                    foreach(Property prop in returns)
                    {
                        //PropertyInfo RefProp = PropInfoCRMTask.Where(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).First();
                        PropertyInfo RefProp = PropInfoCRMTask.GetType().GetProperty(prop.Name);
                        if( RefProp != null)
                        {
                            prop.Value = Utilities.ReflectionUtils.GetPropValue(CRMTaskResult, RefProp.Name);
                        }

                        //PropertyInfo aa = PropInfoCRMTask.Where(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).First();


                        //if (returns.Where(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).First() != null)
                        //{
                        //    returns.Where(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).First().Value = Utilities.ReflectionUtils.GetPropValue(CRMTaskResult, prop.Name);
                        //}

                    }
                    returns.Where(p => p.Name.Equals("responsestatus")).First().Value = ResponseStatus.Success;
                }
                else
                {
                    throw new Exception("CRMTaskResult is null.");
                }

            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }

            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public static RESTSearchResultsSerialized ExecuteSharePointUserSearch(Property[] inputs, RequiredProperties required, Configuration Configuration, ServiceAssemblyBase serviceBroker)
        {
            SearchInputs SearchInputs = Utilities.BrokerUtils.GetUserSearchInputs(inputs);

            return(ExecuteSearch(SearchInputs, Configuration, serviceBroker));
        }
Ejemplo n.º 24
0
        public void ListQueues(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();
            NamespaceManager namespaceManager = null;

            System.Data.DataRow dr;
            try
            {
                namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());
                IEnumerable <QueueDescription> Qs = namespaceManager.GetQueues();

                foreach (QueueDescription Queue in Qs)
                {
                    dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                    foreach (Property prop in returns)
                    {
                        switch (prop.Name)
                        {
                        case "defaultmessagetimetolive":
                            dr[prop.Name] = Queue.DefaultMessageTimeToLive.TotalSeconds;
                            break;

                        case "duplicatedetectionhistorytimewindow":
                            dr[prop.Name] = Queue.DuplicateDetectionHistoryTimeWindow.TotalSeconds;
                            break;

                        case "enablebatchedoperations":
                            prop.Value = Queue.EnableBatchedOperations;
                            break;

                        case "enabledeadletteringonmessageexpiration":
                            dr[prop.Name] = Queue.EnableDeadLetteringOnMessageExpiration;
                            break;

                        case "isreadonly":
                            dr[prop.Name] = Queue.IsReadOnly;
                            break;

                        case "lockduration":
                            dr[prop.Name] = Queue.LockDuration.TotalSeconds;
                            break;

                        case "maxdeliverycount":
                            dr[prop.Name] = Queue.MaxDeliveryCount;
                            break;

                        case "maxsizeinmegabytes":
                            dr[prop.Name] = Queue.MaxSizeInMegabytes;
                            break;

                        case "messagecount":
                            dr[prop.Name] = Queue.MessageCount;
                            break;

                        case "queue":
                            dr[prop.Name] = Queue.Path;
                            break;

                        case "requiresduplicatedetection":
                            dr[prop.Name] = Queue.RequiresDuplicateDetection;
                            break;

                        case "requiressession":
                            dr[prop.Name] = Queue.RequiresSession;
                            break;

                        case "sizeinbytes":
                            dr[prop.Name] = Queue.SizeInBytes;
                            break;
                        }
                    }
                    dr["responsestatus"]            = ResponseStatus.Success;
                    dr["responsestatusdescription"] = "Queues listed";
                    serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                }
            }
            catch (Exception ex)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                dr["responsestatus"]            = ResponseStatus.Error;
                dr["responsestatusdescription"] = ex.Message;
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                return;
            }
            finally
            {
                namespaceManager = null;
            }
        }
Ejemplo n.º 25
0
        public void ExecuteGetUser(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Functions.CRMFunctions CRMFunctions = new Functions.CRMFunctions(Utilities.FunctionsUtils.GetCRMConfig(serviceBroker.Service.ServiceConfiguration));

            Functions.CRMUser CRMUserInput = new Functions.CRMUser();
            Functions.CRMUser CRMUserResult = null;
            
            try
            {
                CRMUserInput.UserFQN = inputs.Where(p => p.Name.Equals("userfqn", StringComparison.OrdinalIgnoreCase)).First().Value.ToString();

                CRMUserResult = CRMFunctions.CRMGetUser(CRMUserInput);

                if (CRMUserResult != null)
                {
                    returns.Where(p => p.Name.Equals("userfqn")).First().Value = CRMUserInput.UserFQN;
                    returns.Where(p => p.Name.Equals("userid")).First().Value = CRMUserResult.UserId;
                    returns.Where(p => p.Name.Equals("responsestatus")).First().Value = ResponseStatus.Success;
                }
                else
                {
                    throw new Exception("CRMUserResult is null.");
                }

            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }
                        
            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public void ListEventHubs(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();
            NamespaceManager namespaceManager = null;

            System.Data.DataRow dr;
            try
            {
                namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());
                IEnumerable <EventHubDescription> EHs = namespaceManager.GetEventHubs();

                foreach (EventHubDescription EventHub in EHs)
                {
                    dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                    foreach (Property prop in returns)
                    {
                        switch (prop.Name)
                        {
                        case "createdat":
                            dr[prop.Name] = EventHub.CreatedAt;
                            break;

                        case "isreadonly":
                            dr[prop.Name] = EventHub.IsReadOnly;
                            break;

                        case "messageretentionindays":
                            prop.Value = EventHub.MessageRetentionInDays;
                            break;

                        case "partitioncount":
                            dr[prop.Name] = EventHub.PartitionCount;
                            break;

                        case "partitionids":
                            dr[prop.Name] = string.Join(",", EventHub.PartitionIds);
                            break;

                        case "path":
                            dr[prop.Name] = EventHub.Path;
                            break;

                        case "status":
                            dr[prop.Name] = EventHub.Status.ToString();
                            break;

                        case "updatedat":
                            dr[prop.Name] = EventHub.UpdatedAt;
                            break;

                        case "usermetadata":
                            dr[prop.Name] = EventHub.UserMetadata;
                            break;

                        case "eventhub":
                            dr[prop.Name] = EventHub.Path;
                            break;
                        }
                    }
                    dr["responsestatus"]            = ResponseStatus.Success;
                    dr["responsestatusdescription"] = "Event Hubs listed";
                    serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                }
            }
            catch (Exception ex)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                dr["responsestatus"]            = ResponseStatus.Error;
                dr["responsestatusdescription"] = ex.Message;
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                return;
            }
            finally
            {
                namespaceManager = null;
            }
        }
        public void CreateEventHubs(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();

            NamespaceManager    namespaceManager = null;
            EventHubDescription ReturnEventHub   = null;

            try
            {
                string eventhubpath = string.Empty;
                if (inputs.Length == 0)
                {
                    eventhubpath = serviceObject.MetaData.DisplayName;
                }
                else
                {
                    eventhubpath = inputs.Where(p => p.Name.Equals("eventhub")).First().Value.ToString();
                }

                namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());

                if (serviceObject.Methods[0].Name.Equals("createeventhubfulldetails"))
                {
                    EventHubDescription EventHub = new EventHubDescription(eventhubpath);

                    foreach (Property prop in inputs)
                    {
                        if (prop.Value != null)
                        {
                            switch (prop.Name)
                            {
                            case "eventhub":
                                EventHub.Path = eventhubpath;
                                break;

                            case "partitioncount":
                                EventHub.PartitionCount = int.Parse(prop.Value.ToString());
                                break;

                            case "messageretentionindays":
                                EventHub.MessageRetentionInDays = int.Parse(prop.Value.ToString());
                                break;
                            }
                        }
                    }

                    ReturnEventHub = namespaceManager.CreateEventHub(EventHub);
                }
                else
                {
                    // create with defaults
                    ReturnEventHub = namespaceManager.CreateEventHub(eventhubpath);
                }

                foreach (Property prop in returns)
                {
                    switch (prop.Name)
                    {
                    case "createdat":
                        prop.Value = ReturnEventHub.CreatedAt;
                        break;

                    case "isreadonly":
                        prop.Value = ReturnEventHub.IsReadOnly;
                        break;

                    case "messageretentionindays":
                        prop.Value = ReturnEventHub.MessageRetentionInDays;
                        break;

                    case "partitioncount":
                        prop.Value = ReturnEventHub.PartitionCount;
                        break;

                    case "partitionids":
                        prop.Value = string.Join(",", ReturnEventHub.PartitionIds);
                        break;

                    case "path":
                        prop.Value = ReturnEventHub.Path;
                        break;

                    case "status":
                        prop.Value = ReturnEventHub.Status.ToString();
                        break;

                    case "updatedat":
                        prop.Value = ReturnEventHub.UpdatedAt;
                        break;

                    case "usermetadata":
                        prop.Value = ReturnEventHub.UserMetadata;
                        break;
                    }
                }
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Success;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = "Event Hub created";
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }
            finally
            {
                namespaceManager = null;
            }

            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public void SendEventHubMessage(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();

            EventHubClient Client    = null;
            EventData      eventData = null;

            try
            {
                string eventhubpath = string.Empty;
                if (inputs.Length == 0)
                {
                    eventhubpath = serviceObject.MetaData.DisplayName;
                }
                else
                {
                    eventhubpath = inputs.Where(p => p.Name.Equals("eventhub")).First().Value.ToString();
                }

                if (inputs.Where(p => p.Name.Equals("data")).Count() > 0)
                {
                    string msgBody = inputs.Where(p => p.Name.Equals("data")).First().Value.ToString();
                    eventData = new EventData(new MemoryStream(Encoding.UTF8.GetBytes(msgBody)));
                }
                else
                {
                    throw new Exception("Data is required to send an Event Hub Message");
                }

                Client = serviceUtilities.GetEventHubClient(eventhubpath);
                Client.Send(eventData);


                //foreach (Property prop in returns)
                //{
                //    switch (prop.Name)
                //    {
                //        case "createdat":
                //            prop.Value = Client.CreatedAt;
                //            break;
                //        case "isreadonly":
                //            prop.Value = Client.IsReadOnly;
                //            break;
                //        case "messageretentionindays":
                //            prop.Value = Client.MessageRetentionInDays;
                //            break;
                //        case "partitioncount":
                //            prop.Value = Client.PartitionCount;
                //            break;
                //        case "partitionids":
                //            prop.Value = string.Join(",", Client.PartitionIds);
                //            break;
                //        case "path":
                //            prop.Value = Client.Path;
                //            break;
                //        case "status":
                //            prop.Value = Client.Status.ToString();
                //            break;
                //        case "updatedat":
                //            prop.Value = Client.UpdatedAt;
                //            break;
                //        case "usermetadata":
                //            prop.Value = Client.UserMetadata;
                //            break;
                //    }
                //}

                returns.Where(p => p.Name.Equals("eventhub")).First().Value                  = inputs.Where(p => p.Name.Equals("eventhub")).First().Value.ToString();
                returns.Where(p => p.Name.Equals("data")).First().Value                      = inputs.Where(p => p.Name.Equals("data")).First().Value.ToString();
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Success;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = "Event Hub message sent";
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }
            finally
            {
                try
                {
                    Client.Close();
                }
                catch { }
                Client = null;
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, SourceCode.SmartObjects.Services.ServiceSDK.Types.MethodType methodType, ServiceObject serviceObject)
        {
            #region Get All Field Values

            if (serviceObject.Methods[0].Name.Equals("getallfieldvalues"))
            {
                serviceObject.Properties.InitResultTable();

                // get input field value
                string pdfuri = inputs.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value.ToString();

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                try
                {
                    using (PdfReader doc = new PdfReader(pdfUri))
                    {
                        // discover pdf doc
                        info = GetPDFDoucmentInformation(doc);
                        fields = GetPDFFormFields(doc, true);
                    }
                }
                catch(Exception ex)
                {
                    throw new Exception(string.Format("Error retrieving PDF document from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                returns.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value = pdfuri;

                foreach(Property prop in returns)
                {
                    PDFField fieldvalue = new PDFField();

                    string fullname = string.Empty;

                    object pfn = prop.MetaData.ServiceProperties["pdffullname"];
                    if (pfn == null)
                    {
                        fullname = prop.Name;
                    }
                    else
                    {
                        fullname = pfn.ToString();
                    }

                    if (fields.TryGetValue(fullname, out fieldvalue))
                    {
                        prop.Value = fieldvalue.FieldValue;
                    }
                }

                Type type = typeof(PDFInfo);
                PropertyInfo[] props = type.GetProperties();
                foreach (var p in props)
                {
                    object v = info.GetType().GetProperty(p.Name).GetValue(info, null);
                    if (v != null)
                    {
                        string value = v.ToString();
                        returns.Where(q => q.Name.Equals(p.Name)).First().Value = value;
                    }
                }

                serviceObject.Properties.BindPropertiesToResultTable();

            }

            #endregion Get All Field Values

            #region Contains Signatures

            if (serviceObject.Methods[0].Name.Equals("containssignatures"))
            {
                serviceObject.Properties.InitResultTable();

                // get input field value
                string pdfuri = inputs.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value.ToString();

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                bool containssigs = false;

                try
                {
                    using (PdfReader doc = new PdfReader(pdfUri))
                    {
                        fields = GetPDFFormFields(doc, true);
                        containssigs = ContainsSignatures(fields);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error retrieving PDF document from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                returns.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value = pdfuri;
                returns.Where(p => p.Name.Equals("containssignatures")).FirstOrDefault().Value = containssigs;

                serviceObject.Properties.BindPropertiesToResultTable();

            }

            #endregion Contains Signatures

            #region Contains Unsigned Signatures

            if (serviceObject.Methods[0].Name.Equals("containsunsignedsignatures"))
            {
                serviceObject.Properties.InitResultTable();

                // get input field value
                string pdfuri = inputs.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value.ToString();

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                bool containsunsignedsigs = false;

                try
                {
                    using (PdfReader doc = new PdfReader(pdfUri))
                    {
                        containsunsignedsigs = ContainsBlankSignatures(doc);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error retrieving PDF document from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                returns.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value = pdfuri;
                returns.Where(p => p.Name.Equals("containsunsignedsignatures")).FirstOrDefault().Value = containsunsignedsigs;

                serviceObject.Properties.BindPropertiesToResultTable();

            }

            #endregion Contains Signatures

            #region Update PDF Field

            if (serviceObject.Methods[0].Name.Equals("updatepdffields"))
            {
                serviceObject.Properties.InitResultTable();

                // get input field value
                string pdfuri = inputs.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value.ToString();
                bool base64 = false;
                string base64temp = inputs.Where(p => p.Name.Equals("returnbase64")).FirstOrDefault().Value.ToString();
                bool.TryParse(base64temp, out base64);

                string workingFolder = serviceBroker.Service.ServiceConfiguration["WorkingFolder"].ToString();
                if (workingFolder.LastIndexOf(@"\") != workingFolder.Length - 1)
                {
                    workingFolder += @"\";
                }
                string filename = Guid.NewGuid().ToString()+".pdf";
                string workingPath = workingFolder + filename;

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                Dictionary<string, string> updates = new Dictionary<string, string>();
                foreach (Property prop in inputs)
                {
                    object pfn = prop.MetaData.ServiceProperties["pdffullname"];
                    if (!prop.Name.Equals("pdfuri") && pfn != null)
                    {
                        if (prop.Value != null)
                        {
                            updates.Add(pfn.ToString(), prop.Value.ToString());
                        }
                    }
                }

                if (updates.Count > 0)
                {
                    // call update method
                    using (PdfReader doc = new PdfReader(pdfuri))
                    {
                        // last parameter ensures that extended document properties are retained

                        using (PdfStamper pdfStamper = new PdfStamper(doc, new FileStream(workingPath, FileMode.Create), '\0', true))
                        {
                            AcroFields pdfFormFields = pdfStamper.AcroFields;
                            foreach (KeyValuePair<string, string> val in updates)
                            {
                                pdfFormFields.SetField(val.Key, val.Value);
                            }
                            pdfStamper.FormFlattening = false;
                            pdfStamper.Close();
                        }
                    }
                }

                returns.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value = pdfuri;
                returns.Where(p => p.Name.Equals("returnpath")).FirstOrDefault().Value = workingPath;
                returns.Where(p => p.Name.Equals("returnbase64")).FirstOrDefault().Value = base64;

                // read created doc
                try
                {
                    using (PdfReader doc = new PdfReader(workingPath))
                    {
                        // discover pdf doc
                        info = GetPDFDoucmentInformation(doc);
                        fields = GetPDFFormFields(doc, true);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error retrieving PDF document from {0}. Exception: {1}", workingPath, ex.Message));
                }

                foreach (Property prop in returns)
                {
                    PDFField fieldvalue = new PDFField();

                    string fullname = string.Empty;

                    object pfn = prop.MetaData.ServiceProperties["pdffullname"];
                    if (pfn == null)
                    {
                        fullname = prop.Name;
                    }
                    else
                    {
                        fullname = pfn.ToString();
                    }

                    if (fields.TryGetValue(fullname, out fieldvalue))
                    {
                        prop.Value = fieldvalue.FieldValue;
                    }
                }

                Type type = typeof(PDFInfo);
                PropertyInfo[] props = type.GetProperties();
                foreach (var p in props)
                {
                    object v = info.GetType().GetProperty(p.Name).GetValue(info, null);
                    if (v != null)
                    {
                        string value = v.ToString();
                        returns.Where(q => q.Name.Equals(p.Name)).First().Value = value;
                    }
                }

                // get base64 of file
                if (base64)
                {
                    FileStream fs = new FileStream(workingPath, FileMode.Open, FileAccess.Read);
                    byte[] filebytes = new byte[fs.Length];
                    fs.Read(filebytes, 0, Convert.ToInt32(fs.Length));
                    string encodedData = Convert.ToBase64String(filebytes);
                    returns.Where(p => p.Name.Equals("base64pdf")).FirstOrDefault().Value = encodedData;
                }

                serviceObject.Properties.BindPropertiesToResultTable();
                return;
            }

            #endregion Update PDF Field

            #region Generate Create Table SQL

            if (serviceObject.Methods[0].Name.Equals("generatecreatetablesql"))
            {
                serviceObject.Properties.InitResultTable();

                string pdfuri = serviceBroker.Service.ServiceConfiguration["pdfUri"].ToString();

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                string sql = string.Empty;

                try
                {
                    using (PdfReader doc = new PdfReader(pdfUri))
                    {
                        info = GetPDFDoucmentInformation(doc);
                        fields = GetPDFFormFields(doc, false);
                        sql = GenerateCreateTableSQL(info, fields);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error generating create table SQL from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                returns.Where(p => p.Name.Equals("generatedsql")).FirstOrDefault().Value = sql;

                serviceObject.Properties.BindPropertiesToResultTable();

            }

            #endregion Generate Create Table SQL

            #region Copy Form Data to SmartObject

            if (serviceObject.Methods[0].Name.Equals("copyformdatatosmartobject"))
            {
                serviceObject.Properties.InitResultTable();

                string pdfuri = inputs.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value.ToString();
                string smoname = inputs.Where(p => p.Name.Equals("formstoresmartobjectname")).FirstOrDefault().Value.ToString();
                string smometh = inputs.Where(p => p.Name.Equals("formstoremethodname")).FirstOrDefault().Value.ToString();
                string returnprop = inputs.Where(p => p.Name.Equals("returnidpropertyname")).FirstOrDefault().Value.ToString();

                string returnvalue = string.Empty;

                PDFInfo info = new PDFInfo();
                Dictionary<string, PDFField> fields = new Dictionary<string, PDFField>();

                try
                {
                    using (PdfReader doc = new PdfReader(pdfUri))
                    {
                        info = GetPDFDoucmentInformation(doc);
                        fields = GetPDFFormFields(doc, true);
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error retrieving PDF document from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                string returnId = string.Empty;
                try
                {
                    returnId = Utilities.SmartObjectUtils.CreateDataFromPDFForm(smoname, smometh, returnprop, info, fields);
                }
                catch (Exception ex)
                {
                    throw new Exception(string.Format("Error updated SmartObject from PDF document from {0}. Exception: {1}", pdfuri, ex.Message));
                }

                returns.Where(p => p.Name.Equals("pdfuri")).FirstOrDefault().Value = pdfuri;
                returns.Where(p => p.Name.Equals("formstoresmartobjectname")).FirstOrDefault().Value = smoname;
                returns.Where(p => p.Name.Equals("formstoremethodname")).FirstOrDefault().Value = smometh;
                returns.Where(p => p.Name.Equals("returnidpropertyname")).FirstOrDefault().Value = returnprop;
                returns.Where(p => p.Name.Equals("returnid")).FirstOrDefault().Value = returnId;

                serviceObject.Properties.BindPropertiesToResultTable();

            }

            #endregion Copy Form Data to SmartObject
        }
 internal virtual Validation GetRequiredProperties(string method)
 {
     RequiredProperties props = new RequiredProperties();
     Validation validation = null;
     validation = new Validation();
     switch (method)
     {
         case "GetWorklistItems":
             {
                 break;
             }
         case "LoadWorklistItem":
             {
                 props.Add(this._svcObject.Properties["SerialNumber"]);
                 break;
             }
     }
     validation.RequiredProperties = props;
     return validation;
 }
        public void ExecuteSearchRead(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            try
            {
                //SearchInputs SearchInputs = GetInputs(inputs);
                RESTSearchResultsSerialized SerializedResults = new RESTSearchResultsSerialized();

                SerializedResults = ExecuteSharePointSearch(inputs, required, returns, methodType, serviceObject);

                if (SerializedResults != null)
                {
                    if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Search))
                    {
                        returns.Where(p => p.Name.Equals("search", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.Search;
                    }

                    if (SerializedResults.Inputs.StartRow.HasValue && SerializedResults.Inputs.StartRow.Value > -1)
                    {
                        returns.Where(p => p.Name.Equals("startrow", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.StartRow.Value;
                    }

                    if (SerializedResults.Inputs.RowLimit.HasValue && SerializedResults.Inputs.RowLimit.Value > 0)
                    {
                        returns.Where(p => p.Name.Equals("rowlimit", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.RowLimit.Value;
                    }

                    if (SerializedResults.Inputs.SourceId != null && SerializedResults.Inputs.SourceId != Guid.Empty)
                    {
                        returns.Where(p => p.Name.Equals("sourceid", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.SourceId;
                    }

                    if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SortString))
                    {
                        returns.Where(p => p.Name.Equals("sort", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.SortString;
                    }

                    if (SerializedResults.Inputs.EnableNicknames.HasValue && SerializedResults.Inputs.EnableNicknames.Value)
                    {
                        returns.Where(p => p.Name.Equals("enablenicknames", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnableNicknames.Value;
                    }

                    if (SerializedResults.Inputs.EnablePhonetic.HasValue && SerializedResults.Inputs.EnablePhonetic.Value)
                    {
                        returns.Where(p => p.Name.Equals("enablephonetic", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnablePhonetic.Value;
                    }

                    if (SerializedResults.ExecutionTime.HasValue)
                    {
                        returns.Where(p => p.Name.Equals("executiontime", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ExecutionTime.Value;
                    }

                    if (SerializedResults.ResultRows.HasValue)
                    {
                        returns.Where(p => p.Name.Equals("resultrows", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ResultRows.Value;
                    }

                    if (SerializedResults.TotalRows.HasValue)
                    {
                        returns.Where(p => p.Name.Equals("totalrows", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.TotalRows.Value;
                    }

                    returns.Where(p => p.Name.Equals("resulttitle", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ResultTitle;
                    returns.Where(p => p.Name.Equals("resulttitleurl", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ResultTitleUrl;
                    returns.Where(p => p.Name.Equals("tabletype", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.TableType;
                    returns.Where(p => p.Name.Equals("spellingsuggestions", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.SpellingSuggestions;

                    //string resultsJson = JsonConvert.SerializeObject(results.Value[0].ResultRows);
                    string resultsJson = JsonConvert.SerializeObject(SerializedResults);

                    returns.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First().Value = resultsJson;

                    returns.Where(p => p.Name.Equals("responsestatus", StringComparison.OrdinalIgnoreCase)).First().Value = ResponseStatus.Success;
                }
                else
                {
                    throw new Exception("No results returned.");
                }
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus", StringComparison.OrdinalIgnoreCase)).First().Value = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription", StringComparison.OrdinalIgnoreCase)).First().Value = ex.Message;
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 32
0
        public void CreateQueues(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
            serviceObject.Properties.InitResultTable();

            NamespaceManager namespaceManager = null;
            QueueDescription ReturnQueue      = null;

            try
            {
                string queuepath = string.Empty;
                if (inputs.Length == 0)
                {
                    queuepath = serviceObject.MetaData.DisplayName;
                }
                else
                {
                    queuepath = inputs.Where(p => p.Name.Equals("queue")).First().Value.ToString();
                }

                namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());

                if (serviceObject.Methods[0].Name.Equals("createqueuefulldetails"))
                {
                    QueueDescription Queue = new QueueDescription(queuepath);

                    foreach (Property prop in inputs)
                    {
                        if (prop.Value != null)
                        {
                            switch (prop.Name)
                            {
                            case "queue":
                                Queue.Path = queuepath;
                                break;

                            case "defaultmessagetimetolive":
                                Queue.DefaultMessageTimeToLive = new TimeSpan(long.Parse(prop.Value.ToString()) * TimeSpan.TicksPerSecond);
                                break;

                            case "duplicatedetectionhistorytimewindow":
                                Queue.DuplicateDetectionHistoryTimeWindow = new TimeSpan(long.Parse(prop.Value.ToString()) * TimeSpan.TicksPerSecond);
                                break;

                            case "lockduration":
                                Queue.LockDuration = new TimeSpan(long.Parse(prop.Value.ToString()) * TimeSpan.TicksPerSecond);
                                break;

                            case "maxsizeinmegabytes":
                                Queue.MaxSizeInMegabytes = long.Parse(prop.Value.ToString());
                                break;

                            case "enabledeadletteringonmessageexpiration":
                                Queue.EnableDeadLetteringOnMessageExpiration = bool.Parse(prop.Value.ToString());
                                break;

                            case "requiresduplicatedetection":
                                Queue.RequiresDuplicateDetection = bool.Parse(prop.Value.ToString());
                                break;

                            case "requiressession":
                                Queue.RequiresSession = bool.Parse(prop.Value.ToString());
                                break;
                            }
                        }
                    }

                    ReturnQueue = namespaceManager.CreateQueue(Queue);
                }
                else
                {
                    // create with defaults
                    ReturnQueue = namespaceManager.CreateQueue(queuepath);
                }

                foreach (Property prop in returns)
                {
                    switch (prop.Name)
                    {
                    case "defaultmessagetimetolive":
                        prop.Value = ReturnQueue.DefaultMessageTimeToLive.TotalSeconds;
                        break;

                    case "duplicatedetectionhistorytimewindow":
                        prop.Value = ReturnQueue.DuplicateDetectionHistoryTimeWindow.TotalSeconds;
                        break;

                    case "enablebatchedoperations":
                        prop.Value = ReturnQueue.EnableBatchedOperations;
                        break;

                    case "enabledeadletteringonmessageexpiration":
                        prop.Value = ReturnQueue.EnableDeadLetteringOnMessageExpiration;
                        break;

                    case "isreadonly":
                        prop.Value = ReturnQueue.IsReadOnly;
                        break;

                    case "lockduration":
                        prop.Value = ReturnQueue.LockDuration.TotalSeconds;
                        break;

                    case "maxdeliverycount":
                        prop.Value = ReturnQueue.MaxDeliveryCount;
                        break;

                    case "maxsizeinmegabytes":
                        prop.Value = ReturnQueue.MaxSizeInMegabytes;
                        break;

                    case "messagecount":
                        prop.Value = ReturnQueue.MessageCount;
                        break;

                    case "queue":
                        prop.Value = ReturnQueue.Path;
                        break;

                    case "requiresduplicatedetection":
                        prop.Value = ReturnQueue.RequiresDuplicateDetection;
                        break;

                    case "requiressession":
                        prop.Value = ReturnQueue.RequiresSession;
                        break;

                    case "sizeinbytes":
                        prop.Value = ReturnQueue.SizeInBytes;
                        break;
                    }
                }
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Success;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = "Queue created";
            }
            catch (Exception ex)
            {
                returns.Where(p => p.Name.Equals("responsestatus")).First().Value            = ResponseStatus.Error;
                returns.Where(p => p.Name.Equals("responsestatusdescription")).First().Value = ex.Message;
            }
            finally
            {
                namespaceManager = null;
            }

            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public void ExecuteSearch(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;
            try
            {
                RESTSearchResultsSerialized SerializedResults = null;

                // if deserializesearchresults
                var sps = inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase));
                if (sps.Count() > 0 && inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First() != null && inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First().Value != null)
                {
                    Property SerializedProp = inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First();
                    //if (SerializedProp != null && SerializedProp.Value != null)
                    //{
                    string json = string.Empty;
                    json = SerializedProp.Value.ToString();

                    //IEnumerable<IDictionary<string, object>> searchResults = JsonConvert.DeserializeObject<IEnumerable<IDictionary<string, object>>>(json.Trim());

                    SerializedResults = JsonConvert.DeserializeObject<RESTSearchResultsSerialized>(json.Trim());

                    if (string.IsNullOrWhiteSpace(json) || SerializedResults == null)
                    {
                        throw new Exception("Failed to deserialize search results");
                    }
                    //}
                }
                else
                {
                    // if Search
                    SerializedResults = ExecuteSharePointSearch(inputs, required, returns, methodType, serviceObject);
                }

                if (SerializedResults != null)
                {
                    // needs updating for REST
                    foreach (ResultRow result in SerializedResults.SearchResults.Rows)
                    {
                        dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Search))
                        {
                            dr["search"] = SerializedResults.Inputs.Search;
                        }

                        if (SerializedResults.Inputs.StartRow.HasValue && SerializedResults.Inputs.StartRow.Value > -1)
                        {
                            dr["startrow"] = SerializedResults.Inputs.StartRow.Value;
                        }

                        if (SerializedResults.Inputs.RowLimit.HasValue && SerializedResults.Inputs.RowLimit.Value > 0)
                        {
                            dr["rowlimit"] = SerializedResults.Inputs.RowLimit.Value;
                        }

                        if (SerializedResults.Inputs.SourceId != null && SerializedResults.Inputs.SourceId != Guid.Empty)
                        {
                            dr["sourceid"] = SerializedResults.Inputs.SourceId;
                        }

                        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SortString))
                        {
                            dr["sort"] = SerializedResults.Inputs.SortString;
                        }

                        if (SerializedResults.Inputs.EnableNicknames.HasValue && SerializedResults.Inputs.EnableNicknames.Value)
                        {
                            dr["enablenicknames"] = SerializedResults.Inputs.EnableNicknames.Value;
                        }

                        if (SerializedResults.Inputs.EnablePhonetic.HasValue && SerializedResults.Inputs.EnablePhonetic.Value)
                        {
                            dr["enablephonetic"] = SerializedResults.Inputs.EnablePhonetic.Value;
                        }

                        if (SerializedResults.ExecutionTime.HasValue)
                        {
                            dr["executiontime"] = SerializedResults.ExecutionTime.Value;
                        }

                        if (SerializedResults.ResultRows.HasValue)
                        {
                            dr["resultrows"] = SerializedResults.ResultRows.Value;
                        }
                        if (SerializedResults.TotalRows.HasValue)
                        {
                            dr["totalrows"] = SerializedResults.TotalRows.Value;
                        }
                        dr["resulttitle"] = SerializedResults.ResultTitle;
                        dr["resulttitleurl"] = SerializedResults.ResultTitleUrl;
                        dr["tabletype"] = SerializedResults.TableType;
                        dr["spellingsuggestions"] = SerializedResults.SpellingSuggestions;


                        List<string> missingprops = new List<string>();
                        foreach (ResultCell cell in result.Cells)
                        {
                            if (dr.Table.Columns.Contains(cell.Key.ToLower()))
                            {
                                if (cell.Value != null)
                                {
                                    dr[cell.Key.ToLower()] = cell.Value;
                                }
                            }
                            else
                            {
                                missingprops.Add(cell.Key);
                            }
                        }

                        dr["responsestatus"] = ResponseStatus.Success;
                        serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                    }
                }
                else
                {
                    throw new Exception("No results returned.");
                }

            }
            catch (Exception ex)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                dr["responsestatus"] = ResponseStatus.Error;
                dr["responsestatusdescription"] = ex.Message;
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }

            //serviceObject.Properties.BindPropertiesToResultTable();
        }
        public RESTSearchResultsSerialized ExecuteSharePointSearch(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            ClientResult<ResultTableCollection> results = null;

            SearchInputs SearchInputs = GetInputs(inputs);

            RESTSearchResultsSerialized SerializedResults = new RESTSearchResultsSerialized();
            SerializedResults.Inputs = SearchInputs;



            //KeywordQuery keywordQuery = new KeywordQuery(cc);
            //keywordQuery.QueryText = SearchInputs.Search;

            //SearchExecutor searchExecutor = new SearchExecutor(cc);
            if (SearchInputs.StartRow.HasValue && SearchInputs.StartRow.Value > -1)
            {
                //keywordQuery.StartRow = SearchInputs.StartRow.Value;
            }

            //keywordQuery.RowsPerPage = int.Parse(txtRowsPerPage.Text);
            if (SearchInputs.RowLimit.HasValue && SearchInputs.RowLimit.Value > -1)
            {
                //keywordQuery.RowLimit = SearchInputs.RowLimit.Value;
            }

            //keywordQuery.Culture = Configuration.LocaleId;

            if (SearchInputs.SourceId != null && SearchInputs.SourceId != Guid.Empty)
            {
                //keywordQuery.SourceId = SearchInputs.SourceId;
            }

            if (SearchInputs.Sort.Count > 0)
            {
                
            }

            if (SearchInputs.EnableNicknames.HasValue && SearchInputs.EnableNicknames.Value)
            {
                //keywordQuery.EnableNicknames = SearchInputs.EnableNicknames.Value;
            }

            if (SearchInputs.EnablePhonetic.HasValue && SearchInputs.EnablePhonetic.Value)
            {
                //keywordQuery.EnablePhonetic = SearchInputs.EnablePhonetic.Value;
            }


            // updated for inputs
            RESTSearchResults res = ExecuteRESTRequest(BuildSearchText(SearchInputs));


            if (res != null)
            {

                int executiontime = res.ElapsedTime;

                int totalresults = res.PrimaryQueryResult.RelevantResults.TotalRows;

                int resultrows = res.PrimaryQueryResult.RelevantResults.RowCount;


                SerializedResults.ResultTitle = res.PrimaryQueryResult.RelevantResults.ResultTitle;
                SerializedResults.ResultTitleUrl = res.PrimaryQueryResult.RelevantResults.ResultTitleUrl;
                SerializedResults.SpellingSuggestions = res.SpellingSuggestion;

                SerializedResults.SearchResults = res.PrimaryQueryResult.RelevantResults.Table;


                // set SourceId from execution results
                Guid sid = Guid.Empty;


                SearchProperty SourceId = res.Properties.Where(p => p.Key.Equals("sourceid", StringComparison.InvariantCultureIgnoreCase)).First();
                if (SourceId != null && Guid.TryParse(SourceId.Value, out sid))
                {
                    SerializedResults.Inputs.SourceId = sid;
                }



            }

            return SerializedResults;
        }
 private Validation GetRequiredProperties(string method)
 {
     RequiredProperties properties = new RequiredProperties();
     Validation validation = null;
     validation = new Validation();
     switch (method)
     {
         case "GetWorklistItems":
             {
                 break;
             }
         case "LoadWorklistItem":
             {
                 properties.Add(new Property("SerialNumber", "System.String", SoType.Text, new MetaData("SerialNumber", "SerialNumber")));
                 break;
             }
     }
     validation.RequiredProperties = properties;
     return validation;
 }
        public void ExecuteSearchRead(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            SPExecute Excute = new SPExecute(this.serviceBroker, this.Configuration);
            Excute.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);

            //serviceObject.Properties.InitResultTable();

            //try
            //{
            //    RESTSearchResultsSerialized SerializedResults = new RESTSearchResultsSerialized();

            //    if (serviceObject.Methods[0].Name.Equals("spsearchread"))
            //    {
            //        SerializedResults = Utilities.BrokerUtils.ExecuteSharePointSearch(inputs, required, Configuration, serviceBroker);
            //    }

            //    if (serviceObject.Methods[0].Name.Equals("spsearchrawread"))
            //    {
            //        SerializedResults = Utilities.BrokerUtils.ExecuteSharePointSearchRaw(inputs, required, Configuration, serviceBroker);
            //    }

            //    if (SerializedResults != null)
            //    {
            //        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Search))
            //        {
            //            returns.Where(p => p.Name.Equals("search", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.Search;
            //        }
                    
            //        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SiteUrl))
            //        {
            //            returns.Where(p => p.Name.Equals("searchsiteurl", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.Search;
            //        }
                    
            //        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.FileExtensionsString))
            //        {
            //            returns.Where(p => p.Name.Equals("fileextensionsfilter", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.FileExtensionsString;
            //        }

            //        if (SerializedResults.Inputs.SourceId != null && SerializedResults.Inputs.SourceId != Guid.Empty)
            //        {
            //            returns.Where(p => p.Name.Equals("sourceid", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.SourceId;
            //        }
                    
            //        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SortString))
            //        {
            //            returns.Where(p => p.Name.Equals("sort", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.SortString;
            //        }
                    
            //        if (SerializedResults.Inputs.StartRow.HasValue && SerializedResults.Inputs.StartRow.Value > -1)
            //        {
            //            returns.Where(p => p.Name.Equals("startrow", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.StartRow.Value;
            //        }

            //        if (SerializedResults.Inputs.RowLimit.HasValue && SerializedResults.Inputs.RowLimit.Value > 0)
            //        {
            //            returns.Where(p => p.Name.Equals("rowlimit", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.RowLimit.Value;
            //        }

            //        if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Properties))
            //        {
            //            returns.Where(p => p.Name.Equals("properties", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.Properties;
            //        }

            //        if (SerializedResults.Inputs.EnableStemming.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("enablestemming", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnableStemming.Value;
            //        }

            //        if (SerializedResults.Inputs.TrimDuplicates.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("trimduplicates", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.TrimDuplicates.Value;
            //        }

            //        if (SerializedResults.Inputs.EnableQueryRules.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("enablequeryrules", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnableQueryRules.Value;
            //        }

            //        if (SerializedResults.Inputs.ProcessBestBets.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("processbestbets", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.ProcessBestBets.Value;
            //        }

            //        if (SerializedResults.Inputs.ProcessPersonal.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("processpersonal", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.ProcessPersonal.Value;
            //        }

            //        if (SerializedResults.Inputs.EnableNicknames.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("enablenicknames", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnableNicknames.Value;
            //        }

            //        if (SerializedResults.Inputs.EnablePhonetic.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("enablephonetic", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.Inputs.EnablePhonetic.Value;
            //        }

            //        if (SerializedResults.ExecutionTime.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("executiontime", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ExecutionTime.Value;
            //        }

            //        if (SerializedResults.ResultRows.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("resultrows", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.ResultRows.Value;
            //        }

            //        if (SerializedResults.TotalRows.HasValue)
            //        {
            //            returns.Where(p => p.Name.Equals("totalrows", StringComparison.OrdinalIgnoreCase)).First().Value = SerializedResults.TotalRows.Value;
            //        }

            //        string resultsJson = JsonConvert.SerializeObject(SerializedResults);

            //        returns.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First().Value = resultsJson;

            //        returns.Where(p => p.Name.Equals("responsestatus", StringComparison.OrdinalIgnoreCase)).First().Value = ResponseStatus.Success;
            //    }
            //    else
            //    {
            //        throw new Exception("No results returned.");
            //    }
            //}
            //catch (Exception ex)
            //{
            //    returns.Where(p => p.Name.Equals("responsestatus", StringComparison.OrdinalIgnoreCase)).First().Value = ResponseStatus.Error;
            //    returns.Where(p => p.Name.Equals("responsestatusdescription", StringComparison.OrdinalIgnoreCase)).First().Value = ex.Message;
            //}
            //serviceObject.Properties.BindPropertiesToResultTable();
        }
        public static RESTSearchResultsSerialized ExecuteSharePointSearchRaw(Property[] inputs, RequiredProperties required, Configuration Configuration, ServiceAssemblyBase serviceBroker)
        {
            // Raw search = append input to end of querytext
            SearchInputs SearchInputs = new SearchInputs();
            string       search       = string.Empty;
            var          searchProp   = inputs.Where(p => p.Name.Equals("search", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

            if (searchProp != null && searchProp.Value != null && !string.IsNullOrWhiteSpace(searchProp.Value.ToString()))
            {
                search = searchProp.Value.ToString();
                SearchInputs.Search = search;
            }
            else
            {
                throw new Exception("Search is a required property");
            }

            string RequestUri = Configuration.SiteUrl + "/_api/search/query?querytext=" + search;

            return(ProcessResults(ExecuteRESTRequest(RequestUri, serviceBroker), SearchInputs));
        }
        public void GetMessageBy(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Helper h = new Helper(serviceBroker);

            string mailbox = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid = string.Empty;
            string subjectfilter = string.Empty;                

            AE.Net.Mail.MailMessage m = null;
            try
            {
                using (var ic = h.GetImapClient())
                {

                    switch (serviceObject.Methods[0].Name.ToLower())
                    {
                        case "getmessagebyuid":
                            uid = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();
                            m = ic.GetMessage(uid, false);
                            break;
                        case "getmessagebysubject":
                            subjectfilter = inputs.Where(p => p.Name.Equals("subjectfilter")).FirstOrDefault().Value.ToString();
                            Lazy<AE.Net.Mail.MailMessage>[] mm = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Subject(subjectfilter)));
                            Lazy<AE.Net.Mail.MailMessage> lm = mm.OrderByDescending(p => p.Value.Date).Where(p => p.Value.Subject.ToLower().Equals(subjectfilter)).FirstOrDefault();

                            if (lm != null && lm.Value != null)
                            {
                                m = lm.Value;
                            }
                            
                            break;
                    }

                    // = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }                    

                    returns.Where(p => p.Name.ToLower().Equals("bcc")).FirstOrDefault().Value = GetAddresses(m.Bcc);
                    returns.Where(p => p.Name.ToLower().Equals("body")).FirstOrDefault().Value = m.Body;
                    returns.Where(p => p.Name.ToLower().Equals("cc")).FirstOrDefault().Value = GetAddresses(m.Cc);
                    returns.Where(p => p.Name.ToLower().Equals("date")).FirstOrDefault().Value = m.Date;
                    returns.Where(p => p.Name.ToLower().Equals("from")).FirstOrDefault().Value = m.From != null ? m.From.Address : "";
                    returns.Where(p => p.Name.ToLower().Equals("importance")).FirstOrDefault().Value = m.Importance.ToString();
                    returns.Where(p => p.Name.ToLower().Equals("replyto")).FirstOrDefault().Value = GetAddresses(m.ReplyTo);
                    returns.Where(p => p.Name.ToLower().Equals("sender")).FirstOrDefault().Value = m.Sender != null ? m.Sender.Address : "";
                    returns.Where(p => p.Name.ToLower().Equals("size")).FirstOrDefault().Value = m.Size;
                    returns.Where(p => p.Name.ToLower().Equals("subject")).FirstOrDefault().Value = m.Subject;
                    returns.Where(p => p.Name.ToLower().Equals("to")).FirstOrDefault().Value = GetAddresses(m.To);
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value = m.Uid;
                    //returns.Where(p => p.Name.ToLower().Equals("rawmessage")).FirstOrDefault().Value = m.RawBody;
                    //returns.Where(p => p.Name.ToLower().Equals("base64emlmessage")).FirstOrDefault().Value = m.Base64Body;
                    returns.Where(p => p.Name.ToLower().Equals("attachmentscount")).FirstOrDefault().Value = m.Attachments != null ? m.Attachments.Count : 0;

                    returns.Where(p => p.Name.ToLower().Equals("mailbox")).FirstOrDefault().Value = mailbox;
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value = uid;
                    returns.Where(p => p.Name.ToLower().Equals("subjectfilter")).FirstOrDefault().Value = subjectfilter;

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
        /// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            #region Container


            if (serviceObject.Methods[0].Name.Equals("loadcontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteLoadContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainers"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListContainers(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("createcontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteCreateContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setcontainerpermissions"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteSetPermissions(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setcontainermetadata"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteSetMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("loadcontainermetadatavalue"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteLoadMetadataValue(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainermetadata"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("deletecontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteDeleteContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainerfolders"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListContainerFolders(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Container


            #region Blob


            if (serviceObject.Methods[0].Name.Equals("loadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteLoadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setblobmetadata"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteSetBlobMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("loadblobmetadatavalue"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteLoadBlobMetadataValue(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listblobmetadata"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteListBlobMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("deleteblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDeleteBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfrombase64"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromBase64(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfromfilesystem"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromFilePath(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfromurl"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromUrl(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listblobs"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteListBlobs(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblobtobase64"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlobAsBase64(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblobtofilesystem"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlobToFileSystem(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setblobproperties"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteSetBlobProperties(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Blob
        }
        /// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            this.GetConfiguration();

            if (serviceObject.Methods[0].Name.Equals("spsearch") || serviceObject.Methods[0].Name.Equals("spsearchraw") || serviceObject.Methods[0].Name.Equals("deserializesearchresults"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchread") || serviceObject.Methods[0].Name.Equals("spsearchrawread"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listsourceidsstatic"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteListSourceIds(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listothersourceidsstatic"))
            {
                SPSearch spsearch = new SPSearch(serviceBroker, this.Configuration);
                spsearch.ExecuteListOtherSourceIds(inputs, required, returns, methodType, serviceObject);
            }


            if (serviceObject.Methods[0].Name.Equals("spsearchusers") || serviceObject.Methods[0].Name.Equals("deserializeusersearchresults"))
            {
                SPSearchUser spsearchuser = new SPSearchUser(serviceBroker, this.Configuration);
                spsearchuser.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchusersread"))
            {
                SPSearchUser spsearchuser = new SPSearchUser(serviceBroker, this.Configuration);
                spsearchuser.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }


            if (serviceObject.Methods[0].Name.Equals("spsearchdocuments") || serviceObject.Methods[0].Name.Equals("deserializedocumentsearchresults"))
            {
                SPSearchDocument spsearchdocumet = new SPSearchDocument(serviceBroker, this.Configuration);
                spsearchdocumet.ExecuteSearch(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("spsearchdocumentsread"))
            {
                SPSearchDocument spsearchdocumet = new SPSearchDocument(serviceBroker, this.Configuration);
                spsearchdocumet.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
            }
        }
        public void GetAttachment(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Helper h = new Helper(serviceBroker);

            string mailbox       = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid           = string.Empty;
            string subjectfilter = string.Empty;
            int    index         = -1;

            uid   = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();
            index = int.Parse(inputs.Where(p => p.Name.Equals("attachmentindex")).FirstOrDefault().Value.ToString());

            AE.Net.Mail.MailMessage       m           = null;
            List <AE.Net.Mail.Attachment> attachments = new List <AE.Net.Mail.Attachment>();

            try
            {
                using (var ic = h.GetImapClient())
                {
                    m = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }

                    attachments = m.Attachments as List <AE.Net.Mail.Attachment>;

                    AE.Net.Mail.Attachment a = null;

                    if (index == -1 || index > attachments.Count)
                    {
                        return;
                    }
                    a = attachments[index];

                    if (a == null)
                    {
                        return;
                    }

                    returns.Where(p => p.Name.ToLower().Equals("body")).FirstOrDefault().Value    = a.Body;
                    returns.Where(p => p.Name.ToLower().Equals("charset")).FirstOrDefault().Value = a.Charset;
                    returns.Where(p => p.Name.ToLower().Equals("contenttransferencoding")).FirstOrDefault().Value = a.ContentTransferEncoding;
                    returns.Where(p => p.Name.ToLower().Equals("contenttype")).FirstOrDefault().Value             = a.ContentType;
                    returns.Where(p => p.Name.ToLower().Equals("filename")).FirstOrDefault().Value        = a.Filename;
                    returns.Where(p => p.Name.ToLower().Equals("rawheaders")).FirstOrDefault().Value      = a.RawHeaders;
                    returns.Where(p => p.Name.ToLower().Equals("onserver")).FirstOrDefault().Value        = a.OnServer;
                    returns.Where(p => p.Name.ToLower().Equals("mailbox")).FirstOrDefault().Value         = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value             = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();;
                    returns.Where(p => p.Name.ToLower().Equals("attachmentindex")).FirstOrDefault().Value = inputs.Where(p => p.Name.Equals("attachmentindex")).FirstOrDefault().Value.ToString();;

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public void GetAllAttachments(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            System.Data.DataRow dr;
            Helper h = new Helper(serviceBroker);

            string mailbox = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid = string.Empty;
            string subjectfilter = string.Empty;

            uid = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();

            AE.Net.Mail.MailMessage m = null;
            List<AE.Net.Mail.Attachment> attachments = new List<AE.Net.Mail.Attachment>();

            try
            {
                using (var ic = h.GetImapClient())
                {
                    m = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }

                    attachments = m.Attachments as List<AE.Net.Mail.Attachment>;

                    foreach (Attachment a in attachments)
                    {
                        dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                        
                        dr["body"] = a.Body;
                        dr["charset"] = a.Charset;
                        dr["contenttransferencoding"] = a.ContentTransferEncoding;
                        dr["contenttype"] = a.ContentType;
                        dr["filename"] = a.Filename;
                        dr["rawheaders"] = a.RawHeaders;
                        dr["onserver"] = a.OnServer;

                        dr["mailbox"] = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
                        dr["uid"] = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();

                        serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                    }

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            
        }
        public void GetMessageBy(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            Helper h = new Helper(serviceBroker);

            string mailbox       = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid           = string.Empty;
            string subjectfilter = string.Empty;

            AE.Net.Mail.MailMessage m = null;
            try
            {
                using (var ic = h.GetImapClient())
                {
                    switch (serviceObject.Methods[0].Name.ToLower())
                    {
                    case "getmessagebyuid":
                        uid = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();
                        m   = ic.GetMessage(uid, false);
                        break;

                    case "getmessagebysubject":
                        subjectfilter = inputs.Where(p => p.Name.Equals("subjectfilter")).FirstOrDefault().Value.ToString();
                        Lazy <AE.Net.Mail.MailMessage>[] mm = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Subject(subjectfilter)));
                        Lazy <AE.Net.Mail.MailMessage>   lm = mm.OrderByDescending(p => p.Value.Date).Where(p => p.Value.Subject.ToLower().Equals(subjectfilter)).FirstOrDefault();

                        if (lm != null && lm.Value != null)
                        {
                            m = lm.Value;
                        }

                        break;
                    }

                    // = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }

                    returns.Where(p => p.Name.ToLower().Equals("bcc")).FirstOrDefault().Value        = GetAddresses(m.Bcc);
                    returns.Where(p => p.Name.ToLower().Equals("body")).FirstOrDefault().Value       = m.Body;
                    returns.Where(p => p.Name.ToLower().Equals("cc")).FirstOrDefault().Value         = GetAddresses(m.Cc);
                    returns.Where(p => p.Name.ToLower().Equals("date")).FirstOrDefault().Value       = m.Date;
                    returns.Where(p => p.Name.ToLower().Equals("from")).FirstOrDefault().Value       = m.From != null ? m.From.Address : "";
                    returns.Where(p => p.Name.ToLower().Equals("importance")).FirstOrDefault().Value = m.Importance.ToString();
                    returns.Where(p => p.Name.ToLower().Equals("replyto")).FirstOrDefault().Value    = GetAddresses(m.ReplyTo);
                    returns.Where(p => p.Name.ToLower().Equals("sender")).FirstOrDefault().Value     = m.Sender != null ? m.Sender.Address : "";
                    returns.Where(p => p.Name.ToLower().Equals("size")).FirstOrDefault().Value       = m.Size;
                    returns.Where(p => p.Name.ToLower().Equals("subject")).FirstOrDefault().Value    = m.Subject;
                    returns.Where(p => p.Name.ToLower().Equals("to")).FirstOrDefault().Value         = GetAddresses(m.To);
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value        = m.Uid;
                    //returns.Where(p => p.Name.ToLower().Equals("rawmessage")).FirstOrDefault().Value = m.RawBody;
                    //returns.Where(p => p.Name.ToLower().Equals("base64emlmessage")).FirstOrDefault().Value = m.Base64Body;
                    returns.Where(p => p.Name.ToLower().Equals("attachmentscount")).FirstOrDefault().Value = m.Attachments != null ? m.Attachments.Count : 0;

                    returns.Where(p => p.Name.ToLower().Equals("mailbox")).FirstOrDefault().Value       = mailbox;
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value           = uid;
                    returns.Where(p => p.Name.ToLower().Equals("subjectfilter")).FirstOrDefault().Value = subjectfilter;

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            serviceObject.Properties.BindPropertiesToResultTable();
        }
        public void GetAttachment(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            
            Helper h = new Helper(serviceBroker);

            string mailbox = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            string uid = string.Empty;
            string subjectfilter = string.Empty;
            int index = -1;
            uid = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();
            index = int.Parse(inputs.Where(p => p.Name.Equals("attachmentindex")).FirstOrDefault().Value.ToString());

            AE.Net.Mail.MailMessage m = null;
            List<AE.Net.Mail.Attachment> attachments = new List<AE.Net.Mail.Attachment>();

            try
            {
                using (var ic = h.GetImapClient())
                {
                    m = ic.GetMessage(uid, false);

                    if (m == null)
                    {
                        return;
                    }

                    attachments = m.Attachments as List<AE.Net.Mail.Attachment>;

                    AE.Net.Mail.Attachment a = null;

                    if (index == -1 || index > attachments.Count)
                    {
                        return;
                    }
                    a = attachments[index];

                    if (a == null)
                    {
                        return;
                    }

                    returns.Where(p => p.Name.ToLower().Equals("body")).FirstOrDefault().Value = a.Body;
                    returns.Where(p => p.Name.ToLower().Equals("charset")).FirstOrDefault().Value = a.Charset;
                    returns.Where(p => p.Name.ToLower().Equals("contenttransferencoding")).FirstOrDefault().Value = a.ContentTransferEncoding;
                    returns.Where(p => p.Name.ToLower().Equals("contenttype")).FirstOrDefault().Value = a.ContentType;
                    returns.Where(p => p.Name.ToLower().Equals("filename")).FirstOrDefault().Value = a.Filename;
                    returns.Where(p => p.Name.ToLower().Equals("rawheaders")).FirstOrDefault().Value = a.RawHeaders;
                    returns.Where(p => p.Name.ToLower().Equals("onserver")).FirstOrDefault().Value = a.OnServer;
                    returns.Where(p => p.Name.ToLower().Equals("mailbox")).FirstOrDefault().Value = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
                    returns.Where(p => p.Name.ToLower().Equals("uid")).FirstOrDefault().Value = inputs.Where(p => p.Name.Equals("uid")).FirstOrDefault().Value.ToString();;
                    returns.Where(p => p.Name.ToLower().Equals("attachmentindex")).FirstOrDefault().Value = inputs.Where(p => p.Name.Equals("attachmentindex")).FirstOrDefault().Value.ToString();;

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            serviceObject.Properties.BindPropertiesToResultTable();

        }
        public static RESTSearchResultsSerialized ExecuteSharePointSearchRaw(Property[] inputs, RequiredProperties required, Configuration Configuration, ServiceAssemblyBase serviceBroker)
        {
            // Raw search = append input to end of querytext
            SearchInputs SearchInputs = new SearchInputs();
            string search = string.Empty;
            var searchProp = inputs.Where(p => p.Name.Equals("search", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
            if (searchProp != null && searchProp.Value != null && !string.IsNullOrWhiteSpace(searchProp.Value.ToString()))
            {
                search = searchProp.Value.ToString();
                SearchInputs.Search = search;
            }
            else
            {
                throw new Exception("Search is a required property");
            }

            string RequestUri = Configuration.SiteUrl + "/_api/search/query?querytext=" + search;

            return ProcessResults(ExecuteRESTRequest(RequestUri, serviceBroker), SearchInputs);
        }
 public void ExecuteSearchRead(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
 {
     SPExecute Excute = new SPExecute(this.serviceBroker, this.Configuration);
     Excute.ExecuteSearchRead(inputs, required, returns, methodType, serviceObject);
 }
        /// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            crmconfig = new CRMConfig
            {
                CRMURL = crmurl,
                CRMOrganization = crmorganization
            };


            #region Container


            if (serviceObject.Methods[0].Name.Equals("loadcontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteLoadContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainers"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListContainers(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("createcontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteCreateContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setcontainerpermissions"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteSetPermissions(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setcontainermetadata"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteSetMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("loadcontainermetadatavalue"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteLoadMetadataValue(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainermetadata"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("deletecontainer"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteDeleteContainer(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listcontainerfolders"))
            {
                BlobContainer container = new BlobContainer(serviceBroker);
                container.ExecuteListContainerFolders(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Container


            #region Blob


            if (serviceObject.Methods[0].Name.Equals("loadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteLoadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setblobmetadata"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteSetBlobMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("loadblobmetadatavalue"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteLoadBlobMetadataValue(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listblobmetadata"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteListBlobMetadata(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("deleteblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDeleteBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfrombase64"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromBase64(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfromfilesystem"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromFilePath(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("uploadblobfromurl"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteUploadBlobFromUrl(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("listblobs"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteListBlobs(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblob"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlob(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblobtobase64"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlobAsBase64(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("downloadblobtofilesystem"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteDownloadBlobToFileSystem(inputs, required, returns, methodType, serviceObject);
            }

            if (serviceObject.Methods[0].Name.Equals("setblobproperties"))
            {
                BlobBlob blob = new BlobBlob(serviceBroker);
                blob.ExecuteSetBlobProperties(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Blob

        }
        // deprecated
        public void ExecuteDeserializeSearchResults(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            string json = string.Empty;

            try
            {
                Property SerializedProp = inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First();
                if (SerializedProp != null && SerializedProp.Value != null)
                {
                    json = SerializedProp.Value.ToString();
                }

                //IEnumerable<IDictionary<string, object>> searchResults = JsonConvert.DeserializeObject<IEnumerable<IDictionary<string, object>>>(json.Trim());

                SearchResultsSerialized SerializedSearch = JsonConvert.DeserializeObject<SearchResultsSerialized>(json.Trim());

                if (string.IsNullOrWhiteSpace(json) || SerializedSearch == null)
                {
                    throw new Exception("Failed to deserialize search results");
                }

                foreach (IDictionary<string, object> result in SerializedSearch.SearchResults)
                {
                    dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                    if (!string.IsNullOrWhiteSpace(SerializedSearch.Inputs.Search))
                    {
                        dr["search"] = SerializedSearch.Inputs.Search;
                    }

                    if (SerializedSearch.Inputs.StartRow.HasValue && SerializedSearch.Inputs.StartRow.Value > -1)
                    {
                        dr["startrow"] = SerializedSearch.Inputs.StartRow.Value;
                    }

                    if (SerializedSearch.Inputs.RowLimit.HasValue && SerializedSearch.Inputs.RowLimit.Value > 0)
                    {
                        dr["rowlimit"] = SerializedSearch.Inputs.RowLimit.Value;
                    }

                    if (!string.IsNullOrWhiteSpace(SerializedSearch.Inputs.SortString))
                    {
                        dr["sort"] = SerializedSearch.Inputs.SortString;
                    }

                    if (!string.IsNullOrWhiteSpace(SerializedSearch.Inputs.SortString))
                    {
                        dr["sourceid"] = SerializedSearch.Inputs.SourceId;
                    }

                    if (SerializedSearch.ExecutionTime.HasValue)
                    {
                        dr["executiontime"] = SerializedSearch.ExecutionTime;
                    }

                    if (SerializedSearch.ResultRows.HasValue)
                    {
                        dr["resultrows"] = SerializedSearch.ResultRows;
                    }
                    if (SerializedSearch.TotalRows.HasValue)
                    {
                        dr["totalrows"] = SerializedSearch.TotalRows;
                    }
                    dr["resulttitle"] = SerializedSearch.ResultTitle;
                    dr["resulttitleurl"] = SerializedSearch.ResultTitleUrl;
                    dr["tabletype"] = SerializedSearch.TableType;
                    dr["spellingsuggestions"] = SerializedSearch.SpellingSuggestions;

                    foreach (string s in result.Keys)
                    {
                        if (result[s] != null)
                        {
                            dr[s.ToLower()] = result[s];
                        }
                    }
                    dr["responsestatus"] = ResponseStatus.Success;
                    serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                }
            }
            catch (Exception ex)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                dr["responsestatus"] = ResponseStatus.Error;
                dr["responsestatusdescription"] = ex.Message;
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }
            //serviceObject.Properties.BindPropertiesToResultTable();
        }
Ejemplo n.º 49
0
 /// <summary>
 /// Test the input property which must be specified in the $filter clause.
 /// </summary>
 /// <param name="propertyPath">The input property path.</param>
 /// <returns>True/False.</returns>
 public bool IsRequiredProperty(string propertyPath)
 {
     return(RequiredProperties != null?RequiredProperties.Any(a => a == propertyPath) : false);
 }
        public void ExecuteListOtherSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            Dictionary<string, string> SourceIds = new Dictionary<string, string>();
            SourceIds.Add("64cde128-76be-4943-b960-146e613a7e1e", "InternetSearchResults");
            SourceIds.Add("1dd9c4dc-8a6a-48a2-88b7-54dc3d97bf15", "InternetSearchSuggestions");
            SourceIds.Add("495318b6-0d9a-4d0f-939b-41cc17b49abd", "LocalPeopleSearchIndex");
            SourceIds.Add("5b557a96-b0ef-443c-8f55-fdcceb1e142a", "LocalSearchIndex");

            foreach (var Source in SourceIds)
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"] = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }

        }
        public void ExecuteSearch(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            SPExecute Excute = new SPExecute(this.serviceBroker, this.Configuration);
            Excute.ExecuteSearch(inputs, required, returns, methodType, serviceObject);

            //serviceObject.Properties.InitResultTable();
            //System.Data.DataRow dr;
            //try
            //{
            //    RESTSearchResultsSerialized SerializedResults = null;

            //    // if deserializesearchresults
            //    if(serviceObject.Methods[0].Name.Equals("deserializesearchresults"))
            //    { 
            //        Property SerializedProp = inputs.Where(p => p.Name.Equals("serializedresults", StringComparison.OrdinalIgnoreCase)).First();
            //        string json = string.Empty;
            //        json = SerializedProp.Value.ToString();

            //        SerializedResults = JsonConvert.DeserializeObject<RESTSearchResultsSerialized>(json.Trim());

            //        if (string.IsNullOrWhiteSpace(json) || SerializedResults == null)
            //        {
            //            throw new Exception("Failed to deserialize search results");
            //        }
            //    }

            //    if (serviceObject.Methods[0].Name.Equals("spsearch"))
            //    {
            //        // if Search
            //        SerializedResults = Utilities.BrokerUtils.ExecuteSharePointSearch(inputs, required, Configuration, serviceBroker);
            //    }

            //    if (serviceObject.Methods[0].Name.Equals("spsearchraw"))
            //    {
            //        // if Search Raw Read
            //        SerializedResults = Utilities.BrokerUtils.ExecuteSharePointSearchRaw(inputs, required, Configuration, serviceBroker);
            //    }


            //    if (SerializedResults != null)
            //    {
            //        // needs updating for REST
            //        foreach (ResultRow result in SerializedResults.SearchResults.Rows)
            //        {
            //            dr = serviceBroker.ServicePackage.ResultTable.NewRow();

            //            if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Search))
            //            {
            //                dr["search"] = SerializedResults.Inputs.Search;
            //            }

            //            if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SiteUrl))
            //            {
            //                dr["searchsiteurl"] = SerializedResults.Inputs.Search;
            //            }

            //            if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.FileExtensionsString))
            //            {
            //                dr["fileextensionsfilter"] = SerializedResults.Inputs.FileExtensionsString;
            //            }

            //            if (SerializedResults.Inputs.SourceId != null && SerializedResults.Inputs.SourceId != Guid.Empty)
            //            {                            
            //                dr["sourceid"] = SerializedResults.Inputs.SourceId;                            
            //            }

            //            if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.SortString))
            //            {
            //                dr["sort"] = SerializedResults.Inputs.SortString;
            //            }

            //            if (SerializedResults.Inputs.StartRow.HasValue && SerializedResults.Inputs.StartRow.Value > -1)
            //            {
            //                dr["startrow"] = SerializedResults.Inputs.StartRow.Value;
            //            }

            //            if (SerializedResults.Inputs.RowLimit.HasValue && SerializedResults.Inputs.RowLimit.Value > 0)
            //            {
            //                dr["rowlimit"] = SerializedResults.Inputs.RowLimit.Value;
            //            }

            //            if (!string.IsNullOrWhiteSpace(SerializedResults.Inputs.Properties))
            //            {
            //                dr["properties"] = SerializedResults.Inputs.Properties;
            //            }

            //            if (SerializedResults.Inputs.EnableStemming.HasValue && SerializedResults.Inputs.EnableStemming.Value)
            //            {
            //                dr["enablestemming"] = SerializedResults.Inputs.EnableStemming.Value;
            //            }

            //            if (SerializedResults.Inputs.TrimDuplicates.HasValue && SerializedResults.Inputs.TrimDuplicates.Value)
            //            {
            //                dr["trimduplicates"] = SerializedResults.Inputs.TrimDuplicates.Value;
            //            }

            //            if (SerializedResults.Inputs.EnableQueryRules.HasValue && SerializedResults.Inputs.EnableQueryRules.Value)
            //            {
            //                dr["enablequeryrules"] = SerializedResults.Inputs.EnableQueryRules.Value;
            //            }

            //            if (SerializedResults.Inputs.ProcessBestBets.HasValue && SerializedResults.Inputs.ProcessBestBets.Value)
            //            {
            //                dr["processbestbets"] = SerializedResults.Inputs.ProcessBestBets.Value;
            //            }

            //            if (SerializedResults.Inputs.ProcessPersonal.HasValue && SerializedResults.Inputs.ProcessPersonal.Value)
            //            {
            //                dr["processpersonal"] = SerializedResults.Inputs.ProcessPersonal.Value;
            //            }

            //            if (SerializedResults.Inputs.EnableNicknames.HasValue && SerializedResults.Inputs.EnableNicknames.Value)
            //            {
            //                dr["enablenicknames"] = SerializedResults.Inputs.EnableNicknames.Value;
            //            }

            //            if (SerializedResults.Inputs.EnablePhonetic.HasValue && SerializedResults.Inputs.EnablePhonetic.Value)
            //            {
            //                dr["enablephonetic"] = SerializedResults.Inputs.EnablePhonetic.Value;
            //            }
                        
            //            if (SerializedResults.ExecutionTime.HasValue)
            //            {
            //                dr["executiontime"] = SerializedResults.ExecutionTime.Value;                            
            //            }

            //            if (SerializedResults.ResultRows.HasValue)
            //            {
            //                dr["resultrows"] = SerializedResults.ResultRows.Value;
            //            }
            //            if (SerializedResults.TotalRows.HasValue)
            //            {
            //                dr["totalrows"] = SerializedResults.TotalRows.Value;
            //            }

            //            List<string> missingprops = new List<string>();
            //            foreach (ResultCell cell in result.Cells)
            //            {
            //                if (dr.Table.Columns.Contains(cell.Key.ToLower()))
            //                {
            //                    if (cell.Value != null)
            //                    {
            //                        dr[cell.Key.ToLower()] = cell.Value;
            //                    }
            //                }
            //                else
            //                {
            //                    missingprops.Add(cell.Key);
            //                }
            //            }

            //            dr["responsestatus"] = ResponseStatus.Success;
            //            serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            //        }
            //    }
            //    else
            //    {
            //        throw new Exception("No results returned.");
            //    }

            //}
            //catch (Exception ex)
            //{
            //    dr = serviceBroker.ServicePackage.ResultTable.NewRow();
            //    dr["responsestatus"] = ResponseStatus.Error;
            //    dr["responsestatusdescription"] = ex.Message;
            //    serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            //}

            ////serviceObject.Properties.BindPropertiesToResultTable();
        }
 private Validation GetRequiredProperties(string method)
 {
     RequiredProperties properties = new RequiredProperties();
     Validation validation = null;
     validation = new Validation();
     switch (method)
     {
         case "ActionWorklistItem":
             {
                 properties.Add(_so.Properties["SerialNumber"]);
                 properties.Add(_so.Properties["ActionName"]);
                 break;
             }
         case "OpenWorklistItem":
             {
                 properties.Add(_so.Properties["SerialNumber"]);
                 break;
             }
         case "ReleaseWorklistItem":
             {
                 properties.Add(_so.Properties["SerialNumber"]);
                 break;
             }
         case "RedirectWorklistItem":
             {
                 properties.Add(_so.Properties["SerialNumber"]);
                 break;
             }
         case "RedirectManagedUserWorklistItem":
             {
                 properties.Add(_so.Properties["SerialNumber"]);
                 break;
             }
         case "GetWorklistItemActions":
             {
                 properties.Add(new Property("SerialNumber", "System.String", SoType.Text, new MetaData("SerialNumber", "SerialNumber")));
                 break;
             }
     }
     validation.RequiredProperties = properties;
     return validation;
 }
        public void ExecuteListOtherSourceIds(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();
            System.Data.DataRow dr;

            foreach (var Source in SPSearchSource.GetOtherSourceIds())
            {
                dr = serviceBroker.ServicePackage.ResultTable.NewRow();
                Guid sid = Guid.Empty;
                if (Guid.TryParse(Source.Key, out sid))
                {
                    dr["sourceid"] = sid;
                    dr["sourcename"] = Source.Value;
                }
                serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
            }

        }
        public void GetMessages(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            serviceObject.Properties.InitResultTable();

            System.Data.DataRow dr;
            Helper h = new Helper(serviceBroker);

            string subjectfilter = string.Empty;
            string bodyfilter = string.Empty;
            string fromfilter = string.Empty;

            string startindex = string.Empty;
            string numberofmessages = string.Empty;

            string mailbox = inputs.Where(p => p.Name.Equals("mailbox")).FirstOrDefault().Value.ToString();
            bool headersonly = bool.Parse(inputs.Where(p => p.Name.Equals("headersonly")).FirstOrDefault().Value.ToString());
            bool setseen = bool.Parse(inputs.Where(p => p.Name.Equals("setseen")).FirstOrDefault().Value.ToString()); ;
            AE.Net.Mail.MailMessage mtemp = new AE.Net.Mail.MailMessage();
            try
            {
                using (var ic = h.GetImapClient())
                {

                    AE.Net.Mail.MailMessage[] m = null;
                    Lazy<AE.Net.Mail.MailMessage>[] mm = null;

                    bool isLazy = false;

                    switch (serviceObject.Methods[0].Name.ToLower())
                    {
                        case "getallmessages":
                            m = ic.GetMessages(0, ic.GetMessageCount(), headersonly, setseen);
                            isLazy = false;
                            break;
                        case "getmessages":
                            startindex = inputs.Where(p => p.Name.Equals("startindex")).FirstOrDefault().Value.ToString();
                            numberofmessages = inputs.Where(p => p.Name.Equals("numberofmessages")).FirstOrDefault().Value.ToString();
                            m = ic.GetMessages(int.Parse(startindex), int.Parse(numberofmessages), headersonly, setseen);                          
                            isLazy = false;
                            break;
                        case "searchmessagesbysubject":
                            subjectfilter = inputs.Where(p => p.Name.Equals("subjectfilter")).FirstOrDefault().Value.ToString();
                            mm = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Subject(subjectfilter)));
                            isLazy = true;
                            break;
                        case "searchmessagesbybody":
                            bodyfilter = inputs.Where(p => p.Name.Equals("bodyfilter")).FirstOrDefault().Value.ToString();
                            mm = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.Body(bodyfilter))).ToArray();
                            isLazy = true;
                            break;
                        case "searchmessagesbyfrom":
                            fromfilter = inputs.Where(p => p.Name.Equals("fromfilter")).FirstOrDefault().Value.ToString();
                            mm = ic.SearchMessages(SearchCondition.Undeleted().And(SearchCondition.From(fromfilter))).ToArray();
                            isLazy = true;
                            break;                            
                    }

                    //AE.Net.Mail.MailMessage[] mm = ic.GetMessages(0, ic.GetMessageCount(), headersonly, setseen);

                    if (isLazy)
                    {
                        foreach (System.Lazy<AE.Net.Mail.MailMessage> msg in mm)
                        {
                            AE.Net.Mail.MailMessage mmsg = msg.Value;
                            dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                            MapMailMessage(dr, mmsg);
                            
                            dr["mailbox"] = mailbox;
                            dr["headersonly"] = headersonly;
                            dr["setseen"] = setseen;

                            switch (serviceObject.Methods[0].Name.ToLower())
                            {
                                case "searchmessagesbysubject":
                                    dr["subjectfilter"] = subjectfilter;
                                    break;
                                case "searchmessagesbybody":
                                    dr["bodyfilter"] = bodyfilter;
                                    break;
                                case "searchmessagesbyfrom":
                                    dr["fromfilter"] = fromfilter;
                                    break;
                            }


                            dr["startindex"] = startindex;
                            dr["numberofmessages"] = numberofmessages;

                            serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                        }
                    }
                    else
                    {
                        foreach (AE.Net.Mail.MailMessage msg in m.OrderByDescending(p => p.Date))
                        {
                            mtemp = msg;
                            dr = serviceBroker.ServicePackage.ResultTable.NewRow();

                            MapMailMessage(dr, msg);

                            dr["mailbox"] = mailbox;
                            dr["headersonly"] = headersonly;
                            dr["setseen"] = setseen;
                            switch (serviceObject.Methods[0].Name.ToLower())
                            {
                                case "searchmessagesbysubject":
                                    dr["subjectfilter"] = subjectfilter;
                                    break;
                                case "searchmessagesbybody":
                                    dr["bodyfilter"] = bodyfilter;
                                    break;
                                case "searchmessagesbyfrom":
                                    dr["fromfilter"] = fromfilter;
                                    break;
                            }
                            dr["startindex"] = startindex;
                            dr["numberofmessages"] = numberofmessages;

                            serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
                        }
                    }

                    ic.Disconnect();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(mtemp.Subject);
                //serviceObject.Properties.BindPropertiesToResultTable();
            }
            //serviceObject.Properties.BindPropertiesToResultTable();
        }